@vuetify/v0 0.1.1 → 0.1.3

package/dist/{index-DmNXO254.d.mts → index-2wh69fk5.d.mts}

@@ -1,10 +1,1523 @@
-import { a as ID, o as MaybeArray } from "./index-DlxrzbvZ.mjs";
-import { B as RegistryContext, D as GroupTicket, E as GroupOptions, F as SelectionTicket, M as SelectionContext, O as GroupTicketInput, T as GroupContextOptions, U as RegistryOptions, V as RegistryContextOptions, W as RegistryTicket, d as SingleOptions, f as SingleTicket, l as SingleContext, p as SingleTicketInput, q as ContextTrinity, w as GroupContext } from "./index-qSuLpob3.mjs";
-import { t as DateAdapter } from "./adapter-L4Php1_S.mjs";
+import { i as Extensible, o as ID, s as MaybeArray } from "./index-BLK67J_-.mjs";
+import { t as DateAdapter } from "./adapter-D95FHAtt.mjs";
+import * as vue820 from "vue";
 import { App, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, Reactive, Ref, ShallowRef, UnwrapNestedRefs, WatchSource } from "vue";
 
+//#region src/composables/createTrinity/index.d.ts
+
+type ContextTrinity<Z = unknown> = readonly [() => Z, (context?: Z, app?: App) => Z, Z];
+/**
+ * Creates a new trinity for a context composable and its provider.
+ *
+ * @param useContext The function that retrieves/uses the context (typically named `useContext`).
+ * @param provideContext The function that provides the context to descendants.
+ * @param context The default context instance to use when no custom context is provided.
+ * @template Z The type of the context.
+ * @returns A readonly tuple containing: [useContext function, provideContext wrapper function, default context instance].
+ *
+ * @remarks The trinity pattern is a foundational pattern used throughout the codebase for creating reusable context systems. It provides three related elements:
+ *
+ * 1. A function to retrieve/use the context
+ * 2. A function to provide the context (with default value support)
+ * 3. The default context instance
+ *
+ * The returned tuple is readonly (using `as const`) to ensure proper type inference.
+ *
+ * @see https://0.vuetifyjs.com/composables/foundation/create-trinity#create-trinity
+ *
+ * @example
+ * ```ts
+ * interface MyContext {
+ *   foo: string
+ *   bar: number
+ * }
+ *
+ * export function createMyFeature<E extends MyContext = MyContext>() {
+ *   const [useContext, _provideContext] = createContext<E>('my-context')
+ *
+ *   const context = { foo: 'hello', bar: 42 }
+ *
+ *   function provideContext (_context: E = context, app?: App): E {
+ *     return _provideContext(_context, app)
+ *   }
+ *
+ *   return createTrinity<E>(useContext, provideContext, context)
+ * }
+ * ```
+ */
+declare function createTrinity<Z = unknown>(useContext: () => Z, provideContext: (_context?: Z, app?: App) => Z, context: Z): ContextTrinity<Z>;
+//#endregion
+//#region src/composables/createRegistry/index.d.ts
+interface RegistryTicket<V = unknown> {
+  /** The unique identifier. Is randomly generated if not provided. */
+  id: ID;
+  /**
+   * The index of the ticket in the registry.
+   *
+   * @remarks Automatically managed by the registry. Updated during reindexing. It's not recommended to manually set this.
+   */
+  index: number;
+  /** The value associated with the ticket. If not provided, it defaults to the index. */
+  value: V;
+  /**
+   * Whether the value is derived from index.
+   *
+   * @remarks Set to true when no explicit value is provided during registration. It's not recommended to manually set this.
+   */
+  valueIsIndex: boolean;
+}
+/** Valid event names for registry operations */
+type RegistryEventName = 'register:ticket' | 'unregister:ticket' | 'update:ticket' | 'clear:registry' | 'reindex:registry';
+/** Maps event names to their payload types */
+type RegistryEventMap<Z extends RegistryTicket> = {
+  'register:ticket': Z;
+  'unregister:ticket': Z;
+  'update:ticket': Z;
+  'clear:registry': undefined;
+  'reindex:registry': undefined;
+};
+/** Callback signature for registry event listeners */
+type RegistryEventCallback<Z extends RegistryTicket = RegistryTicket, K$1 extends RegistryEventName = RegistryEventName> = (data: RegistryEventMap<Z>[K$1]) => void;
+/** Resolves callback type: typed for known events, unknown for custom events */
+type EventHandler$1<Z extends RegistryTicket, K$1 extends string> = K$1 extends RegistryEventName ? (data: RegistryEventMap<Z>[K$1]) => void : (data: unknown) => void;
+/** Resolves payload type: typed for known events, unknown for custom events */
+type EventPayload<Z extends RegistryTicket, K$1 extends string> = K$1 extends RegistryEventName ? RegistryEventMap<Z>[K$1] : unknown;
+interface RegistryContext<Z extends RegistryTicket = RegistryTicket> {
+  /**
+   * The collection of tickets in the registry
+   *
+   * @template ID The type of the ticket ID.
+   * @template Z The type of the registry ticket.
+   *
+   * @remarks Read-only view of the internal collection. Use `register`, `unregister`, `upsert`, and `clear` methods to modify.
+   */
+  collection: ReadonlyMap<ID, Z>;
+  /**
+   * Clear the entire registry
+   *
+   * @remarks Removes all tickets from the registry. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#clear
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * console.log(registry.size) // 2
+   *
+   * registry.clear()
+   *
+   * console.log(registry.size) // 0
+   * ```
+   */
+  clear: () => void;
+  /**
+   * Check if a ticket exists by ID
+   *
+   * @param id The ID of the ticket to check.
+   * @remarks Calls `collection.has` internally.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#has
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-id' })
+   *
+   * const exists = registry.has('ticket-id') // true
+   * ```
+   */
+  has: (id: ID) => boolean;
+  /**
+   * Get all registered IDs
+   *
+   * @remarks Calls `collection.keys` internally with caching. First call is O(n), subsequent calls are O(1) until cache invalidation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#keys
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * const ids = registry.keys() // ['ticket-1', 'ticket-2']
+   * ```
+   */
+  keys: () => readonly ID[];
+  /**
+   * Browse for an ID(s) by value
+   *
+   * @param value The value to browse for.
+   * @remarks Returns an array of IDs that share the given value, or undefined if no match is found.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#browse
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-1', value: 'common-value' })
+   * registry.register({ id: 'ticket-2', value: 'common-value' })
+   * registry.register({ id: 'ticket-3', value: 'unique-value' })
+   *
+   * const common = registry.browse('common-value') // ['ticket-1', 'ticket-2']
+   * const unique = registry.browse('unique-value') // ['ticket-3']
+   * ```
+   */
+  browse: (value: Z['value']) => ID[] | undefined;
+  /**
+   * lookup a ticket by index number
+   *
+   * @param index The index number to lookup.
+   * @remarks Maps do not support indexing by default, this method provides a way to retrieve an ID based on its index in the registry.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#lookup
+   *
+   * @example
+   * ```ts
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * const ticket1 = registry.lookup(0) // 'ticket-1'
+   * const ticket2 = registry.lookup(1) // 'ticket-2'
+   * ```
+   */
+  lookup: (index: number) => ID | undefined;
+  /**
+   * Get a ticket by ID
+   *
+   * @param id The ID of the ticket to retrieve.
+   * @remarks Calls `collection.get` internally.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#get
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-id', value: 'some-value' })
+   *
+   * const ticket = registry.get('ticket-id') // { id: 'ticket-id', index: 0, value: 'some-value', ... }
+   * ```
+   */
+  get: (id: ID) => Z | undefined;
+  /**
+   * Update or insert a ticket by ID
+   *
+   * @param id The ID of the ticket to upsert.
+   * @param ticket The partial ticket data to update or insert.
+   * @remarks If the ticket exists, it will be updated with the provided data. If it doesn't exist, a new ticket will be created with the given ID and data. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#upsert
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * // Insert a new ticket
+   * const ticket = registry.upsert('ticket-id', { value: 'initial-value' })
+   *
+   * // Update the existing ticket
+   * const patched = registry.upsert('ticket-id', { value: 'updated-value' })
+   * ```
+  */
+  upsert: (id: ID, ticket?: Partial<Z>) => Z;
+  /**
+   * Get all values of registered tickets
+   *
+   * @remarks Calls `collection.values` internally with caching. First call is O(n), subsequent calls are O(1) until cache invalidation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#values
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-1', value: 'value-1' })
+   * registry.register({ id: 'ticket-2', value: 'value-2' })
+   *
+   * const values = registry.values() // [{ id: 'ticket-1', ... }, { id: 'ticket-2', ... }]
+   * ```
+   */
+  values: () => readonly Z[];
+  /**
+   * Get all entries of registered tickets
+   *
+   * @remarks Calls `collection.entries` internally with caching. First call is O(n), subsequent calls are O(1) until cache invalidation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#entries
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-1', value: 'value-1' })
+   * registry.register({ id: 'ticket-2', value: 'value-2' })
+   *
+   * const entries = registry.entries() // [['ticket-1', { id: 'ticket-1', ... }], ['ticket-2', { id: 'ticket-2', ... }]]
+   * ```
+  */
+  entries: () => readonly [ID, Z][];
+  /**
+   * Register a new ticket
+   *
+   * @param ticket The partial ticket data to register.
+   * @remarks If no ID is provided, a unique ID will be generated automatically. If no value is provided, it defaults to the ticket's index. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#register
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * const ticket = registry.register()
+   *
+   * console.log(ticket) // { id: 'generated-id', index: 0, value: 0, valueIsIndex: true }
+   * ```
+  */
+  register: (ticket?: Partial<Z>) => Z;
+  /**
+   * Unregister a ticket by ID
+   *
+   * @param id The ID of the ticket to unregister.
+   * @remarks Removes the ticket from the registry and reindexes the remaining tickets. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#unregister
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-id' })
+   *
+   * registry.unregister('ticket-id')
+   * ```
+  */
+  unregister: (id: ID) => void;
+  /**
+   * Reset the index directory and update all tickets
+   *
+   * @remarks Rebuilds the internal index mapping and ensures all tickets have correct index values. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#reindex
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * // After some operations that may affect indexing
+   * registry.reindex()
+   * ```
+  */
+  reindex: () => void;
+  /**
+   * Seek for a ticket based on direction and optional predicate
+   *
+   * @param direction The direction to seek ('first' or 'last'). Defaults to 'first'.
+   * @param from The index to start seeking from. Defaults to the beginning or end based on direction.
+   * @param predicate An optional function to test each ticket. The first ticket that satisfies the predicate will be returned.
+   * @remarks This method allows for flexible searching within the registry, either from the start or end, and can filter tickets based on custom criteria.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#seek
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-1', value: 'apple' })
+   * registry.register({ id: 'ticket-2', value: 'banana' })
+   * registry.register({ id: 'ticket-3', value: 'cherry' })
+   *
+   * // Seek the first ticket
+   * const first = registry.seek('first')
+   *
+   * // Seek the last ticket
+   * const last = registry.seek('last')
+   *
+   * // Seek the first ticket with value 'banana'
+   * const banana = registry.seek('first', undefined, ticket => ticket.value === 'banana')
+   *
+   * // Seek from index 1 to find the next ticket with value starting with 'c'
+   * const cherry = registry.seek('first', 1, ticket => (ticket.value as string).startsWith('c'))
+   * ```
+  */
+  seek: (direction?: 'first' | 'last', from?: number, predicate?: (ticket: Z) => boolean) => Z | undefined;
+  /**
+   * Listen for registry events
+   *
+   * @param event The name of the event to listen for.
+   * @param cb The callback function to invoke when the event is emitted.
+   * @remarks Must be enabled via the `events` option when creating the registry.
+   * Supported events:
+   * - `register:ticket` - Emitted when a ticket is registered, receives the ticket as argument
+   * - `unregister:ticket` - Emitted when a ticket is unregistered, receives the ticket as argument
+   * - `update:ticket` - Emitted when a ticket is updated, receives the updated ticket as argument
+   * - `clear:registry` - Emitted when the registry is cleared
+   * - `reindex:registry` - Emitted when the registry is reindexed
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#on
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry({ events: true })
+   *
+   * registry.on('register:ticket', (ticket) => {
+   *   console.log('Ticket registered:', ticket)
+   * })
+   *
+   * registry.register({ id: 'ticket-id' }) // Console: Ticket registered: { id: 'ticket-id', ... }
+   * ```
+  */
+  on: <K$1 extends Extensible<RegistryEventName>>(event: K$1, cb: EventHandler$1<Z, K$1>) => void;
+  /**
+   * Stop listening for registry events
+   *
+   * @param event The name of the event to stop listening for.
+   * @param cb The callback function to remove.
+   * @remarks Must be enabled via the `events` option when creating the registry.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#off
+   *
+   * @example
+   * ```ts
+   * import { onScopeDispose } from 'vue'
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry({ events: true })
+   *
+   * function onRegister(ticket) {
+   *   console.log('Ticket registered:', ticket)
+   * }
+   *
+   * registry.on('register:ticket', onRegister)
+   *
+   * registry.register({ id: 'ticket-id' }) // Console: Ticket registered: { id: 'ticket-id', ... }
+   *
+   * onScopeDispose(() => {
+   *   registry.off('register:ticket', onRegister)
+   * })
+   * ```
+  */
+  off: <K$1 extends Extensible<RegistryEventName>>(event: K$1, cb: EventHandler$1<Z, K$1>) => void;
+  /**
+   * Emit an event with data
+   *
+   * @param event The name of the event to emit.
+   * @param data The data to pass to event listeners.
+   * @remarks Must be enabled via the `events` option when creating the registry.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#emit
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry({ events: true })
+   *
+   * registry.on('custom-event', (data) => {
+   *   console.log('Custom event received:', data)
+   * })
+   *
+   * registry.emit('custom-event', { message: 'Hello, World!' }) // Console: Custom event received: { message: 'Hello, World!' }
+   * ```
+  */
+  emit: <K$1 extends Extensible<RegistryEventName>>(event: K$1, data: EventPayload<Z, K$1>) => void;
+  /**
+   * Clears the registry and removes all listeners
+   *
+   * @remarks Disposes of the registry by clearing all tickets and removing all event listeners.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#dispose
+   *
+   * @example
+   * ```ts
+   * import { onScopeDispose } from 'vue'
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry({ events: true })
+   *
+   * registry.register({ id: 'ticket-id' })
+   *
+   * onScopeDispose(() => {
+   *   registry.dispose()
+   * })
+   * ```
+  */
+  dispose: () => void;
+  /**
+   * Onboard multiple tickets at once
+   *
+   * @param registrations An array of partial ticket data to register.
+   * @remarks Registers multiple tickets in a single operation and returns the array of registered tickets.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#onboard
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * const tickets = registry.onboard([
+   *   { id: 'ticket-1', value: 'value-1' },
+   *   { id: 'ticket-2', value: 'value-2' },
+   * ])
+   *
+   * console.log(tickets) // [{ id: 'ticket-1', ... }, { id: 'ticket-2', ... }]
+   * ```
+  */
+  onboard: (registrations: Partial<Z>[]) => Z[];
+  /**
+   * Offboard multiple tickets at once
+   *
+   * @param ids An array of ticket IDs to unregister.
+   * @remarks Unregisters multiple tickets in a single operation with optimized reindexing.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#offboard
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.onboard([
+   *   { id: 'ticket-1', value: 'value-1' },
+   *   { id: 'ticket-2', value: 'value-2' },
+   *   { id: 'ticket-3', value: 'value-3' },
+   * ])
+   *
+   * registry.offboard(['ticket-1', 'ticket-3'])
+   *
+   * console.log(registry.size) // 1
+   * ```
+  */
+  offboard: (ids: ID[]) => void;
+  /**
+   * The number of tickets in the registry
+   *
+   * @remarks Reflects the current size of the internal ticket collection.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#size
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * console.log(registry.size) // 2
+   * ```
+  */
+  size: number;
+  /**
+   * Execute operations in a batch, deferring cache invalidation and event emission until complete
+   *
+   * @param fn The function containing batch operations.
+   * @returns The return value of the batch function.
+   * @remarks Useful for bulk operations like onboard(). Invalidation and events happen once at the end, not after each operation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#batch
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry({ events: true })
+   *
+   * // Without batch: N invalidations + N events
+   * // With batch: 1 invalidation + N events (after all registrations)
+   * const tickets = registry.batch(() => {
+   *   return [
+   *     registry.register({ id: 'a' }),
+   *     registry.register({ id: 'b' }),
+   *     registry.register({ id: 'c' }),
+   *   ]
+   * })
+   * ```
+  */
+  batch: <R>(fn: () => R) => R;
+}
+interface RegistryOptions {
+  /**
+   * Enable event emission for registry operations
+   *
+   * @default false
+   * @remarks When enabled, the registry will emit events for operations like registration and unregistration. Listeners can be added using the `on` method.
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry({ events: true })
+   *
+   * registry.on('register:ticket', (ticket) => {
+   *   console.log('Ticket registered:', ticket)
+   * })
+   *
+   * registry.register({ id: 'ticket-id' }) // Console: Ticket registered: { id: 'ticket-id', ... }
+   * ```
+  */
+  events?: boolean;
+  /**
+   * Enable reactive behavior for registry operations
+   *
+   * @default false
+   * @remarks When enabled, the registry will use Vue's shallowReactive to track changes. This is useful for scenarios where you want to reactively update the registry state in response to changes.
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry({ reactive: true })
+   *
+   * registry.register({ id: 'ticket-id' })
+   *
+   * console.log(registry.size) // 1
+   * ```
+  */
+  reactive?: boolean;
+}
+interface RegistryContextOptions extends RegistryOptions {
+  namespace?: string;
+}
+/**
+ * Creates a new registry instance.
+ *
+ * @param options The options for the registry instance.
+ * @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
+ * @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
+ * @returns A new registry instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/create-registry#create-registry
+ *
+ * @example
+ * ```ts
+ * import { createRegistry } from '@vuetify/v0'
+ *
+ * const registry = createRegistry()
+ *
+ * const ticket1 = registry.register({ id: 'user-1', value: { name: 'John' } })
+ * const ticket2 = registry.register({ id: 'user-2', value: { name: 'Jane' } })
+ *
+ * console.log(registry.size) // 2
+ * console.log(registry.get('user-1')) // { id: 'user-1', index: 0, value: { name: 'John' }, ... }
+ * ```
+ */
+declare function createRegistry<Z extends RegistryTicket = RegistryTicket, E extends RegistryContext<Z> = RegistryContext<Z>>(options?: RegistryOptions): E;
+/**
+ * Creates a new registry context.
+ *
+ * @param options The options for the registry context, including `namespace` (defaults to `'v0:registry'`) and `events`.
+ * @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
+ * @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
+ * @returns A new registry context.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/create-registry#create-registry-context
+ *
+ * @example
+ * ```ts
+ * import { createRegistryContext } from '@vuetify/v0'
+ *
+ * // With default namespace 'v0:registry'
+ * export const [useItems, provideItems, items] = createRegistryContext()
+ *
+ * // Or with custom namespace
+ * export const [useItems, provideItems, items] = createRegistryContext({ namespace: 'my-items' })
+ *
+ * // In a parent component:
+ * provideItems()
+ *
+ * // In a child component:
+ * const items = useItems()
+ * items.register({ id: 'item-1', value: 'Value 1' })
+ * ```
+ */
+declare function createRegistryContext<Z extends RegistryTicket = RegistryTicket, E extends RegistryContext<Z> = RegistryContext<Z>>(_options?: RegistryContextOptions): ContextTrinity<E>;
+/**
+ * Uses an existing registry from context.
+ *
+ * @param namespace The namespace for the registry context. Defaults to `'v0:registry'`.
+ * @template Z The type of registry ticket that extends RegistryTicket.
+ * @template E The type of registry context that extends RegistryContext<Z>.
+ * @returns The registry instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/create-registry#use-registry
+ *
+ * @example
+ * ```ts
+ * import { useRegistry } from '@vuetify/v0'
+ *
+ * // In a child component (after provideRegistry was called by an ancestor):
+ * const registry = useRegistry()
+ *
+ * registry.register({ id: 'item-1', value: 'Value 1' })
+ * ```
+ */
+declare function useRegistry<Z extends RegistryTicket = RegistryTicket, E extends RegistryContext<Z> = RegistryContext<Z>>(namespace?: string): E;
+//#endregion
+//#region src/composables/createSelection/index.d.ts
+/**
+ * Input type for selection tickets - what users provide to register().
+ * Custom ticket types should extend this interface.
+ *
+ * @template V The type of the ticket value.
+ *
+ * @example
+ * ```ts
+ * interface MyTicket extends SelectionTicketInput {
+ *   label: string
+ *   disabled?: boolean
+ *   metadata?: Record<string, unknown>
+ * }
+ *
+ * const selection = createSelection<MyTicket>()
+ * selection.register({ label: 'Item 1' })
+ * ```
+ */
+interface SelectionTicketInput<V = unknown> extends RegistryTicket<V> {
+  /** Disabled state of the ticket (optional on input, defaults to false) */
+  disabled?: MaybeRef<boolean>;
+}
+/**
+ * Output type for selection tickets - what users receive from get().
+ * Includes registry-added methods for self-selection.
+ *
+ * @template Z The input ticket type that extends SelectionTicketInput.
+ *
+ * @remarks
+ * The following properties are automatically added by the registry:
+ * - `disabled` - Defaults to `false` if not provided
+ * - `isSelected` - Reactive boolean indicating selection state
+ * - `select()` - Method to select this ticket
+ * - `unselect()` - Method to unselect this ticket
+ * - `toggle()` - Method to toggle selection state
+ */
+type SelectionTicket<Z extends SelectionTicketInput = SelectionTicketInput> = Z & {
+  /** Disabled state of the ticket (guaranteed to exist on output) */
+  disabled: MaybeRef<boolean>;
+  /** Whether the ticket is currently selected */
+  isSelected: Readonly<Ref<boolean, boolean>>;
+  /** Select self */
+  select: () => void;
+  /** Unselect self */
+  unselect: () => void;
+  /** Toggle self on and off */
+  toggle: () => void;
+};
+/**
+ * Context returned by createSelection.
+ *
+ * @template Z The input ticket type (what users provide to register).
+ * @template E The output ticket type (what users receive from get). Defaults to SelectionTicket<Z>.
+ */
+interface SelectionContext<Z extends SelectionTicketInput = SelectionTicketInput, E extends SelectionTicket<Z> = SelectionTicket<Z>> extends Omit<RegistryContext<E>, 'register' | 'onboard'> {
+  /** Set of selected ticket IDs */
+  selectedIds: Reactive<Set<ID>>;
+  /** Set of selected ticket instances */
+  selectedItems: ComputedRef<Set<E>>;
+  /** Set of selected ticket values */
+  selectedValues: ComputedRef<Set<unknown>>;
+  /** Disable state for the entire selection instance */
+  disabled: MaybeRef<boolean>;
+  /** Clear all selected IDs and reindexes */
+  reset: () => void;
+  /** Select a ticket by ID (Toggle ON) */
+  select: (id: ID) => void;
+  /** Unselect a ticket by ID (Toggle OFF) */
+  unselect: (id: ID) => void;
+  /** Toggles a ticket ON and OFF by ID */
+  toggle: (id: ID) => void;
+  /** Check if a ticket is selected by ID */
+  selected: (id: ID) => boolean;
+  /** Mandates selected ID based on "mandatory" Option */
+  mandate: () => void;
+  /** Register a new ticket (accepts input type, returns output type) */
+  register: (ticket?: Partial<Z>) => E;
+  /** Onboard multiple tickets at once */
+  onboard: (registrations: Partial<Z>[]) => E[];
+}
+interface SelectionOptions extends RegistryOptions {
+  /** When true, the entire selection instance is disabled. */
+  disabled?: MaybeRefOrGetter<boolean>;
+  /**
+   * When true, newly registered items are automatically selected if not disabled.
+   * Useful for pre-selecting items in multi-select scenarios.
+   */
+  enroll?: MaybeRefOrGetter<boolean>;
+  /**
+   * Controls mandatory selection behavior:
+   * - `false` (default): No mandatory selection enforcement
+   * - `true`: Prevents deselecting the last selected item (user must always have one selected)
+   * - `'force'`: Automatically selects the first non-disabled item on registration
+   */
+  mandatory?: MaybeRefOrGetter<boolean | 'force'>;
+  /** When true, treats the selection as an array */
+  multiple?: MaybeRefOrGetter<boolean>;
+}
+interface SelectionContextOptions extends SelectionOptions {
+  namespace?: string;
+}
+/**
+ * Creates a new selection instance for managing multiple selected items.
+ *
+ * Extends `useRegistry` with selection tracking via a reactive `Set` of selected IDs.
+ * Supports disabled items, mandatory selection enforcement, and auto-enrollment.
+ *
+ * @param options The options for the selection instance.
+ * @template Z The input ticket type - what users provide to register(). Extend SelectionTicketInput to add custom properties.
+ * @template E The output ticket type - what users receive from get(). Automatically includes selection methods.
+ * @template R The context type. Defaults to SelectionContext<Z, E>.
+ * @returns A new selection instance with selection management methods.
+ *
+ * @remarks
+ * **Key Features:**
+ * - Multi-selection support (unlike `useSingle` which enforces single selection)
+ * - Set-based `selectedIds` tracking for efficient lookups
+ * - Computed `selectedItems` and `selectedValues` for reactive access
+ * - Each ticket gets `isSelected`, `select()`, `unselect()`, and `toggle()` methods
+ * - Disabled items cannot be selected
+ * - Mandatory mode prevents deselecting the last item
+ * - Force mode auto-selects first non-disabled item on registration
+ * - Enroll option auto-selects all non-disabled items on registration
+ *
+ * **Inheritance Chain:**
+ * `useRegistry` → `createSelection` → `createSingle`/`createGroup` → `createStep`
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-selection
+ *
+ * @example
+ * ```ts
+ * import { createSelection } from '@vuetify/v0'
+ *
+ * // Basic usage
+ * const selection = createSelection({ mandatory: true })
+ *
+ * selection.onboard([
+ *   { id: 'item-1', value: 'Item 1' },
+ *   { id: 'item-2', value: 'Item 2', disabled: true },
+ *   { id: 'item-3', value: 'Item 3' },
+ * ])
+ *
+ * selection.select('item-1')
+ * selection.select('item-3')
+ *
+ * console.log(selection.selectedIds) // Set { 'item-1', 'item-3' }
+ * console.log(Array.from(selection.selectedValues.value)) // ['Item 1', 'Item 3']
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With custom ticket type
+ * interface MyTicket extends SelectionTicketInput {
+ *   label: string
+ *   icon?: string
+ * }
+ *
+ * const tabs = createSelection<MyTicket>()
+ *
+ * tabs.register({ label: 'Home', icon: 'mdi-home' })
+ * tabs.register({ label: 'Settings' })
+ *
+ * const ticket = tabs.get('...')
+ * // ticket has: label, icon, isSelected, select(), unselect(), toggle()
+ * ```
+ */
+declare function createSelection<Z extends SelectionTicketInput = SelectionTicketInput, E extends SelectionTicket<Z> = SelectionTicket<Z>, R extends SelectionContext<Z, E> = SelectionContext<Z, E>>(_options?: SelectionOptions): R;
+/**
+ * Creates a new selection context.
+ *
+ * @param options The options for the selection context.
+ * @template Z The input ticket type - what users provide to register().
+ * @template E The output ticket type - what users receive from get().
+ * @template R The context type. Defaults to SelectionContext<Z, E>.
+ * @returns A new selection context.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-selection
+ *
+ * @example
+ * ```ts
+ * import { createSelectionContext } from '@vuetify/v0'
+ *
+ * // With default namespace 'v0:selection'
+ * export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext()
+ *
+ * // Or with custom namespace
+ * export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext({ namespace: 'checkboxes' })
+ *
+ * // In a parent component:
+ * provideCheckboxes()
+ *
+ * // In a child component:
+ * const checkboxes = useCheckboxes()
+ * checkboxes.select('checkbox-1')
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With custom ticket type
+ * interface TabTicket extends SelectionTicketInput {
+ *   label: string
+ *   icon?: string
+ * }
+ *
+ * export const [useTabs, provideTabs, tabs] = createSelectionContext<TabTicket>()
+ * ```
+ */
+declare function createSelectionContext<Z extends SelectionTicketInput = SelectionTicketInput, E extends SelectionTicket<Z> = SelectionTicket<Z>, R extends SelectionContext<Z, E> = SelectionContext<Z, E>>(_options?: SelectionContextOptions): ContextTrinity<R>;
+/**
+ * Returns the current selection instance.
+ *
+ * @param namespace The namespace for the selection context. Defaults to `'v0:selection'`.
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ * @template R The context type.
+ * @returns The current selection instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-selection
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useSelection } from '@vuetify/v0'
+ *
+ *   const selection = useSelection()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Selected: {{ selection.selectedIds.size }}</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useSelection<Z extends SelectionTicketInput = SelectionTicketInput, E extends SelectionTicket<Z> = SelectionTicket<Z>, R extends SelectionContext<Z, E> = SelectionContext<Z, E>>(namespace?: string): R;
+//#endregion
+//#region src/composables/createSingle/index.d.ts
+/**
+ * Input type for single selection tickets.
+ * Extend this interface to add custom properties.
+ */
+interface SingleTicketInput<V = unknown> extends SelectionTicketInput<V> {}
+/**
+ * Output type for single selection tickets.
+ * Includes all input properties plus selection methods.
+ */
+type SingleTicket<Z extends SingleTicketInput = SingleTicketInput> = SelectionTicket<Z>;
+/**
+ * Context returned by createSingle.
+ *
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ */
+interface SingleContext<Z extends SingleTicketInput = SingleTicketInput, E extends SingleTicket<Z> = SingleTicket<Z>> extends Omit<SelectionContext<Z, E>, 'register' | 'onboard'> {
+  selectedId: ComputedRef<ID | undefined>;
+  selectedIndex: ComputedRef<number>;
+  selectedItem: ComputedRef<E | undefined>;
+  selectedValue: ComputedRef<E['value'] | undefined>;
+  /** Register a new ticket (accepts input type, returns output type) */
+  register: (ticket?: Partial<Z>) => E;
+  /** Onboard multiple tickets at once */
+  onboard: (registrations: Partial<Z>[]) => E[];
+}
+interface SingleOptions extends SelectionOptions {}
+interface SingleContextOptions extends SelectionContextOptions {}
+/**
+ * Creates a new single selection instance that enforces only one selected item at a time.
+ *
+ * Extends `createSelection` by automatically clearing previous selections when a new item is selected.
+ * Adds computed singular properties: `selectedId`, `selectedItem`, `selectedIndex`, `selectedValue`.
+ *
+ * @param options The options for the single selection instance.
+ * @template Z The input ticket type - what users provide to register().
+ * @template E The output ticket type - what users receive from get().
+ * @template R The context type.
+ * @returns A new single selection instance with single-selection enforcement.
+ *
+ * @remarks
+ * **Key Differences from `createSelection`:**
+ * - Automatically clears `selectedIds` before selecting a new item (enforces single selection)
+ * - Provides singular computed properties instead of plural sets
+ * - Perfect for tabs, radio buttons, theme selectors, and other single-choice UI components
+ *
+ * **Computed Properties:**
+ * - `selectedId`: The ID of the selected item (undefined if none selected)
+ * - `selectedItem`: The selected ticket object (undefined if none selected)
+ * - `selectedIndex`: The index of the selected item (-1 if none selected)
+ * - `selectedValue`: The value of the selected item (undefined if none selected)
+ *
+ * **Inheritance Chain:**
+ * `useRegistry` → `createSelection` → `createSingle` → `createStep`
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-single
+ *
+ * @example
+ * ```ts
+ * import { createSingle } from '@vuetify/v0'
+ *
+ * const tabs = createSingle({ mandatory: true })
+ *
+ * tabs.onboard([
+ *   { id: 'home', value: 'Home' },
+ *   { id: 'about', value: 'About' },
+ *   { id: 'contact', value: 'Contact' },
+ * ])
+ *
+ * tabs.first() // Select first tab
+ *
+ * console.log(tabs.selectedId.value) // 'home'
+ * console.log(tabs.selectedIndex.value) // 0
+ *
+ * tabs.select('about') // Switch to about tab
+ * console.log(tabs.selectedId.value) // 'about'
+ * console.log(tabs.selectedIds.size) // 1 (always enforces single selection)
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With custom ticket type
+ * interface TabTicket extends SingleTicketInput {
+ *   label: string
+ *   icon?: string
+ * }
+ *
+ * const tabs = createSingle<TabTicket>()
+ * tabs.register({ label: 'Home', icon: 'mdi-home' })
+ * ```
+ */
+declare function createSingle<Z extends SingleTicketInput = SingleTicketInput, E extends SingleTicket<Z> = SingleTicket<Z>, R extends SingleContext<Z, E> = SingleContext<Z, E>>(_options?: SingleOptions): R;
+/**
+ * Creates a new single selection context.
+ *
+ * @param options The options for the single selection context.
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ * @template R The context type.
+ * @returns A new single selection context.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-single
+ *
+ * @example
+ * ```ts
+ * import { createSingleContext } from '@vuetify/v0'
+ *
+ * // With default namespace 'v0:single'
+ * export const [useSingle, provideSingle, context] = createSingleContext()
+ *
+ * // In a parent component:
+ * provideSingle()
+ *
+ * // In a child component:
+ * const single = useSingle()
+ * single.select('tab-1')
+ * ```
+ */
+declare function createSingleContext<Z extends SingleTicketInput = SingleTicketInput, E extends SingleTicket<Z> = SingleTicket<Z>, R extends SingleContext<Z, E> = SingleContext<Z, E>>(_options?: SingleContextOptions): ContextTrinity<R>;
+/**
+ * Returns the current single selection instance.
+ *
+ * @param namespace The namespace for the single selection context. Defaults to `'v0:single'`.
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ * @template R The context type.
+ * @returns The current single selection instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-single
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useSingle } from '@vuetify/v0'
+ *
+ *   const tabs = useSingle()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Selected: {{ tabs.selectedId }}</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useSingle<Z extends SingleTicketInput = SingleTicketInput, E extends SingleTicket<Z> = SingleTicket<Z>, R extends SingleContext<Z, E> = SingleContext<Z, E>>(namespace?: string): R;
+//#endregion
+//#region src/composables/createBreadcrumbs/index.d.ts
+/**
+ * Input type for breadcrumb tickets.
+ */
+interface BreadcrumbTicketInput<V = unknown> extends SingleTicketInput<V> {
+  /** Display text for the breadcrumb */
+  text: string;
+}
+/**
+ * Output type for breadcrumb tickets.
+ */
+type BreadcrumbTicket<Z extends BreadcrumbTicketInput = BreadcrumbTicketInput> = SingleTicket<Z>;
+/**
+ * Context returned by createBreadcrumbs.
+ */
+interface BreadcrumbsContext<Z extends BreadcrumbTicketInput = BreadcrumbTicketInput, E extends BreadcrumbTicket<Z> = BreadcrumbTicket<Z>> extends Omit<SingleContext<Z, E>, 'select'> {
+  /** Number of items in the path */
+  depth: Readonly<Ref<number>>;
+  /** Whether at root level (depth <= 1) */
+  isRoot: Readonly<Ref<boolean>>;
+  /** Whether path is empty (depth === 0) */
+  isEmpty: Readonly<Ref<boolean>>;
+  /** Navigate to root (first item) */
+  first: () => void;
+  /** Navigate up one level (remove last item) */
+  prev: () => void;
+  /** Navigate to specific item by id (truncates path) */
+  select: (id: ID) => void;
+}
+interface BreadcrumbsOptions extends SingleOptions {}
+interface BreadcrumbsContextOptions extends SingleContextOptions {}
+/**
+ * Creates a breadcrumbs navigation model.
+ *
+ * @param options The options for the breadcrumbs instance.
+ * @returns A breadcrumbs context with navigation methods.
+ *
+ * @example
+ * ```ts
+ * import { createBreadcrumbs } from '@vuetify/v0'
+ *
+ * const breadcrumbs = createBreadcrumbs()
+ *
+ * breadcrumbs.register({ text: 'Home' })
+ * breadcrumbs.register({ text: 'Products' })
+ * breadcrumbs.register({ text: 'Electronics' })
+ *
+ * // Navigate back
+ * breadcrumbs.prev() // removes Electronics
+ * breadcrumbs.first() // truncates to Home
+ *
+ * // Derived state
+ * breadcrumbs.depth.value // 1
+ * breadcrumbs.isRoot.value // true
+ * ```
+ */
+declare function createBreadcrumbs<Z extends BreadcrumbTicketInput = BreadcrumbTicketInput, E extends BreadcrumbTicket<Z> = BreadcrumbTicket<Z>, R extends BreadcrumbsContext<Z, E> = BreadcrumbsContext<Z, E>>(options?: BreadcrumbsOptions): R;
+/**
+ * Creates a breadcrumbs context for dependency injection.
+ *
+ * @param options The options including namespace.
+ * @returns A trinity: [useBreadcrumbs, provideBreadcrumbs, defaultContext]
+ *
+ * @example
+ * ```ts
+ * const [useBreadcrumbs, provideBreadcrumbs] = createBreadcrumbsContext()
+ *
+ * // Parent component
+ * provideBreadcrumbs()
+ *
+ * // Child component
+ * const breadcrumbs = useBreadcrumbs()
+ * breadcrumbs.register({ text: 'Details' })
+ * ```
+ */
+declare function createBreadcrumbsContext<Z extends BreadcrumbTicketInput = BreadcrumbTicketInput, E extends BreadcrumbTicket<Z> = BreadcrumbTicket<Z>, R extends BreadcrumbsContext<Z, E> = BreadcrumbsContext<Z, E>>(_options?: BreadcrumbsContextOptions): ContextTrinity<R>;
+/**
+ * Returns the current breadcrumbs instance from context.
+ *
+ * @param namespace The namespace. @default 'v0:breadcrumbs'
+ * @returns The breadcrumbs context.
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useBreadcrumbs } from '@vuetify/v0'
+ *
+ *   const breadcrumbs = useBreadcrumbs()
+ * </script>
+ *
+ * <template>
+ *   <nav>
+ *     <template v-for="ticket in breadcrumbs.values()" :key="ticket.id">
+ *       <a @click="breadcrumbs.select(ticket.id)">{{ ticket.text }}</a>
+ *     </template>
+ *   </nav>
+ * </template>
+ * ```
+ */
+declare function useBreadcrumbs<Z extends BreadcrumbTicketInput = BreadcrumbTicketInput, E extends BreadcrumbTicket<Z> = BreadcrumbTicket<Z>, R extends BreadcrumbsContext<Z, E> = BreadcrumbsContext<Z, E>>(namespace?: string): R;
+//#endregion
+//#region src/composables/createGroup/index.d.ts
+/**
+ * Input type for group tickets.
+ * Extend this interface to add custom properties.
+ */
+interface GroupTicketInput<V = unknown> extends SelectionTicketInput<V> {
+  /** Whether the ticket should start in mixed/indeterminate state */
+  indeterminate?: MaybeRef<boolean>;
+}
+/**
+ * Output type for group tickets.
+ * Includes all input properties plus selection and tri-state methods.
+ */
+type GroupTicket<Z extends GroupTicketInput = GroupTicketInput> = SelectionTicket<Z> & {
+  /** Whether the ticket is in a mixed/indeterminate state */
+  isMixed: Readonly<Ref<boolean>>;
+  /** Set self to mixed/indeterminate state */
+  mix: () => void;
+  /** Clear mixed/indeterminate state from self */
+  unmix: () => void;
+};
+/**
+ * Context returned by createGroup.
+ *
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ */
+interface GroupContext<Z extends GroupTicketInput = GroupTicketInput, E extends GroupTicket<Z> = GroupTicket<Z>> extends Omit<SelectionContext<Z, E>, 'register' | 'onboard' | 'select' | 'unselect' | 'toggle'> {
+  selectedIndexes: ComputedRef<Set<number>>;
+  /** Select one or more Tickets by ID */
+  select: (ids: ID | ID[]) => void;
+  /** Unselect one or more Tickets by ID */
+  unselect: (ids: ID | ID[]) => void;
+  /** Toggle one or more Tickets ON and OFF by ID */
+  toggle: (ids: ID | ID[]) => void;
+  /** Set of mixed/indeterminate ticket IDs */
+  mixedIds: Reactive<Set<ID>>;
+  /** Set of mixed/indeterminate ticket instances */
+  mixedItems: ComputedRef<Set<E>>;
+  /** Set one or more Tickets to mixed/indeterminate state by ID */
+  mix: (ids: ID | ID[]) => void;
+  /** Clear mixed/indeterminate state from one or more Tickets by ID */
+  unmix: (ids: ID | ID[]) => void;
+  /** Check if a ticket is in mixed/indeterminate state by ID */
+  mixed: (id: ID) => boolean;
+  /** Whether no items are currently selected */
+  isNoneSelected: ComputedRef<boolean>;
+  /** Whether all selectable (non-disabled) items are selected */
+  isAllSelected: ComputedRef<boolean>;
+  /** Whether some but not all selectable items are selected */
+  isMixed: ComputedRef<boolean>;
+  /** Select all selectable (non-disabled) items */
+  selectAll: () => void;
+  /** Unselect all items (respects mandatory option) */
+  unselectAll: () => void;
+  /** Toggle between all selected and none selected */
+  toggleAll: () => void;
+  /** Register a new ticket (accepts input type, returns output type) */
+  register: (ticket?: Partial<Z>) => E;
+  /** Onboard multiple tickets at once */
+  onboard: (registrations: Partial<Z>[]) => E[];
+}
+interface GroupOptions extends SelectionOptions {}
+interface GroupContextOptions extends SelectionContextOptions {}
+/**
+ * Creates a new group instance with batch selection and tri-state support.
+ *
+ * Extends `createSelection` to support selecting, unselecting, and toggling multiple items
+ * at once by passing an array of IDs. Adds tri-state (mixed/indeterminate) support for
+ * checkbox trees and similar use cases.
+ *
+ * @param options The options for the group instance.
+ * @template Z The type of the group ticket.
+ * @template E The type of the group context.
+ * @returns A new group instance with batch selection and tri-state support.
+ *
+ * @remarks
+ * **Key Differences from `createSelection`:**
+ * - `select()` accepts `ID | ID[]` for batch operations
+ * - `unselect()` accepts `ID | ID[]` for batch operations
+ * - `toggle()` accepts `ID | ID[]` for batch operations
+ * - Adds `selectedIndexes` computed Set for getting selected item indexes
+ * - Adds tri-state support via `mix()`, `unmix()`, `mixed()`, `mixedIds`, `mixedItems`
+ * - Perfect for checkbox trees, multi-select dropdowns, and bulk operations
+ *
+ * **Tri-State Support:**
+ * - Items can be in one of three states: selected, mixed (indeterminate), or unselected
+ * - `mix(id)` sets item to mixed state (clears selected if set)
+ * - `unmix(id)` clears mixed state
+ * - `select(id)` clears mixed state before selecting
+ * - `toggle(id)` on a mixed item selects it (resolves the indeterminate state positively)
+ * - Mixed state works on disabled items (it's a computed state, not user action)
+ *
+ * **Batch Operations:**
+ * - Single ID: `group.select('item-1')`
+ * - Array of IDs: `group.select(['item-1', 'item-2', 'item-3'])`
+ * - Uses `toArray()` utility internally to normalize input
+ * - Disabled items are automatically skipped in select operations
+ * - Non-existent IDs are silently ignored
+ *
+ * **Inheritance Chain:**
+ * `useRegistry` → `createSelection` → `createGroup`
+ *
+ * **Used By:**
+ * - `createFeatures` for feature flag management with multiple selections
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-group
+ *
+ * @example
+ * ```ts
+ * import { createGroup } from '@vuetify/v0'
+ *
+ * const checkboxes = createGroup()
+ *
+ * checkboxes.onboard([
+ *   { id: 'option-a', value: 'Option A' },
+ *   { id: 'option-b', value: 'Option B' },
+ *   { id: 'option-c', value: 'Option C' },
+ * ])
+ *
+ * // Select multiple items at once
+ * checkboxes.select(['option-a', 'option-c'])
+ *
+ * console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
+ * console.log(Array.from(checkboxes.selectedIndexes.value)) // [0, 2]
+ *
+ * // Set item to mixed/indeterminate state
+ * checkboxes.mix('option-a')
+ * console.log(checkboxes.mixedIds) // Set { 'option-a' }
+ * console.log(checkboxes.selectedIds) // Set { 'option-c' } (option-a removed)
+ *
+ * // Toggle a mixed item selects it
+ * checkboxes.toggle('option-a')
+ * console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
+ * console.log(checkboxes.mixedIds) // Set {} (cleared)
+ * ```
+ */
+declare function createGroup<Z extends GroupTicketInput = GroupTicketInput, E extends GroupTicket<Z> = GroupTicket<Z>, R extends GroupContext<Z, E> = GroupContext<Z, E>>(_options?: GroupOptions): R;
+/**
+ * Creates a new group context.
+ *
+ * @param options The options for the group context.
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ * @template R The context type.
+ * @returns A new group context.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-group
+ *
+ * @example
+ * ```ts
+ * import { createGroupContext } from '@vuetify/v0'
+ *
+ * // With default namespace 'v0:group'
+ * export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext()
+ *
+ * // Or with custom namespace
+ * export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext({ namespace: 'my-group' })
+ *
+ * // In a parent component:
+ * provideMyGroup()
+ *
+ * // In a child component:
+ * const group = useMyGroup()
+ * ```
+ */
+declare function createGroupContext<Z extends GroupTicketInput = GroupTicketInput, E extends GroupTicket<Z> = GroupTicket<Z>, R extends GroupContext<Z, E> = GroupContext<Z, E>>(_options?: GroupContextOptions): ContextTrinity<R>;
+/**
+ * Returns the current group instance.
+ *
+ * @param namespace The namespace for the group context. Defaults to `'v0:group'`.
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ * @template R The context type.
+ * @returns The current group instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-group
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useGroup } from '@vuetify/v0'
+ *
+ *   const group = useGroup()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Selected: {{ group.selectedIds.size }}</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+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/createContext/index.d.ts
-
 type ContextKey<Z> = InjectionKey<Z> | string;
 interface CreateContextOptions {
   /** Optional suffix to append to the runtime key */
