@vuetify/v0 0.1.2 → 0.1.4

package/dist/{index-CLKfXGEQ.d.mts → index-Dd0m0LIJ.d.mts}

@@ -1,10 +1,1499 @@
-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-BFBN5Zl3.mjs";
+import { E as ContextTrinity } from "./adapter-BN-h5JbD.mjs";
+import { t as DateAdapter } from "./adapter-DcwxFryd.mjs";
+import { n as FeaturesAdapterFlags, r as FeaturesAdapterInterface } from "./index-BuOz3Rgm.mjs";
+import { n as LocaleAdapter } from "./v0-DHMoZ7dS.mjs";
+import { t as LoggerAdapter } from "./adapter-CJIj5ySf.mjs";
+import { t as StorageAdapter } from "./index-BDTbJClL.mjs";
 import { App, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, Reactive, Ref, ShallowRef, UnwrapNestedRefs, WatchSource } from "vue";
 
+//#region src/composables/createRegistry/index.d.ts
+
+/**
+ * User-facing input shape for registry tickets.
+ *
+ * Extend this when defining custom ticket types passed to `register()` and `onboard()`.
+ * The registry adds the computed fields (`index`, `valueIsIndex`) automatically — those
+ * live on {@link RegistryTicket}, which is the output type returned by `get()` and `values()`.
+ *
+ * @template V The type of the ticket value.
+ */
+interface RegistryTicketInput<V = unknown> {
+  /** The unique identifier. Optional — auto-generated if not provided. */
+  id?: ID;
+  /** The value associated with the ticket. If not provided, it defaults to the index. */
+  value?: V;
+}
+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 extends RegistryEventName = RegistryEventName> = (data: RegistryEventMap<Z>[K]) => void;
+/** Resolves callback type: typed for known events, unknown for custom events */
+type EventHandler$1<Z extends RegistryTicket, K extends string> = K extends RegistryEventName ? (data: RegistryEventMap<Z>[K]) => void : (data: unknown) => void;
+/** Resolves payload type: typed for known events, unknown for custom events */
+type EventPayload<Z extends RegistryTicket, K extends string> = K extends RegistryEventName ? RegistryEventMap<Z>[K] : unknown;
+interface RegistryContext<Z extends RegistryTicketInput = RegistryTicketInput, E extends RegistryTicket & Z = RegistryTicket & Z> {
+  /**
+   * The collection of tickets in the registry
+   *
+   * @template ID The type of the ticket ID.
+   * @template E 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, E>;
+  /**
+   * 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: E['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) => E | 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>) => E;
+  /**
+   * 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 E[];
+  /**
+   * 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, E][];
+  /**
+   * 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 & RegistryTicket>) => E;
+  /**
+   * 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: E) => boolean) => E | 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 extends Extensible<RegistryEventName>>(event: K, cb: EventHandler$1<E, K>) => 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 extends Extensible<RegistryEventName>>(event: K, cb: EventHandler$1<E, K>) => 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 extends Extensible<RegistryEventName>>(event: K, data: EventPayload<E, K>) => 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 & RegistryTicket>[]) => E[];
+  /**
+   * 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 RegistryTicketInput = RegistryTicketInput, E extends RegistryTicket & Z = RegistryTicket & Z>(options?: RegistryOptions): RegistryContext<Z, 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 RegistryTicketInput = RegistryTicketInput, E extends RegistryTicket & Z = RegistryTicket & Z>(_options?: RegistryContextOptions): ContextTrinity<RegistryContext<Z, 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 RegistryTicketInput = RegistryTicketInput, E extends RegistryTicket & Z = RegistryTicket & Z>(namespace?: string): RegistryContext<Z, 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 RegistryTicketInput<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> = RegistryTicket & 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 */
@@ -127,6 +1616,50 @@ interface Plugin {
  * })
  */
 declare function createPlugin<Z extends Plugin = Plugin>(options: PluginOptions): Z;
+interface PluginContextConfig<O, E> {
+  /**
+   * Optional plugin setup callback, called once per Vue app after context provision.
+   * Use for adapter initialization, Vue app mixins, global side effects, etc.
+   * Receives the plugin options (minus namespace) so adapters and targets are accessible.
+   */
+  setup?: (context: E, app: App, options: O) => void;
+  /**
+   * Optional fallback factory. When provided, the generated `useX` consumer uses the
+   * defensive pattern: returns the fallback when called outside a component instance or
+   * when the context is not found. Required for composables that may be consumed outside
+   * component setup (e.g. useLogger, useLocale, useHydration).
+   *
+   * Receives the requested namespace so error messages can include it.
+   */
+  fallback?: (namespace: string) => E;
+}
+/**
+ * Creates the three standard functions for a plugin composable.
+ *
+ * @param defaultNamespace The default DI namespace string (e.g. `'v0:logger'`).
+ * @param factory Function that creates the composable context instance from options.
+ * @param config Optional setup callback and fallback factory.
+ * @returns A readonly tuple: `[createXContext, createXPlugin, useX]`.
+ *
+ * @example
+ * ```ts
+ * // Simple — no setup or fallback
+ * export const [createStorageContext, createStoragePlugin, useStorage] =
+ *   createPluginContext('v0:storage', options => createStorage(options))
+ *
+ * // With fallback — safe outside component instances
+ * export const [createLoggerContext, createLoggerPlugin, useLogger] =
+ *   createPluginContext('v0:logger', options => createLogger(options), {
+ *     fallback: ns => createFallbackLogger(ns),
+ *     setup: (context) => {
+ *       if (__DEV__ && IN_BROWSER) (window as any).__v0Logger__ = context
+ *     },
+ *   })
+ * ```
+ */
+declare function createPluginContext<O extends {
+  namespace?: string;
+} = Record<never, never>, E = unknown>(defaultNamespace: string, factory: (options: Omit<O, 'namespace'>) => E, config?: PluginContextConfig<Omit<O, 'namespace'>, E>): readonly [<_E extends E = E>(_options?: O) => ContextTrinity<_E>, (_options?: O) => Plugin, <_E extends E = E>(namespace?: string) => _E];
 //#endregion
 //#region src/composables/toArray/index.d.ts
 /**
@@ -220,111 +1753,31 @@ interface BreakpointsContextOptions extends BreakpointsOptions {}
  * Creates a new breakpoints instance.
  *
  * @param options The options for the breakpoints instance.
- * @template E The type of the breakpoints context.
- * @returns A new breakpoints instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
- *
- * @example
- * ```ts
- * import { createBreakpoints } from '@vuetify/v0'
- *
- * export const [useBreakpoints, provideBreakpoints] = createBreakpoints({
- *   namespace: 'v0:breakpoints',
- *   mobileBreakpoint: 'sm',
- *   breakpoints: {
- *     xs: 0,
- *     sm: 680,
- *     md: 1024,
- *     lg: 1280,
- *     xl: 1920,
- *     xxl: 2560,
- *   },
- * })
- * ```
- */
-declare function createBreakpoints<E extends BreakpointsContext = BreakpointsContext>(_options?: BreakpointsOptions): E;
-/**
- * Creates a new breakpoints context.
- *
- * @param options The options for the breakpoints context.
- * @template E The type of the breakpoints context.
- * @returns A new breakpoints context.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
- *
- * @example
- * ```ts
- * import { createBreakpointsContext } from '@vuetify/v0'
- *
- * export const [useBreakpoints, provideBreakpoints, context] = createBreakpointsContext({
- *   namespace: 'v0:breakpoints',
- *   mobileBreakpoint: 'sm',
- * })
- * ```
- */
-declare function createBreakpointsContext<E extends BreakpointsContext = BreakpointsContext>(_options?: BreakpointsContextOptions): ContextTrinity<E>;
-/**
- * Creates a new breakpoints plugin.
- *
- * @param options The options for the breakpoints plugin.
- * @template E The type of the breakpoints context.
- * @returns A new breakpoints plugin.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
- *
- * @example
- * ```ts
- * import { createApp } from 'vue'
- * import { createBreakpointsPlugin } from '@vuetify/v0'
- * import App from './App.vue'
- *
- * const app = createApp(App)
- *
- * app.use(
- *   createBreakpointsPlugin({
- *     namespace: 'v0:breakpoints',
- *     mobileBreakpoint: 'sm',
- *     breakpoints: {
- *       xs: 0,
- *       sm: 680,
- *       md: 1024,
- *       lg: 1280,
- *       xl: 1920,
- *       xxl: 2560,
- *     },
- *   })
- * )
- *
- * app.mount('#app')
- * ```
- */
-declare function createBreakpointsPlugin<E extends BreakpointsContext = BreakpointsContext>(_options?: BreakpointsPluginOptions): Plugin;
-/**
- * Returns the current breakpoints instance.
- *
- * @param namespace The namespace for the breakpoints context. Defaults to `v0:breakpoints`.
- * @returns The current breakpoints instance.
+ * @template E The type of the breakpoints context.
+ * @returns A new breakpoints instance.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
  *
  * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useBreakpoints } from '@vuetify/v0'
- *
- *   const { isMobile, mdAndUp } = useBreakpoints()
- * </script>
+ * ```ts
+ * import { createBreakpoints } from '@vuetify/v0'
  *
- * <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>
- *   </div>
- * </template>
+ * export const [useBreakpoints, provideBreakpoints] = createBreakpoints({
+ *   namespace: 'v0:breakpoints',
+ *   mobileBreakpoint: 'md',
+ *   breakpoints: {
+ *     xs: 0,
+ *     sm: 600,
+ *     md: 840,
+ *     lg: 1145,
+ *     xl: 1545,
+ *     xxl: 2138,
+ *   },
+ * })
  * ```
  */
