@vuetify/v0 0.0.14 → 0.0.16

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

@@ -1,10 +1,98 @@
-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 { a as MaybeArray, i as ID } from "./index-Bd3J4RNS.mjs";
+import { H as ContextTrinity, I as RegistryContext, L as RegistryContextOptions, M as SelectionTicket, R as RegistryOptions, S as GroupContext, T as GroupTicket, c as SingleContext, d as SingleTicket, k as SelectionContext, u as SingleOptions, z as RegistryTicket } from "./index-BulceeMA.mjs";
+import { App, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, Ref, ShallowRef, UnwrapNestedRefs, WatchSource } from "vue";
 
-//#region src/composables/createPlugin/index.d.ts
+//#region src/composables/createContext/index.d.ts
 
+type ContextKey<Z> = InjectionKey<Z> | string;
+interface CreateContextOptions {
+  /** Optional suffix to append to the runtime key */
+  suffix?: string;
+}
+/**
+ * Injects a context provided by an ancestor component.
+ *
+ * @param key The key of the context to inject.
+ * @param defaultValue Optional default value if context is not found.
+ * @template Z The type of the context.
+ * @returns The injected context.
+ * @throws An error if the context is not found and no default is provided.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#use-context
+ *
+ * @example
+ * ```ts
+ * // Without default value
+ * const context = useContext<MyContext>('my-context')
+ *
+ * // With default value
+ * const context = useContext<MyContext>('my-context', defaultContext)
+ * ```
+ */
+declare function useContext<Z>(key: ContextKey<Z>, defaultValue?: Z): Z;
+/**
+ * Provides a context to all descendant components.
+ *
+ * @param key The key of the context to provide.
+ * @param context The context to provide.
+ * @param app Optional Vue app instance to provide the context at app level instead of component level.
+ * @template Z The type of the context.
+ * @returns The provided context.
+ *
+ * @remarks
+ * When `app` parameter is provided, the context is made available to all components in the app.
+ * When omitted, the context is provided at the current component level and available to descendants only.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#provide-context
+ *
+ * @example
+ * ```ts
+ * // Component-level provision
+ * provideContext<MyContext>('my-context', context)
+ *
+ * // App-level provision (typically used in plugins)
+ * const app = createApp()
+ * provideContext<MyContext>('my-context', context, app)
+ * ```
+ */
+declare function provideContext<Z>(key: ContextKey<Z>, context: Z, app?: App): Z;
+/**
+ * Creates a new context for providing and injecting data.
+ *
+ * Supports two modes:
+ * - **Static key mode**: Pass a string/symbol key. The key is fixed at creation time.
+ * - **Dynamic key mode**: Pass nothing or an options object. The key is provided at runtime.
+ *
+ * @template Z The type of the context.
+ * @returns A tuple containing the `useContext` and `provideContext` functions.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#create-context
+ *
+ * @example
+ * ```ts
+ * // Static key mode - key fixed at creation
+ * const [useContext, provideContext] = createContext<ThemeContext>('v0:theme')
+ * provideContext(context)              // provides to 'v0:theme'
+ * useContext()                         // injects from 'v0:theme'
+ *
+ * // Dynamic key mode - key provided at runtime
+ * const [useContext, provideContext] = createContext<PanelContext>()
+ * provideContext('v0:panel', context)  // provides to 'v0:panel'
+ * useContext('v0:panel')               // injects from 'v0:panel'
+ *
+ * // Dynamic key with suffix - suffix appended to runtime key
+ * const [useContext, provideContext] = createContext<ItemContext>({ suffix: 'item' })
+ * provideContext('v0:panel', context)  // provides to 'v0:panel:item'
+ * useContext('v0:panel')               // injects from 'v0:panel:item'
+ * ```
+ */
+declare function createContext<Z>(key: ContextKey<Z>, defaultValue?: Z): readonly [() => Z, (context: Z, app?: App) => Z];
+declare function createContext<Z>(options?: CreateContextOptions): readonly [(key: string, defaultValue?: Z) => Z, (key: string, context: Z, app?: App) => Z];
+//#endregion
+//#region src/composables/createPlugin/index.d.ts
 interface PluginOptions {
   namespace: string;
   provide: (app: App) => void;
@@ -317,127 +405,6 @@ 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 GroupContext<Z extends GroupTicket> extends SelectionContext<Z> {
-  selectedIndexes: ComputedRef<Set<number>>;
-  /** Select one or more Tickets by ID */
-  select: (ids: ID | ID[]) => void;
-  /** Unselect one or more Tickets by ID */
-  unselect: (ids: ID | ID[]) => void;
-  /** Toggle one or more Tickets ON and OFF by ID */
-  toggle: (ids: ID | ID[]) => void;
-}
-interface GroupOptions extends SelectionOptions {}
-interface GroupContextOptions extends SelectionContextOptions {}
-/**
- * Creates a new group instance with batch selection operations.
- *
- * Extends `createSelection` to support selecting, unselecting, and toggling multiple items
- * at once by passing an array of IDs. Adds `selectedIndexes` computed property.
- *
- * @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.
- *
- * @remarks
- * **Key Differences from `createSelection`:**
- * - `select()` accepts `ID | ID[]` for batch operations
- * - `unselect()` accepts `ID | ID[]` for batch operations
- * - `toggle()` accepts `ID | ID[]` for batch operations
- * - Adds `selectedIndexes` computed Set for getting selected item indexes
- * - Perfect for checkboxes, multi-select dropdowns, and bulk operations
- *
- * **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
- * - Non-existent IDs are silently ignored
- *
- * **Inheritance Chain:**
- * `useRegistry` → `createSelection` → `createGroup`
- *
- * **Used By:**
- * - `createFeatures` for feature flag management with multiple selections
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-group
- *
- * @example
- * ```ts
- * import { createGroup } from '@vuetify/v0'
- *
- * const checkboxes = createGroup()
- *
- * checkboxes.onboard([
- *   { id: 'option-a', value: 'Option A' },
- *   { id: 'option-b', value: 'Option B' },
- *   { id: 'option-c', value: 'Option C' },
- * ])
- *
- * // Select multiple items at once
- * checkboxes.select(['option-a', 'option-c'])
- *
- * console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
- * console.log(Array.from(checkboxes.selectedIndexes.value)) // [0, 2]
- *
- * // Toggle operations
- * checkboxes.toggle(['option-a', 'option-b'])
- * console.log(checkboxes.selectedIds) // Set { 'option-b', 'option-c' }
- * ```
- */
-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.
- * @returns A new group context.
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-group
- *
- * @example
- * ```ts
- * import { createGroupContext } from '@vuetify/v0'
- *
- * export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext('my-group')
- *
- * // In a parent component:
- * provideMyGroup()
- *
- * // In a child component:
- * const group = useMyGroup()
- * ```
- */
-declare function createGroupContext<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(_options: GroupContextOptions): ContextTrinity<E>;
-/**
- * Returns the current group instance.
- *
- * @param namespace The namespace for the group context. Defaults to `'v0:group'`.
- * @returns The current group instance.
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-group
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useGroup } from '@vuetify/v0'
- *
- *   const group = useGroup()
- * </script>
- *
- * <template>
- *   <div>
- *     <p>Selected: {{ group.selectedIds.size }}</p>
- *   </div>
- * </template>
- * ```
- */
-declare function useGroup<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(namespace: string): E;
-//#endregion
 //#region src/composables/useTokens/index.d.ts
 interface TokenAlias<T = unknown> {
   [key: string]: unknown;
@@ -447,7 +414,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 +423,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 +564,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 +704,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 +727,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 +751,7 @@ interface FormOptions extends RegistryOptions {
   validateOn?: 'submit' | 'change' | string;
 }
 interface FormContextOptions extends RegistryOptions {
-  namespace: string;
+  namespace?: string;
   validateOn?: 'submit' | 'change' | string;
 }
 /**
@@ -822,7 +787,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 +798,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 +815,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 +869,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 +953,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 +1018,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 +1053,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,131 +1088,18 @@ 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()
- * ```
- */
-declare function useKeydown(handlers: KeyHandler[] | KeyHandler): {
-  startListening: () => void;
-  stopListening: () => void;
-};
-//#endregion
-//#region src/composables/useSingle/index.d.ts
-interface SingleTicket extends SelectionTicket {}
-interface SingleContext<Z extends SingleTicket> extends SelectionContext<Z> {
-  selectedId: ComputedRef<ID | undefined>;
-  selectedIndex: ComputedRef<number>;
-  selectedItem: ComputedRef<Z | undefined>;
-  selectedValue: ComputedRef<unknown>;
-}
-interface SingleOptions extends SelectionOptions {}
-interface SingleContextOptions extends SelectionContextOptions {}
-/**
- * Creates a new single selection instance that enforces only one selected item at a time.
- *
- * Extends `createSelection` by automatically clearing previous selections when a new item is selected.
- * Adds computed singular properties: `selectedId`, `selectedItem`, `selectedIndex`, `selectedValue`.
- *
- * @param options The options for the single selection instance.
- * @template Z The type of the single selection ticket.
- * @template E The type of the single selection context.
- * @returns A new single selection instance with single-selection enforcement.
- *
- * @remarks
- * **Key Differences from `createSelection`:**
- * - Automatically clears `selectedIds` before selecting a new item (enforces single selection)
- * - Provides singular computed properties instead of plural sets
- * - Perfect for tabs, radio buttons, theme selectors, and other single-choice UI components
- *
- * **Computed Properties:**
- * - `selectedId`: The ID of the selected item (undefined if none selected)
- * - `selectedItem`: The selected ticket object (undefined if none selected)
- * - `selectedIndex`: The index of the selected item (-1 if none selected)
- * - `selectedValue`: The value of the selected item (undefined if none selected)
- *
- * **Inheritance Chain:**
- * `useRegistry` → `createSelection` → `createSingle` → `createStep`
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-single
- *
- * @example
- * ```ts
- * import { createSingle } from '@vuetify/v0'
- *
- * const tabs = createSingle({ mandatory: true })
- *
- * tabs.onboard([
- *   { id: 'home', value: 'Home' },
- *   { id: 'about', value: 'About' },
- *   { id: 'contact', value: 'Contact' },
- * ])
- *
- * tabs.first() // Select first tab
- *
- * console.log(tabs.selectedId.value) // 'home'
- * console.log(tabs.selectedIndex.value) // 0
- *
- * tabs.select('about') // Switch to about tab
- * console.log(tabs.selectedId.value) // 'about'
- * console.log(tabs.selectedIds.size) // 1 (always enforces single selection)
- * ```
- */
-declare function createSingle<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(_options?: SingleOptions): E;
-/**
- * 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.
- * @returns A new single selection context.
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-single
- *
- * @example
- * ```ts
- * import { createSingleContext } from '@vuetify/v0'
- *
- * export const [useTabs, provideTabs, tabs] = createSingleContext('tabs', { mandatory: true })
- *
- * // In a parent component:
- * provideTabs()
- *
- * // In a child component:
- * const tabs = useTabs()
- * tabs.select('tab-1')
- * ```
- */
-declare function createSingleContext<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(_options: SingleContextOptions): ContextTrinity<E>;
-/**
- * Returns the current single selection instance.
- *
- * @param namespace The namespace for the single selection context. Defaults to `'v0:single'`.
- * @returns The current single selection instance.
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-single
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useSingle } from '@vuetify/v0'
- *
- *   const tabs = useSingle()
- * </script>
- *
- * <template>
- *   <div>
- *     <p>Selected: {{ tabs.selectedId }}</p>
- *   </div>
- * </template>
+ * // Listener is automatically active when called in component setup
+ * // Manually control if needed:
+ * stop()
+ * start()
  * ```
  */
-declare function useSingle<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(namespace?: string): E;
+declare function useKeydown(handlers: MaybeRefOrGetter<KeyHandler[] | KeyHandler>): UseKeydownReturn;
 //#endregion
 //#region src/composables/useLocale/adapters/adapter.d.ts
 interface LocaleAdapter {
@@ -1237,7 +1113,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 +1124,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 +1170,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.
  *
@@ -1540,6 +1439,28 @@ interface UseMutationObserverOptions {
   characterDataOldValue?: boolean;
   attributeFilter?: string[];
 }
+interface UseMutationObserverReturn {
+  /**
+   * Whether the observer is currently active (created and observing)
+   */
+  readonly isActive: Readonly<Ref<boolean>>;
+  /**
+   * Whether the observer is currently paused
+   */
+  readonly isPaused: Readonly<Ref<boolean>>;
+  /**
+   * Pause observation (disconnects observer but keeps it alive)
+   */
+  pause: () => void;
+  /**
+   * Resume observation
+   */
+  resume: () => void;
+  /**
+   * Stop observation and clean up (destroys observer)
+   */
+  stop: () => void;
+}
 /**
  * A composable that uses the Mutation Observer API to detect changes in the DOM.
  *
@@ -1583,12 +1504,142 @@ interface UseMutationObserverOptions {
  * resume()
  * ```
  */
-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 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/usePermissions/adapters/adapter.d.ts
 interface PermissionAdapterInterface {
@@ -1599,9 +1650,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 +1833,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 +2125,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 +2188,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,167 +2222,7 @@ 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;
-};
-//#endregion
-//#region src/composables/useStep/index.d.ts
-interface StepTicket extends SingleTicket {}
-interface StepContext<Z extends StepTicket> extends SingleContext<Z> {
-  /** Select the first Ticket in the collection */
-  first: () => void;
-  /** Select the last Ticket in the collection */
-  last: () => void;
-  /** Select the next Ticket based on current index */
-  next: () => void;
-  /** Select the previous Ticket based on current index */
-  prev: () => void;
-  /** Step through the collection by a given count */
-  step: (count: number) => void;
-}
-interface StepOptions extends SingleOptions {
-  /**
-   * Enable circular navigation (wrapping at boundaries).
-   * - true: Navigation wraps around (carousel behavior)
-   * - false: Navigation stops at boundaries (pagination behavior)
-   * @default false
-   */
-  circular?: boolean;
-}
-interface StepContextOptions extends SingleContextOptions {
-  /**
-   * Enable circular navigation (wrapping at boundaries).
-   * - true: Navigation wraps around (carousel behavior)
-   * - false: Navigation stops at boundaries (pagination behavior)
-   * @default false
-   */
-  circular?: boolean;
-}
-/**
- * Creates a new step instance with navigation through items.
- *
- * Extends `createSingle` with `first()`, `last()`, `next()`, `prev()`, and `step(count)` methods
- * for sequential navigation. Supports both circular (wrapping) and bounded (stopping at edges) modes.
- *
- * @param options The options for the step instance.
- * @template Z The type of the step ticket.
- * @template E The type of the step context.
- * @returns A new step instance with navigation methods.
- *
- * @remarks
- * **Key Features:**
- * - **Configurable Navigation**: `circular: true` for wrapping, `false` for bounded (default: false)
- * - **Disabled Item Skipping**: Automatically skips disabled items during navigation
- * - **Bidirectional**: Forward (`next`, positive `step`) and backward (`prev`, negative `step`)
- * - **Safe Edge Cases**: Handles empty registries and all-disabled scenarios gracefully
- *
- * **Navigation Methods:**
- * - `first()`: Select first non-disabled item
- * - `last()`: Select last non-disabled item
- * - `next()`: Move to next item (wraps if circular, stops at end if bounded)
- * - `prev()`: Move to previous item (wraps if circular, stops at start if bounded)
- * - `step(count)`: Move by `count` positions (negative for backward)
- *
- * **Circular Mode (`circular: true`):**
- * - Uses modulo arithmetic for wrapping: `((index % length) + length) % length`
- * - Works correctly with negative indexes and large step counts
- * - Perfect for carousels, theme switchers, infinite scrolling
- *
- * **Bounded Mode (`circular: false`, default):**
- * - Navigation stops at boundaries (no wrapping)
- * - `next()` on last item does nothing
- * - `prev()` on first item does nothing
- * - Perfect for pagination, wizards with explicit completion, forms
- *
- * **Inheritance Chain:**
- * `useRegistry` → `createSelection` → `createSingle` → `createStep`
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-step
- *
- * @example
- * ```ts
- * import { createStep } from '@vuetify/v0'
- *
- * // Bounded navigation (default) - for pagination
- * const pagination = createStep({ circular: false })
- * pagination.onboard([
- *   { id: 'page-1', value: 1 },
- *   { id: 'page-2', value: 2 },
- *   { id: 'page-3', value: 3 },
- * ])
- * pagination.first() // Select page 1
- * pagination.prev() // Does nothing (already at first)
- * pagination.next() // Select page 2
- *
- * // Circular navigation - for carousels
- * const carousel = createStep({ circular: true })
- * carousel.onboard([
- *   { id: 'slide-1', value: 'First' },
- *   { id: 'slide-2', value: 'Second' },
- *   { id: 'slide-3', value: 'Third' },
- * ])
- * carousel.first()
- * carousel.prev() // Wraps to 'slide-3'
- * carousel.next() // Wraps to 'slide-1'
- * ```
- */
-declare function createStep<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(_options?: StepOptions): E;
-/**
- * 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.
- * @returns A new step context.
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-step
- *
- * @example
- * ```ts
- * import { createStepContext } from '@vuetify/v0'
- *
- * export const [useWizard, provideWizard, wizard] = createStepContext('wizard')
- *
- * // In a parent component:
- * provideWizard()
- *
- * // In a child component:
- * const wizard = useWizard()
- * wizard.next() // Progress to next step
- * ```
- */
-declare function createStepContext<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(_options: StepContextOptions): ContextTrinity<E>;
-/**
- * Returns the current step instance.
- *
- * @param namespace The namespace for the step context. Defaults to `'v0:step'`.
- * @returns The current step instance.
- *
- * @see https://0.vuetifyjs.com/composables/selection/use-step
- *
- * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useStep } from '@vuetify/v0'
- *
- *   const wizard = useStep()
- * </script>
- *
- * <template>
- *   <div>
- *     <p>Current step: {{ wizard.selectedIndex }}</p>
- *     <button @click="wizard.next()">Next</button>
- *   </div>
- * </template>
- * ```
- */
-declare function useStep<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(namespace?: string): E;
+declare function useElementSize(target: Ref<Element | undefined>): UseElementSizeReturn;
 //#endregion
 //#region src/composables/useStorage/adapters/adapter.d.ts
 interface StorageAdapter$1 {
@@ -2362,8 +2278,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 +2287,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 +2407,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 +2697,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 +2707,7 @@ interface TimelineOptions extends RegistryOptions {
   size?: number;
 }
 interface TimelineContextOptions extends TimelineOptions {
-  namespace: string;
+  namespace?: string;
 }
 /**
  * Creates a new timeline instance.
@@ -2824,13 +2738,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 +2751,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 +2765,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 +2785,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 { createQueue as $, TokenValue as $n, LocaleAdapter as $t, Vuetify0ThemeAdapter as A, FilterMode as An, LoggerOptions as At, StorageAdapter as B, FeatureTicket as Bn, LoggerAdapter as Bt, ThemePluginOptions as C, FormValidationRule as Cn, CreateContextOptions as Cr, useOverflow as Ct, createThemeContext as D, useForm as Dn, useMutationObserver as Dt, createTheme as E, createFormContext as En, useContext as Er, UseMutationObserverReturn as Et, StoragePluginOptions as F, useFilter as Fn, useLogger as Ft, UseElementSizeReturn as G, FlatTokenCollection as Gn, LocaleRecord as Gt, MemoryAdapter as H, createFeaturesContext as Hn, LocaleContextOptions as Ht, createStorage as I, FeatureContext as In, LogLevel as It, useResizeObserver as J, TokenContext as Jn, createLocaleContext as Jt, UseResizeObserverReturn as K, TokenAlias as Kn, LocaleTicket as Kt, createStorageContext as L, FeatureContextOptions as Ln, Vuetify0LoggerAdapter as Lt, StorageContext as M, Primitive as Mn, createLogger as Mt, StorageContextOptions as N, UseFilterOptions as Nn, createLoggerContext as Nt, createThemePlugin as O, FilterFunction as On, LoggerContext as Ot, StorageOptions as P, UseFilterResult as Pn, createLoggerPlugin as Pt, QueueTicket as Q, TokenTicket as Qn, Vuetify0LocaleAdapter as Qt, createStoragePlugin as R, FeatureOptions as Rn, PinoLoggerAdapter as Rt, ThemeOptions as S, FormValidationResult as Sn, ContextKey as Sr, createOverflowContext as St, ThemeTicket as T, createForm as Tn, provideContext as Tr, UseMutationObserverOptions as Tt, ResizeObserverEntry as U, createFeaturesPlugin as Un, LocaleOptions as Ut, StorageType as V, createFeatures as Vn, LocaleContext as Vt, ResizeObserverOptions as W, useFeatures as Wn, LocalePluginOptions as Wt, QueueContextOptions as X, TokenOptions as Xn, createLocalePlugin as Xt, QueueContext as Y, TokenContextOptions as Yn, createLocaleFallback as Yt, QueueOptions as Z, TokenPrimitive as Zn, useLocale as Zt, useTimeline as _, useHydration as _n, toReactive as _r, PermissionAdapterInterface as _t, VirtualItem as a, UseElementIntersectionReturn as an, useDocumentEventListener as ar, ProxyModelOptions as at, ThemeContext as b, FormOptions as bn, PluginOptions as br, OverflowOptions as bt, useVirtual as c, useIntersectionObserver as cn, BreakpointName as cr, PermissionContextOptions as ct, TimelineContext as d, HydrationOptions as dn, BreakpointsOptions as dr, PermissionTicket as dt, KeyHandler as en, createTokens as er, createQueueContext as et, TimelineContextOptions as f, HydrationPluginOptions as fn, BreakpointsPluginOptions as fr, createPermissions as ft, createTimelineContext as g, createHydrationPlugin as gn, useBreakpoints as gr, PermissionAdapter as gt, createTimeline as h, createHydrationContext as hn, createBreakpointsPlugin as hr, usePermissions as ht, VirtualDirection as i, IntersectionObserverOptions as in, EventHandler as ir, useProxyRegistry as it, ThemeAdapter as j, FilterQuery as jn, LoggerPluginOptions as jt, useTheme as k, FilterItem as kn, LoggerContextOptions as kt, ToggleScopeControls as l, HydrationContext as ln, BreakpointsContext as lr, PermissionOptions as lt, TimelineTicket as m, createHydration as mn, createBreakpointsContext as mr, createPermissionsPlugin as mt, VirtualAnchor as n, useKeydown as nn, useTokens as nr, ProxyRegistryContext as nt, VirtualOptions as o, UseIntersectionObserverReturn as on, useEventListener as or, useProxyModel as ot, TimelineOptions as p, createFallbackHydration as pn, createBreakpoints as pr, createPermissionsContext as pt, useElementSize as q, TokenCollection as qn, createLocale as qt, VirtualContext as r, IntersectionObserverEntry as rn, CleanupFunction as rr, ProxyRegistryOptions as rt, VirtualState as s, useElementIntersection as sn, useWindowEventListener as sr, PermissionContext as st, ScrollToOptions as t, UseKeydownReturn as tn, createTokensContext as tr, useQueue as tt, useToggleScope as u, HydrationContextOptions as un, BreakpointsContextOptions as ur, PermissionPluginOptions as ut, Colors as v, FormContext as vn, toArray as vr, OverflowContext as vt, ThemeRecord as w, FormValue as wn, createContext as wr, MutationObserverRecord as wt, ThemeContextOptions as x, FormTicket as xn, createPlugin as xr, createOverflow as xt, ThemeColors as y, FormContextOptions as yn, Plugin as yr, OverflowContextOptions as yt, useStorage as z, FeaturePluginOptions as zn, ConsolaLoggerAdapter as zt };