@@ -19,79 +1532,645 @@ interface CreateContextOptions {
  * @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#use-context
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#use-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#provide-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#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/createFilter/index.d.ts
+type Primitive = string | number | boolean;
+type FilterQuery = MaybeRefOrGetter<Primitive | Primitive[]>;
+type FilterItem = Primitive | Record<string, any>;
+type FilterMode = 'some' | 'every' | 'union' | 'intersection';
+type FilterFunction = (query: Primitive | Primitive[], item: FilterItem) => boolean;
+interface FilterOptions {
+  customFilter?: FilterFunction;
+  keys?: string[];
+  mode?: FilterMode;
+}
+interface FilterResult<Z extends FilterItem = FilterItem> {
+  items: ComputedRef<Z[]>;
+}
+interface FilterContext<Z extends FilterItem = FilterItem> {
+  /** The filter mode */
+  mode: FilterMode;
+  /** Keys to filter on for object items */
+  keys: string[] | undefined;
+  /** Custom filter function */
+  customFilter: FilterFunction | undefined;
+  /** Current query ref */
+  query: ShallowRef<Primitive | Primitive[]>;
+  /**
+   * Apply filter to an array of items
+   *
+   * @param query The query to filter by
+   * @param items The items to filter
+   * @returns The filtered items as a computed ref
+   */
+  apply: <T extends Z>(query: FilterQuery, items: MaybeRef<T[]>) => FilterResult<T>;
+}
+interface FilterContextOptions extends FilterOptions {
+  namespace?: string;
+}
+/**
+ * Creates a filter context with pre-configured options.
+ *
+ * @param options The filter options
+ * @template Z The type of the items
+ * @template E The type of the filter context
+ * @returns A filter context
+ *
+ * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ *
+ * @example
+ * ```ts
+ * import { createFilter } from '@vuetify/v0'
+ *
+ * const filter = createFilter({
+ *   mode: 'intersection',
+ *   keys: ['name', 'email'],
+ * })
+ *
+ * const { items } = filter.apply(query, users)
+ * ```
+ */
+declare function createFilter<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(options?: FilterOptions): E;
+/**
+ * Creates a filter context with dependency injection support.
+ *
+ * @param options The filter context options
+ * @template Z The type of the items
+ * @template E The type of the filter context
+ * @returns A trinity tuple: [useContext, provideContext, defaultContext]
+ *
+ * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ *
+ * @example
+ * ```ts
+ * import { createFilterContext } from '@vuetify/v0'
+ *
+ * export const [useSearchFilter, provideSearchFilter, searchFilter] = createFilterContext({
+ *   namespace: 'app:search',
+ *   mode: 'union',
+ *   keys: ['title', 'description'],
+ * })
+ *
+ * // In parent component
+ * provideSearchFilter()
+ *
+ * // In child component
+ * const filter = useSearchFilter()
+ * const { items } = filter.apply(query, products)
+ * ```
+ */
+declare function createFilterContext<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(_options?: FilterContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current filter context from dependency injection.
+ *
+ * @param namespace The namespace for the filter context. Defaults to `'v0:filter'`.
+ * @template Z The type of the items.
+ * @template E The type of the filter context.
+ * @returns The current filter context.
+ *
+ * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useFilter } from '@vuetify/v0'
+ *
+ *   const filter = useFilter()
+ *   const { items } = filter.apply(query, products)
+ * </script>
+ * ```
+ */
+declare function useFilter<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(namespace?: string): E;
+//#endregion
+//#region src/composables/createPagination/index.d.ts
+type PaginationTicket = {
+  type: 'page';
+  value: number;
+} | {
+  type: 'ellipsis';
+  value: string;
+};
+interface PaginationContext {
+  /** Current page (1-indexed) */
+  page: ShallowRef<number>;
+  /** Items per page */
+  itemsPerPage: number;
+  /** Total number of items */
+  size: number;
+  /** Total number of pages (computed from size / itemsPerPage) */
+  pages: number;
+  /** Ellipsis character, or false if disabled */
+  ellipsis: string | false;
+  /** Visible page numbers and ellipsis for rendering */
+  items: ComputedRef<PaginationTicket[]>;
+  /** Start index of items on current page (0-indexed) */
+  pageStart: ComputedRef<number>;
+  /** End index of items on current page (exclusive, 0-indexed) */
+  pageStop: ComputedRef<number>;
+  /** Whether current page is the first page */
+  isFirst: ComputedRef<boolean>;
+  /** Whether current page is the last page */
+  isLast: ComputedRef<boolean>;
+  /** Go to first page */
+  first: () => void;
+  /** Go to last page */
+  last: () => void;
+  /** Go to next page */
+  next: () => void;
+  /** Go to previous page */
+  prev: () => void;
+  /** Go to specific page */
+  select: (value: number) => void;
+}
+interface PaginationOptions {
+  /** Initial page or ref for v-model (1-indexed). @default 1 */
+  page?: number | ShallowRef<number>;
+  /** Items per page. @default 10 */
+  itemsPerPage?: MaybeRefOrGetter<number>;
+  /** Total number of items. @default 0 */
+  size?: MaybeRefOrGetter<number>;
+  /** Maximum visible page buttons. @default 5 */
+  visible?: MaybeRefOrGetter<number>;
+  /** Ellipsis character. @default '…' */
+  ellipsis?: string | false;
+}
+interface PaginationContextOptions extends PaginationOptions {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+/**
+ * Creates a pagination instance.
+ *
+ * @param options The options for the pagination instance.
+ * @returns A pagination context with navigation methods.
+ *
+ * @example
+ * ```ts
+ * import { createPagination } from '@vuetify/v0'
+ *
+ * // Basic usage
+ * const pagination = createPagination({ size: 100 })
+ * pagination.next()
+ * pagination.items.value // [{ type: 'page', value: 1 }, { type: 'page', value: 2 }, ...]
+ *
+ * // With v-model (pass a ref)
+ * const page = ref(1)
+ * const pagination = createPagination({ page, size: 100 })
+ * // Mutating pagination.page or the passed ref syncs both
+ * ```
+ */
+declare function createPagination(_options?: PaginationOptions): PaginationContext;
+/**
+ * Creates a pagination context for dependency injection.
+ *
+ * @param options The options including namespace.
+ * @returns A trinity: [usePagination, providePagination, defaultContext]
  *
  * @example
  * ```ts
- * // Without default value
- * const context = useContext<MyContext>('my-context')
+ * // With default namespace 'v0:pagination'
+ * const [usePagination, providePaginationContext] = createPaginationContext({ size: 50 })
  *
- * // With default value
- * const context = useContext<MyContext>('my-context', defaultContext)
+ * // Or with custom namespace
+ * const [usePagination, providePaginationContext] = createPaginationContext({
+ *   namespace: 'my-pagination',
+ *   size: 50,
+ * })
+ *
+ * // Parent component
+ * providePaginationContext()
+ *
+ * // Child component
+ * const pagination = usePagination()
+ * pagination.next()
  * ```
  */
-declare function useContext<Z>(key: ContextKey<Z>, defaultValue?: Z): Z;
+declare function createPaginationContext(_options?: PaginationContextOptions): ContextTrinity<PaginationContext>;
 /**
- * Provides a context to all descendant components.
+ * Returns the current pagination instance from context.
  *
- * @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.
+ * @param namespace The namespace. @default 'v0:pagination'
+ * @returns The pagination 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.
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *  import { usePagination } from '@vuetify/v0'
  *
- * @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
- * @see https://0.vuetifyjs.com/composables/foundation/create-context#provide-context
+ *  const pagination = usePagination()
+ * </script>
+ *
+ * <template>
+ *   <button @click="pagination.prev()" :disabled="pagination.isFirst.value">Prev</button>
+ *   <button @click="pagination.next()" :disabled="pagination.isLast.value">Next</button>
+ * </template>
+ * ```
+ */
+declare function usePagination(namespace?: string): PaginationContext;
+//#endregion
+//#region src/composables/createDataTable/adapters/adapter.d.ts
+type SortDirection = 'asc' | 'desc' | 'none';
+interface SortEntry {
+  key: string;
+  direction: SortDirection;
+}
+/** Inputs provided by createDataTable to the adapter */
+interface DataTableAdapterContext<T extends Record<string, unknown>> {
+  /** Source items */
+  items: MaybeRefOrGetter<T[]>;
+  /** Search query ref */
+  search: ShallowRef<string>;
+  /** Column keys eligible for filtering */
+  filterableKeys: ReadonlyArray<keyof T & string>;
+  /** Current sort state derived from sort controls */
+  sortBy: Readonly<Ref<SortEntry[]>>;
+  /** Locale for sorting (reactive, from useLocale or options) */
+  locale: Readonly<Ref<string | undefined>>;
+  /** Filter options (keys excluded, derived from columns) */
+  filterOptions: Omit<FilterOptions, 'keys'>;
+  /** Pagination options (size excluded, derived from pipeline) */
+  paginationOptions: Omit<PaginationOptions, 'size'>;
+  /** Per-column custom sort comparators */
+  customSorts: Partial<Record<keyof T & string, (a: unknown, b: unknown) => number>>;
+  /** Per-column custom filter functions */
+  customColumnFilters: Partial<Record<keyof T & string, (value: unknown, query: string) => boolean>>;
+}
+/** Outputs returned by the adapter to createDataTable */
+interface DataTableAdapterResult<T extends Record<string, unknown>> {
+  /** Raw unprocessed items */
+  allItems: Readonly<Ref<readonly T[]>>;
+  /** Items after filtering */
+  filteredItems: Readonly<Ref<readonly T[]>>;
+  /** Items after filtering and sorting */
+  sortedItems: Readonly<Ref<readonly T[]>>;
+  /** Final visible items (paginated or virtualized) */
+  items: Readonly<Ref<readonly T[]>>;
+  /** Pagination controls */
+  pagination: PaginationContext;
+  /** Total row count for aria-rowcount */
+  total: Readonly<Ref<number>>;
+  /** Loading state (optional, for async adapters) */
+  loading?: Readonly<Ref<boolean>>;
+  /** Error state (optional, for async adapters) */
+  error?: Readonly<Ref<Error | null>>;
+}
+/** Pipeline adapter interface for data table strategies */
+interface DataTableAdapterInterface<T extends Record<string, unknown>> {
+  setup: (context: DataTableAdapterContext<T>) => DataTableAdapterResult<T>;
+}
+declare abstract class DataTableAdapter<T extends Record<string, unknown>> implements DataTableAdapterInterface<T> {
+  /** Create the filter pipeline stage */
+  protected filter(context: DataTableAdapterContext<T>): {
+    allItems: Readonly<Ref<T[], T[]>>;
+    filteredItems: vue820.ComputedRef<T[]>;
+  };
+  /** Create the sort pipeline stage */
+  protected sort(filteredItems: Readonly<Ref<readonly T[]>>, sortBy: Readonly<Ref<SortEntry[]>>, locale?: Readonly<Ref<string | undefined>>, customSorts?: Partial<Record<string, (a: unknown, b: unknown) => number>>): Readonly<Ref<readonly T[]>>;
+  abstract setup(context: DataTableAdapterContext<T>): DataTableAdapterResult<T>;
+}
+//#endregion
+//#region src/composables/createDataTable/adapters/server.d.ts
+interface ServerAdapterOptions {
+  /** Total number of items on the server (for pagination calculation) */
+  total: MaybeRefOrGetter<number>;
+  /** Loading state (e.g., from useFetch) */
+  loading?: MaybeRefOrGetter<boolean>;
+  /** Error state from API */
+  error?: MaybeRefOrGetter<Error | null>;
+}
+declare class ServerAdapter<T extends Record<string, unknown>> implements DataTableAdapterInterface<T> {
+  private options;
+  constructor(options: ServerAdapterOptions);
+  setup(context: DataTableAdapterContext<T>): DataTableAdapterResult<T>;
+}
+//#endregion
+//#region src/composables/createDataTable/adapters/v0.d.ts
+declare class ClientAdapter<T extends Record<string, unknown>> extends DataTableAdapter<T> {
+  setup(context: DataTableAdapterContext<T>): DataTableAdapterResult<T>;
+}
+//#endregion
+//#region src/composables/createDataTable/adapters/virtual.d.ts
+declare class VirtualAdapter<T extends Record<string, unknown>> extends DataTableAdapter<T> {
+  setup(context: DataTableAdapterContext<T>): DataTableAdapterResult<T>;
+}
+//#endregion
+//#region src/composables/createDataTable/index.d.ts
+/** Extract keys of T whose value type extends V */
+type KeysOfType<T, V> = { [K in keyof T]: T[K] extends V ? K : never }[keyof T] & string;
+type SelectStrategy = 'single' | 'page' | 'all';
+interface DataTableColumn<T extends Record<string, unknown> = Record<string, unknown>> {
+  readonly key: keyof T & string;
+  readonly title?: string;
+  readonly sortable?: boolean;
+  readonly filterable?: boolean;
+  /** Custom sort comparator for this column */
+  readonly sort?: (a: unknown, b: unknown) => number;
+  /** Custom filter function for this column */
+  readonly filter?: (value: unknown, query: string) => boolean;
+}
+interface DataTableSort {
+  /** Toggle sort for a column: none → asc → desc → none */
+  toggle: (key: string) => void;
+  /** Current sort columns derived from group state */
+  columns: Readonly<Ref<SortEntry[]>>;
+  /** Order of sort columns (for multi-sort priority) */
+  order: readonly string[];
+  /** Get sort direction for a specific column key */
+  direction: (key: string) => SortDirection;
+  /** Get sort priority index (0-based), or -1 if not sorted */
+  priority: (key: string) => number;
+  /** Reset all sort state */
+  reset: () => void;
+}
+interface DataTableSelection {
+  /** Currently selected row IDs */
+  selectedIds: ReadonlySet<ID>;
+  /** Select a row by ID */
+  select: (id: ID) => void;
+  /** Unselect a row by ID */
+  unselect: (id: ID) => void;
+  /** Toggle a row's selection */
+  toggle: (id: ID) => void;
+  /** Whether a row is selected */
+  isSelected: (id: ID) => boolean;
+  /** Whether a row can be selected (based on itemSelectable) */
+  isSelectable: (id: ID) => boolean;
+  /** Select all items within strategy scope */
+  selectAll: () => void;
+  /** Unselect all items across all pages */
+  unselectAll: () => void;
+  /** Toggle all items within strategy scope */
+  toggleAll: () => void;
+  /** Whether all items within strategy scope are selected */
+  isAllSelected: Readonly<Ref<boolean>>;
+  /** Whether some but not all items within strategy scope are selected */
+  isMixed: Readonly<Ref<boolean>>;
+}
+interface DataTableGroup<T extends Record<string, unknown>> {
+  /** Stringified group identifier */
+  key: string;
+  /** Raw value of the groupBy column for this group */
+  value: T[keyof T & string];
+  /** Items belonging to this group */
+  items: readonly T[];
+}
+interface DataTableGrouping<T extends Record<string, unknown>> {
+  /** Grouped items derived from sortedItems */
+  groups: Readonly<Ref<DataTableGroup<T>[]>>;
+  /** Toggle a group's open/closed state */
+  toggle: (groupKey: string) => void;
+  /** Whether a group is open */
+  isOpen: (groupKey: string) => boolean;
+  /** Open a group */
+  open: (groupKey: string) => void;
+  /** Close a group */
+  close: (groupKey: string) => void;
+  /** Open all groups */
+  openAll: () => void;
+  /** Close all groups */
+  closeAll: () => void;
+}
+interface DataTableExpansion {
+  /** Currently expanded row IDs */
+  expandedIds: ReadonlySet<ID>;
+  /** Expand a row by ID */
+  expand: (id: ID) => void;
+  /** Collapse a row by ID */
+  collapse: (id: ID) => void;
+  /** Toggle a row's expanded state */
+  toggle: (id: ID) => void;
+  /** Whether a row is expanded */
+  isExpanded: (id: ID) => boolean;
+  /** Expand all visible (paginated) items. Requires expandMultiple=true. */
+  expandAll: () => void;
+  /** Collapse all expanded items across all pages (not page-scoped like expandAll) */
+  collapseAll: () => void;
+}
+interface DataTableOptions<T extends Record<string, unknown>> {
+  /** Source items */
+  items: MaybeRefOrGetter<T[]>;
+  /** Column definitions */
+  columns: readonly DataTableColumn<T>[];
+  /** Property used as row identifier. Must resolve to a string or number value. @default 'id' */
+  itemValue?: KeysOfType<T, ID>;
+  /** Filter options (keys derived from columns) */
+  filter?: Omit<FilterOptions, 'keys'>;
+  /** Pagination options (size derived from pipeline) */
+  pagination?: Omit<PaginationOptions, 'size'>;
+  /** Enable multi-column sort. @default false */
+  sortMultiple?: boolean;
+  /** Prevent clearing sort (asc → desc → asc cycle). @default false */
+  mandate?: boolean;
+  /** Direction for first sort click. @default 'asc' */
+  firstSortOrder?: 'asc' | 'desc';
+  /** Selection strategy: 'single' selects one row, 'page' operates on visible items, 'all' operates on all filtered items. @default 'page' */
+  selectStrategy?: SelectStrategy;
+  /** Property that controls per-row selectability */
+  itemSelectable?: keyof T & string;
+  /** Column key to group rows by */
+  groupBy?: keyof T & string;
+  /** Auto-open all groups on creation. @default false */
+  enroll?: boolean;
+  /** Allow multiple rows expanded simultaneously. @default true */
+  expandMultiple?: boolean;
+  /** Locale for sorting (defaults to useLocale's selected locale or browser default) */
+  locale?: string;
+  /** Pipeline adapter. @default ClientAdapter */
+  adapter?: DataTableAdapterInterface<T>;
+}
+interface DataTableContext<T extends Record<string, unknown>> {
+  /** Final paginated items for rendering */
+  items: Readonly<Ref<readonly T[]>>;
+  /** Raw unprocessed items */
+  allItems: Readonly<Ref<readonly T[]>>;
+  /** Items after filtering */
+  filteredItems: Readonly<Ref<readonly T[]>>;
+  /** Items after filtering and sorting */
+  sortedItems: Readonly<Ref<readonly T[]>>;
+  /** Column definitions */
+  columns: readonly DataTableColumn<T>[];
+  /** Set the search query */
+  search: (value: string) => void;
+  /** Current search query (readonly) */
+  query: Readonly<ShallowRef<string>>;
+  /** Sort controls */
+  sort: DataTableSort;
+  /** Pagination controls */
+  pagination: PaginationContext;
+  /** Row selection controls */
+  selection: DataTableSelection;
+  /** Row expansion controls */
+  expansion: DataTableExpansion;
+  /** Row grouping controls. When groupBy is not set, `groups` returns an empty array. */
+  grouping: DataTableGrouping<T>;
+  /** Total row count for aria-rowcount */
+  total: Readonly<Ref<number>>;
+  /** Loading state (managed by adapter) */
+  loading: Readonly<Ref<boolean>>;
+  /** Error state (managed by adapter) */
+  error: Readonly<Ref<Error | null>>;
+}
+interface DataTableContextOptions<T extends Record<string, unknown>> extends DataTableOptions<T> {
+  namespace?: string;
+}
+/**
+ * Creates a data table instance with sort controls, selection, and an
+ * adapter-driven data pipeline.
+ *
+ * Must be called inside a component `setup()` or a Vue effect scope.
+ * Calling at module scope in SSR environments causes request state leakage.
+ *
+ * @param options Data table options
+ * @returns Data table context with pipeline stages and controls
  *
  * @example
  * ```ts
- * // Component-level provision
- * provideContext<MyContext>('my-context', context)
+ * import { createDataTable } from '@vuetify/v0'
+ *
+ * const table = createDataTable({
+ *   items: users,
+ *   columns: [
+ *     { key: 'name', title: 'Name', sortable: true, filterable: true },
+ *     { key: 'email', title: 'Email', sortable: true, filterable: true },
+ *     { key: 'age', title: 'Age', sortable: true },
+ *   ],
+ * })
  *
- * // App-level provision (typically used in plugins)
- * const app = createApp()
- * provideContext<MyContext>('my-context', context, app)
+ * // Search
+ * table.search('john')
+ *
+ * // Sort
+ * table.sort.toggle('name')          // asc
+ * table.sort.toggle('name')          // desc
+ * table.sort.toggle('name')          // none
+ * console.log(table.sort.columns.value) // [{ key: 'name', direction: 'asc' }]
+ *
+ * // Paginate
+ * table.pagination.next()
+ *
+ * // Select rows
+ * table.selection.toggle('user-1')
  * ```
  */
-declare function provideContext<Z>(key: ContextKey<Z>, context: Z, app?: App): Z;
+declare function createDataTable<T extends Record<string, unknown>>(options: DataTableOptions<T>): DataTableContext<T>;
 /**
- * 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.
+ * Creates a data table context with dependency injection support.
  *
- * @see https://vuejs.org/api/composition-api-dependency-injection.html
- * @see https://0.vuetifyjs.com/composables/foundation/create-context#create-context
+ * @param options Data table context options including namespace
+ * @returns A trinity tuple: [useDataTable, provideDataTable, defaultContext]
  *
  * @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'
+ * import { createDataTableContext } from '@vuetify/v0'
+ *
+ * const [useDataTable, provideDataTable, context] = createDataTableContext({
+ *   namespace: 'app:users',
+ *   items: users,
+ *   columns: [
+ *     { key: 'name', title: 'Name', sortable: true },
+ *   ],
+ * })
  *
- * // 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'
+ * // Parent component
+ * provideDataTable()
  *
- * // 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'
+ * // Child component
+ * const table = useDataTable()
  * ```
  */
-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 createDataTableContext<T extends Record<string, unknown>>(_options: DataTableContextOptions<T>): ContextTrinity<DataTableContext<T>>;
+/**
+ * Returns the current data table context from dependency injection.
+ *
+ * @typeParam T - Must be provided explicitly; cannot be inferred from namespace.
+ *   Prefer the `useX` function from {@link createDataTableContext} for type-safe injection.
+ *
+ * @param namespace The namespace for the data table context. @default 'v0:data-table'
+ * @returns The current data table context
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useDataTable } from '@vuetify/v0'
+ *
+ *   const table = useDataTable<User>()
+ * </script>
+ * ```
+ */
+declare function useDataTable<T extends Record<string, unknown>>(namespace?: string): DataTableContext<T>;
 //#endregion
 //#region src/composables/createPlugin/index.d.ts
 interface PluginOptions {
@@ -231,14 +2310,14 @@ interface BreakpointsContextOptions extends BreakpointsOptions {}
  *
  * export const [useBreakpoints, provideBreakpoints] = createBreakpoints({
  *   namespace: 'v0:breakpoints',
- *   mobileBreakpoint: 'sm',
+ *   mobileBreakpoint: 'md',
  *   breakpoints: {
  *     xs: 0,
- *     sm: 680,
- *     md: 1024,
- *     lg: 1280,
- *     xl: 1920,
- *     xxl: 2560,
+ *     sm: 600,
+ *     md: 840,
+ *     lg: 1145,
+ *     xl: 1545,
+ *     xxl: 2138,
  *   },
  * })
  * ```
@@ -284,14 +2363,14 @@ declare function createBreakpointsContext<E extends BreakpointsContext = Breakpo
  * app.use(
  *   createBreakpointsPlugin({
  *     namespace: 'v0:breakpoints',
- *     mobileBreakpoint: 'sm',
+ *     mobileBreakpoint: 'md',
  *     breakpoints: {
  *       xs: 0,
- *       sm: 680,
- *       md: 1024,
- *       lg: 1280,
- *       xl: 1920,
- *       xxl: 2560,
+ *       sm: 600,
+ *       md: 840,
+ *       lg: 1145,
+ *       xl: 1545,
+ *       xxl: 2138,
  *     },
  *   })
  * )
@@ -313,13 +2392,20 @@ declare function createBreakpointsPlugin<E extends BreakpointsContext = Breakpoi
  * <script setup lang="ts">
  *   import { useBreakpoints } from '@vuetify/v0'
  *
+ *   // Destructure for template auto-unwrapping
  *   const { isMobile, mdAndUp } = useBreakpoints()
+ *
+ *   // In script, use .value
+ *   if (isMobile.value) {
+ *     console.log('Mobile detected')
+ *   }
  * </script>
  *
  * <template>
  *   <div class="pa-4">
- *     <p v-if="isMobile.value">Mobile layout active</p>
- *     <p v-else-if="mdAndUp.value">Medium and up layout active</p>
+ *     <!-- Destructured refs auto-unwrap in templates -->
+ *     <p v-if="isMobile">Mobile layout active</p>
+ *     <p v-else-if="mdAndUp">Medium and up layout active</p>
  *   </div>
  * </template>
  * ```
@@ -897,253 +2983,115 @@ interface FeaturePluginOptions extends FeatureContextOptions {
   /**
    * Feature flag adapter for external services.
    *
-   * @remarks Adapters provide dynamic flag values from external services.
-   */
-  adapter?: MaybeArray<FeaturesAdapterInterface>;
-}
-/**
- * Creates a new features instance.
- *
- * @param options The options for the features instance.
- * @template Z The type of the feature ticket.
- * @template E The type of the feature context.
- * @returns A new features instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-features
- *
- * @example
- * ```ts
- * import { createFeatures } from '@vuetify/v0'
- *
- * const [useFeatures, provideFeaturesContext, context] = createFeatures({
- *   namespace: 'v0:features',
- *   features: {
- *     'dark-mode': true,
- *     'theme-color': { $variation: 'blue' },
- *   },
- * })
- * ```
- */
-declare function createFeatures<Z extends FeatureTicketInput = FeatureTicketInput, E extends FeatureTicket<Z> = FeatureTicket<Z>, R extends FeatureContext<Z, E> = FeatureContext<Z, E>>(_options?: FeatureOptions): R;
-/**
- * Creates a new features context.
- *
- * @param options The options for the features context.
- * @template Z The type of the feature ticket.
- * @template E The type of the feature context.
- * @returns A new features context.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-features
- *
- * @example
- * ```ts
- * import { createFeaturesContext } from '@vuetify/v0'
- *
- * export const [useFeatures, provideFeatures, context] = createFeaturesContext({
- *   namespace: 'app:features',
- *   features: {
- *     'dark-mode': true,
- *     'theme-color': { $variation: 'blue' },
- *   },
- * })
- * ```
- */
-declare function createFeaturesContext<Z extends FeatureTicketInput = FeatureTicketInput, E extends FeatureTicket<Z> = FeatureTicket<Z>, R extends FeatureContext<Z, E> = FeatureContext<Z, E>>(_options?: FeatureContextOptions): ContextTrinity<R>;
-/**
- * Creates a new features plugin.
- *
- * @param options The options for the features plugin.
- * @template Z The type of the feature ticket.
- * @template E The type of the feature context.
- * @returns A new features plugin.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-features
- *
- * @example
- * ```ts
- * import { createApp } from 'vue'
- * import { createFeaturesPlugin } from '@vuetify/v0'
- * import App from './App.vue'
- *
- * const app = createApp(App)
- *
- * app.use(
- *   createFeaturesPlugin({
- *     features: {
- *       'dark-mode': true,
- *       'theme-color': { $variation: 'blue' },
- *     },
- *   })
- * )
- *
- * app.mount('#app')
- * ```
- */
-declare function createFeaturesPlugin<Z extends FeatureTicketInput = FeatureTicketInput, E extends FeatureTicket<Z> = FeatureTicket<Z>, R extends FeatureContext<Z, E> = FeatureContext<Z, E>>(_options?: FeaturePluginOptions): Plugin;
-/**
- * Returns the current features instance.
- *
- * @param namespace The namespace for the features context. Defaults to `v0:features`.
- * @template Z The type of the feature ticket.
- * @returns The current features instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-features
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useFeatures } from '@vuetify/v0'
- *
- *   const features = useFeatures()
- * </script>
- *
- * <template>
- *   <div>
- *     <p>Features: {{ features.get('dark-mode') }}</p>
- *     <p>Theme Color: {{ features.variation('theme-color') }}</p>
- *   </div>
- * </template>
- * ```
- */
-declare function useFeatures<Z extends FeatureTicketInput = FeatureTicketInput, E extends FeatureTicket<Z> = FeatureTicket<Z>, R extends FeatureContext<Z, E> = FeatureContext<Z, E>>(namespace?: string): R;
-//#endregion
-//#region src/composables/useFilter/index.d.ts
-type Primitive = string | number | boolean;
-type FilterQuery = MaybeRefOrGetter<Primitive | Primitive[]>;
-type FilterItem = Primitive | Record<string, any>;
-type FilterMode = 'some' | 'every' | 'union' | 'intersection';
-type FilterFunction = (query: Primitive | Primitive[], item: FilterItem) => boolean;
-interface FilterOptions {
-  customFilter?: FilterFunction;
-  keys?: string[];
-  mode?: FilterMode;
-}
-interface FilterResult<Z extends FilterItem = FilterItem> {
-  items: ComputedRef<Z[]>;
-}
-interface FilterContext<Z extends FilterItem = FilterItem> {
-  /** The filter mode */
-  mode: FilterMode;
-  /** Keys to filter on for object items */
-  keys: string[] | undefined;
-  /** Custom filter function */
-  customFilter: FilterFunction | undefined;
-  /** Current query ref */
-  query: ShallowRef<Primitive | Primitive[]>;
-  /**
-   * Apply filter to an array of items
-   *
-   * @param query The query to filter by
-   * @param items The items to filter
-   * @returns The filtered items as a computed ref
-   */
-  apply: <T extends Z>(query: FilterQuery, items: MaybeRef<T[]>) => FilterResult<T>;
-}
-interface FilterContextOptions extends FilterOptions {
-  namespace?: string;
+   * @remarks Adapters provide dynamic flag values from external services.
+   */
+  adapter?: MaybeArray<FeaturesAdapterInterface>;
 }
 /**
- * Creates a filter context with pre-configured options.
+ * Creates a new features instance.
  *
- * @param options The filter options
- * @template Z The type of the items
- * @template E The type of the filter context
- * @returns A filter context
+ * @param options The options for the features instance.
+ * @template Z The type of the feature ticket.
+ * @template E The type of the feature context.
+ * @returns A new features instance.
  *
- * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ * @see https://0.vuetifyjs.com/composables/plugins/use-features
  *
  * @example
  * ```ts
- * import { createFilter } from '@vuetify/v0'
+ * import { createFeatures } from '@vuetify/v0'
  *
- * const filter = createFilter({
- *   mode: 'intersection',
- *   keys: ['name', 'email'],
+ * const [useFeatures, provideFeaturesContext, context] = createFeatures({
+ *   namespace: 'v0:features',
+ *   features: {
+ *     'dark-mode': true,
+ *     'theme-color': { $variation: 'blue' },
+ *   },
  * })
- *
- * const { items } = filter.apply(query, users)
  * ```
  */
-declare function createFilter<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(options?: FilterOptions): E;
+declare function createFeatures<Z extends FeatureTicketInput = FeatureTicketInput, E extends FeatureTicket<Z> = FeatureTicket<Z>, R extends FeatureContext<Z, E> = FeatureContext<Z, E>>(_options?: FeatureOptions): R;
 /**
- * Creates a filter context with dependency injection support.
+ * Creates a new features context.
  *
- * @param options The filter context options
- * @template Z The type of the items
- * @template E The type of the filter context
- * @returns A trinity tuple: [useContext, provideContext, defaultContext]
+ * @param options The options for the features context.
+ * @template Z The type of the feature ticket.
+ * @template E The type of the feature context.
+ * @returns A new features context.
  *
- * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ * @see https://0.vuetifyjs.com/composables/plugins/use-features
  *
  * @example
  * ```ts
- * import { createFilterContext } from '@vuetify/v0'
+ * import { createFeaturesContext } from '@vuetify/v0'
  *
- * export const [useSearchFilter, provideSearchFilter, searchFilter] = createFilterContext({
- *   namespace: 'app:search',
- *   mode: 'union',
- *   keys: ['title', 'description'],
+ * export const [useFeatures, provideFeatures, context] = createFeaturesContext({
+ *   namespace: 'app:features',
+ *   features: {
+ *     'dark-mode': true,
+ *     'theme-color': { $variation: 'blue' },
+ *   },
  * })
- *
- * // In parent component
- * provideSearchFilter()
- *
- * // In child component
- * const filter = useSearchFilter()
- * const { items } = filter.apply(query, products)
  * ```
  */
-declare function createFilterContext<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(_options?: FilterContextOptions): ContextTrinity<E>;
+declare function createFeaturesContext<Z extends FeatureTicketInput = FeatureTicketInput, E extends FeatureTicket<Z> = FeatureTicket<Z>, R extends FeatureContext<Z, E> = FeatureContext<Z, E>>(_options?: FeatureContextOptions): ContextTrinity<R>;
 /**
- * A reusable function for filtering an array of items.
+ * Creates a new features plugin.
  *
- * @param query The query to filter by.
- * @param items The items to filter.
- * @param options The filter options.
- * @template Z The type of the items.
- * @returns The filtered items.
+ * @param options The options for the features plugin.
+ * @template Z The type of the feature ticket.
+ * @template E The type of the feature context.
+ * @returns A new features plugin.
  *
- * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ * @see https://0.vuetifyjs.com/composables/plugins/use-features
  *
  * @example
  * ```ts
- * import { ref } from 'vue'
- * import { useFilter } from '@vuetify/v0'
+ * import { createApp } from 'vue'
+ * import { createFeaturesPlugin } from '@vuetify/v0'
+ * import App from './App.vue'
  *
- * const items = ref([
- *   { name: 'John Doe', age: 30 },
- *   { name: 'Jane Doe', age: 25 },
- *   { name: 'Peter Jones', age: 40 },
- * ])
+ * const app = createApp(App)
  *
- * const query = ref('doe')
- * const { items: filtered } = useFilter(query, items, { keys: ['name'] })
+ * app.use(
+ *   createFeaturesPlugin({
+ *     features: {
+ *       'dark-mode': true,
+ *       'theme-color': { $variation: 'blue' },
+ *     },
+ *   })
+ * )
  *
- * console.log(filtered.value) // [ { name: 'John Doe', age: 30 }, { name: 'Jane Doe', age: 25 } ]
+ * app.mount('#app')
  * ```
  */
-declare function useFilter<Z extends FilterItem>(query: FilterQuery, items: MaybeRef<Z[]>, options?: FilterOptions): FilterResult<Z>;
+declare function createFeaturesPlugin<Z extends FeatureTicketInput = FeatureTicketInput, E extends FeatureTicket<Z> = FeatureTicket<Z>, R extends FeatureContext<Z, E> = FeatureContext<Z, E>>(_options?: FeaturePluginOptions): Plugin;
 /**
- * Returns the current filter context from dependency injection.
+ * Returns the current features instance.
  *
- * @param namespace The namespace for the filter context. Defaults to `'v0:filter'`.
- * @template Z The type of the items.
- * @template E The type of the filter context.
- * @returns The current filter context.
+ * @param namespace The namespace for the features context. Defaults to `v0:features`.
+ * @template Z The type of the feature ticket.
+ * @returns The current features instance.
  *
- * @see https://0.vuetifyjs.com/composables/utilities/use-filter
+ * @see https://0.vuetifyjs.com/composables/plugins/use-features
  *
  * @example
  * ```vue
  * <script setup lang="ts">
- *   import { useFilterContext } from '@vuetify/v0'
+ *   import { useFeatures } from '@vuetify/v0'
  *
- *   const filter = useFilterContext()
- *   const { items } = filter.apply(query, products)
+ *   const features = useFeatures()
  * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Features: {{ features.get('dark-mode') }}</p>
+ *     <p>Theme Color: {{ features.variation('theme-color') }}</p>
+ *   </div>
+ * </template>
  * ```
  */
-declare function useFilterContext<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(namespace?: string): E;
+declare function useFeatures<Z extends FeatureTicketInput = FeatureTicketInput, E extends FeatureTicket<Z> = FeatureTicket<Z>, R extends FeatureContext<Z, E> = FeatureContext<Z, E>>(namespace?: string): R;
 //#endregion
 //#region src/composables/createForm/index.d.ts
 type FormValidationResult = string | true | Promise<string | true>;
@@ -2168,6 +4116,8 @@ declare function useMutationObserver(target: MaybeRef<Element | null | undefined
 interface NestedTicketInput<V = unknown> extends GroupTicketInput<V> {
   /** ID of the parent ticket, or undefined if this is a root item */
   parentId?: ID;
+  /** Whether this ticket is initially active */
+  active?: boolean;
 }
 /**
  * Output type for nested tickets - what users receive from get().
@@ -2180,6 +4130,8 @@ type NestedTicket<Z extends NestedTicketInput = NestedTicketInput> = GroupTicket
   parentId: ID | undefined;
   /** Whether this ticket is currently open/expanded */
   isOpen: Readonly<Ref<boolean>>;
+  /** Whether this ticket is currently active/highlighted */
+  isActive: Readonly<Ref<boolean>>;
   /** Whether this ticket is a leaf node (has no children) */
   isLeaf: Readonly<Ref<boolean>>;
   /** Depth in tree (0 = root) */
@@ -2192,6 +4144,10 @@ type NestedTicket<Z extends NestedTicketInput = NestedTicketInput> = GroupTicket
   flip: () => void;
   /** Reveal this ticket by opening all ancestors */
   reveal: () => void;
+  /** Activate/highlight this ticket */
+  activate: () => void;
+  /** Deactivate/unhighlight this ticket */
+  deactivate: () => void;
   /** Get path from root to self (includes self) */
   getPath: () => ID[];
   /** Get ancestors excluding self */
@@ -2264,6 +4220,20 @@ interface NestedContext<Z extends NestedTicketInput = NestedTicketInput, E exten
   readonly openedIds: Reactive<Set<ID>>;
   /** Computed Set of opened/expanded item instances */
   openedItems: ComputedRef<Set<E>>;
+  /** Reactive Set of active/highlighted item IDs. Use activate/deactivate to modify. */
+  readonly activeIds: Reactive<Set<ID>>;
+  /** Computed Set of active/highlighted item instances */
+  activeItems: ComputedRef<Set<E>>;
+  /** Computed Set of active item indexes (position-based) */
+  activeIndexes: ComputedRef<Set<number>>;
+  /** Activate/highlight one or more items by ID */
+  activate: (ids: ID | ID[]) => void;
+  /** Deactivate/unhighlight one or more items by ID */
+  deactivate: (ids: ID | ID[]) => void;
+  /** Check if an item is active by ID */
+  activated: (id: ID) => boolean;
+  /** Deactivate all items */
+  deactivateAll: () => void;
   /** Open/expand one or more items by ID */
   open: (ids: ID | ID[]) => void;
   /** Close/collapse one or more items by ID */
@@ -2345,6 +4315,12 @@ type NestedSelectionMode = 'cascade' | 'independent' | 'leaf';
 /**
  * Options for creating a nested instance.
  */
+/**
+ * Active mode for nested items.
+ * - `'single'` (default): Only one item can be active at a time
+ * - `'multiple'`: Multiple items can be active simultaneously
+ */
+type NestedActiveMode = 'single' | 'multiple';
 interface NestedOptions extends GroupOptions {
   /**
    * Controls how nodes expand/collapse.
@@ -2369,6 +4345,12 @@ interface NestedOptions extends GroupOptions {
    * - `'leaf'`: Only leaf nodes selectable; parent selection selects leaf descendants
    */
   selection?: NestedSelectionMode;
+  /**
+   * Controls how many items can be active/highlighted simultaneously.
+   * - `'single'` (default): Only one item active at a time
+   * - `'multiple'`: Multiple items can be active simultaneously
+   */
+  active?: NestedActiveMode;
   /**
    * Advanced: Custom strategy for open behavior.
    * Overrides `open` option if provided.
@@ -2403,6 +4385,12 @@ interface NestedContextOptions extends GroupContextOptions {
    * - `'leaf'`: Only leaf nodes selectable; parent selection selects leaf descendants
    */
   selection?: NestedSelectionMode;
+  /**
+   * Controls how many items can be active/highlighted simultaneously.
+   * - `'single'` (default): Only one item active at a time
+   * - `'multiple'`: Multiple items can be active simultaneously
+   */
+  active?: NestedActiveMode;
   /**
    * Advanced: Custom strategy for open behavior.
    * Overrides `open` option if provided.
@@ -2487,173 +4475,33 @@ declare const singleOpenStrategy: OpenStrategy;
  */
 declare function createNested<Z extends NestedTicketInput = NestedTicketInput, E extends NestedTicket<Z> = NestedTicket<Z>, R extends NestedContext<Z, E> = NestedContext<Z, E>>(_options?: NestedOptions): R;
 /**
- * Creates a new nested context with provide/inject pattern.
- *
- * @param options The options for the nested context.
- * @returns A trinity tuple [useNested, provideNested, defaultNested]
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-nested
- *
- * @example
- * ```ts
- * import { createNestedContext } from '@vuetify/v0'
- *
- * export const [useTree, provideTree, tree] = createNestedContext()
- *
- * // In parent: provideTree()
- * // In child: const tree = useTree()
- * ```
- */
-declare function createNestedContext<Z extends NestedTicketInput = NestedTicketInput, E extends NestedTicket<Z> = NestedTicket<Z>, R extends NestedContext<Z, E> = NestedContext<Z, E>>(_options?: NestedContextOptions): ContextTrinity<R>;
-/**
- * Returns the current nested instance from context.
- *
- * @param namespace The namespace for the nested context. Defaults to `'v0:nested'`.
- * @returns The current nested instance.
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-nested
- */
-declare function useNested<Z extends NestedTicketInput = NestedTicketInput, E extends NestedTicket<Z> = NestedTicket<Z>, R extends NestedContext<Z, E> = NestedContext<Z, E>>(namespace?: string): R;
-//#endregion
-//#region src/composables/useOverflow/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.
+ * Creates a new nested context with provide/inject pattern.
  *
- * @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.
+ * @param options The options for the nested context.
+ * @returns A trinity tuple [useNested, provideNested, defaultNested]
  *
- * @throws An error if the overflow context is not found and no default is provided.
+ * @see https://0.vuetifyjs.com/composables/selection/use-nested
  *
  * @example
- * ```vue
- * <script lang="ts" setup>
- *   import { useOverflow } from '@vuetify/v0'
+ * ```ts
+ * import { createNestedContext } from '@vuetify/v0'
  *
- *   // Inject overflow context provided by parent
- *   const overflow = useOverflow()
- * </script>
+ * export const [useTree, provideTree, tree] = createNestedContext()
  *
- * <template>
- *   <div>
- *     <p>Capacity: {{ overflow.capacity.value }}</p>
- *   </div>
- * </template>
+ * // In parent: provideTree()
+ * // In child: const tree = useTree()
  * ```
  */
-declare function useOverflow<E extends OverflowContext = OverflowContext>(namespace?: string): E;
+declare function createNestedContext<Z extends NestedTicketInput = NestedTicketInput, E extends NestedTicket<Z> = NestedTicket<Z>, R extends NestedContext<Z, E> = NestedContext<Z, E>>(_options?: NestedContextOptions): ContextTrinity<R>;
+/**
+ * Returns the current nested instance from context.
+ *
+ * @param namespace The namespace for the nested context. Defaults to `'v0:nested'`.
+ * @returns The current nested instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-nested
+ */
+declare function useNested<Z extends NestedTicketInput = NestedTicketInput, E extends NestedTicket<Z> = NestedTicket<Z>, R extends NestedContext<Z, E> = NestedContext<Z, E>>(namespace?: string): R;
 //#endregion
 //#region src/composables/usePermissions/adapters/adapter.d.ts
 interface PermissionAdapterInterface {
@@ -2782,7 +4630,7 @@ declare function usePermissions<Z extends PermissionTicket = PermissionTicket, E
 //#endregion
 //#region src/composables/useProxyModel/index.d.ts
 interface ProxyModelOptions {
-  multiple?: boolean;
+  multiple?: MaybeRefOrGetter<boolean>;
   transformIn?: (val: unknown) => unknown;
   transformOut?: (val: unknown) => unknown;
 }
@@ -3266,6 +5114,411 @@ interface UseElementSizeReturn extends UseResizeObserverReturn {
  */
 declare function useElementSize(target: MaybeRef<Element | null | undefined>): UseElementSizeReturn;
 //#endregion
+//#region src/composables/useStack/index.d.ts
+/**
+ * Input type for stack tickets - what users provide to register().
+ */
+interface StackTicketInput extends SelectionTicketInput {
+  /**
+   * Callback invoked when the overlay should be dismissed
+   *
+   * @remarks Called by `ticket.dismiss()` or when scrim is clicked.
+   * Typically sets isActive to false.
+   */
+  onDismiss?: () => void;
+  /**
+   * Whether this overlay blocks scrim dismissal
+   *
+   * @default false
+   * @remarks When true, clicking the scrim will not dismiss this overlay.
+   * Use for critical dialogs requiring explicit user action.
+   */
+  blocking?: boolean;
+}
+/**
+ * Output type for stack tickets - what users receive from register().
+ */
+type StackTicket<Z extends StackTicketInput = StackTicketInput> = SelectionTicket<Z> & {
+  /**
+   * Callback invoked when the overlay should be dismissed
+   */
+  onDismiss?: () => void;
+  /**
+   * Whether this overlay blocks scrim dismissal
+   */
+  blocking: boolean;
+  /**
+   * The calculated z-index for this overlay
+   *
+   * @remarks Automatically calculated based on selection order.
+   * First selected overlay gets baseZIndex, each subsequent adds increment.
+   */
+  zIndex: ComputedRef<number>;
+  /**
+   * Whether this overlay is the topmost in the global stack
+   *
+   * @remarks Useful for determining which overlay should handle
+   * global keyboard events (e.g., Escape key).
+   */
+  globalTop: ComputedRef<boolean>;
+  /**
+   * Dismiss this overlay
+   *
+   * @remarks If blocking is false, calls onDismiss callback and unselects.
+   * If blocking is true, does nothing.
+   */
+  dismiss: () => void;
+};
+/**
+ * Context returned by createStack.
+ */
+interface StackContext<Z extends StackTicketInput = StackTicketInput, E extends StackTicket<Z> = StackTicket<Z>> extends Omit<SelectionContext<Z, E>, 'register'> {
+  /**
+   * Whether any overlays are selected (active)
+   *
+   * @remarks Reactive boolean for conditional scrim rendering.
+   */
+  isActive: Readonly<Ref<boolean>>;
+  /**
+   * The topmost selected overlay ticket
+   *
+   * @remarks Access to the current top overlay for inspection.
+   */
+  top: Readonly<Ref<E | undefined>>;
+  /**
+   * Z-index for the scrim (one below top overlay)
+   *
+   * @remarks Position scrim behind the topmost overlay but above all others.
+   */
+  scrimZIndex: Readonly<Ref<number>>;
+  /**
+   * Whether the topmost overlay blocks scrim clicks
+   *
+   * @remarks When true, the topmost overlay has `blocking: true`
+   * and scrim clicks should be ignored.
+   */
+  isBlocking: Readonly<Ref<boolean>>;
+  /**
+   * Register an overlay ticket
+   *
+   * @param input Partial ticket data
+   * @returns Stack ticket with z-index and top tracking
+   *
+   * @remarks When called within component setup, the ticket is automatically
+   * unregistered when the component unmounts.
+   */
+  register: (input?: Partial<Z>) => E;
+}
+interface StackOptions extends SelectionOptions {
+  /**
+   * Base z-index when stack is empty
+   *
+   * @default 2000
+   * @remarks First overlay receives this z-index.
+   */
+  baseZIndex?: number;
+  /**
+   * Z-index increment between overlays
+   *
+   * @default 10
+   * @remarks Gap between overlay z-indexes allows room for
+   * overlay-internal elements (dropdowns, tooltips within dialogs).
+   */
+  increment?: number;
+}
+interface StackContextOptions extends StackOptions {
+  namespace?: string;
+}
+interface StackPluginOptions extends StackContextOptions {}
+/**
+ * Creates a new stack instance for managing overlay z-indexes.
+ *
+ * @param options Configuration options
+ * @returns Stack context with registry methods and scrim helpers
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-stack
+ *
+ * @example
+ * ```ts
+ * import { createStack } from '@vuetify/v0'
+ *
+ * const stack = createStack({ baseZIndex: 1000 })
+ *
+ * const ticket = stack.register({
+ *   onDismiss: () => console.log('dismissed'),
+ *   blocking: false,
+ * })
+ *
+ * ticket.select()  // Activate overlay
+ * console.log(ticket.zIndex.value)  // 1000
+ *
+ * ticket.unselect()  // Deactivate overlay
+ * ```
+ */
+declare function createStack<Z extends StackTicketInput = StackTicketInput, E extends StackTicket<Z> = StackTicket<Z>, R extends StackContext<Z, E> = StackContext<Z, E>>(_options?: StackOptions): R;
+/**
+ * Creates a stack context trinity for provide/inject usage.
+ *
+ * @param options Configuration options including namespace
+ * @returns Trinity of [useStackContext, provideStackContext, context]
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-stack
+ *
+ * @example
+ * ```ts
+ * import { createStackContext } from '@vuetify/v0'
+ *
+ * const [useMyStack, provideMyStack, myStack] = createStackContext({
+ *   namespace: 'my:stack',
+ *   baseZIndex: 3000,
+ * })
+ *
+ * // In parent component:
+ * provideMyStack()
+ *
+ * // In child component:
+ * const stack = useMyStack()
+ * ```
+ */
+declare function createStackContext<Z extends StackTicketInput = StackTicketInput, E extends StackTicket<Z> = StackTicket<Z>, R extends StackContext<Z, E> = StackContext<Z, E>>(_options?: StackContextOptions): ContextTrinity<R>;
+/**
+ * Creates a Vue plugin to provide stack context at app level.
+ *
+ * @param options Configuration options
+ * @returns Vue plugin instance
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-stack
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { createStackPlugin } from '@vuetify/v0'
+ *
+ * const app = createApp(App)
+ * app.use(createStackPlugin({ baseZIndex: 2000 }))
+ * app.mount('#app')
+ * ```
+ */
+declare function createStackPlugin<Z extends StackTicketInput = StackTicketInput, E extends StackTicket<Z> = StackTicket<Z>, R extends StackContext<Z, E> = StackContext<Z, E>>(_options?: StackPluginOptions): Plugin;
+/**
+ * Returns the current stack context.
+ *
+ * @param namespace The namespace for the stack context. Defaults to 'v0:stack'.
+ * @returns The stack context instance
+ *
+ * @remarks Falls back to an internal shared instance if no provider exists.
+ * For SSR safety, use createStackPlugin to provide isolated context per app.
+ *
+ * Tickets registered within component setup are automatically unregistered
+ * when the component is unmounted.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-stack
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { shallowRef, watch } from 'vue'
+ *   import { useStack } from '@vuetify/v0'
+ *
+ *   const stack = useStack()
+ *   const isOpen = shallowRef(false)
+ *
+ *   // Ticket is auto-cleaned up when component unmounts
+ *   const ticket = stack.register({
+ *     onDismiss: () => { isOpen.value = false },
+ *   })
+ *
+ *   // Sync selection state with isOpen
+ *   watch(isOpen, v => v ? ticket.select() : ticket.unselect())
+ * </script>
+ *
+ * <template>
+ *   <button @click="isOpen = true">Open</button>
+ *   <div v-if="isOpen" :style="{ zIndex: ticket.zIndex.value }">
+ *     <p>Dialog content</p>
+ *     <button @click="ticket.dismiss()">Close</button>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useStack<Z extends StackTicketInput = StackTicketInput, E extends StackTicket<Z> = StackTicket<Z>, R extends StackContext<Z, E> = StackContext<Z, E>>(namespace?: string): R;
+//#endregion
+//#region src/composables/createStep/index.d.ts
+/**
+ * Input type for step tickets.
+ * Extend this interface to add custom properties.
+ */
+interface StepTicketInput<V = unknown> extends SingleTicketInput<V> {}
+/**
+ * Output type for step tickets.
+ * Includes all input properties plus selection methods.
+ */
+type StepTicket<Z extends StepTicketInput = StepTicketInput> = SingleTicket<Z>;
+/**
+ * Context returned by createStep.
+ *
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ */
+interface StepContext<Z extends StepTicketInput = StepTicketInput, E extends StepTicket<Z> = StepTicket<Z>> extends Omit<SingleContext<Z, E>, 'register' | 'onboard'> {
+  /** Select the first Ticket in the collection */
+  first: () => void;
+  /** Select the last Ticket in the collection */
+  last: () => void;
+  /** Select the next Ticket based on current index */
+  next: () => void;
+  /** Select the previous Ticket based on current index */
+  prev: () => void;
+  /** Step through the collection by a given count */
+  step: (count: number) => void;
+  /** Register a new ticket (accepts input type, returns output type) */
+  register: (ticket?: Partial<Z>) => E;
+  /** Onboard multiple tickets at once */
+  onboard: (registrations: Partial<Z>[]) => E[];
+}
+interface StepOptions extends SingleOptions {
+  /**
+   * Enable circular navigation (wrapping at boundaries).
+   * - true: Navigation wraps around (carousel behavior)
+   * - false: Navigation stops at boundaries (pagination behavior)
+   * @default false
+   */
+  circular?: boolean;
+}
+interface StepContextOptions extends SingleContextOptions {
+  /**
+   * Enable circular navigation (wrapping at boundaries).
+   * - true: Navigation wraps around (carousel behavior)
+   * - false: Navigation stops at boundaries (pagination behavior)
+   * @default false
+   */
+  circular?: boolean;
+}
+/**
+ * Creates a new step instance with navigation through items.
+ *
+ * Extends `createSingle` with `first()`, `last()`, `next()`, `prev()`, and `step(count)` methods
+ * for sequential navigation. Supports both circular (wrapping) and bounded (stopping at edges) modes.
+ *
+ * @param options The options for the step instance.
+ * @template Z The type of the step ticket.
+ * @template E The type of the step context.
+ * @returns A new step instance with navigation methods.
+ *
+ * @remarks
+ * **Key Features:**
+ * - **Configurable Navigation**: `circular: true` for wrapping, `false` for bounded (default: false)
+ * - **Disabled Item Skipping**: Automatically skips disabled items during navigation
+ * - **Bidirectional**: Forward (`next`, positive `step`) and backward (`prev`, negative `step`)
+ * - **Safe Edge Cases**: Handles empty registries and all-disabled scenarios gracefully
+ *
+ * **Navigation Methods:**
+ * - `first()`: Select first non-disabled item
+ * - `last()`: Select last non-disabled item
+ * - `next()`: Move to next item (wraps if circular, stops at end if bounded)
+ * - `prev()`: Move to previous item (wraps if circular, stops at start if bounded)
+ * - `step(count)`: Move by `count` positions (negative for backward)
+ *
+ * **Circular Mode (`circular: true`):**
+ * - Uses modulo arithmetic for wrapping: `((index % length) + length) % length`
+ * - Works correctly with negative indexes and large step counts
+ * - Perfect for carousels, theme switchers, infinite scrolling
+ *
+ * **Bounded Mode (`circular: false`, default):**
+ * - Navigation stops at boundaries (no wrapping)
+ * - `next()` on last item does nothing
+ * - `prev()` on first item does nothing
+ * - Perfect for pagination, wizards with explicit completion, forms
+ *
+ * **Inheritance Chain:**
+ * `useRegistry` → `createSelection` → `createSingle` → `createStep`
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-step
+ *
+ * @example
+ * ```ts
+ * import { createStep } from '@vuetify/v0'
+ *
+ * // Bounded navigation (default) - for pagination
+ * const pagination = createStep({ circular: false })
+ * pagination.onboard([
+ *   { id: 'page-1', value: 1 },
+ *   { id: 'page-2', value: 2 },
+ *   { id: 'page-3', value: 3 },
+ * ])
+ * pagination.first() // Select page 1
+ * pagination.prev() // Does nothing (already at first)
+ * pagination.next() // Select page 2
+ *
+ * // Circular navigation - for carousels
+ * const carousel = createStep({ circular: true })
+ * carousel.onboard([
+ *   { id: 'slide-1', value: 'First' },
+ *   { id: 'slide-2', value: 'Second' },
+ *   { id: 'slide-3', value: 'Third' },
+ * ])
+ * carousel.first()
+ * carousel.prev() // Wraps to 'slide-3'
+ * carousel.next() // Wraps to 'slide-1'
+ * ```
+ */
+declare function createStep<Z extends StepTicketInput = StepTicketInput, E extends StepTicket<Z> = StepTicket<Z>, R extends StepContext<Z, E> = StepContext<Z, E>>(_options?: StepOptions): R;
+/**
+ * Creates a new step context.
+ *
+ * @param options The options for the step context.
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ * @template R The context type.
+ * @returns A new step context.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-step
+ *
+ * @example
+ * ```ts
+ * import { createStepContext } from '@vuetify/v0'
+ *
+ * // With default namespace 'v0:step'
+ * export const [useStep, provideStep, context] = createStepContext()
+ *
+ * // In a parent component:
+ * provideStep()
+ *
+ * // In a child component:
+ * const context = useStep()
+ * context.next() // Progress to next step
+ * ```
+ */
+declare function createStepContext<Z extends StepTicketInput = StepTicketInput, E extends StepTicket<Z> = StepTicket<Z>, R extends StepContext<Z, E> = StepContext<Z, E>>(_options?: StepContextOptions): ContextTrinity<R>;
+/**
+ * Returns the current step instance.
+ *
+ * @param namespace The namespace for the step context. Defaults to `'v0:step'`.
+ * @template Z The input ticket type.
+ * @template E The output ticket type.
+ * @template R The context type.
+ * @returns The current step instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-step
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useStep } from '@vuetify/v0'
+ *
+ *   const wizard = useStep()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Current step: {{ wizard.selectedIndex }}</p>
+ *     <button @click="wizard.next()">Next</button>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useStep<Z extends StepTicketInput = StepTicketInput, E extends StepTicket<Z> = StepTicket<Z>, R extends StepContext<Z, E> = StepContext<Z, E>>(namespace?: string): R;
+//#endregion
 //#region src/composables/useStorage/adapters/adapter.d.ts
 interface StorageAdapter$1 {
   getItem: (key: string) => string | null;
@@ -3928,7 +6181,7 @@ interface ToggleScopeControls {
  */
 declare function useToggleScope(source: WatchSource<boolean>, fn: (() => void) | ((controls: ToggleScopeControls) => void)): ToggleScopeControls;
 //#endregion
-//#region src/composables/useVirtual/index.d.ts
+//#region src/composables/createVirtual/index.d.ts
 type VirtualDirection = 'forward' | 'reverse';
 type VirtualState = 'loading' | 'empty' | 'error' | 'ok';
 type VirtualAnchor = 'auto' | 'start' | 'end' | ((items: readonly unknown[]) => number | string);
@@ -4007,9 +6260,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { element } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { element } = virtual
    * </script>
    *
    * <template>
@@ -4027,9 +6281,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { items } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { items } = virtual
    * </script>
    *
    * <template>
@@ -4046,9 +6301,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { offset } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { offset } = virtual
    * </script>
    *
    * <template>
@@ -4063,9 +6319,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { size } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { size } = virtual
    * </script>
    *
    * <template>
@@ -4080,9 +6337,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { state } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { state } = virtual
    * </script>
    *
    * <template>
@@ -4100,9 +6358,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { scrollTo } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { scrollTo } = virtual
    * </script>
    *
    * <template>
@@ -4118,9 +6377,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { element, scroll } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { element, scroll } = virtual
    * </script>
    *
    * <template>
@@ -4139,9 +6399,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { scroll, scrollend } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { scroll, scrollend } = virtual
    * </script>
    *
    * <template>
@@ -4160,9 +6421,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { resize } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { resize } = virtual
    * </script>
    *
    * <template>
@@ -4177,9 +6439,10 @@ interface VirtualContext<T = unknown> {
    * @example
    * ```vue
    * <script setup lang="ts">
-   *   import { useVirtual } from '@vuetify/v0'
+   *   import { createVirtual } from '@vuetify/v0'
    *
-   *   const { reset } = useVirtual(items)
+   *   const virtual = createVirtual(items)
+   *   const { reset } = virtual
    * </script>
    *
    * <template>
@@ -4192,6 +6455,10 @@ interface VirtualContext<T = unknown> {
    */
   reset: () => void;
 }
+interface VirtualContextOptions extends VirtualOptions {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
 /**
  * Virtual scrolling composable for efficiently rendering large lists
  *
@@ -4199,33 +6466,88 @@ interface VirtualContext<T = unknown> {
  * @param options Configuration options
  * @returns Virtual scrolling context
  *
- * @see https://0.vuetifyjs.com/composables/utilities/use-virtual
+ * @see https://0.vuetifyjs.com/composables/utilities/create-virtual
  *
  * @example
  * ```vue
  * <script setup lang="ts">
- *   import { useVirtual } from '@vuetify/v0'
+ *   import { createVirtual } from '@vuetify/v0'
  *
  *   const items = ref(Array.from({ length: 10000 }, (_, i) => ({ id: i, name: `Item ${i}` })))
+ *   const virtual = createVirtual(items)
  * </script>
  *
  * <template>
  *   <div
- *     ref="element"
+ *     ref="virtual.element"
  *     style="height: 600px; overflow-y: auto;"
- *     @scroll="scroll"
+ *     @scroll="virtual.scroll"
  *   >
- *     <div :style="{ height: `${offset}px` }" />
+ *     <div :style="{ height: `${virtual.offset.value}px` }" />
  *
- *     <div v-for="item in items" :key="item.index">
+ *     <div v-for="item in virtual.items.value" :key="item.index">
  *       {{ item.raw.name }}
  *     </div>
  *
- *     <div :style="{ height: `${size}px` }" />
+ *     <div :style="{ height: `${virtual.size.value}px` }" />
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function createVirtual<T = unknown>(items: Ref<readonly T[]>, _options?: VirtualOptions): VirtualContext<T>;
+/**
+ * Creates a virtual scrolling context with dependency injection support.
+ *
+ * @param items Reactive array of items to virtualize
+ * @param options Configuration options including namespace
+ * @template T The type of the items
+ * @returns Trinity tuple: [useVirtual, provideVirtual, defaultVirtual]
+ *
+ * @see https://0.vuetifyjs.com/composables/utilities/create-virtual
+ *
+ * @example
+ * ```ts
+ * // Create injectable context
+ * const [useVirtual, provideVirtual, virtual] = createVirtualContext(items, {
+ *   namespace: 'my-virtual',
+ *   overscan: 10,
+ * })
+ *
+ * // In parent component
+ * provideVirtual()
+ *
+ * // In child component
+ * const virtual = useVirtual()
+ * ```
+ */
+declare function createVirtualContext<T = unknown>(items: Ref<readonly T[]>, _options?: VirtualContextOptions): ContextTrinity<VirtualContext<T>>;
+/**
+ * Returns the current virtual context from dependency injection.
+ *
+ * @param namespace The namespace for the virtual context. Defaults to `v0:virtual`.
+ * @template T The type of the items
+ * @returns The current virtual context.
+ *
+ * @throws An error if the virtual context is not found and no default is provided.
+ *
+ * @see https://0.vuetifyjs.com/composables/utilities/create-virtual
+ *
+ * @example
+ * ```vue
+ * <script lang="ts" setup>
+ *   import { createVirtual } from '@vuetify/v0'
+ *
+ *   // Inject virtual context provided by parent
+ *   const virtual = useVirtual()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Visible items: {{ virtual.items.value.length }}</p>
  *   </div>
  * </template>
  * ```
  */
-declare function useVirtual<T = unknown>(items: Ref<readonly T[]>, _options?: VirtualOptions): VirtualContext<T>;
+declare function useVirtual<T = unknown>(namespace?: string): VirtualContext<T>;
 //#endregion
-export { QueueTicket as $, createForm as $n, useDate as $r, LoggerPluginOptions as $t, useTheme as A, useElementIntersection as An, TokenAlias as Ar, singleOpenStrategy as At, useStorage as B, useHydration as Bn, useTokens as Br, OpenStrategyContext as Bt, ThemePluginOptions as C, provideContext as Ci, LazyContext as Cn, createFeaturesPlugin as Cr, createOverflow as Ct, createTheme as D, IntersectionObserverOptions as Dn, FeaturesAdapterInterface as Dr, createNestedContext as Dt, ThemeTicketInput as E, IntersectionObserverEntry as En, FeaturesAdapterFlags as Er, createNested as Et, StorageOptions as F, HydrationPluginOptions as Fn, TokenPrimitive as Fr, NestedRegistration as Ft, ResizeObserverOptions as G, FormContext as Gn, useWindowEventListener as Gr, MediaQueryContext as Gt, StorageType as H, UseHotkeyOptions as Hn, EventHandler as Hr, UseMutationObserverOptions as Ht, StoragePluginOptions as I, createFallbackHydration as In, TokenTicket as Ir, NestedSelectionMode as It, useElementSize as J, FormTicket as Jn, DateOptions as Jr, usePrefersDark as Jt, UseElementSizeReturn as K, FormContextOptions as Kn, DateContext as Kr, useMediaQuery as Kt, createStorage as L, createHydration as Ln, TokenValue as Lr, NestedTicket as Lt, ThemeAdapter as M, HydrationContext as Mn, TokenContext as Mr, NestedContextOptions as Mt, StorageContext as N, HydrationContextOptions as Nn, TokenContextOptions as Nr, NestedOpenMode as Nt, createThemeContext as O, UseElementIntersectionReturn as On, FeaturesAdapterValue as Or, useNested as Ot, StorageContextOptions as P, HydrationOptions as Pn, TokenOptions as Pr, NestedOptions as Pt, QueueOptions as Q, FormValue as Qn, createDatePlugin as Qr, LoggerOptions as Qt, createStorageContext as R, createHydrationContext as Rn, createTokens as Rr, NestedTicketInput as Rt, ThemeOptions as S, createContext as Si, LocaleAdapter as Sn, createFeaturesContext as Sr, OverflowOptions as St, ThemeTicket as T, useLazy as Tn, FeaturesAdapter as Tr, useOverflow as Tt, MemoryAdapter as U, UseHotkeyReturn as Un, useDocumentEventListener as Ur, UseMutationObserverReturn as Ut, StorageAdapter as V, PlatformContext as Vn, CleanupFunction as Vr, MutationObserverRecord as Vt, ResizeObserverEntry as W, useHotkey as Wn, useEventListener as Wr, useMutationObserver as Wt, QueueContext as X, FormValidationResult as Xn, createDate as Xr, LoggerContext as Xt, useResizeObserver as Y, FormTicketInput as Yn, DatePluginOptions as Yr, usePrefersReducedMotion as Yt, QueueContextOptions as Z, FormValidationRule as Zn, createDateContext as Zr, LoggerContextOptions as Zt, useTimeline as _, Plugin as _i, createLocaleContext as _n, FeatureOptions as _r, usePermissions as _t, VirtualItem as a, useClickOutside as ai, Vuetify0LoggerAdapter as an, FilterItem as ar, ProxyRegistryOptions as at, ThemeContext as b, ContextKey as bi, useLocale as bn, FeatureTicketInput as br, OverflowContext as bt, useVirtual as c, BreakpointsContextOptions as ci, LoggerAdapter as cn, FilterQuery as cr, useProxyModel as ct, TimelineContext as d, createBreakpoints as di, LocaleOptions as dn, createFilter as dr, PermissionOptions as dt, ClickOutsideElement as ei, createLogger as en, createFormContext as er, QueueTicketInput as et, TimelineContextOptions as f, createBreakpointsContext as fi, LocalePluginOptions as fn, createFilterContext as fr, PermissionPluginOptions as ft, createTimelineContext as g, toArray as gi, createLocale as gn, FeatureContextOptions as gr, createPermissionsPlugin as gt, createTimeline as h, toReactive as hi, LocaleTicketInput as hn, FeatureContext as hr, createPermissionsContext as ht, VirtualDirection as i, UseClickOutsideReturn as ii, LogLevel as in, FilterFunction as ir, ProxyRegistryContext as it, Vuetify0ThemeAdapter as j, useIntersectionObserver as jn, TokenCollection as jr, NestedContext as jt, createThemePlugin as k, UseIntersectionObserverReturn as kn, FlatTokenCollection as kr, multipleOpenStrategy as kt, ToggleScopeControls as l, BreakpointsOptions as li, LocaleContext as ln, FilterResult as lr, PermissionContext as lt, TimelineTicket as m, useBreakpoints as mi, LocaleTicket as mn, useFilterContext as mr, createPermissions as mt, VirtualAnchor as n, ClickOutsideTarget as ni, createLoggerPlugin as nn, FilterContext as nr, createQueueContext as nt, VirtualOptions as o, BreakpointName as oi, PinoLoggerAdapter as on, FilterMode as or, useProxyRegistry as ot, TimelineOptions as p, createBreakpointsPlugin as pi, LocaleRecord as pn, useFilter as pr, PermissionTicket as pt, UseResizeObserverReturn as q, FormOptions as qn, DateContextOptions as qr, usePrefersContrast as qt, VirtualContext as r, UseClickOutsideOptions as ri, useLogger as rn, FilterContextOptions as rr, useQueue as rt, VirtualState as s, BreakpointsContext as si, ConsolaLoggerAdapter as sn, FilterOptions as sr, ProxyModelOptions as st, ScrollToOptions as t, ClickOutsideIgnoreTarget as ti, createLoggerContext as tn, useForm as tr, createQueue as tt, useToggleScope as u, BreakpointsPluginOptions as ui, LocaleContextOptions as un, Primitive as ur, PermissionContextOptions as ut, Colors as v, PluginOptions as vi, createLocaleFallback as vn, FeaturePluginOptions as vr, PermissionAdapter as vt, ThemeRecord as w, useContext as wi, LazyOptions as wn, useFeatures as wr, createOverflowContext as wt, ThemeContextOptions as x, CreateContextOptions as xi, Vuetify0LocaleAdapter as xn, createFeatures as xr, OverflowContextOptions as xt, ThemeColors as y, createPlugin as yi, createLocalePlugin as yn, FeatureTicket as yr, PermissionAdapterInterface as yt, createStoragePlugin as z, createHydrationPlugin as zn, createTokensContext as zr, OpenStrategy as zt };
+export { createStepContext as $, useSelection as $a, FilterContext as $i, createHydration as $n, createDate as $r, NestedTicket as $t, createTheme as A, BreadcrumbTicket as Aa, DataTableSelection as Ai, LocaleTicket as An, FeaturesAdapterInterface as Ar, PermissionContext as At, createStorage as B, SingleOptions as Ba, DataTableAdapter as Bi, LazyOptions as Bn, TokenValue as Br, PermissionAdapterInterface as Bt, ThemeContext as C, GroupContextOptions as Ca, DataTableColumn as Ci, ConsolaLoggerAdapter as Cn, FeatureTicketInput as Cr, createQueueContext as Ct, ThemeRecord as D, createGroup as Da, DataTableGroup as Di, LocaleOptions as Dn, useFeatures as Dr, useProxyRegistry as Dt, ThemePluginOptions as E, GroupTicketInput as Ea, DataTableExpansion as Ei, LocaleContextOptions as En, createFeaturesPlugin as Er, ProxyRegistryOptions as Et, ThemeAdapter as F, createBreadcrumbs as Fa, useDataTable as Fi, createLocalePlugin as Fn, TokenContext as Fr, createPermissions as Ft, StorageType as G, useSingle as Ga, SortEntry as Gi, UseIntersectionObserverReturn as Gn, EventHandler as Gr, singleOpenStrategy as Gt, createStoragePlugin as H, SingleTicketInput as Ha, DataTableAdapterInterface as Hi, IntersectionObserverEntry as Hn, createTokensContext as Hr, createNestedContext as Ht, StorageContext as I, createBreadcrumbsContext as Ia, VirtualAdapter as Ii, useLocale as In, TokenContextOptions as Ir, createPermissionsContext as It, StepContextOptions as J, SelectionOptions as Ja, PaginationOptions as Ji, HydrationContext as Jn, useWindowEventListener as Jr, NestedContextOptions as Jt, MemoryAdapter as K, SelectionContext as Ka, PaginationContext as Ki, useElementIntersection as Kn, useDocumentEventListener as Kr, NestedActiveMode as Kt, StorageContextOptions as L, useBreadcrumbs as La, ClientAdapter as Li, Vuetify0LocaleAdapter as Ln, TokenOptions as Lr, createPermissionsPlugin as Lt, createThemePlugin as M, BreadcrumbsContext as Ma, SelectStrategy as Mi, createLocale as Mn, FlatTokenCollection as Mr, PermissionOptions as Mt, useTheme as N, BreadcrumbsContextOptions as Na, createDataTable as Ni, createLocaleContext as Nn, TokenAlias as Nr, PermissionPluginOptions as Nt, ThemeTicket as O, createGroupContext as Oa, DataTableGrouping as Oi, LocalePluginOptions as On, FeaturesAdapter as Or, ProxyModelOptions as Ot, Vuetify0ThemeAdapter as P, BreadcrumbsOptions as Pa, createDataTableContext as Pi, createLocaleFallback as Pn, TokenCollection as Pr, PermissionTicket as Pt, createStep as Q, createSelectionContext as Qa, usePagination as Qi, createFallbackHydration as Qn, DatePluginOptions as Qr, NestedSelectionMode as Qt, StorageOptions as R, SingleContext as Ra, ServerAdapter as Ri, LocaleAdapter as Rn, TokenPrimitive as Rr, usePermissions as Rt, ThemeColors as S, GroupContext as Sa, createPlugin as Si, PinoLoggerAdapter as Sn, FeatureTicket as Sr, createQueue as St, ThemeOptions as T, GroupTicket as Ta, DataTableContextOptions as Ti, LocaleContext as Tn, createFeaturesContext as Tr, ProxyRegistryContext as Tt, useStorage as U, createSingle as Ua, DataTableAdapterResult as Ui, IntersectionObserverOptions as Un, useTokens as Ur, useNested as Ut, createStorageContext as V, SingleTicket as Va, DataTableAdapterContext as Vi, useLazy as Vn, createTokens as Vr, createNested as Vt, StorageAdapter as W, createSingleContext as Wa, SortDirection as Wi, UseElementIntersectionReturn as Wn, CleanupFunction as Wr, multipleOpenStrategy as Wt, StepTicket as X, SelectionTicketInput as Xa, createPagination as Xi, HydrationOptions as Xn, DateContextOptions as Xr, NestedOptions as Xt, StepOptions as Y, SelectionTicket as Ya, PaginationTicket as Yi, HydrationContextOptions as Yn, DateContext as Yr, NestedOpenMode as Yt, StepTicketInput as Z, createSelection as Za, createPaginationContext as Zi, HydrationPluginOptions as Zn, DateOptions as Zr, NestedRegistration as Zt, TimelineTicket as _, OverflowContextOptions as _a, useBreakpoints as _i, createLoggerContext as _n, useForm as _r, QueueContext as _t, VirtualDirection as a, FilterQuery as aa, ClickOutsideTarget as ai, UseMutationObserverReturn as an, RegistryOptions as ao, UseHotkeyReturn as ar, StackTicket as at, useTimeline as b, createOverflowContext as ba, Plugin as bi, LogLevel as bn, FeatureOptions as br, QueueTicket as bt, VirtualState as c, createFilter as ca, useClickOutside as ci, useMediaQuery as cn, createRegistryContext as co, FormContextOptions as cr, createStackContext as ct, useVirtual as d, ContextKey as da, BreakpointsContextOptions as di, usePrefersReducedMotion as dn, createTrinity as do, FormTicketInput as dr, ResizeObserverEntry as dt, FilterContextOptions as ea, createDateContext as ei, NestedTicketInput as en, RegistryContext as eo, createHydrationContext as er, useStep as et, ToggleScopeControls as f, CreateContextOptions as fa, BreakpointsOptions as fi, LoggerContext as fn, FormValidationResult as fr, ResizeObserverOptions as ft, TimelineOptions as g, OverflowContext as ga, createBreakpointsPlugin as gi, createLogger as gn, createFormContext as gr, useResizeObserver as gt, TimelineContextOptions as h, useContext as ha, createBreakpointsContext as hi, LoggerPluginOptions as hn, createForm as hr, useElementSize as ht, VirtualContextOptions as i, FilterOptions as ia, ClickOutsideIgnoreTarget as ii, UseMutationObserverOptions as in, RegistryEventName as io, UseHotkeyOptions as ir, StackPluginOptions as it, createThemeContext as j, BreadcrumbTicketInput as ja, DataTableSort as ji, LocaleTicketInput as jn, FeaturesAdapterValue as jr, PermissionContextOptions as jt, ThemeTicketInput as k, useGroup as ka, DataTableOptions as ki, LocaleRecord as kn, FeaturesAdapterFlags as kr, useProxyModel as kt, createVirtual as l, createFilterContext as la, BreakpointName as li, usePrefersContrast as ln, useRegistry as lo, FormOptions as lr, createStackPlugin as lt, TimelineContext as m, provideContext as ma, createBreakpoints as mi, LoggerOptions as mn, FormValue as mr, UseResizeObserverReturn as mt, VirtualAnchor as n, FilterItem as na, useDate as ni, OpenStrategyContext as nn, RegistryEventCallback as no, useHydration as nr, StackContextOptions as nt, VirtualItem as o, FilterResult as oa, UseClickOutsideOptions as oi, useMutationObserver as on, RegistryTicket as oo, useHotkey as or, StackTicketInput as ot, useToggleScope as p, createContext as pa, BreakpointsPluginOptions as pi, LoggerContextOptions as pn, FormValidationRule as pr, UseElementSizeReturn as pt, StepContext as q, SelectionContextOptions as qa, PaginationContextOptions as qi, useIntersectionObserver as qn, useEventListener as qr, NestedContext as qt, VirtualContext as r, FilterMode as ra, ClickOutsideElement as ri, MutationObserverRecord as rn, RegistryEventMap as ro, PlatformContext as rr, StackOptions as rt, VirtualOptions as s, Primitive as sa, UseClickOutsideReturn as si, MediaQueryContext as sn, createRegistry as so, FormContext as sr, createStack as st, ScrollToOptions as t, FilterFunction as ta, createDatePlugin as ti, OpenStrategy as tn, RegistryContextOptions as to, createHydrationPlugin as tr, StackContext as tt, createVirtualContext as u, useFilter as ua, BreakpointsContext as ui, usePrefersDark as un, ContextTrinity as uo, FormTicket as ur, useStack as ut, createTimeline as v, OverflowOptions as va, toReactive as vi, createLoggerPlugin as vn, FeatureContext as vr, QueueContextOptions as vt, ThemeContextOptions as w, GroupOptions as wa, DataTableContext as wi, LoggerAdapter as wn, createFeatures as wr, useQueue as wt, Colors as x, useOverflow as xa, PluginOptions as xi, Vuetify0LoggerAdapter as xn, FeaturePluginOptions as xr, QueueTicketInput as xt, createTimelineContext as y, createOverflow as ya, toArray as yi, useLogger as yn, FeatureContextOptions as yr, QueueOptions as yt, StoragePluginOptions as z, SingleContextOptions as za, ServerAdapterOptions as zi, LazyContext as zn, TokenTicket as zr, PermissionAdapter as zt };