-declare function useBreakpoints<E extends BreakpointsContext = BreakpointsContext>(namespace?: string): E;
+declare function createBreakpoints<E extends BreakpointsContext = BreakpointsContext>(_options?: BreakpointsOptions): E;
+declare const createBreakpointsContext: <_E extends BreakpointsContext = BreakpointsContext>(_options?: BreakpointsContextOptions | undefined) => ContextTrinity<_E>, createBreakpointsPlugin: (_options?: BreakpointsContextOptions | undefined) => Plugin, useBreakpoints: <_E extends BreakpointsContext = BreakpointsContext>(namespace?: string) => _E;
 //#endregion
 //#region src/composables/useClickOutside/index.d.ts
 type ClickOutsideElement = HTMLElement | null | undefined;
@@ -827,34 +2280,6 @@ declare function createTokensContext<Z extends TokenTicket = TokenTicket, E exte
  */
 declare function useTokens<Z extends TokenTicket = TokenTicket, E extends TokenContext<Z> = TokenContext<Z>>(namespace?: string): E;
 //#endregion
-//#region src/composables/useFeatures/adapters/generic/index.d.ts
-type FeaturesAdapterValue = boolean | {
-  $value?: boolean;
-  $variation?: unknown;
-};
-type FeaturesAdapterFlags = Record<ID, FeaturesAdapterValue>;
-interface FeaturesAdapterInterface {
-  /**
-   * Initialize the adapter and return initial flags.
-   *
-   * @param onUpdate Callback invoked when flags change.
-   * @returns Initial feature flags.
-   *
-   * @remarks Called during plugin setup. Sets up change listeners
-   * and returns the initial flag values.
-   */
-  setup: (onUpdate: (flags: FeaturesAdapterFlags) => void) => FeaturesAdapterFlags;
-  /**
-   * Cleanup adapter resources.
-   *
-   * @remarks Called when the plugin is disposed.
-   */
-  dispose?: () => void;
-}
-declare abstract class FeaturesAdapter implements FeaturesAdapterInterface {
-  abstract setup(onUpdate: (flags: FeaturesAdapterFlags) => void): FeaturesAdapterFlags;
-}
-//#endregion
 //#region src/composables/useFeatures/index.d.ts
 /**
  * Input type for feature tickets - what users provide to register().
@@ -925,225 +2350,7 @@ interface FeaturePluginOptions extends FeatureContextOptions {
  * ```
  */
 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;
-}
-/**
- * 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>;
-/**
- * A reusable function for filtering an array of items.
- *
- * @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.
- *
- * @see https://0.vuetifyjs.com/composables/utilities/use-filter
- *
- * @example
- * ```ts
- * import { ref } from 'vue'
- * import { useFilter } from '@vuetify/v0'
- *
- * const items = ref([
- *   { name: 'John Doe', age: 30 },
- *   { name: 'Jane Doe', age: 25 },
- *   { name: 'Peter Jones', age: 40 },
- * ])
- *
- * const query = ref('doe')
- * const { items: filtered } = useFilter(query, items, { keys: ['name'] })
- *
- * console.log(filtered.value) // [ { name: 'John Doe', age: 30 }, { name: 'Jane Doe', age: 25 } ]
- * ```
- */
-declare function useFilter<Z extends FilterItem>(query: FilterQuery, items: MaybeRef<Z[]>, options?: FilterOptions): FilterResult<Z>;
-/**
- * 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 { useFilterContext } from '@vuetify/v0'
- *
- *   const filter = useFilterContext()
- *   const { items } = filter.apply(query, products)
- * </script>
- * ```
- */
-declare function useFilterContext<Z extends FilterItem = FilterItem, E extends FilterContext<Z> = FilterContext<Z>>(namespace?: string): E;
+declare const createFeaturesContext: <_E extends FeatureContext<FeatureTicketInput, FeatureTicket<FeatureTicketInput>> = FeatureContext<FeatureTicketInput, FeatureTicket<FeatureTicketInput>>>(_options?: FeaturePluginOptions | undefined) => ContextTrinity<_E>, createFeaturesPlugin: (_options?: FeaturePluginOptions | undefined) => Plugin, useFeatures: <_E extends FeatureContext<FeatureTicketInput, FeatureTicket<FeatureTicketInput>> = FeatureContext<FeatureTicketInput, FeatureTicket<FeatureTicketInput>>>(namespace?: string) => _E;
 //#endregion
 //#region src/composables/createForm/index.d.ts
 type FormValidationResult = string | true | Promise<string | true>;
@@ -1155,7 +2362,7 @@ type FormValue = Ref<unknown> | ShallowRef<unknown>;
  *
  * @template V The type of the field value.
  */
