@vuetify/v0 0.0.13 → 0.0.15

package/dist/{index-CQjOW_w5.d.mts → index-CkmnMjE3.d.mts}

@@ -1,10 +1,848 @@
 import { a as MaybeArray, i as ID } from "./index-DY7-T630.mjs";
-import { a as SelectionContext, c as SelectionTicket, f as RegistryContext, h as RegistryTicket, m as RegistryOptions, o as SelectionContextOptions, p as RegistryContextOptions, s as SelectionOptions, t as ContextKey, v as ContextTrinity } from "./index-D-EP6KrS.mjs";
-import * as vue231 from "vue";
-import { App, ComputedRef, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef, UnwrapNestedRefs } from "vue";
+import { App, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, Reactive, Ref, ShallowRef, UnwrapNestedRefs, WatchSource } from "vue";
 
+//#region src/composables/createTrinity/index.d.ts
+
+type ContextTrinity<Z = unknown> = readonly [() => Z, (context?: Z, app?: App) => Z, Z];
+/**
+ * Creates a new trinity for a context composable and its provider.
+ *
+ * @param useContext The function that retrieves/uses the context (typically named `useContext`).
+ * @param provideContext The function that provides the context to descendants.
+ * @param context The default context instance to use when no custom context is provided.
+ * @template Z The type of the context.
+ * @returns A readonly tuple containing: [useContext function, provideContext wrapper function, default context instance].
+ *
+ * @remarks The trinity pattern is a foundational pattern used throughout the codebase for creating reusable context systems. It provides three related elements:
+ *
+ * 1. A function to retrieve/use the context
+ * 2. A function to provide the context (with default value support)
+ * 3. The default context instance
+ *
+ * The returned tuple is readonly (using `as const`) to ensure proper type inference.
+ *
+ * @see https://0.vuetifyjs.com/composables/foundation/create-trinity#create-trinity
+ *
+ * @example
+ * ```ts
+ * interface MyContext {
+ *   foo: string
+ *   bar: number
+ * }
+ *
+ * export function createMyFeature<E extends MyContext = MyContext>() {
+ *   const [useContext, _provideContext] = createContext<E>('my-context')
+ *
+ *   const context = { foo: 'hello', bar: 42 }
+ *
+ *   function provideContext (_context: E = context, app?: App): E {
+ *     return _provideContext(_context, app)
+ *   }
+ *
+ *   return createTrinity<E>(useContext, provideContext, context)
+ * }
+ * ```
+ */
+declare function createTrinity<Z = unknown>(useContext: () => Z, provideContext: (_context?: Z, app?: App) => Z, context: Z): ContextTrinity<Z>;
+//#endregion
+//#region src/composables/useRegistry/index.d.ts
+interface RegistryTicket<V = unknown> {
+  /** The unique identifier. Is randomly generated if not provided. */
+  id: ID;
+  /**
+   * The index of the ticket in the registry.
+   *
+   * @remarks Automatically managed by the registry. Updated during reindexing. It's not recommended to manually set this.
+   */
+  index: number;
+  /** The value associated with the ticket. If not provided, it defaults to the index. */
+  value: V;
+  /**
+   * Whether the value is derived from index.
+   *
+   * @remarks Set to true when no explicit value is provided during registration. It's not recommended to manually set this.
+   */
+  valueIsIndex: boolean;
+}
+interface RegistryContext<Z extends RegistryTicket = RegistryTicket> {
+  /**
+   * The collection of tickets in the registry
+   *
+   * @template ID The type of the ticket ID.
+   * @template Z The type of the registry ticket.
+   *
+   * @remarks Exposed for read-only access and advanced use cases. **Warning:** Direct mutation may cause inconsistencies in indexes, catalogs, and caches. Always prefer using the provided methods (`register`, `unregister`, etc.) to maintain internal consistency.
+   */
+  collection: Map<ID, Z>;
+  /**
+   * Clear the entire registry
+   *
+   * @remarks Removes all tickets from the registry. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#clear
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * const ids = registry.keys() // ['ticket-1', 'ticket-2']
+   * ```
+   */
+  keys: () => ID[];
+  /**
+   * Browse for an ID(s) by value
+   *
+   * @param value The value to browse for.
+   * @remarks Returns a single ID or an array of IDs if multiple tickets share the same value.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#browse
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * 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: unknown) => ID | 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 = useRegistry()
+   *
+   * 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-id', value: 'some-value' })
+   *
+   * const ticket = registry.get('ticket-id') // { id: 'ticket-id', index: 0, value: 'some-value', ... }
+   * ```
+   */
+  get: (id: ID) => Z | undefined;
+  /**
+   * Update or insert a ticket by ID
+   *
+   * @param id The ID of the ticket to upsert.
+   * @param ticket The partial ticket data to update or insert.
+   * @remarks If the ticket exists, it will be updated with the provided data. If it doesn't exist, a new ticket will be created with the given ID and data. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#upsert
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * // Insert a new ticket
+   * const ticket = registry.upsert('ticket-id', { value: 'initial-value' })
+   *
+   * // Update the existing ticket
+   * const patched = registry.upsert('ticket-id', { value: 'updated-value' })
+   * ```
+  */
+  upsert: (id: ID, ticket?: Partial<Z>) => Z;
+  /**
+   * Get all values of registered tickets
+   *
+   * @remarks Calls `collection.values` internally with caching. First call is O(n), subsequent calls are O(1) until cache invalidation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#values
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * 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: () => Z[];
+  /**
+   * Get all entries of registered tickets
+   *
+   * @remarks Calls `collection.entries` internally with caching. First call is O(n), subsequent calls are O(1) until cache invalidation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#entries
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * 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: () => [ID, Z][];
+  /**
+   * Register a new ticket
+   *
+   * @param ticket The partial ticket data to register.
+   * @remarks If no ID is provided, a unique ID will be generated automatically. If no value is provided, it defaults to the ticket's index. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#register
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * const ticket = registry.register()
+   *
+   * console.log(ticket) // { id: 'generated-id', index: 0, value: 0, valueIsIndex: true }
+   * ```
+  */
+  register: (ticket?: Partial<Z>) => Z;
+  /**
+   * Unregister an 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1', value: 'apple' })
+   * registry.register({ id: 'ticket-2', value: 'banana' })
+   * registry.register({ id: 'ticket-3', value: 'cherry' })
+   *
+   * // Seek the first ticket
+   * const first = registry.seek('first')
+   *
+   * // Seek the last ticket
+   * const last = registry.seek('last')
+   *
+   * // Seek the first ticket with value 'banana'
+   * const banana = registry.seek('first', undefined, ticket => ticket.value === 'banana')
+   *
+   * // Seek from index 1 to find the next ticket with value starting with 'c'
+   * const cherry = registry.seek('first', 1, ticket => (ticket.value as string).startsWith('c'))
+   * ```
+  */
+  seek: (direction?: 'first' | 'last', from?: number, predicate?: (ticket: Z) => boolean) => Z | undefined;
+  /**
+   * Listen for registry events
+   *
+   * @param event The name of the event to listen for.
+   * @param cb The callback function to invoke when the event is emitted.
+   * @remarks Must be enabled via the `events` option when creating the registry.
+   * Supported events:
+   * - `register:ticket` - Emitted when a ticket is registered, receives the ticket as argument
+   * - `unregister:ticket` - Emitted when a ticket is unregistered, receives the ticket as argument
+   * - `update:ticket` - Emitted when a ticket is updated, receives the updated ticket as argument
+   * - `clear:registry` - Emitted when the registry is cleared
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#on
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ events: true })
+   *
+   * registry.on('register:ticket', (ticket) => {
+   *   console.log('Ticket registered:', ticket)
+   * })
+   *
+   * registry.register({ id: 'ticket-id' }) // Console: Ticket registered: { id: 'ticket-id', ... }
+   * ```
+  */
+  on: (event: string, cb: Function) => 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ 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: (event: string, cb: Function) => 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ 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: (event: string, data: unknown) => 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * const tickets = registry.onboard([
+   *   { id: 'ticket-1', value: 'value-1' },
+   *   { id: 'ticket-2', value: 'value-2' },
+   * ])
+   *
+   * console.log(tickets) // [{ id: 'ticket-1', ... }, { id: 'ticket-2', ... }]
+   * ```
+  */
+  onboard: (registrations: Partial<Z>[]) => Z[];
+  /**
+   * Offboard multiple tickets at once
+   *
+   * @param ids An array of ticket IDs to unregister.
+   * @remarks Unregisters multiple tickets in a single operation with optimized reindexing.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#offboard
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * 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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * console.log(registry.size) // 2
+   * ```
+  */
+  size: number;
+}
+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 { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ 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;
+}
+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/use-registry#use-registry
+ *
+ * @example
+ * ```ts
+ * import { useRegistry } from '@vuetify/v0'
+ *
+ * const registry = useRegistry()
+ *
+ * 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 useRegistry<Z extends RegistryTicket = RegistryTicket, E extends RegistryContext<Z> = RegistryContext<Z>>(options?: RegistryOptions): E;
+/**
+ * Creates a new registry context.
+ *
+ * @param namespace The namespace for the registry context.
+ * @param options The options for the registry context.
+ * @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/use-registry#create-registry-context
+ *
+ * @example
+ * ```ts
+ * import { createRegistryContext } from '@vuetify/v0'
+ *
+ * // With default namespace 'v0:registry'
+ * export const [useItems, provideItems, items] = createRegistryContext()
+ *
+ * // Or with custom namespace
+ * export const [useItems, provideItems, items] = createRegistryContext({ namespace: 'my-items' })
+ *
+ * // In a parent component:
+ * provideItems()
+ *
+ * // In a child component:
+ * const items = useItems()
+ * items.register({ id: 'item-1', value: 'Value 1' })
+ * ```
+ */
+declare function createRegistryContext<Z extends RegistryTicket = RegistryTicket, E extends RegistryContext<Z> = RegistryContext<Z>>(_options?: RegistryContextOptions): ContextTrinity<E>;
+//#endregion
+//#region src/composables/useSelection/index.d.ts
+interface SelectionTicket<V = unknown> extends RegistryTicket<V> {
+  /** Disabled state of the ticket */
+  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;
+}
+interface SelectionContext<Z extends SelectionTicket> extends RegistryContext<Z> {
+  /** Set of selected ticket IDs */
+  selectedIds: Reactive<Set<ID>>;
+  /** Set of selected ticket instances */
+  selectedItems: ComputedRef<Set<Z>>;
+  /** 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;
+}
+interface SelectionOptions extends RegistryOptions {
+  /** When true, the entire selection instance is disabled. */
+  disabled?: MaybeRef<boolean>;
+  /**
+   * When true, newly registered items are automatically selected if not disabled.
+   * Useful for pre-selecting items in multi-select scenarios.
+   */
+  enroll?: 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?: boolean | 'force';
+  /** When true, treats the selection as an array */
+  multiple?: 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 type of the selection ticket.
+ * @template E The type of the selection context.
+ * @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'
+ *
+ * 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']
+ * ```
+ */
+declare function createSelection<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(_options?: SelectionOptions): E;
+/**
+ * Creates a new selection context.
+ *
+ * @param options The options for the selection context.
+ * @template Z The type of the selection ticket.
+ * @template E The type of the selection context.
+ * @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')
+ * ```
+ */
+declare function createSelectionContext<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(_options?: SelectionContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current selection instance.
+ *
+ * @param namespace The namespace for the selection context. Defaults to `'v0:selection'`.
+ * @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 SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(namespace?: string): E;
+//#endregion
+//#region src/composables/createContext/index.d.ts
+type ContextKey<Z> = InjectionKey<Z> | string;
+/**
+ * Injects a context provided by an ancestor component.
+ *
+ * @param key The key of the context to inject.
+ * @param defaultValue Optional default value if context is not found.
+ * @template Z The type of the context.
+ * @returns The injected context.
+ * @throws An error if the context is not found and no default is provided.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#use-context
+ *
+ * @example
+ * ```ts
+ * // Without default value
+ * const context = useContext<MyContext>('my-context')
+ *
+ * // With default value
+ * const context = useContext<MyContext>('my-context', defaultContext)
+ * ```
+ */
+declare function useContext<Z>(key: ContextKey<Z>, defaultValue?: Z): Z;
+/**
+ * Provides a context to all descendant components.
+ *
+ * @param key The key of the context to provide.
+ * @param context The context to provide.
+ * @param app Optional Vue app instance to provide the context at app level instead of component level.
+ * @template Z The type of the context.
+ * @returns The provided context.
+ *
+ * @remarks
+ * When `app` parameter is provided, the context is made available to all components in the app.
+ * When omitted, the context is provided at the current component level and available to descendants only.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#provide-context
+ *
+ * @example
+ * ```ts
+ * // Component-level provision
+ * provideContext<MyContext>('my-context', context)
+ *
+ * // App-level provision (typically used in plugins)
+ * const app = createApp()
+ * provideContext<MyContext>('my-context', context, app)
+ * ```
+ */
+declare function provideContext<Z>(key: ContextKey<Z>, context: Z, app?: App): Z;
+/**
+ * Creates a new context for providing and injecting data.
+ *
+ * @param key The key of the context to create.
+ * @param defaultValue Optional default value if context is not found.
+ * @template Z The type of the context.
+ * @returns A tuple containing the `useContext` and `provideContext` functions.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#create-context
+ *
+ * @example
+ * ```ts
+ * // Without default value
+ * const [useMyContext, provideMyContext] = createContext<MyContext>('my-context')
+ *
+ * // With default value
+ * const [useMyContext, provideMyContext] = createContext<MyContext>('my-context', defaultContext)
+ * ```
+ */
+declare function createContext<Z>(_key: ContextKey<Z>, defaultValue?: Z): readonly [(key?: ContextKey<Z>) => Z, (context: Z, app?: App) => Z];
+//#endregion
 //#region src/composables/createPlugin/index.d.ts
-
 interface PluginOptions {
   namespace: string;
   provide: (app: App) => void;
@@ -318,7 +1156,16 @@ declare function useWindowEventListener<E extends keyof WindowEventMap>(event: M
 declare function useDocumentEventListener<E extends keyof DocumentEventMap>(event: MaybeRefOrGetter<MaybeArray<E>>, listener: MaybeRef<MaybeArray<(this: Document, event: DocumentEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CleanupFunction;
 //#endregion
 //#region src/composables/useGroup/index.d.ts
-interface GroupTicket extends SelectionTicket {}
+interface GroupTicket<V = unknown> extends SelectionTicket<V> {
+  /** Whether the ticket should start in mixed/indeterminate state */
+  indeterminate?: MaybeRef<boolean>;
+  /** 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;
+}
 interface GroupContext<Z extends GroupTicket> extends SelectionContext<Z> {
   selectedIndexes: ComputedRef<Set<number>>;
   /** Select one or more Tickets by ID */
@@ -327,19 +1174,42 @@ interface GroupContext<Z extends GroupTicket> extends SelectionContext<Z> {
   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<Z>>;
+  /** 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;
 }
 interface GroupOptions extends SelectionOptions {}
 interface GroupContextOptions extends SelectionContextOptions {}
 /**
- * Creates a new group instance with batch selection operations.
+ * 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 `selectedIndexes` computed property.
+ * 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 support.
+ * @returns A new group instance with batch selection and tri-state support.
  *
  * @remarks
  * **Key Differences from `createSelection`:**
@@ -347,13 +1217,22 @@ interface GroupContextOptions extends SelectionContextOptions {}
  * - `unselect()` accepts `ID | ID[]` for batch operations
  * - `toggle()` accepts `ID | ID[]` for batch operations
  * - Adds `selectedIndexes` computed Set for getting selected item indexes
- * - Perfect for checkboxes, multi-select dropdowns, and bulk operations
+ * - 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 batch operations
+ * - Disabled items are automatically skipped in select operations
  * - Non-existent IDs are silently ignored
  *
  * **Inheritance Chain:**
@@ -382,16 +1261,21 @@ interface GroupContextOptions extends SelectionContextOptions {}
  * console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
  * console.log(Array.from(checkboxes.selectedIndexes.value)) // [0, 2]
  *
- * // Toggle operations
- * checkboxes.toggle(['option-a', 'option-b'])
- * console.log(checkboxes.selectedIds) // Set { 'option-b', 'option-c' }
+ * // 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 GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(_options?: GroupOptions): E;
 /**
  * Creates a new group context.
  *
- * @param namespace The namespace for the group context.
  * @param options The options for the group context.
  * @template Z The type of the group ticket.
  * @template E The type of the group context.
@@ -403,7 +1287,11 @@ declare function createGroup<Z extends GroupTicket = GroupTicket, E extends Grou
  * ```ts
  * import { createGroupContext } from '@vuetify/v0'
  *
- * export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext('my-group')
+ * // 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()
@@ -412,7 +1300,7 @@ declare function createGroup<Z extends GroupTicket = GroupTicket, E extends Grou
  * const group = useMyGroup()
  * ```
  */
-declare function createGroupContext<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(_options: GroupContextOptions): ContextTrinity<E>;
+declare function createGroupContext<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(_options?: GroupContextOptions): ContextTrinity<E>;
 /**
  * Returns the current group instance.
  *
@@ -436,7 +1324,7 @@ declare function createGroupContext<Z extends GroupTicket = GroupTicket, E exten
  * </template>
  * ```
  */
-declare function useGroup<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(namespace: string): E;
+declare function useGroup<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(namespace?: string): E;
 //#endregion
 //#region src/composables/useTokens/index.d.ts
 interface TokenAlias<T = unknown> {
@@ -447,7 +1335,7 @@ interface TokenAlias<T = unknown> {
   $extensions?: Record<string, unknown>;
   $deprecated?: boolean | string;
 }
-type TokenPrimitive = string | number | boolean | null;
+type TokenPrimitive = string | number | boolean | null | Function;
 type TokenValue = TokenPrimitive | TokenAlias;
 interface TokenCollection {
   [key: string]: TokenValue | TokenCollection;
@@ -456,7 +1344,7 @@ type FlatTokenCollection = {
   id: string;
   value: TokenValue;
 };
-interface TokenTicket extends RegistryTicket {}
+interface TokenTicket<Z extends TokenValue = TokenValue> extends RegistryTicket<Z> {}
 interface TokenContext<Z extends TokenTicket> extends RegistryContext<Z> {
   /**
    * Checks if a token is an alias
@@ -597,11 +1485,9 @@ 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/index.d.ts
-interface FeatureTicket extends GroupTicket {
-  value: TokenValue;
-}
+interface FeatureTicket extends GroupTicket<TokenValue> {}
 interface FeatureContext<Z extends FeatureTicket = FeatureTicket> extends GroupContext<Z> {
-  variation: (id: ID, fallback?: any) => any;
+  variation: (id: ID, fallback?: unknown) => unknown;
 }
 interface FeatureOptions extends RegistryOptions {
   features?: Record<ID, boolean | TokenCollection>;
@@ -739,7 +1625,7 @@ interface UseFilterResult<Z extends FilterItem = FilterItem> {
  * @template Z The type of the items.
  * @returns The filtered items.
  *
- * @see https://0.vuetifyjs.com/composables/selection/use-filter
+ * @see https://0.vuetifyjs.com/composables/utilities/use-filter
  *
  * @example
  * ```ts
@@ -762,9 +1648,9 @@ declare function useFilter<Z extends FilterItem>(query: FilterQuery, items: Mayb
 //#endregion
 //#region src/composables/useForm/index.d.ts
 type FormValidationResult = string | true | Promise<string | true>;
-type FormValidationRule = (value: any) => FormValidationResult;
-type FormValue = Ref<any> | ShallowRef<any>;
-interface FormTicket extends RegistryTicket {
+type FormValidationRule = (value: unknown) => FormValidationResult;
+type FormValue = Ref<unknown> | ShallowRef<unknown>;
+interface FormTicket<V = unknown> extends RegistryTicket<V> {
   validate: (silent?: boolean) => Promise<boolean>;
   reset: () => void;
   validateOn: 'submit' | 'change' | string;
@@ -786,7 +1672,7 @@ interface FormOptions extends RegistryOptions {
   validateOn?: 'submit' | 'change' | string;
 }
 interface FormContextOptions extends RegistryOptions {
-  namespace: string;
+  namespace?: string;
   validateOn?: 'submit' | 'change' | string;
 }
 /**
@@ -822,7 +1708,6 @@ declare function createForm<Z extends FormTicket = FormTicket, E extends FormCon
 /**
  * Creates a new form context.
  *
- * @param namespace The namespace for the form context.
  * @param options The options for the form context.
  * @template Z The type of the form ticket.
  * @template E The type of the form context.
@@ -834,7 +1719,12 @@ declare function createForm<Z extends FormTicket = FormTicket, E extends FormCon
  * ```ts
  * import { createFormContext } from '@vuetify/v0'
  *
- * export const [useMyForm, provideMyForm, myForm] = createFormContext('my-form', {
+ * // With default namespace 'v0:form'
+ * export const [useMyForm, provideMyForm, myForm] = createFormContext({ validateOn: 'change' })
+ *
+ * // Or with custom namespace
+ * export const [useMyForm, provideMyForm, myForm] = createFormContext({
+ *   namespace: 'my-form',
  *   validateOn: 'change',
  * })
  *
@@ -846,7 +1736,7 @@ declare function createForm<Z extends FormTicket = FormTicket, E extends FormCon
  * form.register({ id: 'field', value: ref(''), rules: [...] })
  * ```
  */
-declare function createFormContext<Z extends FormTicket = FormTicket, E extends FormContext<Z> = FormContext<Z>>(_options: FormContextOptions): ContextTrinity<E>;
+declare function createFormContext<Z extends FormTicket = FormTicket, E extends FormContext<Z> = FormContext<Z>>(_options?: FormContextOptions): ContextTrinity<E>;
 /**
  * Returns the current form instance.
  *
@@ -900,6 +1790,7 @@ interface HydrationPluginOptions extends HydrationContextOptions {}
  * ```
  */
 declare function createHydration<E extends HydrationContext = HydrationContext>(): E;
+declare function createFallbackHydration<E extends HydrationContext = HydrationContext>(): E;
 /**
  * Creates a new hydration context trinity.
  *
@@ -983,6 +1874,32 @@ interface IntersectionObserverOptions {
   rootMargin?: string;
   threshold?: number | number[];
 }
+interface UseIntersectionObserverReturn {
+  /**
+   * Whether the observer is currently active (created and observing)
+   */
+  readonly isActive: Readonly<Ref<boolean>>;
+  /**
+   * 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
  * is visible in the viewport.
@@ -1022,13 +1939,13 @@ interface IntersectionObserverOptions {
  * resume()
  * ```
  */
-declare function useIntersectionObserver(target: Ref<Element | undefined>, callback: (entries: IntersectionObserverEntry[]) => void, options?: IntersectionObserverOptions): {
-  isIntersecting: Readonly<Ref<boolean, boolean>>;
-  isPaused: Readonly<Ref<boolean, boolean>>;
-  pause: () => void;
-  resume: () => void;
-  stop: () => void;
-};
+declare function useIntersectionObserver(target: Ref<Element | undefined>, callback: (entries: IntersectionObserverEntry[]) => void, options?: IntersectionObserverOptions): UseIntersectionObserverReturn;
+interface UseElementIntersectionReturn extends UseIntersectionObserverReturn {
+  /**
+   * The intersection ratio (0.0 to 1.0) indicating how much of the element is visible
+   */
+  readonly intersectionRatio: Readonly<Ref<number>>;
+}
 /**
  * A convenience composable that uses the Intersection Observer API to detect
  * when an element is visible in the viewport.
@@ -1057,36 +1974,29 @@ declare function useIntersectionObserver(target: Ref<Element | undefined>, callb
  * })
  * ```
  */
-declare function useElementIntersection(target: Ref<Element | undefined>, options?: IntersectionObserverOptions): {
-  isIntersecting: Readonly<Ref<boolean, boolean>>;
-  intersectionRatio: Readonly<Ref<number, number>>;
-  isPaused: Readonly<Ref<boolean, boolean>>;
-  pause: () => void;
-  resume: () => void;
-  stop: () => void;
-};
+declare function useElementIntersection(target: Ref<Element | undefined>, options?: IntersectionObserverOptions): UseElementIntersectionReturn;
 //#endregion
 //#region src/composables/useKeydown/index.d.ts
-/**
- * @module useKeydown
- *
- * @remarks
- * Keydown event listener composable with key filtering.
- *
- * Key features:
- * - Key-specific event handling
- * - preventDefault and stopPropagation options
- * - Automatic cleanup on scope disposal
- * - Auto-starts when in component scope
- *
- * Simplified wrapper around useEventListener for keyboard interactions.
- */
 interface KeyHandler {
   key: string;
   handler: (event: KeyboardEvent) => void;
   preventDefault?: boolean;
   stopPropagation?: boolean;
 }
+interface UseKeydownReturn {
+  /**
+   * Whether the listener is currently active
+   */
+  readonly isActive: Readonly<Ref<boolean>>;
+  /**
+   * Start listening for keydown events
+   */
+  start: () => void;
+  /**
+   * Stop listening for keydown events
+   */
+  stop: () => void;
+}
 /**
  * A composable that adds a keydown event listener to the document.
  *
@@ -1099,27 +2009,26 @@ interface KeyHandler {
  * ```ts
  * import { useKeydown } from '@vuetify/v0'
  *
- * const { startListening, stopListening } = useKeydown([
+ * const { isActive, start, stop } = useKeydown([
  *   { key: 'Enter', handler: () => console.log('Enter pressed') },
  *   { key: 'Escape', handler: () => console.log('Escape pressed'), preventDefault: true },
  * ])
  *
- * startListening()
- * stopListening()
+ * // Listener is automatically active when called in component setup
+ * // Manually control if needed:
+ * stop()
+ * start()
  * ```
  */
-declare function useKeydown(handlers: KeyHandler[] | KeyHandler): {
-  startListening: () => void;
-  stopListening: () => void;
-};
+declare function useKeydown(handlers: MaybeRefOrGetter<KeyHandler[] | KeyHandler>): UseKeydownReturn;
 //#endregion
 //#region src/composables/useSingle/index.d.ts
-interface SingleTicket extends SelectionTicket {}
+interface SingleTicket<V = unknown> extends SelectionTicket<V> {}
 interface SingleContext<Z extends SingleTicket> extends SelectionContext<Z> {
   selectedId: ComputedRef<ID | undefined>;
   selectedIndex: ComputedRef<number>;
   selectedItem: ComputedRef<Z | undefined>;
-  selectedValue: ComputedRef<unknown>;
+  selectedValue: ComputedRef<Z['value'] | undefined>;
 }
 interface SingleOptions extends SelectionOptions {}
 interface SingleContextOptions extends SelectionContextOptions {}
@@ -1177,7 +2086,6 @@ declare function createSingle<Z extends SingleTicket = SingleTicket, E extends S
 /**
  * Creates a new single selection context.
  *
- * @param namespace The namespace for the single selection context.
  * @param options The options for the single selection context.
  * @template Z The type of the single selection ticket.
  * @template E The type of the single selection context.
@@ -1189,17 +2097,18 @@ declare function createSingle<Z extends SingleTicket = SingleTicket, E extends S
  * ```ts
  * import { createSingleContext } from '@vuetify/v0'
  *
- * export const [useTabs, provideTabs, tabs] = createSingleContext('tabs', { mandatory: true })
+ * // With default namespace 'v0:single'
+ * export const [useSingle, provideSingle, context] = createSingleContext()
  *
  * // In a parent component:
- * provideTabs()
+ * provideSingle()
  *
  * // In a child component:
- * const tabs = useTabs()
- * tabs.select('tab-1')
+ * const single = useSingle()
+ * single.select('tab-1')
  * ```
  */
-declare function createSingleContext<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(_options: SingleContextOptions): ContextTrinity<E>;
+declare function createSingleContext<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(_options?: SingleContextOptions): ContextTrinity<E>;
 /**
  * Returns the current single selection instance.
  *
@@ -1237,7 +2146,7 @@ interface LocaleAdapter {
  *
  * This adapter provides translation and number formatting
  * capabilities using the Intl API and supports both
- * numbered and named variables in translation strings.
+ * numbered ({0}, {1}) and named ({name}) variables in translation strings.
  */
 declare class Vuetify0LocaleAdapter implements LocaleAdapter {
   t(message: string, ...params: unknown[]): string;
@@ -1248,7 +2157,29 @@ declare class Vuetify0LocaleAdapter implements LocaleAdapter {
 type LocaleRecord = TokenCollection;
 type LocaleTicket = SingleTicket;
 interface LocaleContext<Z extends LocaleTicket> extends SingleContext<Z> {
-  t: (key: string, ...params: unknown[]) => string;
+  /**
+   * Translate a message key with optional parameters and fallback.
+   *
+   * @param key - The message key to look up
+   * @param params - Optional object with named parameters for interpolation
+   * @param fallback - Optional fallback string if key not found in messages
+   * @returns The translated and interpolated message
+   *
+   * @example
+   * ```ts
+   * // Simple key lookup
+   * locale.t('hello') // Returns message for 'hello' or 'hello' if not found
+   *
+   * // With parameters
+   * locale.t('greeting', { name: 'World' }) // 'Hello {name}' → 'Hello World'
+   *
+   * // With fallback (useful for dynamic keys)
+   * locale.t('Pagination.goToPage', { page: 5 }, `Go to page 5`)
+   * // If 'pagination.goToPage' exists: uses that message with {page} replaced
+   * // If not found: returns 'Go to page 5'
+   * ```
+   */
+  t: (key: string, params?: Record<string, unknown>, fallback?: string) => string;
   n: (value: number) => string;
 }
 interface LocaleOptions<Z extends LocaleRecord = LocaleRecord> extends SingleOptions {
@@ -1272,6 +2203,7 @@ interface LocalePluginOptions extends LocaleContextOptions {}
  * @see https://0.vuetifyjs.com/composables/plugins/use-locale
  */
 declare function createLocale<Z extends LocaleTicket = LocaleTicket, E extends LocaleContext<Z> = LocaleContext<Z>>(_options?: LocaleOptions): E;
+declare function createLocaleFallback<Z extends LocaleTicket = LocaleTicket, E extends LocaleContext<Z> = LocaleContext<Z>>(): E;
 /**
  * Creates a new locale context.
  *
@@ -1530,65 +2462,340 @@ interface MutationObserverRecord {
   attributeNamespace: string | null;
   oldValue: string | null;
 }
-interface UseMutationObserverOptions {
-  immediate?: boolean;
-  childList?: boolean;
-  attributes?: boolean;
-  characterData?: boolean;
-  subtree?: boolean;
-  attributeOldValue?: boolean;
-  characterDataOldValue?: boolean;
-  attributeFilter?: string[];
+interface UseMutationObserverOptions {
+  immediate?: boolean;
+  childList?: boolean;
+  attributes?: boolean;
+  characterData?: boolean;
+  subtree?: boolean;
+  attributeOldValue?: boolean;
+  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;
+}
+/**
+ * A composable that uses the Mutation Observer API to detect changes in the DOM.
+ *
+ * @param target The element to observe.
+ * @param callback The callback to execute when a mutation is observed.
+ * @param options The options for the Mutation Observer.
+ * @returns An object with methods to control the observer.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+ * @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
+ *
+ * @example
+ * ```ts
+ * import { ref } from 'vue'
+ * import { useMutationObserver } from '@vuetify/v0'
+ *
+ * const container = ref<HTMLElement>()
+ *
+ * const { pause, resume, isPaused } = useMutationObserver(
+ *   container,
+ *   (mutations) => {
+ *     mutations.forEach((mutation) => {
+ *       if (mutation.type === 'childList') {
+ *         console.log('Children changed:', mutation.addedNodes, mutation.removedNodes)
+ *       } else if (mutation.type === 'attributes') {
+ *         console.log('Attribute changed:', mutation.attributeName)
+ *       }
+ *     })
+ *   },
+ *   {
+ *     childList: true,
+ *     attributes: true,
+ *     subtree: true
+ *   }
+ * )
+ *
+ * // Pause observation
+ * pause()
+ *
+ * // Resume observation
+ * resume()
+ * ```
+ */
+declare function useMutationObserver(target: Ref<Element | undefined>, callback: (entries: MutationObserverRecord[]) => void, options?: UseMutationObserverOptions): UseMutationObserverReturn;
+//#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.
+   */
+  container?: MaybeRefOrGetter<Element | 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 | 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
+ * @returns Trinity tuple: [useContext, provideContext, defaultContext]
+ *
+ * @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`.
+ * @returns The current overflow context.
+ *
+ * @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/usePagination/index.d.ts
+interface PaginationItem {
+  type: 'page' | 'ellipsis';
+  value: number | string;
+}
+interface PaginationContext<Z extends PaginationItem = PaginationItem> {
+  /** Current page (1-indexed) */
+  page: ShallowRef<number>;
+  /** Items per page */
+  itemsPerPage: number;
+  /** Total number of items */
+  size: number;
+  /** Total number of pages (computed from size / itemsPerPage) */
+  pages: number;
+  /** Ellipsis character, or false if disabled */
+  ellipsis: string | false;
+  /** Visible page numbers and ellipsis for rendering */
+  items: ComputedRef<Z[]>;
+  /** Start index of items on current page (0-indexed) */
+  pageStart: ComputedRef<number>;
+  /** End index of items on current page (exclusive, 0-indexed) */
+  pageStop: ComputedRef<number>;
+  /** Whether current page is the first page */
+  isFirst: ComputedRef<boolean>;
+  /** Whether current page is the last page */
+  isLast: ComputedRef<boolean>;
+  /** Go to first page */
+  first: () => void;
+  /** Go to last page */
+  last: () => void;
+  /** Go to next page */
+  next: () => void;
+  /** Go to previous page */
+  prev: () => void;
+  /** Go to specific page */
+  select: (value: number) => void;
+}
+interface PaginationOptions {
+  /** Initial page or ref for v-model (1-indexed). @default 1 */
+  page?: number | ShallowRef<number>;
+  /** Items per page. @default 10 */
+  itemsPerPage?: MaybeRefOrGetter<number>;
+  /** Total number of items. @default 0 */
+  size?: MaybeRefOrGetter<number>;
+  /** Maximum visible page buttons. @default 5 */
+  visible?: MaybeRefOrGetter<number>;
+  /** Ellipsis character. @default '…' */
+  ellipsis?: string | false;
+}
+interface PaginationContextOptions extends PaginationOptions {
+  /** Namespace for dependency injection */
+  namespace?: string;
 }
 /**
- * A composable that uses the Mutation Observer API to detect changes in the DOM.
+ * Creates a pagination instance.
  *
- * @param target The element to observe.
- * @param callback The callback to execute when a mutation is observed.
- * @param options The options for the Mutation Observer.
- * @returns An object with methods to control the observer.
+ * @param options The options for the pagination instance.
+ * @returns A pagination context with navigation methods.
  *
- * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
- * @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
+ * @example
+ * ```ts
+ * import { createPagination } from '@vuetify/v0'
+ *
+ * // Basic usage
+ * const pagination = createPagination({ size: 100 })
+ * pagination.next()
+ * pagination.items.value // [{ type: 'page', value: 1 }, { type: 'page', value: 2 }, ...]
+ *
+ * // With v-model (pass a ref)
+ * const page = ref(1)
+ * const pagination = createPagination({ page, size: 100 })
+ * // Mutating pagination.page or the passed ref syncs both
+ * ```
+ */
+declare function createPagination<Z extends PaginationItem = PaginationItem, E extends PaginationContext<Z> = PaginationContext<Z>>(_options?: PaginationOptions): E;
+/**
+ * Creates a pagination context for dependency injection.
+ *
+ * @param options The options including namespace.
+ * @returns A trinity: [usePagination, providePagination, defaultContext]
  *
  * @example
  * ```ts
- * import { ref } from 'vue'
- * import { useMutationObserver } from '@vuetify/v0'
+ * // With default namespace 'v0:pagination'
+ * const [usePagination, providePaginationContext] = createPaginationContext({ size: 50 })
  *
- * const container = ref<HTMLElement>()
+ * // Or with custom namespace
+ * const [usePagination, providePaginationContext] = createPaginationContext({
+ *   namespace: 'my-pagination',
+ *   size: 50,
+ * })
  *
- * const { pause, resume, isPaused } = useMutationObserver(
- *   container,
- *   (mutations) => {
- *     mutations.forEach((mutation) => {
- *       if (mutation.type === 'childList') {
- *         console.log('Children changed:', mutation.addedNodes, mutation.removedNodes)
- *       } else if (mutation.type === 'attributes') {
- *         console.log('Attribute changed:', mutation.attributeName)
- *       }
- *     })
- *   },
- *   {
- *     childList: true,
- *     attributes: true,
- *     subtree: true
- *   }
- * )
+ * // Parent component
+ * providePaginationContext()
  *
- * // Pause observation
- * pause()
+ * // Child component
+ * const pagination = usePagination()
+ * pagination.next()
+ * ```
+ */
+declare function createPaginationContext<Z extends PaginationItem = PaginationItem, E extends PaginationContext<Z> = PaginationContext<Z>>(_options?: PaginationContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current pagination instance from context.
  *
- * // Resume observation
- * resume()
+ * @param namespace The namespace. @default 'v0:pagination'
+ * @returns The pagination context.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ *  import { usePagination } from '@vuetify/v0'
+ *
+ *  const pagination = usePagination()
+ * </script>
+ *
+ * <template>
+ *   <button @click="pagination.prev()" :disabled="pagination.isFirst.value">Prev</button>
+ *   <button @click="pagination.next()" :disabled="pagination.isLast.value">Next</button>
+ * </template>
  * ```
  */
-declare function useMutationObserver(target: Ref<Element | undefined>, callback: (entries: MutationObserverRecord[]) => void, options?: UseMutationObserverOptions): {
-  isPaused: Readonly<Ref<boolean, boolean>>;
-  pause: () => void;
-  resume: () => void;
-  stop: () => void;
-};
+declare function usePagination<Z extends PaginationItem = PaginationItem, E extends PaginationContext<Z> = PaginationContext<Z>>(namespace?: string): E;
 //#endregion
 //#region src/composables/usePermissions/adapters/adapter.d.ts
 interface PermissionAdapterInterface {
@@ -1599,9 +2806,7 @@ declare abstract class PermissionAdapter implements PermissionAdapterInterface {
 }
 //#endregion
 //#region src/composables/usePermissions/index.d.ts
-interface PermissionTicket extends TokenTicket {
-  value: boolean | ((context: Record<string, any>) => boolean);
-}
+interface PermissionTicket extends TokenTicket<boolean | ((context: Record<string, any>) => boolean)> {}
 interface PermissionContext<Z extends PermissionTicket = PermissionTicket> extends TokenContext<Z> {
   can: (id: ID, action: string, subject: string, context?: Record<string, any>) => boolean;
 }
@@ -1784,7 +2989,7 @@ interface ProxyRegistryContext<Z extends RegistryTicket = RegistryTicket> {
 declare function useProxyRegistry<Z extends RegistryTicket = RegistryTicket>(registry: RegistryContext<Z>, options?: ProxyRegistryOptions): ProxyRegistryContext<Z>;
 //#endregion
 //#region src/composables/useQueue/index.d.ts
-interface QueueTicket extends RegistryTicket {
+interface QueueTicket<V = unknown> extends RegistryTicket<V> {
   /**
    * Timeout in milliseconds
    *
@@ -2076,6 +3281,28 @@ interface ResizeObserverOptions {
   immediate?: boolean;
   box?: 'content-box' | 'border-box';
 }
+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;
+  /**
+   * Resume observation
+   */
+  resume: () => void;
+  /**
+   * Stop observation and clean up (destroys observer)
+   */
+  stop: () => void;
+}
 /**
  * A composable that uses the Resize Observer API to detect when an element's
  * size changes.
@@ -2117,12 +3344,17 @@ interface ResizeObserverOptions {
  * resume()
  * ```
  */
-declare function useResizeObserver(target: Ref<Element | undefined>, callback: (entries: ResizeObserverEntry[]) => void, options?: ResizeObserverOptions): {
-  isPaused: Readonly<Ref<boolean, boolean>>;
-  pause: () => void;
-  resume: () => void;
-  stop: () => void;
-};
+declare function useResizeObserver(target: Ref<Element | 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>;
+}
 /**
  * A convenience composable that uses the Resize Observer API to track an
  * element's size.
@@ -2146,17 +3378,10 @@ declare function useResizeObserver(target: Ref<Element | undefined>, callback: (
  * })
  * ```
  */
-declare function useElementSize(target: Ref<Element | undefined>): {
-  width: vue231.ShallowRef<number, number>;
-  height: vue231.ShallowRef<number, number>;
-  isPaused: Readonly<Ref<boolean, boolean>>;
-  pause: () => void;
-  resume: () => void;
-  stop: () => void;
-};
+declare function useElementSize(target: Ref<Element | undefined>): UseElementSizeReturn;
 //#endregion
 //#region src/composables/useStep/index.d.ts
-interface StepTicket extends SingleTicket {}
+interface StepTicket<V = unknown> extends SingleTicket<V> {}
 interface StepContext<Z extends StepTicket> extends SingleContext<Z> {
   /** Select the first Ticket in the collection */
   first: () => void;
@@ -2259,7 +3484,6 @@ declare function createStep<Z extends StepTicket = StepTicket, E extends StepCon
 /**
  * Creates a new step context.
  *
- * @param namespace The namespace for the step context.
  * @param options The options for the step context.
  * @template Z The type of the step ticket.
  * @template E The type of the step context.
@@ -2271,17 +3495,18 @@ declare function createStep<Z extends StepTicket = StepTicket, E extends StepCon
  * ```ts
  * import { createStepContext } from '@vuetify/v0'
  *
- * export const [useWizard, provideWizard, wizard] = createStepContext('wizard')
+ * // With default namespace 'v0:step'
+ * export const [useStep, provideStep, context] = createStepContext()
  *
  * // In a parent component:
- * provideWizard()
+ * provideStep()
  *
  * // In a child component:
- * const wizard = useWizard()
- * wizard.next() // Progress to next step
+ * const context = useStep()
+ * context.next() // Progress to next step
  * ```
  */
-declare function createStepContext<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(_options: StepContextOptions): ContextTrinity<E>;
+declare function createStepContext<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(_options?: StepContextOptions): ContextTrinity<E>;
 /**
  * Returns the current step instance.
  *
@@ -2362,8 +3587,8 @@ interface StorageOptions {
   prefix?: string;
   /** Custom serializer for reading and writing values. Defaults to JSON.parse/stringify */
   serializer?: {
-    read: (value: string) => any;
-    write: (value: any) => string;
+    read: (value: string) => unknown;
+    write: (value: unknown) => string;
   };
 }
 interface StorageContextOptions extends StorageOptions {
@@ -2371,7 +3596,6 @@ interface StorageContextOptions extends StorageOptions {
   namespace?: string;
 }
 interface StoragePluginOptions extends StorageContextOptions {}
-declare const useStorageContext: (key?: ContextKey<StorageContext>) => StorageContext, provideStorageContext: (context: StorageContext, app?: App) => StorageContext;
 /**
  * Creates a new storage instance.
  *
@@ -2492,12 +3716,11 @@ type ThemeColors = {
   [key: string]: Colors | string;
 };
 type ThemeRecord = {
-  [key: string]: any;
   dark?: boolean;
   lazy?: boolean;
   colors: ThemeColors;
 };
-interface ThemeTicket extends SingleTicket {
+interface ThemeTicket extends SingleTicket<ThemeColors> {
   /**
    * Indicates whether the theme is dark or light.
    *
@@ -2783,7 +4006,7 @@ interface TimelineContext<Z extends TimelineTicket> extends RegistryContext<Z> {
    */
   redo: () => Z | undefined;
 }
-interface TimelineTicket extends RegistryTicket {}
+interface TimelineTicket<V = unknown> extends RegistryTicket<V> {}
 interface TimelineOptions extends RegistryOptions {
   /**
    * The maximum size of the timeline.
@@ -2793,7 +4016,7 @@ interface TimelineOptions extends RegistryOptions {
   size?: number;
 }
 interface TimelineContextOptions extends TimelineOptions {
-  namespace: string;
+  namespace?: string;
 }
 /**
  * Creates a new timeline instance.
@@ -2824,13 +4047,12 @@ interface TimelineContextOptions extends TimelineOptions {
  */
 declare function createTimeline<Z extends TimelineTicket = TimelineTicket, E extends TimelineContext<Z> = TimelineContext<Z>>(_options?: TimelineOptions): E;
 /**
- * Creates a new timeline plugin.
+ * Creates a new timeline context.
  *
- * @param namespace The namespace for the timeline plugin.
- * @param options The options for the timeline plugin.
+ * @param options The options for the timeline context.
  * @template Z The type of the timeline ticket.
  * @template E The type of the timeline context.
- * @returns A new timeline plugin.
+ * @returns A new timeline context.
  *
  * @see https://0.vuetifyjs.com/composables/registration/use-timeline
  *
@@ -2838,7 +4060,9 @@ declare function createTimeline<Z extends TimelineTicket = TimelineTicket, E ext
  * ```ts
  * import { createTimelineContext } from '@vuetify/v0'
  *
- * export const [useTimeline, provideTimeline, context] = createTimelineContext('v0:timeline', { size: 5 })
+ * // With default namespace 'v0:timeline'
+ * export const [useTimeline, provideTimeline, context] = createTimelineContext({ size: 5 })
+ *
  * context.register({ id: 'example' })
  *
  * // In a parent component
@@ -2850,7 +4074,7 @@ declare function createTimeline<Z extends TimelineTicket = TimelineTicket, E ext
  * console.log(timeline.values()) // [{ id: 'example' }]
  * ```
  */
-declare function createTimelineContext<Z extends TimelineTicket = TimelineTicket, E extends TimelineContext<Z> = TimelineContext<Z>>(_options: TimelineContextOptions): ContextTrinity<E>;
+declare function createTimelineContext<Z extends TimelineTicket = TimelineTicket, E extends TimelineContext<Z> = TimelineContext<Z>>(_options?: TimelineContextOptions): ContextTrinity<E>;
 /**
  * Returns the current timeline instance.
  *
@@ -2870,4 +4094,372 @@ declare function createTimelineContext<Z extends TimelineTicket = TimelineTicket
  */
 declare function useTimeline<Z extends TimelineTicket = TimelineTicket, E extends TimelineContext<Z> = TimelineContext<Z>>(namespace?: string): E;
 //#endregion
-export { ProxyRegistryContext as $, createGroup as $n, IntersectionObserverOptions as $t, useStorage as A, FeatureOptions as An, LoggerAdapter as At, createStepContext as B, TokenContext as Bn, useLocale as Bt, StorageContextOptions as C, FilterQuery as Cn, createLoggerContext as Ct, createStorageContext as D, useFilter as Dn, Vuetify0LoggerAdapter as Dt, createStorage as E, UseFilterResult as En, LogLevel as Et, StepContext as F, createFeaturesPlugin as Fn, LocaleRecord as Ft, useResizeObserver as G, TokenValue as Gn, SingleOptions as Gt, ResizeObserverEntry as H, TokenOptions as Hn, LocaleAdapter as Ht, StepContextOptions as I, useFeatures as In, LocaleTicket as It, QueueOptions as J, useTokens as Jn, createSingleContext as Jt, QueueContext as K, createTokens as Kn, SingleTicket as Kt, StepOptions as L, FlatTokenCollection as Ln, createLocale as Lt, StorageAdapter as M, FeatureTicket as Mn, LocaleContextOptions as Mt, StorageType as N, createFeatures as Nn, LocaleOptions as Nt, createStoragePlugin as O, FeatureContext as On, PinoLoggerAdapter as Ot, MemoryAdapter as P, createFeaturesContext as Pn, LocalePluginOptions as Pt, useQueue as Q, GroupTicket as Qn, IntersectionObserverEntry as Qt, StepTicket as R, TokenAlias as Rn, createLocaleContext as Rt, StorageContext as S, FilterMode as Sn, createLogger as St, StoragePluginOptions as T, UseFilterOptions as Tn, useLogger as Tt, ResizeObserverOptions as U, TokenPrimitive as Un, SingleContext as Ut, useStep as V, TokenContextOptions as Vn, Vuetify0LocaleAdapter as Vt, useElementSize as W, TokenTicket as Wn, SingleContextOptions as Wt, createQueue as X, GroupContextOptions as Xn, KeyHandler as Xt, QueueTicket as Y, GroupContext as Yn, useSingle as Yt, createQueueContext as Z, GroupOptions as Zn, useKeydown as Zt, createThemeContext as _, createForm as _n, toArray as _r, useMutationObserver as _t, createTimeline as a, HydrationPluginOptions as an, useEventListener as ar, PermissionContextOptions as at, Vuetify0ThemeAdapter as b, FilterFunction as bn, createPlugin as br, LoggerOptions as bt, Colors as c, createHydrationPlugin as cn, BreakpointsContext as cr, PermissionTicket as ct, ThemeContextOptions as d, FormContextOptions as dn, BreakpointsPluginOptions as dr, createPermissionsPlugin as dt, useElementIntersection as en, createGroupContext as er, ProxyRegistryOptions as et, ThemeOptions as f, FormOptions as fn, createBreakpoints as fr, usePermissions as ft, createTheme as g, FormValue as gn, toReactive as gr, UseMutationObserverOptions as gt, ThemeTicket as h, FormValidationRule as hn, useBreakpoints as hr, MutationObserverRecord as ht, TimelineTicket as i, HydrationOptions as in, useDocumentEventListener as ir, PermissionContext as it, useStorageContext as j, FeaturePluginOptions as jn, LocaleContext as jt, provideStorageContext as k, FeatureContextOptions as kn, ConsolaLoggerAdapter as kt, ThemeColors as l, useHydration as ln, BreakpointsContextOptions as lr, createPermissions as lt, ThemeRecord as m, FormValidationResult as mn, createBreakpointsPlugin as mr, PermissionAdapterInterface as mt, TimelineContextOptions as n, HydrationContext as nn, CleanupFunction as nr, ProxyModelOptions as nt, createTimelineContext as o, createHydration as on, useWindowEventListener as or, PermissionOptions as ot, ThemePluginOptions as p, FormTicket as pn, createBreakpointsContext as pr, PermissionAdapter as pt, QueueContextOptions as q, createTokensContext as qn, createSingle as qt, TimelineOptions as r, HydrationContextOptions as rn, EventHandler as rr, useProxyModel as rt, useTimeline as s, createHydrationContext as sn, BreakpointName as sr, PermissionPluginOptions as st, TimelineContext as t, useIntersectionObserver as tn, useGroup as tr, useProxyRegistry as tt, ThemeContext as u, FormContext as un, BreakpointsOptions as ur, createPermissionsContext as ut, createThemePlugin as v, createFormContext as vn, Plugin as vr, LoggerContext as vt, StorageOptions as w, Primitive as wn, createLoggerPlugin as wt, ThemeAdapter as x, FilterItem as xn, LoggerPluginOptions as xt, useTheme as y, useForm as yn, PluginOptions as yr, LoggerContextOptions as yt, createStep as z, TokenCollection as zn, createLocalePlugin as zt };
+//#region src/composables/useToggleScope/index.d.ts
+interface ToggleScopeControls {
+  /**
+   * Whether the scope is currently active (created and running)
+   */
+  readonly isActive: Readonly<Ref<boolean>>;
+  /**
+   * Stop the scope (destroys and cleans up all effects)
+   */
+  stop: () => void;
+  /**
+   * Start the scope (creates and runs effects)
+   */
+  start: () => void;
+  /**
+   * Reset the scope (stops and immediately restarts)
+   */
+  reset: () => void;
+}
+/**
+ * Conditionally manages an effect scope based on a reactive boolean source.
+ *
+ * @param source A reactive boolean value or getter that controls the scope lifecycle
+ * @param fn The function to run within the effect scope. Can optionally receive controls for manual scope management.
+ * @returns Controls object with isActive state and start/stop/reset methods
+ *
+ * @see https://vuejs.org/api/reactivity-advanced.html#effectscope
+ * @see https://0.vuetifyjs.com/composables/system/use-toggle-scope
+ *
+ * @example
+ * ```ts
+ * import { ref } from 'vue'
+ * import { useToggleScope } from '@vuetify/v0'
+ *
+ * const isEnabled = ref(false)
+ *
+ * const { isActive } = useToggleScope(isEnabled, () => {
+ *   // This code runs when isEnabled becomes true
+ *   const unwatch = watch(someRef, () => {
+ *     console.log('Watching...')
+ *   })
+ *
+ *   // Cleanup happens automatically when isEnabled becomes false
+ * })
+ *
+ * // Toggle the scope on/off
+ * isEnabled.value = true  // Starts the scope
+ * console.log(isActive.value) // true
+ * isEnabled.value = false // Stops and cleans up
+ * console.log(isActive.value) // false
+ * ```
+ *
+ * @example
+ * With manual controls:
+ * ```ts
+ * const isEnabled = ref(true)
+ *
+ * useToggleScope(isEnabled, (controls) => {
+ *   // Access controls inside the scope
+ *   console.log('Active:', controls.isActive.value)
+ *
+ *   // Manually reset the scope if needed
+ *   someEvent.on('reset', () => controls.reset())
+ * })
+ * ```
+ */
+declare function useToggleScope(source: WatchSource<boolean>, fn: (() => void) | ((controls: ToggleScopeControls) => void)): ToggleScopeControls;
+//#endregion
+//#region src/composables/useVirtual/index.d.ts
+type VirtualDirection = 'forward' | 'reverse';
+type VirtualState = 'loading' | 'empty' | 'error' | 'ok';
+type VirtualAnchor = 'auto' | 'start' | 'end' | ((items: readonly unknown[]) => number | string);
+interface ScrollToOptions {
+  /**
+   * The behavior of the scroll animation.
+   */
+  behavior?: 'auto' | 'smooth' | 'instant';
+  /**
+   * The alignment of the scroll position.
+   */
+  block?: 'start' | 'center' | 'end' | 'nearest';
+  /**
+   * The offset of the scroll position.
+   */
+  offset?: number;
+}
+interface VirtualOptions {
+  /**
+   * The height of the item.
+   */
+  itemHeight?: number | string | null;
+  /**
+   * The height of the container.
+   */
+  height?: number | string;
+  /**
+   * The number of extra items to render.
+   */
+  overscan?: number;
+  /**
+   * The direction of the scrolling.
+   */
+  direction?: VirtualDirection;
+  /**
+   * The anchor of the scrolling.
+   */
+  anchor?: VirtualAnchor;
+  /**
+   * Whether to smooth the anchor position.
+   */
+  anchorSmooth?: boolean;
+  /**
+   * The callback to call when the start is reached.
+   */
+  onStartReached?: (distance: number) => void | Promise<void>;
+  /**
+   * The callback to call when the end is reached.
+   */
+  onEndReached?: (distance: number) => void | Promise<void>;
+  /**
+   * The threshold for the start.
+   */
+  startThreshold?: number;
+  /**
+   * The threshold for the end.
+   */
+  endThreshold?: number;
+  /**
+   * Whether to enable momentum scrolling.
+   */
+  momentum?: boolean;
+  /**
+   * Whether to enable elastic scrolling.
+   */
+  elastic?: boolean;
+}
+interface VirtualItem<T = unknown> {
+  raw: T;
+  index: number;
+}
+interface VirtualContext<T = unknown> {
+  /**
+   * The element that is being virtualized.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { element } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <div ref="element">
+   *     <div v-for="item in items" :key="item.index">
+   *       {{ item.raw }}
+   *     </div>
+   *   </div>
+   * </template>
+   */
+  element: Ref<HTMLElement | undefined>;
+  /**
+   * The items that are being virtualized.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { items } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <div v-for="item in items" :key="item.index">
+   *     {{ item.raw }}
+   *   </div>
+   * </template>
+   * ```
+   */
+  items: ComputedRef<VirtualItem<T>[]>;
+  /**
+   * The offset of the virtualized items.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { offset } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <div :style="{ height: `${offset}px` }" />
+   * </template>
+   * ```
+   */
+  offset: Readonly<ShallowRef<number>>;
+  /**
+   * The size of the virtualized items.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { size } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <div :style="{ height: `${size}px` }" />
+   * </template>
+   * ```
+   */
+  size: Readonly<ShallowRef<number>>;
+  /**
+   * The state of the virtualized items.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { state } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <div v-if="state === 'loading'">Loading...</div>
+   *   <div v-else-if="state === 'empty'">No items</div>
+   *   <div v-else-if="state === 'error'">Error</div>
+   *   <div v-else>Items</div>
+   * </template>
+   * ```
+   */
+  state: ShallowRef<VirtualState>;
+  /**
+   * Scroll to an item by index.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { scrollTo } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <button @click="scrollTo(0)">Scroll to top</button>
+   *   <button @click="scrollTo(items.length - 1)">Scroll to bottom</button>
+   * </template>
+   * ```
+   */
+  scrollTo: (index: number, options?: ScrollToOptions) => void;
+  /**
+   * The scroll event handler.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { element, scroll } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <div ref="element" @scroll="scroll">
+   *     <div v-for="item in items" :key="item.index">
+   *       {{ item.raw }}
+   *     </div>
+   *   </div>
+   * </template>
+   * ```
+   */
+  scroll: () => void;
+  /**
+   * The scrollend event handler.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { scroll, scrollend } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <div ref="element" @scroll="scroll" @scrollend="scrollend">
+   *     <div v-for="item in items" :key="item.index">
+   *       {{ item.raw }}
+   *     </div>
+   *   </div>
+   * </template>
+   * ```
+   */
+  scrollend: () => void;
+  /**
+   * Resize an item by index.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { resize } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <button @click="resize(0, 100)">Resize first item</button>
+   * </template>
+   * ```
+   */
+  resize: (index: number, height: number) => void;
+  /**
+   * Reset the virtualized items.
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { useVirtual } from '@vuetify/v0'
+   *
+   *   const { reset } = useVirtual(items)
+   * </script>
+   *
+   * <template>
+   *   <button @click="reset">Reset</button>
+   *   <div v-for="item in items" :key="item.index">
+   *     {{ item.raw }}
+   *   </div>
+   * </template>
+   * ```
+   */
+  reset: () => void;
+}
+/**
+ * Virtual scrolling composable for efficiently rendering large lists
+ *
+ * @param items Reactive array of items to virtualize
+ * @param options Configuration options
+ * @returns Virtual scrolling context
+ *
+ * @see https://0.vuetifyjs.com/composables/utilities/use-virtual
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useVirtual } from '@vuetify/v0'
+ *
+ *   const items = ref(Array.from({ length: 10000 }, (_, i) => ({ id: i, name: `Item ${i}` })))
+ * </script>
+ *
+ * <template>
+ *   <div
+ *     ref="element"
+ *     style="height: 600px; overflow-y: auto;"
+ *     @scroll="scroll"
+ *   >
+ *     <div :style="{ height: `${offset}px` }" />
+ *
+ *     <div v-for="item in items" :key="item.index">
+ *       {{ item.raw.name }}
+ *     </div>
+ *
+ *     <div :style="{ height: `${size}px` }" />
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useVirtual<T = unknown>(items: Ref<readonly T[]>, _options?: VirtualOptions): VirtualContext<T>;
+//#endregion
+export { UseResizeObserverReturn as $, Primitive as $n, useContext as $r, ConsolaLoggerAdapter as $t, Vuetify0ThemeAdapter as A, HydrationContext as An, useGroup as Ar, createPaginationContext as At, StorageAdapter as B, FormContextOptions as Bn, BreakpointsPluginOptions as Br, UseMutationObserverReturn as Bt, ThemePluginOptions as C, useKeydown as Cn, useTokens as Cr, PermissionAdapter as Ct, createThemeContext as D, UseIntersectionObserverReturn as Dn, GroupTicket as Dr, PaginationItem as Dt, createTheme as E, UseElementIntersectionReturn as En, GroupOptions as Er, PaginationContextOptions as Et, StoragePluginOptions as F, createHydration as Fn, useWindowEventListener as Fr, createOverflow as Ft, StepOptions as G, FormValue as Gn, toReactive as Gr, LoggerPluginOptions as Gt, MemoryAdapter as H, FormTicket as Hn, createBreakpointsContext as Hr, LoggerContext as Ht, createStorage as I, createHydrationContext as In, BreakpointName as Ir, createOverflowContext as It, createStepContext as J, useForm as Jn, PluginOptions as Jr, createLoggerPlugin as Jt, StepTicket as K, createForm as Kn, toArray as Kr, createLogger as Kt, createStorageContext as L, createHydrationPlugin as Ln, BreakpointsContext as Lr, useOverflow as Lt, StorageContext as M, HydrationOptions as Mn, EventHandler as Mr, OverflowContext as Mt, StorageContextOptions as N, HydrationPluginOptions as Nn, useDocumentEventListener as Nr, OverflowContextOptions as Nt, createThemePlugin as O, useElementIntersection as On, createGroup as Or, PaginationOptions as Ot, StorageOptions as P, createFallbackHydration as Pn, useEventListener as Pr, OverflowOptions as Pt, UseElementSizeReturn as Q, FilterQuery as Qn, provideContext as Qr, PinoLoggerAdapter as Qt, createStoragePlugin as R, useHydration as Rn, BreakpointsContextOptions as Rr, MutationObserverRecord as Rt, ThemeOptions as S, UseKeydownReturn as Sn, createTokensContext as Sr, usePermissions as St, ThemeTicket as T, IntersectionObserverOptions as Tn, GroupContextOptions as Tr, PaginationContext as Tt, StepContext as U, FormValidationResult as Un, createBreakpointsPlugin as Ur, LoggerContextOptions as Ut, StorageType as V, FormOptions as Vn, createBreakpoints as Vr, useMutationObserver as Vt, StepContextOptions as W, FormValidationRule as Wn, useBreakpoints as Wr, LoggerOptions as Wt, ResizeObserverEntry as X, FilterItem as Xn, ContextKey as Xr, LogLevel as Xt, useStep as Y, FilterFunction as Yn, createPlugin as Yr, useLogger as Yt, ResizeObserverOptions as Z, FilterMode as Zn, createContext as Zr, Vuetify0LoggerAdapter as Zt, useTimeline as _, SingleTicket as _n, TokenOptions as _r, PermissionPluginOptions as _t, VirtualItem as a, createSelectionContext as ai, LocaleRecord as an, FeatureOptions as ar, QueueTicket as at, ThemeContext as b, useSingle as bn, TokenValue as br, createPermissionsContext as bt, useVirtual as c, RegistryContextOptions as ci, createLocaleContext as cn, createFeatures as cr, useQueue as ct, TimelineContext as d, createRegistryContext as di, useLocale as dn, useFeatures as dr, useProxyRegistry as dt, SelectionContext as ei, LoggerAdapter as en, UseFilterOptions as er, useElementSize as et, TimelineContextOptions as f, useRegistry as fi, Vuetify0LocaleAdapter as fn, FlatTokenCollection as fr, ProxyModelOptions as ft, createTimelineContext as g, SingleOptions as gn, TokenContextOptions as gr, PermissionOptions as gt, createTimeline as h, SingleContextOptions as hn, TokenContext as hr, PermissionContextOptions as ht, VirtualDirection as i, createSelection as ii, LocalePluginOptions as in, FeatureContextOptions as ir, QueueOptions as it, ThemeAdapter as j, HydrationContextOptions as jn, CleanupFunction as jr, usePagination as jt, useTheme as k, useIntersectionObserver as kn, createGroupContext as kr, createPagination as kt, ToggleScopeControls as l, RegistryOptions as li, createLocaleFallback as ln, createFeaturesContext as lr, ProxyRegistryContext as lt, TimelineTicket as m, createTrinity as mi, SingleContext as mn, TokenCollection as mr, PermissionContext as mt, VirtualAnchor as n, SelectionOptions as ni, LocaleContextOptions as nn, useFilter as nr, QueueContext as nt, VirtualOptions as o, useSelection as oi, LocaleTicket as on, FeaturePluginOptions as or, createQueue as ot, TimelineOptions as p, ContextTrinity as pi, LocaleAdapter as pn, TokenAlias as pr, useProxyModel as pt, createStep as q, createFormContext as qn, Plugin as qr, createLoggerContext as qt, VirtualContext as r, SelectionTicket as ri, LocaleOptions as rn, FeatureContext as rr, QueueContextOptions as rt, VirtualState as s, RegistryContext as si, createLocale as sn, FeatureTicket as sr, createQueueContext as st, ScrollToOptions as t, SelectionContextOptions as ti, LocaleContext as tn, UseFilterResult as tr, useResizeObserver as tt, useToggleScope as u, RegistryTicket as ui, createLocalePlugin as un, createFeaturesPlugin as ur, ProxyRegistryOptions as ut, Colors as v, createSingle as vn, TokenPrimitive as vr, PermissionTicket as vt, ThemeRecord as w, IntersectionObserverEntry as wn, GroupContext as wr, PermissionAdapterInterface as wt, ThemeContextOptions as x, KeyHandler as xn, createTokens as xr, createPermissionsPlugin as xt, ThemeColors as y, createSingleContext as yn, TokenTicket as yr, createPermissions as yt, useStorage as z, FormContext as zn, BreakpointsOptions as zr, UseMutationObserverOptions as zt };