@vuetify/v0 1.0.0-alpha.4 → 1.0.0-beta.0

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

@@ -1,13 +1,15 @@
-import { a as ID, i as Extensible, o as MaybeArray } from "./index-CLR1QMM3.mjs";
+import { a as ID, i as Extensible, o as MaybeArray } from "./index-DHmuwBdv.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";
+import { a as RegistryEventName, c as RegistryTicketInput, o as RegistryOptions, r as RegistryEventCallback, s as RegistryTicket, t as RegistryContext } from "./index-BIyQ3OxC.mjs";
+import { _ as FilterMode } from "./adapter-BO75n0Cn.mjs";
+import { _ as ColumnNode, c as DataTableOptions, n as DataTableColumnTicketInput, r as DataTableContext, t as DataTableColumnTicket } from "./index-ZD3hw2Zo.mjs";
+import { c as TokenTicket, i as TokenContext, o as TokenOptions, r as TokenCollection } from "./index-DWAgQOBa.mjs";
+import { t as DateAdapter } from "./adapter-B6IrPwib.mjs";
+import { n as FeaturesAdapterFlags, t as FeaturesAdapter } from "./adapter-DZeI0ZbW.mjs";
+import { t as LocaleAdapter } from "./adapter-we-0GbFH.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, ShallowReactive, ShallowRef, UnwrapNestedRefs, WatchSource, WritableComputedRef } from "vue";
 
 //#region src/composables/createModel/index.d.ts
 /**
@@ -629,6 +631,151 @@ interface UseImageReturn {
  */
 declare function useImage(options: UseImageOptions): UseImageReturn;
 //#endregion