-interface FormTicketInput<V = unknown> extends RegistryTicket<V> {
+interface FormTicketInput<V = unknown> extends RegistryTicketInput<V> {
   /** Validation rules for this field */
   rules?: FormValidationRule[];
   /** When validation should trigger (inherits from form if not set) */
@@ -1169,7 +2376,7 @@ interface FormTicketInput<V = unknown> extends RegistryTicket<V> {
  *
  * @template Z The input ticket type that extends FormTicketInput.
  */
-type FormTicket<Z extends FormTicketInput = FormTicketInput> = Z & {
+type FormTicket<Z extends FormTicketInput = FormTicketInput> = RegistryTicket & Z & {
   validate: (silent?: boolean) => Promise<boolean>;
   reset: () => void;
   validateOn: 'submit' | 'change' | string;
@@ -1432,57 +2639,31 @@ declare function createFallbackHydration<E extends HydrationContext = HydrationC
  * })
  * ```
  */
-declare function createHydrationContext<E extends HydrationContext = HydrationContext>(_options?: HydrationContextOptions): ContextTrinity<E>;
-/**
- * Creates a new hydration plugin.
- *
- * @param options The options for the hydration plugin.
- * @template E The type of the hydration context.
- * @returns A new hydration plugin.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-hydration
- *
- * @example
- * ```ts
- * import { createApp } from 'vue'
- * import { createHydrationPlugin } from '@vuetify/v0'
- * import App from './App.vue'
- *
- * const app = createApp(App)
- *
- * app.use(createHydrationPlugin())
- *
- * app.mount('#app')
- * ```
- */
-declare function createHydrationPlugin<E extends HydrationContext = HydrationContext>(_options?: HydrationPluginOptions): Plugin;
-/**
- * Returns the current hydration instance.
- *
- * @param namespace The namespace for the hydration context. Defaults to `v0:hydration`.
- * @returns The current hydration instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-hydration
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useHydration } from '@vuetify/v0'
- *
- *   const { isHydrated, isSettled } = useHydration()
- *
- *   // Use isSettled to gate animations after state restoration
- *   const transition = computed(() => isSettled.value ? 'fade' : undefined)
- * </script>
- *
- * <template>
- *   <Transition :name="transition">
- *     <div v-if="show">Animates only after hydration settles</div>
- *   </Transition>
- * </template>
- * ```
- */
-declare function useHydration<E extends HydrationContext = HydrationContext>(namespace?: string): E;
+declare const createHydrationContext: <_E extends HydrationContext = HydrationContext>(_options?: HydrationContextOptions | undefined) => ContextTrinity<_E>, createHydrationPlugin: (_options?: HydrationContextOptions | undefined) => Plugin, useHydration: <_E extends HydrationContext = HydrationContext>(namespace?: string) => _E;
+//#endregion
+//#region src/composables/createObserver/index.d.ts
+interface ObserverReturn {
+  /**
+   * Whether the observer is currently active (created and observing)
+   */
+  readonly isActive: Readonly<Ref<boolean>>;
+  /**
+   * Whether the observer is currently paused
+   */
+  readonly isPaused: Readonly<Ref<boolean>>;
+  /**
+   * Pause observation (disconnects observer but keeps it alive)
+   */
+  pause: () => void;
+  /**
+   * Resume observation
+   */
+  resume: () => void;
+  /**
+   * Stop observation and clean up (destroys observer)
+   */
+  stop: () => void;
+}
 //#endregion
 //#region src/composables/useIntersectionObserver/index.d.ts
 interface IntersectionObserverEntry {
@@ -1501,31 +2682,11 @@ interface IntersectionObserverOptions {
   rootMargin?: string;
   threshold?: number | number[];
 }
-interface UseIntersectionObserverReturn {
-  /**
-   * Whether the observer is currently active (created and observing)
-   */
-  readonly isActive: Readonly<Ref<boolean>>;
+interface UseIntersectionObserverReturn extends ObserverReturn {
   /**
    * Whether the target element is currently intersecting with the viewport
    */
   readonly isIntersecting: Readonly<Ref<boolean>>;
-  /**
-   * Whether the observer is currently paused
-   */
-  readonly isPaused: Readonly<Ref<boolean>>;
-  /**
-   * Pause observation (disconnects observer but keeps it alive)
-   */
-  pause: () => void;
-  /**
-   * Resume observation
-   */
-  resume: () => void;
-  /**
-   * Stop observation and clean up (destroys observer)
-   */
-  stop: () => void;
 }
 /**
  * A composable that uses the Intersection Observer API to detect when an element
@@ -1675,25 +2836,6 @@ interface LazyContext {
  */
 declare function useLazy(active: MaybeRefOrGetter<boolean>, options?: LazyOptions): LazyContext;
 //#endregion
-//#region src/composables/useLocale/adapters/adapter.d.ts
-interface LocaleAdapter {
-  t: (message: string, ...params: unknown[]) => string;
-  n: (value: number, locale: ID | undefined, ...params: unknown[]) => string;
-}
-//#endregion
-//#region src/composables/useLocale/adapters/v0.d.ts
-/**
- * Vuetify0.x locale adapter implementation
- *
- * This adapter provides translation and number formatting
- * capabilities using the Intl API and supports both
- * numbered ({0}, {1}) and named ({name}) variables in translation strings.
- */
-declare class Vuetify0LocaleAdapter implements LocaleAdapter {
-  t(message: string, ...params: unknown[]): string;
-  n(value: number, locale: ID | undefined, ...params: unknown[]): string;
-}
-//#endregion
 //#region src/composables/useLocale/index.d.ts
 type LocaleRecord = TokenCollection;
 /**
@@ -1745,138 +2887,16 @@ interface LocalePluginOptions extends LocaleContextOptions {}
 /**
  * Creates a new locale instance.
  *
- * @param options The options for the locale instance.
- * @template Z The type of the locale ticket.
- * @template E The type of the locale context.
- * @returns A new locale instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-locale
- */
-declare function createLocale<Z extends LocaleTicketInput = LocaleTicketInput, E extends LocaleTicket<Z> = LocaleTicket<Z>, R extends LocaleContext<Z, E> = LocaleContext<Z, E>>(_options?: LocaleOptions): R;
-declare function createLocaleFallback<Z extends LocaleTicketInput = LocaleTicketInput, E extends LocaleTicket<Z> = LocaleTicket<Z>, R extends LocaleContext<Z, E> = LocaleContext<Z, E>>(): R;
-/**
- * Creates a new locale context.
- *
- * @param options The options for the locale context.
- * @template Z The type of the locale ticket.
- * @template E The type of the locale context.
- * @returns A new locale context.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-locale
- *
- * @example
- * ```ts
- * import { createLocaleContext } from '@vuetify/v0'
- *
- * export const [useAppLocale, provideAppLocale, appLocale] = createLocaleContext({
- *   namespace: 'app:locale',
- *   messages: {
- *     en: { hello: 'Hello' },
- *     es: { hello: 'Hola' },
- *   },
- * })
- *
- * // In a parent component:
- * provideAppLocale()
- *
- * // In a child component:
- * const locale = useAppLocale()
- * locale.select('es')
- * ```
- */
-declare function createLocaleContext<Z extends LocaleTicketInput = LocaleTicketInput, E extends LocaleTicket<Z> = LocaleTicket<Z>, R extends LocaleContext<Z, E> = LocaleContext<Z, E>>(_options?: LocaleContextOptions): ContextTrinity<R>;
-/**
- * Creates a new locale plugin.
- *
- * @param options The options for the locale plugin.
- * @template Z The type of the locale ticket.
- * @template E The type of the locale context.
- * @template R The type of the token ticket.
- * @template O The type of the token context.
- * @returns A new locale plugin.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-locale
- */
-declare function createLocalePlugin<Z extends LocaleTicketInput = LocaleTicketInput, E extends LocaleTicket<Z> = LocaleTicket<Z>, R extends LocaleContext<Z, E> = LocaleContext<Z, E>>(_options?: LocalePluginOptions): Plugin;
-/**
- * Returns the current locale instance.
- *
- * @returns The current locale instance.
+ * @param options The options for the locale instance.
+ * @template Z The type of the locale ticket.
+ * @template E The type of the locale context.
+ * @returns A new locale instance.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-locale
  */
-declare function useLocale<Z extends LocaleTicketInput = LocaleTicketInput, E extends LocaleTicket<Z> = LocaleTicket<Z>, R extends LocaleContext<Z, E> = LocaleContext<Z, E>>(namespace?: string): R;
-//#endregion
-//#region src/composables/useLogger/adapters/adapter.d.ts
-interface LoggerAdapter {
-  debug: (message: string, ...args: unknown[]) => void;
-  info: (message: string, ...args: unknown[]) => void;
-  warn: (message: string, ...args: unknown[]) => void;
-  error: (message: string, ...args: unknown[]) => void;
-  trace?: (message: string, ...args: unknown[]) => void;
-  fatal?: (message: string, ...args: unknown[]) => void;
-}
-//#endregion
-//#region src/composables/useLogger/adapters/consola.d.ts
-declare class ConsolaLoggerAdapter implements LoggerAdapter {
-  private consola;
-  constructor(consolaInstance: any);
-  debug(message: string, ...args: unknown[]): void;
-  info(message: string, ...args: unknown[]): void;
-  warn(message: string, ...args: unknown[]): void;
-  error(message: string, ...args: unknown[]): void;
-  trace(message: string, ...args: unknown[]): void;
-  fatal(message: string, ...args: unknown[]): void;
-}
-//#endregion
-//#region src/composables/useLogger/adapters/pino.d.ts
-/**
- * Pino logger adapter implementation
- *
- * This adapter integrates with the Pino logging library,
- * providing high-performance structured logging optimized
- * for Node.js applications with minimal overhead.
- */
-declare class PinoLoggerAdapter implements LoggerAdapter {
-  private pino;
-  constructor(pinoInstance: any);
-  debug(message: string, ...args: unknown[]): void;
-  info(message: string, ...args: unknown[]): void;
-  warn(message: string, ...args: unknown[]): void;
-  error(message: string, ...args: unknown[]): void;
-  trace(message: string, ...args: unknown[]): void;
-  fatal(message: string, ...args: unknown[]): void;
-  private format;
-}
-//#endregion
-//#region src/composables/useLogger/adapters/v0.d.ts
-/**
- * Vuetify0.x logger adapter implementation
- *
- * This adapter provides console-based logging with proper formatting,
- * color coding, timestamps, and log level filtering for development
- * and production environments.
- */
-declare class Vuetify0LoggerAdapter implements LoggerAdapter {
-  private prefix;
-  private colors;
-  private timestamps;
-  constructor(options?: {
-    prefix?: string;
-    colors?: boolean;
-    timestamps?: boolean;
-  });
-  debug(message: string, ...args: unknown[]): void;
-  info(message: string, ...args: unknown[]): void;
-  warn(message: string, ...args: unknown[]): void;
-  error(message: string, ...args: unknown[]): void;
-  trace(message: string, ...args: unknown[]): void;
-  fatal(message: string, ...args: unknown[]): void;
-  private format;
-  private timestamp;
-  private style;
-  private log;
-}
+declare function createLocale<Z extends LocaleTicketInput = LocaleTicketInput, E extends LocaleTicket<Z> = LocaleTicket<Z>, R extends LocaleContext<Z, E> = LocaleContext<Z, E>>(_options?: LocaleOptions): R;
+declare function createLocaleFallback<Z extends LocaleTicketInput = LocaleTicketInput, E extends LocaleTicket<Z> = LocaleTicket<Z>, R extends LocaleContext<Z, E> = LocaleContext<Z, E>>(): R;
+declare const createLocaleContext: <_E extends LocaleContext<LocaleTicketInput, LocaleTicket<LocaleTicketInput>> = LocaleContext<LocaleTicketInput, LocaleTicket<LocaleTicketInput>>>(_options?: LocaleContextOptions | undefined) => ContextTrinity<_E>, createLocalePlugin: (_options?: LocaleContextOptions | undefined) => Plugin, useLocale: <_E extends LocaleContext<LocaleTicketInput, LocaleTicket<LocaleTicketInput>> = LocaleContext<LocaleTicketInput, LocaleTicket<LocaleTicketInput>>>(namespace?: string) => _E;
 //#endregion
 //#region src/composables/useLogger/types.d.ts
 type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal' | 'silent';
@@ -1949,56 +2969,7 @@ declare function createLogger<E extends LoggerContext = LoggerContext>(options?:
  * })
  * ```
  */
-declare function createLoggerContext<E extends LoggerContext = LoggerContext>(_options?: LoggerContextOptions): ContextTrinity<E>;
-/**
- * Creates a new logger plugin.
- *
- * @param options The options for the logger plugin.
- * @returns A new logger plugin.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-logger
- *
- * @example
- * ```ts
- * import { createApp } from 'vue'
- * import { createLoggerPlugin } from '@vuetify/v0'
- * import App from './App.vue'
- *
- * const app = createApp(App)
- *
- * app.use(
- *  createLoggerPlugin({
- *    level: 'debug',
- *    prefix: '[MyApp]',
- *  })
- * )
- *
- * app.mount('#app')
- * ```
- */
-declare function createLoggerPlugin<E extends LoggerContext = LoggerContext>(_options?: LoggerPluginOptions): Plugin;
-/**
- * Uses an existing or creates a new logger instance.
- *
- * @param namespace The namespace for the logger context. Defaults to `'v0:logger'`.
- * @returns The logger instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-logger
- *
- * @example
- * ```ts
- * import { useLogger } from '@vuetify/v0'
- *
- * const logger = useLogger()
- *
- * logger.info('This is an info message')
- * logger.debug('This is a debug message')
- * logger.error('This is an error message')
- * logger.level('debug')
- * logger.debug('This debug message will now be logged')
- * ```
- */
-declare function useLogger<E extends LoggerContext = LoggerContext>(namespace?: string): E;
+declare const createLoggerContext: <_E extends LoggerContext = LoggerContext>(_options?: LoggerContextOptions | undefined) => ContextTrinity<_E>, createLoggerPlugin: (_options?: LoggerContextOptions | undefined) => Plugin, useLogger: <_E extends LoggerContext = LoggerContext>(namespace?: string) => _E;
 //#endregion
 //#region src/composables/useMediaQuery/index.d.ts
 interface MediaQueryContext {
@@ -2069,11 +3040,17 @@ declare function usePrefersReducedMotion(): MediaQueryContext;
 declare function usePrefersContrast(): MediaQueryContext;
 //#endregion
 //#region src/composables/useMutationObserver/index.d.ts
+interface ObservableNodeList {
+  readonly length: number;
+  item: (index: number) => Node | null;
+  forEach: (callback: (node: Node, index: number, list: ObservableNodeList) => void) => void;
+  [Symbol.iterator]: () => Iterator<Node>;
+}
 interface MutationObserverRecord {
   type: 'attributes' | 'childList' | 'characterData';
   target: Node;
-  addedNodes: NodeList;
-  removedNodes: NodeList;
+  addedNodes: ObservableNodeList;
+  removedNodes: ObservableNodeList;
   previousSibling: Node | null;
   nextSibling: Node | null;
   attributeName: string | null;
@@ -2091,28 +3068,7 @@ interface UseMutationObserverOptions {
   characterDataOldValue?: boolean;
   attributeFilter?: string[];
 }
-interface UseMutationObserverReturn {
-  /**
-   * Whether the observer is currently active (created and observing)
-   */
-  readonly isActive: Readonly<Ref<boolean>>;
-  /**
-   * Whether the observer is currently paused
-   */
-  readonly isPaused: Readonly<Ref<boolean>>;
-  /**
-   * Pause observation (disconnects observer but keeps it alive)
-   */
-  pause: () => void;
-  /**
-   * Resume observation
-   */
-  resume: () => void;
-  /**
-   * Stop observation and clean up (destroys observer)
-   */
-  stop: () => void;
-}
+interface UseMutationObserverReturn extends ObserverReturn {}
 /**
  * A composable that uses the Mutation Observer API to detect changes in the DOM.
  *
@@ -2168,6 +3124,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 +3138,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 +3152,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 +3228,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 +3323,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 +3353,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 +3393,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.
@@ -2515,146 +3511,6 @@ declare function createNestedContext<Z extends NestedTicketInput = NestedTicketI
  */
 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.
- *
- * @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/usePermissions/adapters/adapter.d.ts
 interface PermissionAdapterInterface {
   can: <Z extends PermissionTicket = PermissionTicket>(role: ID, action: string, subject: string, context: Record<string, any>, permissions: PermissionContext<Z>) => boolean;
@@ -2679,106 +3535,28 @@ interface PermissionPluginOptions extends PermissionContextOptions {}
 /**
  * Creates a new permissions instance.
  *
- * @param options The options for the permissions instance.
- * @template Z The type of the permission ticket.
- * @template E The type of the permission context.
- * @returns A new permissions instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-permissions
- *
- * @example
- * ```ts
- * import { createPermissions } from '@vuetify/v0'
- *
- * const [usePermissions, providePermissions] = createPermissions({
- *   namespace: 'v0:permissions',
- *   permissions: {
- *     admin: [['read', 'users']],
- *     editor: [['edit', 'posts']],
- *   },
- * })
- * ```
- */
-declare function createPermissions<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(_options?: PermissionOptions): E;
-/**
- * Creates a new permissions context.
- *
- * @param options The options for the permissions context.
- * @template Z The type of the permission ticket.
- * @template E The type of the permission context.
- * @returns A new permissions context.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-permissions
- *
- * @example
- * ```ts
- * import { createPermissionsContext } from '@vuetify/v0'
- *
- * export const [usePermissions, providePermissions, context] = createPermissionsContext({
- *   namespace: 'app:permissions',
- *   permissions: {
- *     admin: [['read', 'users'], ['edit', 'users']],
- *     editor: [['edit', 'posts']],
- *   },
- * })
- * ```
- */
-declare function createPermissionsContext<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(_options?: PermissionContextOptions): ContextTrinity<E>;
-/**
- * Creates a new permissions plugin.
- *
- * @param options The options for the permissions plugin.
+ * @param options The options for the permissions instance.
  * @template Z The type of the permission ticket.
  * @template E The type of the permission context.
- * @returns A new permissions plugin.
+ * @returns A new permissions instance.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-permissions
  *
  * @example
  * ```ts
- * import { createApp } from 'vue'
- * import { createPermissionsPlugin } from '@vuetify/v0'
- * import App from './App.vue'
- *
- * const app = createApp(App)
- *
- * app.use(
- *   createPermissionsPlugin({
- *     permissions: {
- *       admin: [['read', 'users']],
- *       editor: [['edit', 'posts']],
- *     },
- *   })
- * )
- *
- * app.mount('#app')
- * ```
- */
-declare function createPermissionsPlugin<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(_options?: PermissionPluginOptions): Plugin;
-/**
- * Returns the current permissions instance.
- *
- * @template Z The type of the permission ticket.
- * @returns The current permissions instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-permissions
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- *   import { usePermissions } from '@vuetify/v0'
- *
- *   const { can } = usePermissions()
- * </script>
+ * import { createPermissions } from '@vuetify/v0'
  *
- * <template>
- *   <div>
- *     <p v-if="can('admin', 'read', 'users')">Admin access</p>
- *   </div>
- * </template>
+ * const [usePermissions, providePermissions] = createPermissions({
+ *   namespace: 'v0:permissions',
+ *   permissions: {
+ *     admin: [['read', 'users']],
+ *     editor: [['edit', 'posts']],
+ *   },
+ * })
  * ```
  */
-declare function usePermissions<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(namespace?: string): E;
+declare function createPermissions<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(_options?: PermissionOptions): E;
+declare const createPermissionsContext: <_E extends PermissionContext<PermissionTicket> = PermissionContext<PermissionTicket>>(_options?: PermissionContextOptions | undefined) => ContextTrinity<_E>, createPermissionsPlugin: (_options?: PermissionContextOptions | undefined) => Plugin, usePermissions: <_E extends PermissionContext<PermissionTicket> = PermissionContext<PermissionTicket>>(namespace?: string) => _E;
 //#endregion
 //#region src/composables/useProxyModel/index.d.ts
 interface ProxyModelOptions {
@@ -2853,7 +3631,7 @@ declare function useProxyRegistry<Z extends RegistryTicket = RegistryTicket>(reg
  *
  * @template V The type of the ticket value.
  */
-interface QueueTicketInput<V = unknown> extends RegistryTicket<V> {
+interface QueueTicketInput<V = unknown> extends RegistryTicketInput<V> {
   /**
    * Timeout in milliseconds
    *
@@ -2870,7 +3648,7 @@ interface QueueTicketInput<V = unknown> extends RegistryTicket<V> {
  *
  * @template Z The input ticket type that extends QueueTicketInput.
  */
-type QueueTicket<Z extends QueueTicketInput = QueueTicketInput> = Z & {
+type QueueTicket<Z extends QueueTicketInput = QueueTicketInput> = RegistryTicket & Z & {
   /**
    * Timeout in milliseconds (resolved from input or default)
    */
@@ -3150,155 +3928,505 @@ declare function createQueueContext<Z extends QueueTicketInput = QueueTicketInpu
  * </script>
  * ```
  */
-declare function useQueue<Z extends QueueTicketInput = QueueTicketInput, E extends QueueTicket<Z> = QueueTicket<Z>, R extends QueueContext<Z, E> = QueueContext<Z, E>>(namespace?: string): R;
-//#endregion
-//#region src/composables/useResizeObserver/index.d.ts
-interface ResizeObserverEntry {
-  contentRect: {
-    width: number;
-    height: number;
-    top: number;
-    left: number;
-  };
-  target: Element;
-}
-interface ResizeObserverOptions {
-  immediate?: boolean;
-  once?: boolean;
-  box?: 'content-box' | 'border-box';
+declare function useQueue<Z extends QueueTicketInput = QueueTicketInput, E extends QueueTicket<Z> = QueueTicket<Z>, R extends QueueContext<Z, E> = QueueContext<Z, E>>(namespace?: string): R;
+//#endregion
+//#region src/composables/useResizeObserver/index.d.ts
+interface ResizeObserverEntry {
+  contentRect: {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+  };
+  target: Element;
+}
+interface ResizeObserverOptions {
+  immediate?: boolean;
+  once?: boolean;
+  box?: 'content-box' | 'border-box';
+}
+interface UseResizeObserverReturn extends ObserverReturn {}
+/**
+ * A composable that uses the Resize Observer API to detect when an element's
+ * size changes.
+ *
+ * @param target The element to observe.
+ * @param callback The callback to execute when the element's size changes.
+ * @param options The options for the Resize Observer.
+ * @returns An object with methods to control the observer.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+ * @see https://0.vuetifyjs.com/composables/system/use-resize-observer
+ *
+ * @example
+ * ```ts
+ * import { ref } from 'vue'
+ * import { useResizeObserver } from '@vuetify/v0'
+ *
+ * const el = ref<HTMLElement>()
+ * const width = ref(0)
+ * const height = ref(0)
+ *
+ * const { pause, resume, isPaused } = useResizeObserver(
+ *   el,
+ *   (entries) => {
+ *     const entry = entries[0]
+ *     if (entry) {
+ *       width.value = entry.contentRect.width
+ *       height.value = entry.contentRect.height
+ *       console.log('Size changed:', width.value, 'x', height.value)
+ *     }
+ *   },
+ *   { immediate: true }
+ * )
+ *
+ * // Pause observation
+ * pause()
+ *
+ * // Resume observation
+ * resume()
+ * ```
+ */
+declare function useResizeObserver(target: MaybeRef<Element | null | undefined>, callback: (entries: ResizeObserverEntry[]) => void, options?: ResizeObserverOptions): UseResizeObserverReturn;
+interface UseElementSizeReturn extends UseResizeObserverReturn {
+  /**
+   * The width of the element in pixels
+   */
+  readonly width: Readonly<Ref<number>>;
+  /**
+   * The height of the element in pixels
+   */
+  readonly height: Readonly<Ref<number>>;
+}
+/**
+ * A convenience composable that uses the Resize Observer API to track an
+ * element's size.
+ *
+ * @param target The element to observe.
+ * @returns An object with the element's width and height.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-resize-observer#use-element-size
+ *
+ * @example
+ * ```ts
+ * import { ref, watchEffect } from 'vue'
+ * import { useElementSize } from '@vuetify/v0'
+ *
+ * const box = ref<HTMLElement>()
+ * const { width, height } = useElementSize(box)
+ *
+ * // Width and height are reactive refs
+ * watchEffect(() => {
+ *   console.log('Box size:', width.value, 'x', height.value)
+ * })
+ * ```
+ */
+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 UseResizeObserverReturn {
-  /**
-   * Whether the observer is currently active (created and observing)
-   */
-  readonly isActive: Readonly<Ref<boolean>>;
-  /**
-   * Whether the observer is currently paused
-   */
-  readonly isPaused: Readonly<Ref<boolean>>;
-  /**
-   * Pause observation (disconnects observer but keeps it alive)
-   */
-  pause: () => void;
+interface StepOptions extends SingleOptions {
   /**
-   * Resume observation
+   * Enable circular navigation (wrapping at boundaries).
+   * - true: Navigation wraps around (carousel behavior)
+   * - false: Navigation stops at boundaries (pagination behavior)
+   * @default false
    */
-  resume: () => void;
+  circular?: boolean;
+}
+interface StepContextOptions extends SingleContextOptions {
   /**
-   * Stop observation and clean up (destroys observer)
+   * Enable circular navigation (wrapping at boundaries).
+   * - true: Navigation wraps around (carousel behavior)
+   * - false: Navigation stops at boundaries (pagination behavior)
+   * @default false
    */
-  stop: () => void;
+  circular?: boolean;
 }
 /**
- * A composable that uses the Resize Observer API to detect when an element's
- * size changes.
+ * Creates a new step instance with navigation through items.
  *
- * @param target The element to observe.
- * @param callback The callback to execute when the element's size changes.
- * @param options The options for the Resize Observer.
- * @returns An object with methods to control the observer.
+ * Extends `createSingle` with `first()`, `last()`, `next()`, `prev()`, and `step(count)` methods
+ * for sequential navigation. Supports both circular (wrapping) and bounded (stopping at edges) modes.
  *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
- * @see https://0.vuetifyjs.com/composables/system/use-resize-observer
+ * @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 { ref } from 'vue'
- * import { useResizeObserver } from '@vuetify/v0'
+ * 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.
  *
- * const el = ref<HTMLElement>()
- * const width = ref(0)
- * const height = ref(0)
+ * @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.
  *
- * const { pause, resume, isPaused } = useResizeObserver(
- *   el,
- *   (entries) => {
- *     const entry = entries[0]
- *     if (entry) {
- *       width.value = entry.contentRect.width
- *       height.value = entry.contentRect.height
- *       console.log('Size changed:', width.value, 'x', height.value)
- *     }
- *   },
- *   { immediate: true }
- * )
+ * @see https://0.vuetifyjs.com/composables/selection/use-step
  *
- * // Pause observation
- * pause()
+ * @example
+ * ```ts
+ * import { createStepContext } from '@vuetify/v0'
  *
- * // Resume observation
- * resume()
+ * // 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 useResizeObserver(target: MaybeRef<Element | null | undefined>, callback: (entries: ResizeObserverEntry[]) => void, options?: ResizeObserverOptions): UseResizeObserverReturn;
-interface UseElementSizeReturn extends UseResizeObserverReturn {
-  /**
-   * The width of the element in pixels
-   */
-  width: Ref<number>;
-  /**
-   * The height of the element in pixels
-   */
-  height: Ref<number>;
-}
+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>;
 /**
- * A convenience composable that uses the Resize Observer API to track an
- * element's size.
+ * Returns the current step instance.
  *
- * @param target The element to observe.
- * @returns An object with the element's width and height.
+ * @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/system/use-resize-observer#use-element-size
+ * @see https://0.vuetifyjs.com/composables/selection/use-step
  *
  * @example
- * ```ts
- * import { ref, watchEffect } from 'vue'
- * import { useElementSize } from '@vuetify/v0'
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useStep } from '@vuetify/v0'
  *
- * const box = ref<HTMLElement>()
- * const { width, height } = useElementSize(box)
+ *   const wizard = useStep()
+ * </script>
  *
- * // Width and height are reactive refs
- * watchEffect(() => {
- *   console.log('Box size:', width.value, 'x', height.value)
- * })
+ * <template>
+ *   <div>
+ *     <p>Current step: {{ wizard.selectedIndex }}</p>
+ *     <button @click="wizard.next()">Next</button>
+ *   </div>
+ * </template>
  * ```
  */
-declare function useElementSize(target: MaybeRef<Element | null | undefined>): UseElementSizeReturn;
-//#endregion
-//#region src/composables/useStorage/adapters/adapter.d.ts
-interface StorageAdapter$1 {
-  getItem: (key: string) => string | null;
-  setItem: (key: string, value: string) => void;
-  removeItem: (key: string) => void;
-  readonly length?: number;
-  key?: (index: number) => string | null;
-}
-//#endregion
-//#region src/composables/useStorage/adapters/memory.d.ts
-/**
- * In-memory storage adapter that implements the StorageAdapter interface.
- * This adapter provides temporary storage that persists only for the current
- * session and is useful for testing or when persistent storage is not available.
- */
-declare class MemoryAdapter implements StorageAdapter$1 {
-  private store;
-  get length(): number;
-  getItem(key: string): string | null;
-  setItem(key: string, value: string): void;
-  removeItem(key: string): void;
-  key(index: number): string;
-}
-//#endregion
-//#region src/composables/useStorage/adapters/index.d.ts
-type StorageType = 'localStorage' | 'sessionStorage' | 'memory';
-interface StorageAdapter {
-  getItem: (key: string) => string | null;
-  setItem: (key: string, value: string) => void;
-  removeItem: (key: string) => void;
-  readonly length?: number;
-  key?: (index: number) => string | null;
-}
+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/index.d.ts
 interface StorageContext {
@@ -3354,54 +4482,7 @@ interface StoragePluginOptions extends StorageContextOptions {}
  * ```
  */
 declare function createStorage<E extends StorageContext>(options?: StorageOptions): E;
-declare function createStorageContext<E extends StorageContext = StorageContext>(_options?: StorageContextOptions): ContextTrinity<E>;
-/**
- * Creates a new storage plugin.
- *
- * @param options The options for the storage plugin.
- * @returns A new storage plugin.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-storage
- *
- * @example
- * ```ts
- * import { createApp } from 'vue'
- * import { createStoragePlugin } from '@vuetify/v0'
- * import App from './App.vue'
- *
- * const app = createApp(App)
- *
- * app.use(createStoragePlugin())
- *
- * app.mount('#app')
- * ```
- */
-declare function createStoragePlugin<E extends StorageContext = StorageContext>(_options?: StoragePluginOptions): Plugin;
-/**
- * Returns the current storage instance.
- *
- * @param namespace The namespace for the storage context. Defaults to `'v0:storage'`.
- * @returns The current storage instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-storage
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useStorage } from '@vuetify/v0'
- *
- *   const storage = useStorage()
- *   const username = storage.get('username', 'Guest')
- * </script>
- *
- * <template>
- *   <div>
- *     <p>Username: {{ username }}</p>
- *   </div>
- * </template>
- * ```
- */
-declare function useStorage<E extends StorageContext = StorageContext>(namespace?: string): E;
+declare const createStorageContext: <_E extends StorageContext = StorageContext>(_options?: StorageContextOptions | undefined) => ContextTrinity<_E>, createStoragePlugin: (_options?: StorageContextOptions | undefined) => Plugin, useStorage: <_E extends StorageContext = StorageContext>(namespace?: string) => _E;
 //#endregion
 //#region src/composables/useTheme/adapters/adapter.d.ts
 interface ThemeAdapterSetupContext {
@@ -3618,107 +4699,7 @@ interface ThemePluginOptions extends ThemeContextOptions {}
  * ```
  */
 declare function createTheme<Z extends ThemeTicketInput = ThemeTicketInput, E extends ThemeTicket<Z> = ThemeTicket<Z>, R extends ThemeContext<Z, E> = ThemeContext<Z, E>>(_options?: ThemeOptions): R;
-/**
- * Creates a new theme context trinity.
- *
- * @param options The options for the theme context.
- * @template Z The type of the theme ticket.
- * @template E The type of the theme context.
- * @returns A new theme context trinity.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-theme
- *
- * @example
- * ```ts
- * import { createThemeContext } from '@vuetify/v0'
- *
- * export const [useThemeContext, provideThemeContext, context] = createThemeContext({
- *   namespace: 'v0:theme',
- *   default: 'light',
- *   themes: {
- *     light: {
- *       dark: false,
- *       colors: {
- *         primary: '#3b82f6',
- *       },
- *     },
- *     dark: {
- *       dark: true,
- *       colors: {
- *         primary: '#675496',
- *       },
- *     },
- *   },
- * })
- * ```
- */
-declare function createThemeContext<Z extends ThemeTicketInput = ThemeTicketInput, E extends ThemeTicket<Z> = ThemeTicket<Z>, R extends ThemeContext<Z, E> = ThemeContext<Z, E>>(_options?: ThemeContextOptions): ContextTrinity<R>;
-/**
- * Creates a new theme plugin.
- *
- * @param options The options for the theme plugin.
- * @template Z The type of the theme ticket.
- * @template E The type of the theme context.
- * @returns A new theme plugin.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-theme
- *
- * @example
- * ```ts
- * import { createApp } from 'vue'
- * import { createThemePlugin } from '@vuetify/v0'
- * import App from './App.vue'
- *
- * const app = createApp(App)
- *
- * app.use(
- *   createThemePlugin({
- *     default: 'light',
- *     themes: {
- *       light: {
- *         dark: false,
- *         colors: {
- *           primary: '#3b82f6',
- *         },
- *       },
- *       dark: {
- *         dark: true,
- *         colors: {
- *           primary: '#675496',
- *         },
- *       },
- *     },
- *   })
- * )
- *
- * app.mount('#app')
- * ```
- */
-declare function createThemePlugin<Z extends ThemeTicketInput = ThemeTicketInput, E extends ThemeTicket<Z> = ThemeTicket<Z>, R extends ThemeContext<Z, E> = ThemeContext<Z, E>>(_options?: ThemePluginOptions): Plugin;
-/**
- * Returns the current theme instance.
- *
- * @param namespace The namespace for the theme context. Defaults to `v0:theme`.
- * @returns The current theme instance.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-theme
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useTheme } from '@vuetify/v0'
- *
- *   const theme = useTheme()
- * </script>
- *
- * <template>
- *   <div>
- *     <p>Current theme: {{ theme.selected.value }}</p>
- *   </div>
- * </template>
- * ```
- */
-declare function useTheme<Z extends ThemeTicketInput = ThemeTicketInput, E extends ThemeTicket<Z> = ThemeTicket<Z>, R extends ThemeContext<Z, E> = ThemeContext<Z, E>>(namespace?: string): R;
+declare const createThemeContext: <_E extends ThemeContext<ThemeTicketInput, ThemeTicket<ThemeTicketInput>> = ThemeContext<ThemeTicketInput, ThemeTicket<ThemeTicketInput>>>(_options?: ThemePluginOptions | undefined) => ContextTrinity<_E>, createThemePlugin: (_options?: ThemePluginOptions | undefined) => Plugin, useTheme: <_E extends ThemeContext<ThemeTicketInput, ThemeTicket<ThemeTicketInput>> = ThemeContext<ThemeTicketInput, ThemeTicket<ThemeTicketInput>>>(namespace?: string) => _E;
 //#endregion
 //#region src/composables/createTimeline/index.d.ts
 interface TimelineContext<Z extends TimelineTicket> extends RegistryContext<Z> {
@@ -3928,7 +4909,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 +4988,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 +5009,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 +5029,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 +5047,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 +5065,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 +5086,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 +5105,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 +5127,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 +5149,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 +5167,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 +5183,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 +5194,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 { useStep as $, SelectionTicket as $i, UseHotkeyReturn as $n, BreakpointName as $r, NestedTicketInput as $t, createTheme as A, GroupTicketInput as Ai, createLocaleFallback as An, TokenValue as Ar, PermissionContextOptions as At, StorageOptions as B, createBreadcrumbsContext as Bi, useElementIntersection as Bn, DateContextOptions as Br, createNested as Bt, ThemeContext as C, createOverflow as Ci, LocaleOptions as Cn, TokenAlias as Cr, useQueue as Ct, ThemeRecord as D, GroupContextOptions as Di, LocaleTicketInput as Dn, TokenOptions as Dr, ProxyModelOptions as Dt, ThemePluginOptions as E, GroupContext as Ei, LocaleTicket as En, TokenContextOptions as Er, useProxyRegistry as Et, Vuetify0ThemeOptions as F, BreadcrumbTicketInput as Fi, useLazy as Fn, EventHandler as Fr, createPermissionsContext as Ft, useStorage as G, SingleTicket as Gi, HydrationPluginOptions as Gn, createDatePlugin as Gr, NestedActiveMode as Gt, createStorage as H, SingleContext as Hi, HydrationContext as Hn, DatePluginOptions as Hr, useNested as Ht, ThemeAdapter as I, BreadcrumbsContext as Ii, IntersectionObserverEntry as In, useDocumentEventListener as Ir, createPermissionsPlugin as It, StepOptions as J, createSingleContext as Ji, createHydrationContext as Jn, ClickOutsideIgnoreTarget as Jr, NestedOpenMode as Jt, StepContext as K, SingleTicketInput as Ki, createFallbackHydration as Kn, useDate as Kr, NestedContext as Kt, ThemeAdapterInterface as L, BreadcrumbsContextOptions as Li, IntersectionObserverOptions as Ln, useEventListener as Lr, usePermissions as Lt, createThemePlugin as M, createGroupContext as Mi, useLocale as Mn, createTokensContext as Mr, PermissionPluginOptions as Mt, useTheme as N, useGroup as Ni, LazyContext as Nn, useTokens as Nr, PermissionTicket as Nt, ThemeTicket as O, GroupOptions as Oi, createLocale as On, TokenPrimitive as Or, useProxyModel as Ot, Vuetify0ThemeAdapter as P, BreadcrumbTicket as Pi, LazyOptions as Pn, CleanupFunction as Pr, createPermissions as Pt, createStepContext as Q, SelectionOptions as Qi, UseHotkeyOptions as Qn, useClickOutside as Qr, NestedTicket as Qt, StorageContext as R, BreadcrumbsOptions as Ri, UseElementIntersectionReturn as Rn, useWindowEventListener as Rr, PermissionAdapter as Rt, ThemeColors as S, OverflowOptions as Si, LocaleContextOptions as Sn, FlatTokenCollection as Sr, createQueueContext as St, ThemeOptions as T, useOverflow as Ti, LocaleRecord as Tn, TokenContext as Tr, ProxyRegistryOptions as Tt, createStorageContext as U, SingleContextOptions as Ui, HydrationContextOptions as Un, createDate as Ur, multipleOpenStrategy as Ut, StoragePluginOptions as V, useBreadcrumbs as Vi, useIntersectionObserver as Vn, DateOptions as Vr, createNestedContext as Vt, createStoragePlugin as W, SingleOptions as Wi, HydrationOptions as Wn, createDateContext as Wr, singleOpenStrategy as Wt, StepTicketInput as X, SelectionContext as Xi, useHydration as Xn, UseClickOutsideOptions as Xr, NestedRegistration as Xt, StepTicket as Y, useSingle as Yi, createHydrationPlugin as Yn, ClickOutsideTarget as Yr, NestedOptions as Yt, createStep as Z, SelectionContextOptions as Zi, PlatformContext as Zn, UseClickOutsideReturn as Zr, NestedSelectionMode as Zt, TimelineTicket as _, createContext as _i, createLoggerContext as _n, FeatureTicketInput as _r, QueueContextOptions as _t, VirtualDirection as a, RegistryContextOptions as aa, createBreakpointsContext as ai, UseMutationObserverReturn as an, FormTicketInput as ar, StackTicketInput as at, useTimeline as b, OverflowContext as bi, LogLevel as bn, createFeaturesPlugin as br, QueueTicketInput as bt, VirtualState as c, RegistryEventName as ca, toReactive as ci, useMediaQuery as cn, FormValue as cr, createStackPlugin as ct, useVirtual as d, RegistryTicketInput as da, PluginContextConfig as di, usePrefersReducedMotion as dn, useForm as dr, ResizeObserverOptions as dt, SelectionTicketInput as ea, BreakpointsContext as ei, OpenStrategy as en, useHotkey as er, StackContext as et, ToggleScopeControls as f, createRegistry as fa, PluginOptions as fi, LoggerContext as fn, FeatureContext as fr, UseElementSizeReturn as ft, TimelineOptions as g, CreateContextOptions as gi, createLogger as gn, FeatureTicket as gr, QueueContext as gt, TimelineContextOptions as h, ContextKey as hi, LoggerPluginOptions as hn, FeaturePluginOptions as hr, useResizeObserver as ht, VirtualContextOptions as i, RegistryContext as ia, createBreakpoints as ii, UseMutationObserverOptions as in, FormTicket as ir, StackTicket as it, createThemeContext as j, createGroup as ji, createLocalePlugin as jn, createTokens as jr, PermissionOptions as jt, ThemeTicketInput as k, GroupTicket as ki, createLocaleContext as kn, TokenTicket as kr, PermissionContext as kt, createVirtual as l, RegistryOptions as la, toArray as li, usePrefersContrast as ln, createForm as lr, useStack as lt, TimelineContext as m, useRegistry as ma, createPluginContext as mi, LoggerOptions as mn, FeatureOptions as mr, useElementSize as mt, VirtualAnchor as n, createSelectionContext as na, BreakpointsOptions as ni, MutationObserverRecord as nn, FormContextOptions as nr, StackOptions as nt, VirtualItem as o, RegistryEventCallback as oa, createBreakpointsPlugin as oi, useMutationObserver as on, FormValidationResult as or, createStack as ot, useToggleScope as p, createRegistryContext as pa, createPlugin as pi, LoggerContextOptions as pn, FeatureContextOptions as pr, UseResizeObserverReturn as pt, StepContextOptions as q, createSingle as qi, createHydration as qn, ClickOutsideElement as qr, NestedContextOptions as qt, VirtualContext as r, useSelection as ra, BreakpointsPluginOptions as ri, ObservableNodeList as rn, FormOptions as rr, StackPluginOptions as rt, VirtualOptions as s, RegistryEventMap as sa, useBreakpoints as si, MediaQueryContext as sn, FormValidationRule as sr, createStackContext as st, ScrollToOptions as t, createSelection as ta, BreakpointsContextOptions as ti, OpenStrategyContext as tn, FormContext as tr, StackContextOptions as tt, createVirtualContext as u, RegistryTicket as ua, Plugin as ui, usePrefersDark as un, createFormContext as ur, ResizeObserverEntry as ut, createTimeline as v, provideContext as vi, createLoggerPlugin as vn, createFeatures as vr, QueueOptions as vt, ThemeContextOptions as w, createOverflowContext as wi, LocalePluginOptions as wn, TokenCollection as wr, ProxyRegistryContext as wt, Colors as x, OverflowContextOptions as xi, LocaleContext as xn, useFeatures as xr, createQueue as xt, createTimelineContext as y, useContext as yi, useLogger as yn, createFeaturesContext as yr, QueueTicket as yt, StorageContextOptions as z, createBreadcrumbs as zi, UseIntersectionObserverReturn as zn, DateContext as zr, PermissionAdapterInterface as zt };