@vuetify/v0 1.0.0-alpha.5 → 1.0.0-beta.1

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

@@ -1,14 +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 { a as RegistryEventName, c as RegistryTicketInput, o as RegistryOptions, r as RegistryEventCallback, s as RegistryTicket, t as RegistryContext } from "./index-C0ewabdY.mjs";
+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 { c as TokenTicket, i as TokenContext, o as TokenOptions, r as TokenCollection } from "./index-C_t6t0Z-.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-CspReV3g.mjs";
-import { t as LocaleAdapter } from "./adapter-DDJHLC8K.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, ShallowRef, UnwrapNestedRefs, WatchSource, WritableComputedRef } from "vue";
+import { App, ComponentPublicInstance, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, Reactive, Ref, ShallowReactive, ShallowRef, UnwrapNestedRefs, WatchSource, WritableComputedRef } from "vue";
 
 //#region src/composables/createModel/index.d.ts
 /**
@@ -630,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.
@@ -1071,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.
@@ -1397,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) */
@@ -1701,6 +1709,368 @@ declare function provideContext<Z>(key: ContextKey<Z>, context: Z, app?: App): Z
 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
+ * const grid = createDataGrid<Product>({
+ *   editing: { onEdit (row, column, value, item) { persist(item.id, column, value) } },
+ *   rowSpanning: (item, column) => column === 'group' ? 3 : 1,
+ *   preserveRowOrder: true,
+ * })
+ * ```
+ */
+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;
+}
+/**
+ * The reactive grid instance returned by {@link createDataGrid}. Spreads the
+ * inherited {@link DataTableContext} surface and adds `layout`, `rows`,
+ * `editing`, and `spans`.
+ *
+ * @template T Row value type.
+ *
+ * @example
+ * ```ts
+ * const grid = createDataGrid<Product>()
+ *
+ * grid.layout.pin('name', 'left')
+ * grid.rows.move(id, 0)
+ * grid.editing.edit(1, 'email')
+ * grid.spans.value.get(id)?.get('group')
+ * ```
+ */
+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;
+}
+/**
+ * Creates a data grid instance with layout, editing, row ordering, and spanning
+ * layered on top of the createDataTable pipeline.
+ *
+ * Rows live on the inherited registry surface — register them with
+ * `grid.onboard(rows.map(value => ({ id: value.id, value })))` or
+ * `grid.register({ id, value })`.
+ *
+ * @param options Data grid options
+ * @returns Data grid context
+ *
+ * @example
+ * ```ts
+ * const grid = createDataGrid({ pagination: { initial: 1 } })
+ *
+ * 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 createDataGrid<T extends Record<string, unknown>>(_options?: DataGridOptions<T>): DataGridContext<T>;
+/**
+ * Creates a data grid context with dependency injection support.
+ *
+ * @param options Data grid context options including namespace
+ * @returns A trinity tuple: [useDataGridContext, provideDataGridContext, defaultContext]
+ *
+ * @example
+ * ```ts
+ * const [useDataGrid, provideDataGrid, grid] = createDataGridContext({
+ *   namespace: 'v0:projects',
+ * })
+ *
+ * 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
+ * const grid = useDataGrid<Project>()
+ *
+ * grid.layout.pin('id', 'left')
+ * grid.rows.reset()
+ * ```
+ */
+declare function useDataGrid<T extends Record<string, unknown>>(namespace?: string): DataGridContext<T>;
+//#endregion
 //#region src/composables/createPlugin/index.d.ts
 interface PluginOptions {
   namespace: string;
@@ -6224,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 {
@@ -7574,4 +7969,133 @@ interface ToggleScopeControls {
  */
 declare function useToggleScope(source: WatchSource<boolean>, fn: (() => void) | ((controls: ToggleScopeControls) => void)): ToggleScopeControls;
 //#endregion
-export { RtlAdapterSetupContext as $, ValidationOptions as $a, createProgressContext as $i, useFeatures as $n, OverflowContextOptions as $o, createBreakpointsPlugin as $r, usePrefersDark as $t, createStoragePlugin as A, SortableContext as Aa, createSlider as Ai, useIntersectionObserver as An, useCombobox as Ao, UseDelayStartOptions as Ar, UseImageReturn as As, usePermissions as At, createStackPlugin as B, createInput as Ba, QueueContextOptions as Bi, PlatformContext as Bn, useVirtualFocus as Bo, ClickOutsideElement as Br, ModelContext as Bs, createNotifications as Bt, ThemeAdapter as C, KanbanColumnTicket as Ca, TimelineTicket as Ci, LazyOptions as Cn, createContext as Co, PointerAdapter as Cr, SingleTicket as Cs, PermissionContextOptions as Ct, StoragePluginOptions as D, KanbanOptions as Da, SliderContext as Di, UseElementIntersectionReturn as Dn, ComboboxOptions as Do, DragDropAdapterEmit as Dr, useSingle as Ds, createPermissions as Dt, StorageOptions as E, KanbanEventListener as Ea, useTimeline as Ei, IntersectionObserverOptions as En, ComboboxContext as Eo, DragDropAdapterContext as Er, createSingleContext as Es, PermissionTicket as Et, StackPluginOptions as F, SortableTicketInput as Fa, RatingOptions as Fi, createFallbackHydration as Fn, ComboboxAdapterContext as Fo, DatePluginOptions as Fr, SelectionTicket as Fs, NotificationTicket as Ft, RtlPluginOptions as G, FormTicketInput as Ga, createQueueContext as Gi, FeatureContextOptions as Gn, StepContextOptions as Go, useClickOutside as Gr, MutationObserverRecord as Gt, RtlContext as H, FormContextOptions as Ha, QueueTicket as Hi, UseHotkeyReturn as Hn, PopoverReturn as Ho, ClickOutsideTarget as Hr, ModelTicket as Hs, createNotificationsPlugin as Ht, StackTicket as I, createSortable as Ia, createRating as Ii, createHydration as In, ComboboxAdapterResult as Io, createDate as Ir, SelectionTicketInput as Is, NotificationsAdapterContext as It, createRtlFallback as J, FormValue as Ja, ProgressContextOptions as Ji, FeatureTicket as Jn, StepTicketInput as Jo, BreakpointsContextOptions as Jr, UseMutationObserverReturn as Jt, createRtl as K, FormValidationResult as Ka, useQueue as Ki, FeatureOptions as Kn, StepOptions as Ko, BreakpointName as Kr, ObservableNodeList as Kt, StackTicketInput as L, InputContext as La, createRatingContext as Li, createHydrationContext as Ln, VirtualFocusItem as Lo, createDateContext as Lr, createSelection as Ls, NotificationsContext as Lt, StackContext as M, SortableMovePayload as Ma, RatingContextOptions as Mi, HydrationContextOptions as Mn, ClientComboboxAdapter as Mo, DateContext as Mr, SelectionContext as Ms, PermissionsAdapter as Mt, StackContextOptions as N, SortableOptions as Na, RatingItemDescriptor as Ni, HydrationOptions as Nn, ClientComboboxAdapterOptions as No, DateContextOptions as Nr, SelectionContextOptions as Ns, NotificationInput as Nt, createStorage as O, KanbanTransferPayload as Oa, SliderOptions as Oi, UseIntersectionObserverReturn as On, createCombobox as Oo, UseDelayOptions as Or, ImageStatus as Os, createPermissionsContext as Ot, StackOptions as P, SortableTicket as Pa, RatingItemState as Pi, HydrationPluginOptions as Pn, ComboboxAdapter as Po, DateOptions as Pr, SelectionOptions as Ps, NotificationSeverity as Pt, RtlAdapter as Q, ValidationContext as Qa, createProgress as Qi, createFeaturesPlugin as Qn, OverflowContext as Qo, createBreakpointsContext as Qr, usePrefersContrast as Qt, createStack as R, InputOptions as Ra, useRating as Ri, createHydrationPlugin as Rn, VirtualFocusOptions as Ro, createDatePlugin as Rr, createSelectionContext as Rs, NotificationsOptions as Rt, Vuetify0ThemeOptions as S, NestedTicketInput as Sa, TimelineOptions as Si, LazyContext as Sn, CreateContextOptions as So, KeyboardAdapterOptions as Sr, SingleOptions as Ss, PermissionContext as St, StorageContextOptions as T, KanbanContext as Ta, createTimelineContext as Ti, IntersectionObserverEntry as Tn, useContext as To, DragDropAdapter as Tr, createSingle as Ts, PermissionPluginOptions as Tt, RtlContextOptions as U, FormOptions as Ua, QueueTicketInput as Ui, useHotkey as Un, usePopover as Uo, UseClickOutsideOptions as Ur, ModelTicketInput as Us, useNotifications as Ut, useStack as V, FormContext as Va, QueueOptions as Vi, UseHotkeyOptions as Vn, PopoverOptions as Vo, ClickOutsideIgnoreTarget as Vr, ModelOptions as Vs, createNotificationsContext as Vt, RtlOptions as W, FormTicket as Wa, createQueue as Wi, FeatureContext as Wn, StepContext as Wo, UseClickOutsideReturn as Wr, createModel as Ws, NotificationsAdapter as Wt, useRtl as X, createFormContext as Xa, ProgressTicket as Xi, createFeatures as Xn, createStepContext as Xo, BreakpointsPluginOptions as Xr, MediaQueryContext as Xt, createRtlPlugin as Y, createForm as Ya, ProgressOptions as Yi, FeatureTicketInput as Yn, createStep as Yo, BreakpointsOptions as Yr, useMutationObserver as Yt, V0RtlAdapter as Z, useForm as Za, ProgressTicketInput as Zi, createFeaturesContext as Zn, useStep as Zo, createBreakpoints as Zr, useMediaQuery as Zt, createThemePlugin as _, NestedOpenMode as _a, createVirtual as _i, createLocale as _n, PluginContextConfig as _o, DropZoneTicketInput as _r, createBreadcrumbs as _s, useProxyModel as _t, useTimer as a, NumberFieldContext as aa, toHighlight as ai, createLogger as an, RuleInput as ao, ActiveDrag as ar, GroupContextOptions as as, ResizeObserverOptions as at, V0UnheadThemeOptions as b, NestedSelectionMode as ba, TimelineContext as bi, createLocalePlugin as bn, createPluginContext as bo, useDragDrop as br, SingleContext as bs, UsePresenceReturn as bt, ThemeContext as c, NumericContext as ca, toArray as ci, useLogger as cn, RulesOptions as co, DragDropPlugin as cr, GroupTicketInput as cs, useElementSize as ct, ThemePluginOptions as d, createNested as da, VirtualContext as di, LocaleContextOptions as dn, createRulesFallback as do, DraggableTicket as dr, useGroup as ds, useRaf as dt, useProgress as ea, useBreakpoints as ei, usePrefersReducedMotion as en, ValidationTicket as eo, CleanupFunction as er, OverflowOptions as es, RovingFocusOptions as et, ThemeRecord as f, createNestedContext as fa, VirtualContextOptions as fi, LocaleOptions as fn, createRulesPlugin as fo, DraggableTicketInput as fr, BreadcrumbTicket as fs, ProxyRegistryContext as ft, createThemeContext as g, NestedContextOptions as ga, VirtualState as gi, LocaleTicketInput as gn, Plugin as go, DropZoneTicket as gr, BreadcrumbsOptions as gs, ProxyModelTarget as gt, createTheme as h, NestedContext as ha, VirtualOptions as hi, LocaleTicket as hn, isStandardSchema as ho, DropPosition as hr, BreadcrumbsContextOptions as hs, ProxyModelOptions as ht, TimerOptions as i, createOtp as ia, ToHighlightOptions as ii, LoggerPluginOptions as in, RuleAliases as io, useWindowEventListener as ir, GroupContext as is, ResizeObserverEntry as it, useStorage as j, SortableEventListener as ja, RatingContext as ji, HydrationContext as jn, ServerComboboxAdapter as jo, useDelay as jr, useImage as js, V0PermissionsAdapter as jt, createStorageContext as k, createKanban as ka, SliderTicketInput as ki, useElementIntersection as kn, createComboboxContext as ko, UseDelayReturn as kr, UseImageOptions as ks, createPermissionsPlugin as kt, ThemeContextOptions as l, NumericOptions as la, ScrollToOptions as li, LogLevel as ln, createRules as lo, DragType as lr, createGroup as ls, useResizeObserver as lt, ThemeTicketInput as m, NestedActiveMode as ma, VirtualItem as mi, LocaleRecord as mn, StandardSchemaV1 as mo, DropIndicator as mr, BreadcrumbsContext as ms, useProxyRegistry as mt, useToggleScope as n, OtpOptions as na, HighlightChunk as ni, LoggerContextOptions as nn, createValidation as no, useDocumentEventListener as nr, createOverflowContext as ns, RovingItem as nt, Colors as o, NumberFieldOptions as oa, MaybeElementRef as oi, createLoggerContext as on, RulesContext as oo, DragDropContext as or, GroupOptions as os, UseElementSizeReturn as ot, ThemeTicket as p, useNested as pa, VirtualDirection as pi, LocalePluginOptions as pn, useRules as po, DraggablesContext as pr, BreadcrumbTicketInput as ps, ProxyRegistryOptions as pt, createRtlContext as q, FormValidationRule as qa, ProgressContext as qi, FeaturePluginOptions as qn, StepTicket as qo, BreakpointsContext as qr, UseMutationObserverOptions as qt, TimerContext as r, OtpPattern as ra, MatchRange as ri, LoggerOptions as rn, RuleAlias as ro, useEventListener as rr, useOverflow as rs, useRovingFocus as rt, ThemeColors as s, createNumberField as sa, toElement as si, createLoggerPlugin as sn, RulesContextOptions as so, DragDropOptions as sr, GroupTicket as ss, UseResizeObserverReturn as st, ToggleScopeControls as t, OtpContext as ta, toReactive as ti, LoggerContext as tn, ValidationTicketInput as to, EventHandler as tr, createOverflow as ts, RovingFocusReturn as tt, ThemeOptions as u, createNumeric as ua, VirtualAnchor as ui, LocaleContext as un, createRulesContext as uo, DragVia as ur, createGroupContext as us, UseRafReturn as ut, useTheme as v, NestedOptions as va, createVirtualContext as vi, createLocaleContext as vn, PluginOptions as vo, Orientation as vr, createBreadcrumbsContext as vs, PresenceState as vt, StorageContext as w, KanbanColumnTicketInput as wa, createTimeline as wi, useLazy as wn, provideContext as wo, PointerAdapterOptions as wr, SingleTicketInput as ws, PermissionOptions as wt, V0StyleSheetThemeAdapter as x, NestedTicket as xa, TimelineContextOptions as xi, useLocale as xn, ContextKey as xo, KeyboardAdapter as xr, SingleContextOptions as xs, usePresence as xt, V0UnheadThemeAdapter as y, NestedRegistration as ya, useVirtual as yi, createLocaleFallback as yn, createPlugin as yo, ZonesContext as yr, useBreadcrumbs as ys, UsePresenceOptions as yt, createStackContext as z, InputState as za, QueueContext as zi, useHydration as zn, VirtualFocusReturn as zo, useDate as zr, useSelection as zs, NotificationsPluginOptions as zt };
+//#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 };