+//#region src/composables/createOverflow/index.d.ts
+interface OverflowOptions {
+  /**
+   * Container element to track. Can be a ref, getter, or MaybeRefOrGetter.
+   * When provided, useOverflow tracks this element's width automatically.
+   * Accepts null for compatibility with Vue's useTemplateRef.
+   */
+  container?: MaybeRefOrGetter<Element | null | undefined>;
+  /** Gap between items in pixels */
+  gap?: MaybeRefOrGetter<number>;
+  /** Reserved space in pixels (for nav buttons, ellipsis, etc) */
+  reserved?: MaybeRefOrGetter<number>;
+  /**
+   * Uniform item width in pixels. When provided, enables uniform mode
+   * where capacity is calculated as available space / itemWidth.
+   * Use this for same-width items like pagination buttons.
+   */
+  itemWidth?: MaybeRefOrGetter<number>;
+  /**
+   * Calculate capacity from end instead of start.
+   * Useful for breadcrumbs where trailing items take priority.
+   * Only affects variable mode (uniform mode capacity is direction-independent).
+   */
+  reverse?: MaybeRefOrGetter<boolean>;
+}
+interface OverflowContext {
+  /** Container element ref */
+  container: ShallowRef<Element | null | undefined>;
+  /** Current container width */
+  width: Readonly<ShallowRef<number>>;
+  /** How many items fit in available space */
+  capacity: ComputedRef<number>;
+  /** Total width of all measured items */
+  total: ComputedRef<number>;
+  /** Whether items overflow the container */
+  isOverflowing: Readonly<Ref<boolean>>;
+  /**
+   * Register an item's element for width measurement. Required for every
+   * child in both modes — variable mode reads the measured widths for
+   * capacity; uniform mode reads only the entry count for isOverflowing.
+   * Pass `undefined` to unregister.
+   */
+  measure: (index: number, el: Element | undefined) => void;
+  /** Clear all measurements */
+  reset: () => void;
+}
+interface OverflowContextOptions extends OverflowOptions {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+/**
+ * Creates a new overflow context for computing how many items fit in a container.
+ *
+ * @param options Configuration options
+ * @returns Overflow context with container ref, capacity, and measurement functions
+ *
+ * @example Variable-width mode (Breadcrumbs)
+ * ```vue
+ * <script lang="ts" setup>
+ *   import { useTemplateRef } from 'vue'
+ *   import { createOverflow } from '@vuetify/v0'
+ *
+ *   const containerRef = useTemplateRef('container')
+ *   const overflow = createOverflow({
+ *     container: containerRef,
+ *     gap: 8,
+ *     reserved: 40,
+ *   })
+ * </script>
+ *
+ * <template>
+ *   <div ref="container">
+ *     <span
+ *       v-for="(item, i) in items.slice(0, overflow.capacity.value)"
+ *       :key="i"
+ *       :ref="el => overflow.measure(i, el)"
+ *     >
+ *       {{ item }}
+ *     </span>
+ *     <span v-if="overflow.isOverflowing.value">...</span>
+ *   </div>
+ * </template>
+ * ```
+ *
+ * @example Uniform-width mode (Pagination)
+ * ```ts
+ * const overflow = createOverflow({
+ *   container: () => atom.value?.element,
+ *   itemWidth: buttonWidth,
+ *   reserved: () => buttonWidth.value * 4,
+ * })
+ * ```
+ */
+declare function createOverflow<E extends OverflowContext = OverflowContext>(options?: OverflowOptions): E;
+/**
+ * Creates an overflow context with dependency injection support.
+ *
+ * @param options Configuration options including namespace
+ * @template E The type of the overflow context
+ * @returns Trinity tuple: [useOverflow, provideOverflow, defaultOverflow]
+ *
+ * @example
+ * ```ts
+ * // Create injectable context
+ * const [useOverflow, provideOverflow, overflow] = createOverflowContext({
+ *   namespace: 'my-overflow',
+ *   gap: 8,
+ *   reserved: 160,
+ * })
+ *
+ * // In parent component
+ * provideOverflow()
+ *
+ * // In child component
+ * const overflow = useOverflow()
+ * ```
+ */
+declare function createOverflowContext<E extends OverflowContext = OverflowContext>(_options?: OverflowContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current overflow context from dependency injection.
+ *
+ * @param namespace The namespace for the overflow context. Defaults to `v0:overflow`.
+ * @template E The type of the overflow context
+ * @returns The current overflow context.
+ *
+ * @throws An error if the overflow context is not found and no default is provided.
+ *
+ * @example
+ * ```vue
+ * <script lang="ts" setup>
+ *   import { useOverflow } from '@vuetify/v0'
+ *
+ *   // Inject overflow context provided by parent
+ *   const overflow = useOverflow()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Capacity: {{ overflow.capacity.value }}</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useOverflow<E extends OverflowContext = OverflowContext>(namespace?: string): E;
+//#endregion
 //#region src/composables/createSingle/index.d.ts
 /**
  * Input type for single selection tickets.
@@ -1070,146 +1217,6 @@ declare function createGroupContext<Z extends GroupTicketInput = GroupTicketInpu
  */
 declare function useGroup<Z extends GroupTicketInput = GroupTicketInput, E extends GroupTicket<Z> = GroupTicket<Z>, R extends GroupContext<Z, E> = GroupContext<Z, E>>(namespace?: string): R;
 //#endregion
-//#region src/composables/createOverflow/index.d.ts
-interface OverflowOptions {
-  /**
-   * Container element to track. Can be a ref, getter, or MaybeRefOrGetter.
-   * When provided, useOverflow tracks this element's width automatically.
-   * Accepts null for compatibility with Vue's useTemplateRef.
-   */
-  container?: MaybeRefOrGetter<Element | null | undefined>;
-  /** Gap between items in pixels */
-  gap?: MaybeRefOrGetter<number>;
-  /** Reserved space in pixels (for nav buttons, ellipsis, etc) */
-  reserved?: MaybeRefOrGetter<number>;
-  /**
-   * Uniform item width in pixels. When provided, enables uniform mode
-   * where capacity is calculated as available space / itemWidth.
-   * Use this for same-width items like pagination buttons.
-   */
-  itemWidth?: MaybeRefOrGetter<number>;
-  /**
-   * Calculate capacity from end instead of start.
-   * Useful for breadcrumbs where trailing items take priority.
-   * Only affects variable mode (uniform mode capacity is direction-independent).
-   */
-  reverse?: MaybeRefOrGetter<boolean>;
-}
-interface OverflowContext {
-  /** Container element ref */
-  container: ShallowRef<Element | null | undefined>;
-  /** Current container width */
-  width: Readonly<ShallowRef<number>>;
-  /** How many items fit in available space */
-  capacity: ComputedRef<number>;
-  /** Total width of all measured items */
-  total: ComputedRef<number>;
-  /** Whether items overflow the container */
-  isOverflowing: Readonly<Ref<boolean>>;
-  /** Register an item's element for width measurement */
-  measure: (index: number, el: Element | undefined) => void;
-  /** Clear all measurements */
-  reset: () => void;
-}
-interface OverflowContextOptions extends OverflowOptions {
-  /** Namespace for dependency injection */
-  namespace?: string;
-}
-/**
- * Creates a new overflow context for computing how many items fit in a container.
- *
- * @param options Configuration options
- * @returns Overflow context with container ref, capacity, and measurement functions
- *
- * @example Variable-width mode (Breadcrumbs)
- * ```vue
- * <script lang="ts" setup>
- *   import { useTemplateRef } from 'vue'
- *   import { createOverflow } from '@vuetify/v0'
- *
- *   const containerRef = useTemplateRef('container')
- *   const overflow = createOverflow({
- *     container: containerRef,
- *     gap: 8,
- *     reserved: 40,
- *   })
- * </script>
- *
- * <template>
- *   <div ref="container">
- *     <span
- *       v-for="(item, i) in items.slice(0, overflow.capacity.value)"
- *       :key="i"
- *       :ref="el => overflow.measure(i, el)"
- *     >
- *       {{ item }}
- *     </span>
- *     <span v-if="overflow.isOverflowing.value">...</span>
- *   </div>
- * </template>
- * ```
- *
- * @example Uniform-width mode (Pagination)
- * ```ts
- * const overflow = createOverflow({
- *   container: () => atom.value?.element,
- *   itemWidth: buttonWidth,
- *   reserved: () => buttonWidth.value * 4,
- * })
- * ```
- */
-declare function createOverflow<E extends OverflowContext = OverflowContext>(options?: OverflowOptions): E;
-/**
- * Creates an overflow context with dependency injection support.
- *
- * @param options Configuration options including namespace
- * @template E The type of the overflow context
- * @returns Trinity tuple: [useOverflow, provideOverflow, defaultOverflow]
- *
- * @example
- * ```ts
- * // Create injectable context
- * const [useOverflow, provideOverflow, overflow] = createOverflowContext({
- *   namespace: 'my-overflow',
- *   gap: 8,
- *   reserved: 160,
- * })
- *
- * // In parent component
- * provideOverflow()
- *
- * // In child component
- * const overflow = useOverflow()
- * ```
- */
-declare function createOverflowContext<E extends OverflowContext = OverflowContext>(_options?: OverflowContextOptions): ContextTrinity<E>;
-/**
- * Returns the current overflow context from dependency injection.
- *
- * @param namespace The namespace for the overflow context. Defaults to `v0:overflow`.
- * @template E The type of the overflow context
- * @returns The current overflow context.
- *
- * @throws An error if the overflow context is not found and no default is provided.
- *
- * @example
- * ```vue
- * <script lang="ts" setup>
- *   import { useOverflow } from '@vuetify/v0'
- *
- *   // Inject overflow context provided by parent
- *   const overflow = useOverflow()
- * </script>
- *
- * <template>
- *   <div>
- *     <p>Capacity: {{ overflow.capacity.value }}</p>
- *   </div>
- * </template>
- * ```
- */
-declare function useOverflow<E extends OverflowContext = OverflowContext>(namespace?: string): E;
-//#endregion
 //#region src/composables/createStep/index.d.ts
 /**
  * Input type for step tickets.
@@ -1396,22 +1403,24 @@ interface PopoverOptions {
   positionTry?: string;
   /** External ref for bidirectional open state (e.g., from defineModel) */
   isOpen?: Ref<boolean>;
-  /** Delay in ms before showing the popover. @default 0 */
-  showDelay?: number;
-  /** Delay in ms before hiding the popover. @default 0 */
-  hideDelay?: number;
+  /** Delay in ms before opening the popover. @default 0 */
+  openDelay?: MaybeRefOrGetter<number>;
+  /** Delay in ms before closing the popover. @default 0 */
+  closeDelay?: MaybeRefOrGetter<number>;
 }
 interface PopoverReturn {
   /** Whether the popover is open */
   isOpen: Ref<boolean>;
   /** Unique ID for the popover */
   id: string;
-  /** Open the popover */
+  /** Open the popover (respects openDelay) */
   open: () => void;
-  /** Close the popover */
+  /** Close the popover (respects closeDelay) */
   close: () => void;
   /** Toggle open/close */
   toggle: () => void;
+  /** Cancel any pending open or close transition */
+  cancel: () => void;
   /** Styles to spread on the activator element (anchor-name) */
   anchorStyles: Readonly<Ref<Record<string, string>>>;
   /** Attrs to spread on the content element (id, popover) */
@@ -1599,106 +1608,468 @@ declare function createComboboxContext(options?: ComboboxOptions & {
  * @param namespace - DI namespace. Defaults to `'v0:combobox'`.
  * @returns The combobox context from the nearest provider.
  *
- * @see https://0.vuetifyjs.com/composables/forms/create-combobox
+ * @see https://0.vuetifyjs.com/composables/forms/create-combobox
+ *
+ * @example
+ * ```ts
+ * import { useCombobox } from '@vuetify/v0'
+ *
+ * const combobox = useCombobox()
+ * combobox.query.value = 'search term'
+ * ```
+ */
+declare function useCombobox(namespace?: string): ComboboxContext;
+//#endregion
+//#region src/composables/createContext/index.d.ts
+type ContextKey<Z> = InjectionKey<Z> | string;
+interface CreateContextOptions {
+  /** Optional suffix to append to the runtime key */
+  suffix?: string;
+}
+/**
+ * Injects a context provided by an ancestor component.
+ *
+ * @param key The key of the context to inject.
+ * @param defaultValue Optional default value if context is not found.
+ * @template Z The type of the context.
+ * @returns The injected context.
+ * @throws An error if the context is not found and no default is provided.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context
+ *
+ * @example
+ * ```ts
+ * // Without default value
+ * const context = useContext<MyContext>('my-context')
+ *
+ * // With default value
+ * const context = useContext<MyContext>('my-context', defaultContext)
+ * ```
+ */
+declare function useContext<Z>(key: ContextKey<Z>, defaultValue?: Z): Z;
+/**
+ * Provides a context to all descendant components.
+ *
+ * @param key The key of the context to provide.
+ * @param context The context to provide.
+ * @param app Optional Vue app instance to provide the context at app level instead of component level.
+ * @template Z The type of the context.
+ * @returns The provided context.
+ *
+ * @remarks
+ * When `app` parameter is provided, the context is made available to all components in the app.
+ * When omitted, the context is provided at the current component level and available to descendants only.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context
+ *
+ * @example
+ * ```ts
+ * // Component-level provision
+ * provideContext<MyContext>('my-context', context)
+ *
+ * // App-level provision (typically used in plugins)
+ * const app = createApp()
+ * provideContext<MyContext>('my-context', context, app)
+ * ```
+ */
+declare function provideContext<Z>(key: ContextKey<Z>, context: Z, app?: App): Z;
+/**
+ * Creates a new context for providing and injecting data.
+ *
+ * Supports two modes:
+ * - **Static key mode**: Pass a string/symbol key. The key is fixed at creation time.
+ * - **Dynamic key mode**: Pass nothing or an options object. The key is provided at runtime.
+ *
+ * @template Z The type of the context.
+ * @returns A tuple containing the `useContext` and `provideContext` functions.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context
+ *
+ * @example
+ * ```ts
+ * // Static key mode - key fixed at creation
+ * const [useContext, provideContext] = createContext<ThemeContext>('v0:theme')
+ * provideContext(context)              // provides to 'v0:theme'
+ * useContext()                         // injects from 'v0:theme'
+ *
+ * // Dynamic key mode - key provided at runtime
+ * const [useContext, provideContext] = createContext<PanelContext>()
+ * provideContext('v0:panel', context)  // provides to 'v0:panel'
+ * useContext('v0:panel')               // injects from 'v0:panel'
+ *
+ * // Dynamic key with suffix - suffix appended to runtime key
+ * const [useContext, provideContext] = createContext<ItemContext>({ suffix: 'item' })
+ * provideContext('v0:panel', context)  // provides to 'v0:panel:item'
+ * useContext('v0:panel')               // injects from 'v0:panel:item'
+ * ```
+ */
+declare function createContext<Z>(key: ContextKey<Z>, defaultValue?: Z): readonly [() => Z, (context: Z, app?: App) => Z];
+declare function createContext<Z>(options?: CreateContextOptions): readonly [(key: string, defaultValue?: Z) => Z, (key: string, context: Z, app?: App) => Z];
+//#endregion
+//#region src/composables/createDataGrid/editing.d.ts
+interface EditableColumn<T = unknown> {
+  readonly id: string;
+  readonly editable?: boolean | ((item: T) => boolean);
+  readonly validate?: (value: unknown, item?: T) => string | true;
+}
+/**
+ * Minimal structural type of the row registry surface that
+ * `createCellEditing` subscribes to for pruning stale state.
+ *
+ * Compatible with the registry returned by `createDataTable` / spread onto
+ * `createDataGrid`. The `on` / `off` channel is needed — handlers subscribe at
+ * setup and unsubscribe on scope dispose, so a registry that outlives the
+ * editing instance does not accumulate listeners. The payload arrives as
+ * `unknown` and is narrowed inside the handler.
+ */
+interface CellEditingRegistry {
+  on: (event: string, listener: (data: unknown) => void) => void;
+  off: (event: string, listener: (data: unknown) => void) => void;
+}
+interface CellEditingOptions<T = unknown> {
+  /**
+   * Editable columns, read reactively. Accepts a ref or getter so the column
+   * set can change after construction — e.g. a grid that derives editables
+   * from a live column registry. Resolved via `toValue` on every `edit` /
+   * `commit`, so newly-onboarded editable columns are picked up without
+   * re-creating the editing instance.
+   */
+  columns: MaybeRefOrGetter<readonly EditableColumn<T>[]>;
+  onEdit?: (row: ID, column: string, value: unknown) => void;
+  lookup?: (row: ID) => T | undefined;
+  registry?: CellEditingRegistry;
+}
+interface ActiveCell {
+  row: ID;
+  column: string;
+}
+/**
+ * Cell editing state and controls returned by {@link createCellEditing}.
+ *
+ * @example
+ * ```ts
+ * grid.editing.edit(1, 'email')
+ * grid.editing.commit('x@y.z')
+ *
+ * grid.editing.active.value // { row: 1, column: 'email' } | null
+ * grid.editing.error.value  // 'Invalid email' | null
+ * grid.editing.dirty        // Map<ID, Map<string, unknown>> (ShallowReactive)
+ * ```
+ */
+interface CellEditing {
+  active: Readonly<ShallowRef<ActiveCell | null>>;
+  edit: (row: ID, column: string) => void;
+  commit: (value: unknown) => void;
+  cancel: () => void;
+  error: Readonly<ShallowRef<string | null>>;
+  /**
+   * Map of rows that have staged (uncommitted) cell values. The outer key
+   * is the row id; the inner Map is column id → staged value. Empty
+   * entries are not pre-created — consumers that want to stage a value
+   * insert their own per-row Map (or use the dirty Map's `set`).
+   *
+   * `dirty` is a consumer-managed staging area for uncommitted values;
+   * `commit(value)` commits its explicit `value` argument and merely deletes
+   * the matching staged entry — it does not read or auto-flush staged values.
+   */
+  dirty: Readonly<ShallowReactive<Map<ID, Map<string, unknown>>>>;
+}
+//#endregion
+//#region src/composables/createDataGrid/layout.d.ts
+type PinPosition = 'left' | 'right' | false;
+interface GridColumnDef extends ColumnNode {
+  /** Width as a percentage (0–100). Unset columns share remaining space equally. */
+  readonly size?: number;
+  /** Minimum width as a percentage. @default 2 */
+  readonly minSize?: number;
+  /** Maximum width as a percentage. @default 100 */
+  readonly maxSize?: number;
+  /** Pin position. @default false */
+  readonly pinned?: PinPosition;
+  /** Allow resizing. @default true */
+  readonly resizable?: boolean;
+  /** Allow reordering. @default true */
+  readonly reorderable?: boolean;
+  readonly children?: readonly GridColumnDef[];
+}
+interface ResolvedColumn {
+  id: string;
+  index: number;
+  /** Current size as a percentage */
+  size: number;
+  /** Distance from the column's pinning edge — left edge for left/scrollable, right edge for right. Apply directly as the CSS `left` / `right` value for sticky positioning. */
+  offset: number;
+  pinned: PinPosition;
+  resizable: boolean;
+  reorderable: boolean;
+  minSize: number;
+  maxSize: number;
+  /** Whether the column is part of the render set. Always `true` for render-set entries; meaningful on `all`, where hidden columns surface as `false`. */
+  visible: boolean;
+}
+interface PinnedRegion {
+  left: ResolvedColumn[];
+  scrollable: ResolvedColumn[];
+  right: ResolvedColumn[];
+}
+interface ColumnLayout {
+  /** Resolved columns for each pin region (hidden columns excluded) */
+  pinned: Readonly<Ref<PinnedRegion>>;
+  /** All visible resolved columns in display order (hidden columns excluded) */
+  columns: Readonly<Ref<ResolvedColumn[]>>;
+  /** Every column in display order, including hidden ones, each carrying a `visible` flag — for a column chooser. */
+  all: Readonly<Ref<ResolvedColumn[]>>;
+  /** Pin a column to a region (or unpin with false) */
+  pin: (id: string, position: PinPosition) => void;
+  /**
+   * Resize a column by delta percentage within its pin region.
+   * The neighbor to the right absorbs the inverse delta.
+   * No-op for the last column in its region or non-resizable columns.
+   */
+  resize: (id: string, delta: number) => void;
+  /**
+   * Move a column from one display-order index to another. Indices address
+   * the visible display set (matching `columns`), so hidden columns are not
+   * counted. No-op if the resolved top-level group has `reorderable: false`.
+   */
+  reorder: (from: number, to: number) => void;
+  /** Replace all sizes at once and normalize to sum to 100 */
+  distribute: (sizes: number[]) => void;
+  /** Show a previously hidden column */
+  show: (id: string) => void;
+  /** Hide a column — excludes it from the render set without redistributing */
+  hide: (id: string) => void;
+  /** Toggle a column's visibility */
+  toggle: (id: string) => void;
+  /** Restore initial sizes, order, and pins */
+  reset: () => void;
+}
+//#endregion
+//#region src/composables/createDataGrid/spanning.d.ts
+interface SpanEntry {
+  rowSpan: number;
+  hidden: boolean;
+}
+/**
+ * Options for {@link createRowSpanning}.
+ *
+ * @template T Row value type.
+ *
+ * @example
+ * ```ts
+ * const options: RowSpanningOptions<Holding> = {
+ *   items: computed(() => grid.items.value),
+ *   columns: ['group', 'ticker', 'value'],
+ *   span: (item, column) => column === 'group' ? 3 : 1,
+ * }
+ * ```
+ */
+interface RowSpanningOptions<T = Record<string, unknown>> {
+  items: Ref<readonly T[]> | ComputedRef<readonly T[]>;
+  columns: MaybeRefOrGetter<readonly string[]>;
+  /**
+   * Projects the row key from its item and index. Takes precedence over
+   * `itemKey` — the grid passes the registry ticket id so the span map shares
+   * identity with the rest of the grid. Rows whose projected key is
+   * `undefined` are skipped, since their spans can't be addressed.
+   */
+  key?: (item: T, index: number) => ID | undefined;
+  /**
+   * Property used to identify each row in the span map when `key` is absent.
+   * Rows whose value for this key is `undefined` are skipped, since their
+   * spans can't be addressed.
+   */
+  itemKey?: string;
+  /**
+   * Resolves the row span for a cell. Return a value < 1 (or `NaN`) to span a
+   * single row. When absent, no spans are produced.
+   */
+  span?: (item: T, column: string) => number;
+}
+//#endregion
+//#region src/composables/createDataGrid/index.d.ts
+/**
+ * Column registration shape for `createDataGrid`. Extends the data-table
+ * column ticket input with grid-specific layout, editing, and spanning config.
+ *
+ * The extra fields ride on the column ticket — `createRegistry` preserves them
+ * via `{ ...registration }` — so layout/editing/spanning read config straight
+ * off the registered ticket. Nested `children` config rides inline on the
+ * parent ticket, mirroring `DataTableColumnTicketInput`.
+ *
+ * @template T Row value type.
+ *
+ * @example
+ * ```ts
+ * const grid = createDataGrid<Product>()
+ *
+ * grid.columns.onboard([
+ *   { id: 'name', sortable: true, size: 40, pinned: 'left' },
+ *   { id: 'price', editable: true, validate: v => Number(v) >= 0 || 'must be positive' },
+ * ])
+ * ```
+ */
+interface DataGridColumnTicketInput<T extends Record<string, unknown> = Record<string, unknown>> extends DataTableColumnTicketInput<T> {
+  /** Width as a percentage (0–100). Unset columns share remaining space equally. */
+  size?: number;
+  /** Minimum width as a percentage. @default 2 */
+  minSize?: number;
+  /** Maximum width as a percentage. @default 100 */
+  maxSize?: number;
+  /** Pin position. @default false */
+  pinned?: PinPosition;
+  /** Allow resizing. @default true */
+  resizable?: boolean;
+  /** Allow reordering. @default true */
+  reorderable?: boolean;
+  /** Whether cells in this column can be edited. A function gates per-row. */
+  editable?: boolean | ((item: T) => boolean);
+  /** Validate an edited value; return `true` to accept or a string error to reject. */
+  validate?: (value: unknown, item?: T) => string | true;
+  /** Row span for a cell in this column. */
+  span?: (item: T) => number;
+  /** Header-group children (recursive). Children are NOT separately registered. */
+  children?: readonly DataGridColumnTicketInput<T>[];
+}
+/**
+ * Output ticket returned by `grid.columns.register` / `grid.columns.onboard`.
+ *
+ * Combines the standard registry ticket fields (`index`, `valueIsIndex`,
+ * `unregister`) with the column-shape fields from {@link DataGridColumnTicketInput}.
+ *
+ * @template T Row value type.
+ */
+type DataGridColumnTicket<T extends Record<string, unknown> = Record<string, unknown>> = DataTableColumnTicket<T> & DataGridColumnTicketInput<T>;
+/**
+ * @deprecated Use {@link DataGridColumnTicketInput}. Columns are now onboarded
+ * via `grid.columns.onboard([...])` rather than passed as a factory option.
+ */
+type DataGridColumn<T extends Record<string, unknown> = Record<string, unknown>> = DataGridColumnTicketInput<T>;
+/**
+ * Factory options for {@link createDataGrid}. Extends {@link DataTableOptions}
+ * with cell-editing, row-spanning, and row-order-preservation config.
+ *
+ * @template T Row value type.
  *
  * @example
  * ```ts
- * import { useCombobox } from '@vuetify/v0'
- *
- * const combobox = useCombobox()
- * combobox.query.value = 'search term'
+ * const grid = createDataGrid<Product>({
+ *   editing: { onEdit (row, column, value, item) { persist(item.id, column, value) } },
+ *   rowSpanning: (item, column) => column === 'group' ? 3 : 1,
+ *   preserveRowOrder: true,
+ * })
  * ```
  */
-declare function useCombobox(namespace?: string): ComboboxContext;
-//#endregion
-//#region src/composables/createContext/index.d.ts
-type ContextKey<Z> = InjectionKey<Z> | string;
-interface CreateContextOptions {
-  /** Optional suffix to append to the runtime key */
-  suffix?: string;
+interface DataGridOptions<T extends Record<string, unknown>> extends DataTableOptions<T> {
+  editing?: {
+    onEdit?: (row: ID, column: string, value: unknown, item: T) => void;
+  };
+  preserveRowOrder?: MaybeRefOrGetter<boolean>;
+  rowSpanning?: (item: T, column: string) => number;
 }
 /**
- * Injects a context provided by an ancestor component.
- *
- * @param key The key of the context to inject.
- * @param defaultValue Optional default value if context is not found.
- * @template Z The type of the context.
- * @returns The injected context.
- * @throws An error if the context is not found and no default is provided.
+ * The reactive grid instance returned by {@link createDataGrid}. Spreads the
+ * inherited {@link DataTableContext} surface and adds `layout`, `rows`,
+ * `editing`, and `spans`.
  *
- * @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
- * @see https://0.vuetifyjs.com/composables/foundation/create-context
+ * @template T Row value type.
  *
  * @example
  * ```ts
- * // Without default value
- * const context = useContext<MyContext>('my-context')
+ * const grid = createDataGrid<Product>()
  *
- * // With default value
- * const context = useContext<MyContext>('my-context', defaultContext)
+ * grid.layout.pin('name', 'left')
+ * grid.rows.move(id, 0)
+ * grid.editing.edit(1, 'email')
+ * grid.spans.value.get(id)?.get('group')
  * ```
  */
-declare function useContext<Z>(key: ContextKey<Z>, defaultValue?: Z): Z;
+interface DataGridContext<T extends Record<string, unknown>> extends DataTableContext<T> {
+  /**
+   * Column registry, widened to the grid column ticket shape. Covariant
+   * override of the inherited {@link DataTableContext.columns} (PHILOSOPHY
+   * §2.6): every grid-added column field (`size`, `pinned`, `editable`,
+   * `validate`, `span`, `minSize`, `maxSize`, `resizable`, `reorderable`) is
+   * optional, so the widened input still satisfies the base `register` /
+   * `onboard` signatures and runtime behavior is unchanged.
+   */
+  columns: RegistryContext<DataGridColumnTicketInput<T>, DataGridColumnTicket<T>>;
+  layout: ColumnLayout;
+  rows: {
+    order: Readonly<Ref<ID[]>>;
+    move: (id: ID, toIndex: number) => void;
+    reset: () => void;
+  };
+  editing: CellEditing;
+  spans: ComputedRef<Map<ID, Map<string, SpanEntry>>>;
+}
+interface DataGridContextOptions<T extends Record<string, unknown>> extends DataGridOptions<T> {
+  namespace?: string;
+}
 /**
- * Provides a context to all descendant components.
- *
- * @param key The key of the context to provide.
- * @param context The context to provide.
- * @param app Optional Vue app instance to provide the context at app level instead of component level.
- * @template Z The type of the context.
- * @returns The provided context.
+ * Creates a data grid instance with layout, editing, row ordering, and spanning
+ * layered on top of the createDataTable pipeline.
  *
- * @remarks
- * When `app` parameter is provided, the context is made available to all components in the app.
- * When omitted, the context is provided at the current component level and available to descendants only.
+ * Rows live on the inherited registry surface — register them with
+ * `grid.onboard(rows.map(value => ({ id: value.id, value })))` or
+ * `grid.register({ id, value })`.
  *
- * @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
- * @see https://0.vuetifyjs.com/composables/foundation/create-context
+ * @param options Data grid options
+ * @returns Data grid context
  *
  * @example
  * ```ts
- * // Component-level provision
- * provideContext<MyContext>('my-context', context)
+ * const grid = createDataGrid({ pagination: { initial: 1 } })
  *
- * // App-level provision (typically used in plugins)
- * const app = createApp()
- * provideContext<MyContext>('my-context', context, app)
+ * grid.columns.onboard([
+ *   { id: 'name', sortable: true },
+ *   { id: 'progress', editable: true, validate: v => Number(v) >= 0 || 'must be positive' },
+ * ])
+ *
+ * grid.onboard(rows.map(value => ({ id: value.id, value })))
+ * grid.layout.pin('name', 'left')
+ * grid.rows.move(rowId, 0)
+ * grid.editing.edit(row.id, 'progress')
  * ```
  */
-declare function provideContext<Z>(key: ContextKey<Z>, context: Z, app?: App): Z;
+declare function createDataGrid<T extends Record<string, unknown>>(_options?: DataGridOptions<T>): DataGridContext<T>;
 /**
- * Creates a new context for providing and injecting data.
+ * Creates a data grid context with dependency injection support.
  *
- * Supports two modes:
- * - **Static key mode**: Pass a string/symbol key. The key is fixed at creation time.
- * - **Dynamic key mode**: Pass nothing or an options object. The key is provided at runtime.
+ * @param options Data grid context options including namespace
+ * @returns A trinity tuple: [useDataGridContext, provideDataGridContext, defaultContext]
  *
- * @template Z The type of the context.
- * @returns A tuple containing the `useContext` and `provideContext` functions.
+ * @example
+ * ```ts
+ * const [useDataGrid, provideDataGrid, grid] = createDataGridContext({
+ *   namespace: 'v0:projects',
+ * })
  *
- * @see https://vuejs.org/api/composition-api-dependency-injection.html
- * @see https://0.vuetifyjs.com/composables/foundation/create-context
+ * grid.columns.onboard(columns)
+ * grid.onboard(rows.map(value => ({ id: value.id, value })))
+ * provideDataGrid()
+ * const ctx = useDataGrid()
+ * ```
+ */
+declare function createDataGridContext<T extends Record<string, unknown>>(_options?: DataGridContextOptions<T>): ContextTrinity<DataGridContext<T>>;
+/**
+ * Returns the current data grid context from dependency injection.
+ *
+ * @param namespace The namespace for the data grid context. @default 'v0:data-grid'
+ * @returns The current data grid context
  *
  * @example
  * ```ts
- * // Static key mode - key fixed at creation
- * const [useContext, provideContext] = createContext<ThemeContext>('v0:theme')
- * provideContext(context)              // provides to 'v0:theme'
- * useContext()                         // injects from 'v0:theme'
- *
- * // Dynamic key mode - key provided at runtime
- * const [useContext, provideContext] = createContext<PanelContext>()
- * provideContext('v0:panel', context)  // provides to 'v0:panel'
- * useContext('v0:panel')               // injects from 'v0:panel'
+ * const grid = useDataGrid<Project>()
  *
- * // Dynamic key with suffix - suffix appended to runtime key
- * const [useContext, provideContext] = createContext<ItemContext>({ suffix: 'item' })
- * provideContext('v0:panel', context)  // provides to 'v0:panel:item'
- * useContext('v0:panel')               // injects from 'v0:panel:item'
+ * grid.layout.pin('id', 'left')
+ * grid.rows.reset()
  * ```
  */
-declare function createContext<Z>(key: ContextKey<Z>, defaultValue?: Z): readonly [() => Z, (context: Z, app?: App) => Z];
-declare function createContext<Z>(options?: CreateContextOptions): readonly [(key: string, defaultValue?: Z) => Z, (key: string, context: Z, app?: App) => Z];
+declare function useDataGrid<T extends Record<string, unknown>>(namespace?: string): DataGridContext<T>;
 //#endregion
 //#region src/composables/createPlugin/index.d.ts
 interface PluginOptions {
@@ -1774,7 +2145,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
  *     },
  *   })
  * ```
@@ -3000,6 +3371,118 @@ interface 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>>;
 type ProgressTicket = ModelTicket<ProgressTicketInput>;
@@ -4454,6 +4937,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`.
@@ -6026,7 +6594,32 @@ declare function createLogger(options?: LoggerOptions): LoggerContext;
  * })
  * ```
  */
-declare const createLoggerContext: <_E extends LoggerContext = LoggerContext>(_options?: LoggerContextOptions | undefined) => ContextTrinity<_E>, createLoggerPlugin: (_options?: LoggerContextOptions | undefined) => Plugin, useLogger: <_E extends LoggerContext = LoggerContext>(namespace?: string) => _E;
+declare const createLoggerContext: <_E extends LoggerContext = LoggerContext>(_options?: LoggerContextOptions | undefined) => ContextTrinity<_E>, createLoggerPlugin: (_options?: LoggerContextOptions | undefined) => Plugin;
+/**
+ * Consumes the application logger provided by `createLoggerPlugin`.
+ *
+ * Call with no argument to use the configured logger as-is. Pass a scope key to get a
+ * logger that prefixes every message with a `[scope]` segment after the plugin prefix —
+ * useful for telling apart output from composables that share the app-level logger. A
+ * scoped logger shares the underlying logger's level, enabled state, and adapter; only
+ * the message prefix differs. A blank scope is treated as no scope.
+ *
+ * @param scope Optional per-caller scope key prefixed onto every message.
+ * @returns The application logger, or a scoped wrapper around it.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-logger
+ *
+ * @example
+ * ```ts
+ * import { useLogger } from '@vuetify/v0'
+ *
+ * const logger = useLogger('createKanban')
+ *
+ * logger.warn('drop rejected')
+ * // → [v0 warn] [createKanban] drop rejected
+ * ```
+ */
+declare function useLogger(scope?: string): LoggerContext;
 //#endregion
 //#region src/composables/useMediaQuery/index.d.ts
 interface MediaQueryContext {
@@ -7376,4 +7969,133 @@ interface ToggleScopeControls {
  */
 declare function useToggleScope(source: WatchSource<boolean>, fn: (() => void) | ((controls: ToggleScopeControls) => void)): ToggleScopeControls;
 //#endregion
-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 };
+//#region src/composables/useTooltip/index.d.ts
+/**
+ * Options accepted by the tooltip factory.
+ *
+ * @example
+ * ```ts
+ * import { createTooltipPlugin } from '@vuetify/v0'
+ *
+ * app.use(createTooltipPlugin({ openDelay: 500, closeDelay: 100 }))
+ * ```
+ */
+interface TooltipOptions {
+  /** Default open delay in ms. @default 700 */
+  openDelay?: MaybeRefOrGetter<number>;
+  /** Default close delay in ms. @default 150 */
+  closeDelay?: MaybeRefOrGetter<number>;
+  /** Window in ms after a tooltip closes during which the next open is instant. @default 300 */
+  skipDelay?: MaybeRefOrGetter<number>;
+  /** Disable all tooltips in this region. @default false */
+  disabled?: MaybeRefOrGetter<boolean>;
+}
+interface TooltipContext {
+  /**
+   * Reactive open delay in ms.
+   *
+   * @example
+   * ```ts
+   * const tooltip = useTooltip()
+   * console.log(tooltip.openDelay.value)
+   * ```
+   */
+  openDelay: Readonly<Ref<number>>;
+  /**
+   * Reactive close delay in ms.
+   *
+   * @example
+   * ```ts
+   * const tooltip = useTooltip()
+   * console.log(tooltip.closeDelay.value)
+   * ```
+   */
+  closeDelay: Readonly<Ref<number>>;
+  /**
+   * Reactive skip-window length in ms.
+   *
+   * @example
+   * ```ts
+   * const tooltip = useTooltip()
+   * console.log(tooltip.skipDelay.value)
+   * ```
+   */
+  skipDelay: Readonly<Ref<number>>;
+  /**
+   * Reactive disabled flag for the region.
+   *
+   * @example
+   * ```ts
+   * const tooltip = useTooltip()
+   * if (tooltip.disabled.value) return
+   * ```
+   */
+  disabled: Readonly<Ref<boolean>>;
+  /**
+   * True when at least one tooltip is currently open in this region.
+   *
+   * @example
+   * ```ts
+   * const tooltip = useTooltip()
+   * watch(tooltip.isAnyOpen, open => console.log(open))
+   * ```
+   */
+  isAnyOpen: Readonly<Ref<boolean>>;
+  /**
+   * Returns true when the next opening tooltip should skip its open delay.
+   *
+   * @remarks
+   * The skip rule is two-pronged: skip when another tooltip is already open
+   * in the region, or skip when the previous tooltip closed within the
+   * `skipDelay` window.
+   *
+   * @example
+   * ```ts
+   * const tooltip = useTooltip()
+   * const delay = tooltip.shouldSkipOpenDelay() ? 0 : tooltip.openDelay.value
+   * ```
+   */
+  shouldSkipOpenDelay: () => boolean;
+  /**
+   * Register an open tooltip with the region.
+   *
+   * @example
+   * ```ts
+   * const tooltip = useTooltip()
+   * const ticket = tooltip.register({ id: 'tooltip:1' })
+   * ```
+   */
+  register: (input?: Partial<RegistryTicketInput>) => RegistryTicket;
+  /**
+   * Unregister a tooltip and stamp the close timestamp.
+   *
+   * @example
+   * ```ts
+   * const tooltip = useTooltip()
+   * tooltip.unregister(ticket.id)
+   * ```
+   */
+  unregister: (id: ID) => void;
+}
+interface TooltipContextOptions extends TooltipOptions {
+  namespace?: string;
+}
+interface TooltipPluginOptions extends TooltipContextOptions {}
+/**
+ * Synthesized fallback used when `useTooltip()` is called without
+ * `app.use(createTooltipPlugin())`. Returns a fresh context with the
+ * documented defaults — `<Tooltip.Root>` keeps working but warmup
+ * coordination is per-instance instead of region-wide.
+ *
+ * @example
+ * ```ts
+ * import { createTooltipFallback } from '@vuetify/v0'
+ *
+ * const tooltip = createTooltipFallback()
+ * console.log(tooltip.openDelay.value) // 700
+ * ```
+ */
+declare function createTooltipFallback(): TooltipContext;
+declare const createTooltipContext: <_E extends TooltipContext = TooltipContext>(_options?: TooltipPluginOptions | undefined) => ContextTrinity<_E>, createTooltipPlugin: (_options?: TooltipPluginOptions | undefined) => Plugin, useTooltip: <_E extends TooltipContext = TooltipContext>(namespace?: string) => _E;
+//#endregion
+export { RtlPluginOptions as $, FormTicketInput as $a, createQueueContext as $i, FeatureContextOptions as $n, provideContext as $o, useClickOutside as $r, OverflowOptions as $s, MutationObserverRecord as $t, Vuetify0ThemeOptions as A, NestedTicketInput as Aa, TimelineOptions as Ai, LazyContext as An, DataGridColumnTicket as Ao, KeyboardAdapterOptions as Ar, GroupTicket as As, PermissionContext as At, StackContext as B, SortableMovePayload as Ba, RatingContextOptions as Bi, HydrationContextOptions as Bn, ColumnLayout as Bo, DateContext as Br, createBreadcrumbs as Bs, PermissionsAdapter as Bt, createTheme as C, NestedContext as Ca, VirtualOptions as Ci, LocaleTicket as Cn, isStandardSchema as Co, DropPosition as Cr, StepTicketInput as Cs, ProxyModelOptions as Ct, V0UnheadThemeAdapter as D, NestedRegistration as Da, useVirtual as Di, createLocaleFallback as Dn, createPlugin as Do, ZonesContext as Dr, GroupContext as Ds, UsePresenceOptions as Dt, useTheme as E, NestedOptions as Ea, createVirtualContext as Ei, createLocaleContext as En, PluginOptions as Eo, Orientation as Er, useStep as Es, PresenceState as Et, StoragePluginOptions as F, KanbanOptions as Fa, SliderContext as Fi, UseElementIntersectionReturn as Fn, createDataGrid as Fo, DragDropAdapterEmit as Fr, BreadcrumbTicket as Fs, createPermissions as Ft, StackTicketInput as G, InputContext as Ga, createRatingContext as Gi, createHydrationContext as Gn, ActiveCell as Go, createDateContext as Gr, SingleOptions as Gs, NotificationsContext as Gt, StackOptions as H, SortableTicket as Ha, RatingItemState as Hi, HydrationPluginOptions as Hn, PinPosition as Ho, DateOptions as Hr, useBreadcrumbs as Hs, NotificationSeverity as Ht, createStorage as I, KanbanTransferPayload as Ia, SliderOptions as Ii, UseIntersectionObserverReturn as In, createDataGridContext as Io, UseDelayOptions as Ir, BreadcrumbTicketInput as Is, createPermissionsContext as It, createStackPlugin as J, createInput as Ja, QueueContextOptions as Ji, PlatformContext as Jn, CellEditingRegistry as Jo, ClickOutsideElement as Jr, createSingle as Js, createNotifications as Jt, createStack as K, InputOptions as Ka, useRating as Ki, createHydrationPlugin as Kn, CellEditing as Ko, createDatePlugin as Kr, SingleTicket as Ks, NotificationsOptions as Kt, createStorageContext as L, createKanban as La, SliderTicketInput as Li, useElementIntersection as Ln, useDataGrid as Lo, UseDelayReturn as Lr, BreadcrumbsContext as Ls, createPermissionsPlugin as Lt, StorageContext as M, KanbanColumnTicketInput as Ma, createTimeline as Mi, useLazy as Mn, DataGridContext as Mo, PointerAdapterOptions as Mr, createGroup as Ms, PermissionOptions as Mt, StorageContextOptions as N, KanbanContext as Na, createTimelineContext as Ni, IntersectionObserverEntry as Nn, DataGridContextOptions as No, DragDropAdapter as Nr, createGroupContext as Ns, PermissionPluginOptions as Nt, V0UnheadThemeOptions as O, NestedSelectionMode as Oa, TimelineContext as Oi, createLocalePlugin as On, createPluginContext as Oo, useDragDrop as Or, GroupContextOptions as Os, UsePresenceReturn as Ot, StorageOptions as P, KanbanEventListener as Pa, useTimeline as Pi, IntersectionObserverOptions as Pn, DataGridOptions as Po, DragDropAdapterContext as Pr, useGroup as Ps, PermissionTicket as Pt, RtlOptions as Q, FormTicket as Qa, createQueue as Qi, FeatureContext as Qn, createContext as Qo, UseClickOutsideReturn as Qr, OverflowContextOptions as Qs, NotificationsAdapter as Qt, createStoragePlugin as R, SortableContext as Ra, createSlider as Ri, useIntersectionObserver as Rn, RowSpanningOptions as Ro, UseDelayStartOptions as Rr, BreadcrumbsContextOptions as Rs, usePermissions as Rt, ThemeTicketInput as S, NestedActiveMode as Sa, VirtualItem as Si, LocaleRecord as Sn, StandardSchemaV1 as So, DropIndicator as Sr, StepTicket as Ss, useProxyRegistry as St, createThemePlugin as T, NestedOpenMode as Ta, createVirtual as Ti, createLocale as Tn, PluginContextConfig as To, DropZoneTicketInput as Tr, createStepContext as Ts, useProxyModel as Tt, StackPluginOptions as U, SortableTicketInput as Ua, RatingOptions as Ui, createFallbackHydration as Un, PinnedRegion as Uo, DatePluginOptions as Ur, SingleContext as Us, NotificationTicket as Ut, StackContextOptions as V, SortableOptions as Va, RatingItemDescriptor as Vi, HydrationOptions as Vn, GridColumnDef as Vo, DateContextOptions as Vr, createBreadcrumbsContext as Vs, NotificationInput as Vt, StackTicket as W, createSortable as Wa, createRating as Wi, createHydration as Wn, ResolvedColumn as Wo, createDate as Wr, SingleContextOptions as Ws, NotificationsAdapterContext as Wt, RtlContext as X, FormContextOptions as Xa, QueueTicket as Xi, UseHotkeyReturn as Xn, ContextKey as Xo, ClickOutsideTarget as Xr, useSingle as Xs, createNotificationsPlugin as Xt, useStack as Y, FormContext as Ya, QueueOptions as Yi, UseHotkeyOptions as Yn, EditableColumn as Yo, ClickOutsideIgnoreTarget as Yr, createSingleContext as Ys, createNotificationsContext as Yt, RtlContextOptions as Z, FormOptions as Za, QueueTicketInput as Zi, useHotkey as Zn, CreateContextOptions as Zo, UseClickOutsideOptions as Zr, OverflowContext as Zs, useNotifications as Zt, ThemeContextOptions as _, NumericOptions as _a, ModelTicket as _c, ScrollToOptions as _i, LogLevel as _n, createRules as _o, DragType as _r, PopoverReturn as _s, useResizeObserver as _t, createTooltipContext as a, ProgressTicketInput as aa, UseImageReturn as ac, createBreakpoints as ai, useMediaQuery as an, useForm as ao, createFeaturesContext as ar, useCombobox as as, V0RtlAdapter as at, ThemeRecord as b, createNestedContext as ba, VirtualContextOptions as bi, LocaleOptions as bn, createRulesPlugin as bo, DraggableTicketInput as br, StepContextOptions as bs, ProxyRegistryContext as bt, useTooltip as c, useProgress as ca, SelectionContextOptions as cc, useBreakpoints as ci, usePrefersReducedMotion as cn, ValidationTicket as co, CleanupFunction as cr, ClientComboboxAdapterOptions as cs, RovingFocusOptions as ct, TimerContext as d, OtpPattern as da, SelectionTicketInput as dc, MatchRange as di, LoggerOptions as dn, RuleAlias as do, useEventListener as dr, ComboboxAdapterResult as ds, useRovingFocus as dt, useQueue as ea, createOverflow as ec, BreakpointName as ei, ObservableNodeList as en, FormValidationResult as eo, FeatureOptions as er, useContext as es, createRtl as et, TimerOptions as f, createOtp as fa, createSelection as fc, ToHighlightOptions as fi, LoggerPluginOptions as fn, RuleAliases as fo, useWindowEventListener as fr, VirtualFocusItem as fs, ResizeObserverEntry as ft, ThemeContext as g, NumericContext as ga, ModelOptions as gc, toArray as gi, useLogger as gn, RulesOptions as go, DragDropPlugin as gr, PopoverOptions as gs, useElementSize as gt, ThemeColors as h, createNumberField as ha, ModelContext as hc, toElement as hi, createLoggerPlugin as hn, RulesContextOptions as ho, DragDropOptions as hr, useVirtualFocus as hs, UseResizeObserverReturn as ht, TooltipPluginOptions as i, ProgressTicket as ia, UseImageOptions as ic, BreakpointsPluginOptions as ii, MediaQueryContext as in, createFormContext as io, createFeatures as ir, createComboboxContext as is, useRtl as it, ThemeAdapter as j, KanbanColumnTicket as ja, TimelineTicket as ji, LazyOptions as jn, DataGridColumnTicketInput as jo, PointerAdapter as jr, GroupTicketInput as js, PermissionContextOptions as jt, V0StyleSheetThemeAdapter as k, NestedTicket as ka, TimelineContextOptions as ki, useLocale as kn, DataGridColumn as ko, KeyboardAdapter as kr, GroupOptions as ks, usePresence as kt, ToggleScopeControls as l, OtpContext as la, SelectionOptions as lc, toReactive as li, LoggerContext as ln, ValidationTicketInput as lo, EventHandler as lr, ComboboxAdapter as ls, RovingFocusReturn as lt, Colors as m, NumberFieldOptions as ma, useSelection as mc, MaybeElementRef as mi, createLoggerContext as mn, RulesContext as mo, DragDropContext as mr, VirtualFocusReturn as ms, UseElementSizeReturn as mt, TooltipContextOptions as n, ProgressContextOptions as na, useOverflow as nc, BreakpointsContextOptions as ni, UseMutationObserverReturn as nn, FormValue as no, FeatureTicket as nr, ComboboxOptions as ns, createRtlFallback as nt, createTooltipFallback as o, createProgress as oa, useImage as oc, createBreakpointsContext as oi, usePrefersContrast as on, ValidationContext as oo, createFeaturesPlugin as or, ServerComboboxAdapter as os, RtlAdapter as ot, useTimer as p, NumberFieldContext as pa, createSelectionContext as pc, toHighlight as pi, createLogger as pn, RuleInput as po, ActiveDrag as pr, VirtualFocusOptions as ps, ResizeObserverOptions as pt, createStackContext as q, InputState as qa, QueueContext as qi, useHydration as qn, CellEditingOptions as qo, useDate as qr, SingleTicketInput as qs, NotificationsPluginOptions as qt, TooltipOptions as r, ProgressOptions as ra, ImageStatus as rc, BreakpointsOptions as ri, useMutationObserver as rn, createForm as ro, FeatureTicketInput as rr, createCombobox as rs, createRtlPlugin as rt, createTooltipPlugin as s, createProgressContext as sa, SelectionContext as sc, createBreakpointsPlugin as si, usePrefersDark as sn, ValidationOptions as so, useFeatures as sr, ClientComboboxAdapter as ss, RtlAdapterSetupContext as st, TooltipContext as t, ProgressContext as ta, createOverflowContext as tc, BreakpointsContext as ti, UseMutationObserverOptions as tn, FormValidationRule as to, FeaturePluginOptions as tr, ComboboxContext as ts, createRtlContext as tt, useToggleScope as u, OtpOptions as ua, SelectionTicket as uc, HighlightChunk as ui, LoggerContextOptions as un, createValidation as uo, useDocumentEventListener as ur, ComboboxAdapterContext as us, RovingItem as ut, ThemeOptions as v, createNumeric as va, ModelTicketInput as vc, VirtualAnchor as vi, LocaleContext as vn, createRulesContext as vo, DragVia as vr, usePopover as vs, UseRafReturn as vt, createThemeContext as w, NestedContextOptions as wa, VirtualState as wi, LocaleTicketInput as wn, Plugin as wo, DropZoneTicket as wr, createStep as ws, ProxyModelTarget as wt, ThemeTicket as x, useNested as xa, VirtualDirection as xi, LocalePluginOptions as xn, useRules as xo, DraggablesContext as xr, StepOptions as xs, ProxyRegistryOptions as xt, ThemePluginOptions as y, createNested as ya, createModel as yc, VirtualContext as yi, LocaleContextOptions as yn, createRulesFallback as yo, DraggableTicket as yr, StepContext as ys, useRaf as yt, useStorage as z, SortableEventListener as za, RatingContext as zi, HydrationContext as zn, SpanEntry as zo, useDelay as zr, BreadcrumbsOptions as zs, V0PermissionsAdapter as zt };