@vuetify/v0 0.0.7 → 0.0.8

package/dist/{index-BoDCUSPn.d.ts → index-Bcj8Vovs.d.ts}

@@ -1,41 +1,56 @@
 import { a as MaybeArray, i as ID } from "./index-C_lAPFXS.js";
-import * as vue169 from "vue";
+import * as vue97 from "vue";
 import { App, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, Reactive, Ref, ShallowRef, UnwrapNestedRefs } from "vue";
 
 //#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.
+ * @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
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#use-context
  *
  * @example
  * ```ts
- * const myContext = useContext<MyContext>('my-context')
+ * // 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>): Z & ({} | null);
+declare function useContext<Z>(key: ContextKey<Z>, defaultValue?: Z): Z & ({} | null);
 /**
  * Provides a context to all descendant components.
  *
  * @param key The key of the context to provide.
  * @param context The context to provide.
- * @param app The Vue app instance to provide the context to.
+ * @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
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#provide-context
  *
  * @example
  * ```ts
- * provideContext<MyContext>('my-context', myContext)
+ * // 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;
@@ -43,18 +58,23 @@ 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
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context#create-context
  *
  * @example
  * ```ts
- * const [provideMyContext, useMyContext] = createContext<MyContext>('my-context')
+ * // 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>): readonly [(key?: ContextKey<Z>) => Z & ({} | null), (context: Z, app?: App) => Z];
+declare function createContext<Z>(_key: ContextKey<Z>, defaultValue?: Z): readonly [(key?: ContextKey<Z>) => Z & ({} | null), (context: Z, app?: App) => Z];
 //#endregion
 //#region src/composables/createPlugin/index.d.ts
 interface PluginOptions {
@@ -63,7 +83,7 @@ interface PluginOptions {
   setup?: (app: App) => void;
 }
 interface Plugin {
-  install: (app: App, ...options: any[]) => void;
+  install: (app: App, ...options: unknown[]) => void;
 }
 /**
  * Creates a new Vue plugin.
@@ -71,8 +91,7 @@ interface Plugin {
  * @param options The plugin options.
  * @returns A new Vue plugin.
  *
- * @see https://vuejs.org/guide/reusability/plugins.html
- * @see https://0.vuetifyjs.com/composables/foundation/create-plugin
+ * @see https://0.vuetifyjs.com/composables/foundation/create-plugin#create-plugin
  *
  * @example
  * ```ts
@@ -97,13 +116,21 @@ type ContextTrinity<Z = unknown> = readonly [() => Z, (context?: Z, app?: App) =
 /**
  * Creates a new trinity for a context composable and its provider.
  *
- * @param createContext The function that creates the context.
- * @param provideContext The function that provides the context.
- * @param context The context to provide.
+ * @param createContext 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 new trinity.
+ * @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
  *
- * @see https://0.vuetifyjs.com/composables/foundation/create-trinity
+ * 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
@@ -123,10 +150,21 @@ type ContextTrinity<Z = unknown> = readonly [() => Z, (context?: Z, app?: App) =
  *
  *   return createTrinity<E>(useContext, provideContext, context)
  * }
+ * ```
  */
 declare function createTrinity<Z = unknown>(createContext: () => Z, provideContext: (_context?: Z, app?: App) => Z, context: Z): ContextTrinity<Z>;
 //#endregion
 //#region src/composables/toArray/index.d.ts
+/**
+ * @module toArray
+ *
+ * @remarks
+ * Utility function to normalize single values and arrays into arrays.
+ *
+ * Converts single values into single-element arrays, passes arrays through unchanged,
+ * and handles null/undefined by returning empty arrays. Perfect for functions that
+ * accept both single values and arrays as input (e.g., ID | ID[]).
+ */
 /**
  * Converts a value to an array.
  *
@@ -156,7 +194,7 @@ declare function toArray<Z>(value: Z | Z[]): Z[];
  * @template Z The type of the object.
  * @returns The converted object.
  *
- * @see https://vuejs.org/api/reactivity-utilities.html#toreactive
+ * @see https://0.vuetifyjs.com/composables/transformers/to-reactive
  *
  * @example
  * ```ts
@@ -197,15 +235,16 @@ interface BreakpointsContext {
   xxlAndDown: Readonly<ShallowRef<boolean>>;
   update: () => void;
 }
-interface BreakpointsOptions extends BreakpointsPluginOptions {}
-interface BreakpointsPluginOptions {
+interface BreakpointsOptions {
+  namespace?: string;
   mobileBreakpoint?: BreakpointName | number;
   breakpoints?: Partial<Record<BreakpointName, number>>;
 }
+interface BreakpointsPluginOptions extends BreakpointsOptions {}
+interface BreakpointsContextOptions extends BreakpointsOptions {}
 /**
  * Creates a new breakpoints instance.
  *
- * @param namespace The namespace to use for the breakpoints instance.
  * @param options The options for the breakpoints instance.
  * @template E The type of the breakpoints context.
  * @returns A new breakpoints instance.
@@ -216,7 +255,8 @@ interface BreakpointsPluginOptions {
  * ```ts
  * import { createBreakpoints } from '@vuetify/v0'
  *
- * export const [useBreakpoints, provideBreakpoints] = createBreakpoints('v0:breakpoints', {
+ * export const [useBreakpoints, provideBreakpoints] = createBreakpoints({
+ *   namespace: 'v0:breakpoints',
  *   mobileBreakpoint: 'sm',
  *   breakpoints: {
  *     xs: 0,
@@ -229,31 +269,27 @@ interface BreakpointsPluginOptions {
  * })
  * ```
  */
-declare function createBreakpoints<E extends BreakpointsContext = BreakpointsContext>(namespace?: string, options?: BreakpointsOptions): ContextTrinity<E>;
+declare function createBreakpoints<E extends BreakpointsContext = BreakpointsContext>(_options?: BreakpointsOptions): E;
 /**
- * Returns the current breakpoints instance.
+ * Creates a new breakpoints context.
  *
- * @returns The current breakpoints instance.
+ * @param options The options for the breakpoints context.
+ * @template E The type of the breakpoints context.
+ * @returns A new breakpoints context.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
  *
  * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useBreakpoints } from '@vuetify/v0'
- *
- *   const { isMobile, mdAndUp } = useBreakpoints()
- * </script>
+ * ```ts
+ * import { createBreakpointsContext } from '@vuetify/v0'
  *
- * <template>
- *   <div class="pa-4">
- *     <p v-if="isMobile.value">Mobile layout active</p>
- *     <p v-else-if="mdAndUp.value">Medium and up layout active</p>
- *   </div>
- * </template>
+ * export const [useBreakpoints, provideBreakpoints, context] = createBreakpointsContext({
+ *   namespace: 'v0:breakpoints',
+ *   mobileBreakpoint: 'sm',
+ * })
  * ```
  */
-declare function useBreakpoints(): BreakpointsContext;
+declare function createBreakpointsContext<E extends BreakpointsContext = BreakpointsContext>(_options?: BreakpointsContextOptions): ContextTrinity<E>;
 /**
  * Creates a new breakpoints plugin.
  *
@@ -273,6 +309,7 @@ declare function useBreakpoints(): BreakpointsContext;
  *
  * app.use(
  *   createBreakpointsPlugin({
+ *     namespace: 'v0:breakpoints',
  *     mobileBreakpoint: 'sm',
  *     breakpoints: {
  *       xs: 0,
@@ -288,7 +325,32 @@ declare function useBreakpoints(): BreakpointsContext;
  * app.mount('#app')
  * ```
  */
-declare function createBreakpointsPlugin<E extends BreakpointsContext = BreakpointsContext>(options?: BreakpointsPluginOptions): Plugin;
+declare function createBreakpointsPlugin<E extends BreakpointsContext = BreakpointsContext>(_options?: BreakpointsPluginOptions): Plugin;
+/**
+ * Returns the current breakpoints instance.
+ *
+ * @param namespace The namespace for the breakpoints context. Defaults to `v0:breakpoints`.
+ * @returns The current breakpoints instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useBreakpoints } from '@vuetify/v0'
+ *
+ *   const { isMobile, mdAndUp } = useBreakpoints()
+ * </script>
+ *
+ * <template>
+ *   <div class="pa-4">
+ *     <p v-if="isMobile.value">Mobile layout active</p>
+ *     <p v-else-if="mdAndUp.value">Medium and up layout active</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useBreakpoints<E extends BreakpointsContext = BreakpointsContext>(namespace?: string): E;
 //#endregion
 //#region src/composables/useEventListener/index.d.ts
 type CleanupFunction = () => void;
@@ -764,7 +826,7 @@ interface RegistryContext<Z extends RegistryTicket = RegistryTicket> {
    * registry.emit('custom-event', { message: 'Hello, World!' }) // Console: Custom event received: { message: 'Hello, World!' }
    * ```
   */
-  emit: (event: string, data: any) => void;
+  emit: (event: string, data: unknown) => void;
   /**
    * Clears the registry and removes all listeners
    *
@@ -853,6 +915,9 @@ interface RegistryOptions {
   */
   events?: boolean;
 }
+interface RegistryContextOptions extends RegistryOptions {
+  namespace: string;
+}
 /**
  * Creates a new registry instance.
  *
@@ -861,7 +926,7 @@ interface RegistryOptions {
  * @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
+ * @see https://0.vuetifyjs.com/composables/registration/use-registry#use-registry
  *
  * @example
  * ```ts
@@ -882,11 +947,11 @@ declare function useRegistry<Z extends RegistryTicket = RegistryTicket, E extend
  *
  * @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
+ * @see https://0.vuetifyjs.com/composables/registration/use-registry#create-registry-context
  *
  * @example
  * ```ts
@@ -902,7 +967,7 @@ declare function useRegistry<Z extends RegistryTicket = RegistryTicket, E extend
  * items.register({ id: 'item-1', value: 'Value 1' })
  * ```
  */
-declare function createRegistryContext<Z extends RegistryTicket = RegistryTicket, E extends RegistryContext<Z> = RegistryContext<Z>>(namespace: string, options?: RegistryOptions): ContextTrinity<E>;
+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 extends RegistryTicket {
@@ -933,25 +998,54 @@ interface SelectionContext<Z extends SelectionTicket> extends RegistryContext<Z>
   mandate: () => void;
 }
 interface SelectionOptions extends RegistryOptions {
-  /** When true, newly registered items are automatically selected if not disabled */
+  /**
+   * 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';
 }
+interface SelectionContextOptions extends SelectionOptions {
+  namespace: string;
+}
 /**
- * Creates a new selection instance.
+ * 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.
+ * @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 { useSelection } from '@vuetify/v0'
+ * import { createSelection } from '@vuetify/v0'
  *
- * const selection = useSelection({ mandatory: true })
+ * const selection = createSelection({ mandatory: true })
  *
  * selection.onboard([
  *   { id: 'item-1', value: 'Item 1' },
@@ -963,9 +1057,10 @@ interface SelectionOptions extends RegistryOptions {
  * 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 useSelection<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(options?: SelectionOptions): E;
+declare function createSelection<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(options?: SelectionOptions): E;
 /**
  * Creates a new selection context.
  *
@@ -991,7 +1086,31 @@ declare function useSelection<Z extends SelectionTicket = SelectionTicket, E ext
  * checkboxes.select('checkbox-1')
  * ```
  */
-declare function createSelectionContext<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(namespace: string, options?: SelectionOptions): ContextTrinity<E>;
+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/useGroup/index.d.ts
 interface GroupTicket extends SelectionTicket {}
@@ -1005,34 +1124,65 @@ interface GroupContext<Z extends GroupTicket> extends SelectionContext<Z> {
   toggle: (ids: ID | ID[]) => void;
 }
 interface GroupOptions extends SelectionOptions {}
+interface GroupContextOptions extends SelectionContextOptions {}
 /**
- * Creates a new group instance.
+ * 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.
+ * @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 { useGroup } from '@vuetify/v0'
+ * import { createGroup } from '@vuetify/v0'
  *
- * const group = useGroup()
+ * const checkboxes = createGroup()
  *
- * group.onboard([
- *   { id: 'item-1', value: 'Item 1' },
- *   { id: 'item-2', value: 'Item 2' },
- *   { id: 'item-3', value: 'Item 3' },
+ * checkboxes.onboard([
+ *   { id: 'option-a', value: 'Option A' },
+ *   { id: 'option-b', value: 'Option B' },
+ *   { id: 'option-c', value: 'Option C' },
  * ])
  *
- * group.select(['item-1', 'item-2'])
+ * // Select multiple items at once
+ * checkboxes.select(['option-a', 'option-c'])
  *
- * console.log(group.selectedIds) // Set { 'item-1', 'item-2' }
+ * 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 useGroup<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(options?: GroupOptions): E;
+declare function createGroup<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(options?: GroupOptions): E;
 /**
  * Creates a new group context.
  *
@@ -1057,7 +1207,31 @@ declare function useGroup<Z extends GroupTicket = GroupTicket, E extends GroupCo
  * const group = useMyGroup()
  * ```
  */
-declare function createGroupContext<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(namespace: string, options?: GroupOptions): ContextTrinity<E>;
+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> {
@@ -1068,7 +1242,7 @@ interface TokenAlias<T = unknown> {
   $extensions?: Record<string, unknown>;
   $deprecated?: boolean | string;
 }
-type TokenPrimitive = string | number | boolean;
+type TokenPrimitive = string | number | boolean | null;
 type TokenValue = TokenPrimitive | TokenAlias;
 interface TokenCollection {
   [key: string]: TokenValue | TokenCollection;
@@ -1079,13 +1253,70 @@ type FlatTokenCollection = {
 };
 interface TokenTicket extends RegistryTicket {}
 interface TokenContext<Z extends TokenTicket> extends RegistryContext<Z> {
+  /**
+   * Checks if a token is an alias
+   *
+   * @param token The token to check.
+   * @returns True if the token is an alias, false otherwise.
+   * @remarks An alias is a string that starts with "{" and ends with "}".
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-tokens#is-alias
+   *
+   * @example
+   * ```ts
+   * const tokens = useTokens({
+   *   colors: {
+   *     primary: '#3b82f6',
+   *     secondary: '{colors.primary}', // Alias reference
+   *   },
+   * })
+   *
+   * console.log(tokens.isAlias('{colors.primary}')) // true
+   * console.log(tokens.isAlias('#3b82f6')) // false
+   * ```
+   */
   isAlias: (token: unknown) => token is string;
+  /**
+   * Resolves a token or alias to its value.
+   *
+   * @param token The token or alias to resolve.
+   * @returns The resolved value of the token or alias, or undefined if not found.
+   * @remarks This function can resolve nested aliases and supports token paths using dot notation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-tokens#resolve
+   *
+   * @example
+   * ```ts
+   * const tokens = useTokens({
+   *   colors: {
+   *     primary: '#3b82f6',
+   *     secondary: '{colors.primary}', // Alias reference
+   *   },
+   * })
+   *
+   * console.log(tokens.resolve('{colors.primary}')) // '#3b82f6'
+   * console.log(tokens.resolve('{colors.secondary}')) // '#3b82f6'
+   * ```
+   */
   resolve: (token: string | TokenAlias) => unknown | undefined;
 }
-interface TokenOptions {
+interface TokenOptions extends RegistryOptions {
+  /**
+   * Whether to flatten nested token structures.
+   *
+   * @default false
+   */
   flat?: boolean;
+  /**
+   * An optional prefix to prepend to each token ID during registration.
+   *
+   * @remarks This is useful for namespacing tokens.
+   */
   prefix?: string;
 }
+interface TokenContextOptions extends TokenOptions, RegistryContextOptions {
+  tokens?: TokenCollection;
+}
 /**
  * Creates a new token instance.
  *
@@ -1113,7 +1344,7 @@ interface TokenOptions {
  * console.log(tokens.resolve('{colors.secondary}')) // '#3b82f6'
  * ```
  */
-declare function useTokens<Z extends TokenTicket = TokenTicket, E extends TokenContext<Z> = TokenContext<Z>>(tokens?: TokenCollection, options?: TokenOptions): E;
+declare function createTokens<Z extends TokenTicket = TokenTicket, E extends TokenContext<Z> = TokenContext<Z>>(tokens?: TokenCollection, options?: TokenOptions): E;
 /**
  * Creates a new token context.
  *
@@ -1129,26 +1360,36 @@ declare function useTokens<Z extends TokenTicket = TokenTicket, E extends TokenC
  * ```ts
  * import { createTokensContext } from '@vuetify/v0'
  *
- * const myTokens = {
- *   spacing: {
- *     sm: '8px',
- *     md: '16px',
- *     lg: '24px',
- *   },
- * }
+ * export const [useTokens, provideTokens, context] = createTokensContext({
+ *  namespace: 'v0:tokens',
+ *  tokens: {
+ *    colors: {
+ *      primary: '#3b82f6',
+ *      secondary: '{colors.primary}', // Alias reference
+ *    },
+ *  },
+ * })
+ * ```
+ */
+declare function createTokensContext<Z extends TokenTicket = TokenTicket, E extends TokenContext<Z> = TokenContext<Z>>(_options: TokenContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current tokens instance.
  *
- * export const [useDesignTokens, provideDesignTokens, designTokens] = createTokensContext('design-tokens', myTokens)
+ * @param namespace The namespace for the tokens context. Defaults to `'v0:tokens'`.
+ * @returns The current tokens instance.
  *
- * // In a parent component:
- * provideDesignTokens()
+ * @see https://0.vuetifyjs.com/composables/registration/use-tokens
  *
- * // In a child component:
- * const tokens = useDesignTokens()
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useTokens } from '@vuetify/v0'
  *
- * console.log(tokens.resolve('{spacing.md}')) // '16px'
+ *   const tokens = useTokens()
+ * </script>
  * ```
  */
-declare function createTokensContext<Z extends TokenTicket = TokenTicket, E extends TokenContext<Z> = TokenContext<Z>>(namespace: string, tokens?: TokenCollection): ContextTrinity<E>;
+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 {
@@ -1157,26 +1398,29 @@ interface FeatureTicket extends GroupTicket {
 interface FeatureContext<Z extends FeatureTicket = FeatureTicket> extends GroupContext<Z> {
   variation: (id: ID, fallback?: any) => any;
 }
-interface FeatureOptions extends FeaturePluginOptions {}
-interface FeaturePluginOptions {
+interface FeatureOptions extends RegistryOptions {
   features?: Record<ID, boolean | TokenCollection>;
 }
+interface FeatureContextOptions extends FeatureOptions {
+  namespace?: string;
+}
+interface FeaturePluginOptions extends FeatureContextOptions {}
 /**
  * Creates a new features instance.
  *
- * @param namespace The namespace to use for the features instance.
  * @param options The options for the features instance.
  * @template Z The type of the feature ticket.
  * @template E The type of the feature context.
  * @returns A new features instance.
  *
- * @see https://0.vuetifyjs.com/composables/plugins/create-features
+ * @see https://0.vuetifyjs.com/composables/plugins/use-features
  *
  * @example
  * ```ts
  * import { createFeatures } from '@vuetify/v0'
  *
- * const [useFeatures, provideFeaturesContext] = createFeatures('v0:features', {
+ * const [useFeatures, provideFeaturesContext, context] = createFeatures({
+ *   namespace: 'v0:features',
  *   features: {
  *     'dark-mode': true,
  *     'theme-color': { $variation: 'blue' },
@@ -1184,32 +1428,31 @@ interface FeaturePluginOptions {
  * })
  * ```
  */
-declare function createFeatures<Z extends FeatureTicket = FeatureTicket, E extends FeatureContext<Z> = FeatureContext<Z>>(namespace?: string, options?: FeatureOptions): ContextTrinity<E>;
+declare function createFeatures<Z extends FeatureTicket = FeatureTicket, E extends FeatureContext<Z> = FeatureContext<Z>>(_options?: FeatureOptions): E;
 /**
- * Returns the current features instance.
+ * Creates a new features context.
  *
+ * @param options The options for the features context.
  * @template Z The type of the feature ticket.
- * @returns The current features instance.
+ * @template E The type of the feature context.
+ * @returns A new features context.
  *
- * @see https://0.vuetifyjs.com/composables/plugins/create-features
+ * @see https://0.vuetifyjs.com/composables/plugins/use-features
  *
  * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useFeatures } from '@vuetify/v0'
- *
- *   const features = useFeatures()
- * </script>
+ * ```ts
+ * import { createFeaturesContext } from '@vuetify/v0'
  *
- * <template>
- *   <div>
- *     <p>Features: {{ features.get('dark-mode') }}</p>
- *     <p>Theme Color: {{ features.variation('theme-color') }}</p>
- *   </div>
- * </template>
+ * export const [useFeatures, provideFeatures, context] = createFeaturesContext({
+ *   namespace: 'app:features',
+ *   features: {
+ *     'dark-mode': true,
+ *     'theme-color': { $variation: 'blue' },
+ *   },
+ * })
  * ```
  */
-declare function useFeatures<Z extends FeatureTicket = FeatureTicket>(): FeatureContext<Z>;
+declare function createFeaturesContext<Z extends FeatureTicket = FeatureTicket, E extends FeatureContext<Z> = FeatureContext<Z>>(_options?: FeatureContextOptions): ContextTrinity<E>;
 /**
  * Creates a new features plugin.
  *
@@ -1218,7 +1461,7 @@ declare function useFeatures<Z extends FeatureTicket = FeatureTicket>(): Feature
  * @template E The type of the feature context.
  * @returns A new features plugin.
  *
- * @see https://0.vuetifyjs.com/composables/plugins/create-features
+ * @see https://0.vuetifyjs.com/composables/plugins/use-features
  *
  * @example
  * ```ts
@@ -1240,7 +1483,33 @@ declare function useFeatures<Z extends FeatureTicket = FeatureTicket>(): Feature
  * app.mount('#app')
  * ```
  */
-declare function createFeaturesPlugin<Z extends FeatureTicket = FeatureTicket, E extends FeatureContext<Z> = FeatureContext<Z>>(options?: FeaturePluginOptions): Plugin;
+declare function createFeaturesPlugin<Z extends FeatureTicket = FeatureTicket, E extends FeatureContext<Z> = FeatureContext<Z>>(_options?: FeaturePluginOptions): Plugin;
+/**
+ * Returns the current features instance.
+ *
+ * @param namespace The namespace for the features context. Defaults to `v0:features`.
+ * @template Z The type of the feature ticket.
+ * @returns The current features instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-features
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useFeatures } from '@vuetify/v0'
+ *
+ *   const features = useFeatures()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Features: {{ features.get('dark-mode') }}</p>
+ *     <p>Theme Color: {{ features.variation('theme-color') }}</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useFeatures<Z extends FeatureTicket = FeatureTicket, E extends FeatureContext<Z> = FeatureContext<Z>>(namespace?: string): E;
 //#endregion
 //#region src/composables/useFilter/index.d.ts
 type Primitive = string | number | boolean;
@@ -1311,6 +1580,10 @@ interface FormContext<Z extends FormTicket = FormTicket> extends RegistryContext
 interface FormOptions extends RegistryOptions {
   validateOn?: 'submit' | 'change' | string;
 }
+interface FormContextOptions extends RegistryOptions {
+  namespace: string;
+  validateOn?: 'submit' | 'change' | string;
+}
 /**
  * Creates a new form instance.
  *
@@ -1323,9 +1596,9 @@ interface FormOptions extends RegistryOptions {
  *
  * @example
  * ```ts
- * import { useForm } from '@vuetify/v0'
+ * import { createForm } from '@vuetify/v0'
  *
- * const form = useForm()
+ * const form = createForm()
  *
  * const username = form.register({
  *   id: 'username',
@@ -1340,14 +1613,70 @@ interface FormOptions extends RegistryOptions {
  * form.reset()
  * ```
  */
-declare function useForm<Z extends FormTicket = FormTicket, E extends FormContext<Z> = FormContext<Z>>(options?: FormOptions): E;
+declare function createForm<Z extends FormTicket = FormTicket, E extends FormContext<Z> = FormContext<Z>>(options?: FormOptions): E;
+/**
+ * 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.
+ * @returns A new form context.
+ *
+ * @see https://0.vuetifyjs.com/composables/forms/use-form
+ *
+ * @example
+ * ```ts
+ * import { createFormContext } from '@vuetify/v0'
+ *
+ * export const [useMyForm, provideMyForm, myForm] = createFormContext('my-form', {
+ *   validateOn: 'change',
+ * })
+ *
+ * // In a parent component:
+ * provideMyForm()
+ *
+ * // In a child component:
+ * const form = useMyForm()
+ * form.register({ id: 'field', value: ref(''), rules: [...] })
+ * ```
+ */
+declare function createFormContext<Z extends FormTicket = FormTicket, E extends FormContext<Z> = FormContext<Z>>(_options: FormContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current form instance.
+ *
+ * @param namespace The namespace for the form context. Defaults to `'v0:form'`.
+ * @returns The current form instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/forms/use-form
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useForm } from '@vuetify/v0'
+ *
+ *   const form = useForm()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Form is {{ form.isValid.value ? 'valid' : 'invalid' }}</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useForm<Z extends FormTicket = FormTicket, E extends FormContext<Z> = FormContext<Z>>(namespace?: string): E;
 //#endregion
 //#region src/composables/useHydration/index.d.ts
 interface HydrationContext {
   isHydrated: Readonly<ShallowRef<boolean>>;
   hydrate: () => void;
 }
-declare const useHydrationContext: (key?: ContextKey<HydrationContext>) => HydrationContext, provideHydrationContext: (context: HydrationContext, app?: App) => HydrationContext;
+interface HydrationOptions {}
+interface HydrationContextOptions extends HydrationOptions {
+  namespace?: string;
+}
+interface HydrationPluginOptions extends HydrationContextOptions {}
 /**
  * Creates a new hydration instance.
  *
@@ -1359,36 +1688,37 @@ declare const useHydrationContext: (key?: ContextKey<HydrationContext>) => Hydra
  * ```ts
  * import { createHydration } from '@vuetify/v0'
  *
- * const [useHydration, provideHydration] = createHydration()
+ * const hydration = createHydration()
+ * console.log(hydration.isHydrated.value) // false
+ * hydration.hydrate()
+ * console.log(hydration.isHydrated.value) // true
  * ```
  */
-declare function createHydration(): HydrationContext;
+declare function createHydration<E extends HydrationContext = HydrationContext>(): E;
 /**
- * Returns the current hydration instance.
+ * Creates a new hydration context trinity.
  *
- * @returns The current hydration instance.
+ * @param options Options for creating the hydration context.
+ * @template E The type of the hydration context.
+ * @returns A new hydration context trinity.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-hydration
  *
  * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useHydration } from '@vuetify/v0'
- *
- *   const hydration = useHydration()
- * </script>
+ * ```ts
+ * import { createHydrationContext } from '@vuetify/v0'
  *
- * <template>
- *   <div>
- *     <p>Is hydrated: {{ hydration.isHydrated.value }}</p>
- *   </div>
- * </template>
+ * export const [useHydrationContext, provideHydrationContext, context] = createHydrationContext({
+ *   namespace: 'app:hydration',
+ * })
  * ```
  */
-declare function useHydration(): HydrationContext;
+declare function createHydrationContext<E extends HydrationContext = HydrationContext>(_options?: HydrationContextOptions): ContextTrinity<E>;
 /**
  * Creates a new hydration plugin.
  *
+ * @param options The options for the hydration plugin.
+ * @template E The type of the hydration context.
  * @returns A new hydration plugin.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-hydration
@@ -1399,24 +1729,46 @@ declare function useHydration(): HydrationContext;
  * import { createHydrationPlugin } from '@vuetify/v0'
  * import App from './App.vue'
  *
- * const plugin = createHydrationPlugin()
- *
  * const app = createApp(App)
  *
- * app.use(plugin)
+ * app.use(createHydrationPlugin())
  *
  * app.mount('#app')
  * ```
  */
-declare function createHydrationPlugin(): Plugin;
-//#endregion
-//#region src/composables/useIntersectionObserver/index.d.ts
-interface IntersectionObserverEntry {
-  boundingClientRect: DOMRectReadOnly;
-  intersectionRatio: number;
-  intersectionRect: DOMRectReadOnly;
-  isIntersecting: boolean;
-  rootBounds: DOMRectReadOnly | null;
+declare function createHydrationPlugin<E extends HydrationContext = HydrationContext>(_options?: HydrationPluginOptions): Plugin;
+/**
+ * Returns the current hydration instance.
+ *
+ * @param namespace The namespace for the hydration context. Defaults to `v0:hydration`.
+ * @returns The current hydration instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useHydration } from '@vuetify/v0'
+ *
+ *   const hydration = useHydration()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Is hydrated: {{ hydration.isHydrated.value }}</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useHydration<E extends HydrationContext = HydrationContext>(namespace?: string): E;
+//#endregion
+//#region src/composables/useIntersectionObserver/index.d.ts
+interface IntersectionObserverEntry {
+  boundingClientRect: DOMRectReadOnly;
+  intersectionRatio: number;
+  intersectionRect: DOMRectReadOnly;
+  isIntersecting: boolean;
+  rootBounds: DOMRectReadOnly | null;
   target: Element;
   time: number;
 }
@@ -1510,6 +1862,20 @@ declare function useElementIntersection(target: Ref<Element | undefined>, option
 };
 //#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;
@@ -1551,33 +1917,58 @@ interface SingleContext<Z extends SingleTicket> extends SelectionContext<Z> {
   selectedValue: ComputedRef<unknown>;
 }
 interface SingleOptions extends SelectionOptions {}
+interface SingleContextOptions extends SelectionContextOptions {}
 /**
- * Creates a new single selection instance.
+ * 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.
+ * @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 { useSingle } from '@vuetify/v0'
+ * import { createSingle } from '@vuetify/v0'
  *
- * const single = useSingle()
+ * const tabs = createSingle({ mandatory: true })
  *
- * single.onboard([
- *   { id: 'option-1', value: 'Option 1' },
- *   { id: 'option-2', value: 'Option 2' },
+ * tabs.onboard([
+ *   { id: 'home', value: 'Home' },
+ *   { id: 'about', value: 'About' },
+ *   { id: 'contact', value: 'Contact' },
  * ])
  *
- * single.select('option-1')
+ * tabs.first() // Select first tab
  *
- * console.log(single.selectedId.value) // 'option-1'
+ * 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 useSingle<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(options?: SingleOptions): E;
+declare function createSingle<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(options?: SingleOptions): E;
 /**
  * Creates a new single selection context.
  *
@@ -1603,7 +1994,31 @@ declare function useSingle<Z extends SingleTicket = SingleTicket, E extends Sing
  * tabs.select('tab-1')
  * ```
  */
-declare function createSingleContext<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(namespace: string, options?: SingleOptions): 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.
+ *
+ * @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>
+ * ```
+ */
+declare function useSingle<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(namespace?: string): E;
 //#endregion
 //#region src/composables/useLocale/adapters/adapter.d.ts
 interface LocaleAdapter {
@@ -1631,17 +2046,19 @@ interface LocaleContext<Z extends LocaleTicket> extends SingleContext<Z> {
   t: (key: string, ...params: unknown[]) => string;
   n: (value: number) => string;
 }
-interface LocaleOptions extends LocalePluginOptions {}
-interface LocalePluginOptions<Z extends LocaleRecord = LocaleRecord> {
+interface LocaleOptions<Z extends LocaleRecord = LocaleRecord> extends SingleOptions {
   adapter?: LocaleAdapter;
   default?: ID;
   fallback?: ID;
   messages?: Record<ID, Z>;
 }
+interface LocaleContextOptions extends LocaleOptions {
+  namespace?: string;
+}
+interface LocalePluginOptions extends LocaleContextOptions {}
 /**
  * Creates a new locale instance.
  *
- * @param namespace The namespace for the locale instance.
  * @param options The options for the locale instance.
  * @template Z The type of the locale ticket.
  * @template E The type of the locale context.
@@ -1649,15 +2066,38 @@ interface LocalePluginOptions<Z extends LocaleRecord = LocaleRecord> {
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-locale
  */
-declare function createLocale<Z extends LocaleTicket = LocaleTicket, E extends LocaleContext<Z> = LocaleContext<Z>>(namespace?: string, options?: LocaleOptions): ContextTrinity<E>;
+declare function createLocale<Z extends LocaleTicket = LocaleTicket, E extends LocaleContext<Z> = LocaleContext<Z>>(_options?: LocaleOptions): E;
 /**
- * Returns the current locale instance.
+ * Creates a new locale context.
  *
- * @returns The current locale instance.
+ * @param options The options for the locale context.
+ * @template Z The type of the locale ticket.
+ * @template E The type of the locale context.
+ * @returns A new locale context.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-locale
+ *
+ * @example
+ * ```ts
+ * import { createLocaleContext } from '@vuetify/v0'
+ *
+ * export const [useAppLocale, provideAppLocale, appLocale] = createLocaleContext({
+ *   namespace: 'app:locale',
+ *   messages: {
+ *     en: { hello: 'Hello' },
+ *     es: { hello: 'Hola' },
+ *   },
+ * })
+ *
+ * // In a parent component:
+ * provideAppLocale()
+ *
+ * // In a child component:
+ * const locale = useAppLocale()
+ * locale.select('es')
+ * ```
  */
-declare function useLocale(): LocaleContext<LocaleTicket>;
+declare function createLocaleContext<Z extends LocaleTicket = LocaleTicket, E extends LocaleContext<Z> = LocaleContext<Z>>(_options?: LocaleContextOptions): ContextTrinity<E>;
 /**
  * Creates a new locale plugin.
  *
@@ -1671,6 +2111,14 @@ declare function useLocale(): LocaleContext<LocaleTicket>;
  * @see https://0.vuetifyjs.com/composables/plugins/use-locale
  */
 declare function createLocalePlugin<Z extends LocaleTicket = LocaleTicket, E extends LocaleContext<Z> = LocaleContext<Z>>(_options?: LocalePluginOptions): Plugin;
+/**
+ * Returns the current locale instance.
+ *
+ * @returns The current locale instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-locale
+ */
+declare function useLocale<Z extends LocaleTicket = LocaleTicket, E extends LocaleContext<Z> = LocaleContext<Z>>(namespace?: string): E;
 //#endregion
 //#region src/composables/useLogger/adapters/adapter.d.ts
 interface LoggerAdapter {
@@ -1766,6 +2214,10 @@ interface LoggerOptions {
   prefix?: string;
   enabled?: boolean;
 }
+interface LoggerContextOptions extends LoggerOptions {
+  namespace?: string;
+}
+interface LoggerPluginOptions extends LoggerContextOptions {}
 /**
  * Creates a new logger instance.
  *
@@ -1773,17 +2225,44 @@ interface LoggerOptions {
  * @returns A new logger instance.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-logger
+ *
+ * @example
+ * ```ts
+ * import { createLogger } from '@vuetify/v0'
+ *
+ * const logger = createLogger({
+ *   level: 'debug',
+ *   prefix: '[MyApp]',
+ * })
+ *
+ * logger.info('This is an info message')
+ * logger.debug('This is a debug message')
+ * logger.error('This is an error message')
+ * logger.level('debug')
+ * logger.debug('This debug message will now be logged')
+ * ```
  */
-declare function createLogger(options?: LoggerOptions): LoggerContext;
+declare function createLogger<E extends LoggerContext = LoggerContext>(options?: LoggerOptions): E;
 /**
- * Uses an existing or creates a new logger instance.
+ * Creates a new logger context.
  *
- * @param namespace The namespace for the logger context.
- * @returns The logger instance.
+ * @param options The options for the logger context.
+ * @template E The type of the logger context.
+ * @returns A new logger context.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-logger
+ *
+ * @example
+ * ```ts
+ * import { createLoggerContext } from '@vuetify/v0'
+ *
+ * export const [useAppLogger, provideAppLogger, appLogger] = createLoggerContext({
+ *   namespace: 'app:logger',
+ *   level: 'debug',
+ * })
+ * ```
  */
-declare function useLogger(namespace?: string): LoggerContext;
+declare function createLoggerContext<E extends LoggerContext = LoggerContext>(_options?: LoggerContextOptions): ContextTrinity<E>;
 /**
  * Creates a new logger plugin.
  *
@@ -1791,8 +2270,48 @@ declare function useLogger(namespace?: string): LoggerContext;
  * @returns A new logger plugin.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-logger
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { createLoggerPlugin } from '@vuetify/v0'
+ * import App from './App.vue'
+ *
+ * const app = createApp(App)
+ *
+ * app.use(
+ *  createLoggerPlugin({
+ *    level: 'debug',
+ *    prefix: '[MyApp]',
+ *  })
+ * )
+ *
+ * app.mount('#app')
+ * ```
+ */
+declare function createLoggerPlugin<E extends LoggerContext = LoggerContext>(_options?: LoggerPluginOptions): Plugin;
+/**
+ * Uses an existing or creates a new logger instance.
+ *
+ * @param namespace The namespace for the logger context. Defaults to `'v0:logger'`.
+ * @returns The logger instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-logger
+ *
+ * @example
+ * ```ts
+ * import { useLogger } from '@vuetify/v0'
+ *
+ * const logger = useLogger()
+ *
+ * logger.info('This is an info message')
+ * logger.debug('This is a debug message')
+ * logger.error('This is an error message')
+ * logger.level('debug')
+ * logger.debug('This debug message will now be logged')
+ * ```
  */
-declare function createLoggerPlugin(options?: LoggerOptions): Plugin;
+declare function useLogger<E extends LoggerContext = LoggerContext>(namespace?: string): E;
 //#endregion
 //#region src/composables/useMutationObserver/index.d.ts
 interface MutationObserverRecord {
@@ -1881,27 +2400,30 @@ interface PermissionTicket extends TokenTicket {
 interface PermissionContext<Z extends PermissionTicket = PermissionTicket> extends TokenContext<Z> {
   can: (id: ID, action: string, subject: string, context?: Record<string, any>) => boolean;
 }
-interface PermissionOptions extends PermissionPluginOptions {}
-interface PermissionPluginOptions {
+interface PermissionOptions extends TokenOptions {
   adapter?: PermissionAdapter;
   permissions?: Record<ID, any>;
 }
+interface PermissionContextOptions extends PermissionOptions {
+  namespace?: string;
+}
+interface PermissionPluginOptions extends PermissionContextOptions {}
 /**
  * Creates a new permissions instance.
  *
- * @param namespace The namespace for the permissions instance.
  * @param options The options for the permissions instance.
  * @template Z The type of the permission ticket.
  * @template E The type of the permission context.
  * @returns A new permissions instance.
  *
- * @see https://0.vuetifyjs.com/composables/plugins/create-permissions
+ * @see https://0.vuetifyjs.com/composables/plugins/use-permissions
  *
  * @example
  * ```ts
  * import { createPermissions } from '@vuetify/v0'
  *
- * const [usePermissions, providePermissions] = createPermissions('v0:permissions', {
+ * const [usePermissions, providePermissions] = createPermissions({
+ *   namespace: 'v0:permissions',
  *   permissions: {
  *     admin: [['read', 'users']],
  *     editor: [['edit', 'posts']],
@@ -1909,31 +2431,31 @@ interface PermissionPluginOptions {
  * })
  * ```
  */
-declare function createPermissions<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(namespace?: string, options?: PermissionOptions): ContextTrinity<E>;
+declare function createPermissions<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(_options?: PermissionOptions): E;
 /**
- * Returns the current permissions instance.
+ * Creates a new permissions context.
  *
+ * @param options The options for the permissions context.
  * @template Z The type of the permission ticket.
- * @returns The current permissions instance.
+ * @template E The type of the permission context.
+ * @returns A new permissions context.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-permissions
  *
  * @example
- * ```vue
- * <script setup lang="ts">
- *   import { usePermissions } from '@vuetify/v0'
- *
- *   const { can } = usePermissions()
- * </script>
+ * ```ts
+ * import { createPermissionsContext } from '@vuetify/v0'
  *
- * <template>
- *   <div>
- *     <p v-if="can('admin', 'read', 'users')">Admin access</p>
- *   </div>
- * </template>
+ * export const [usePermissions, providePermissions, context] = createPermissionsContext({
+ *   namespace: 'app:permissions',
+ *   permissions: {
+ *     admin: [['read', 'users'], ['edit', 'users']],
+ *     editor: [['edit', 'posts']],
+ *   },
+ * })
  * ```
  */
-declare function usePermissions<Z extends PermissionTicket = PermissionTicket>(): PermissionContext<Z>;
+declare function createPermissionsContext<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(_options?: PermissionContextOptions): ContextTrinity<E>;
 /**
  * Creates a new permissions plugin.
  *
@@ -1964,7 +2486,31 @@ declare function usePermissions<Z extends PermissionTicket = PermissionTicket>()
  * app.mount('#app')
  * ```
  */
-declare function createPermissionsPlugin<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(options?: PermissionOptions): Plugin;
+declare function createPermissionsPlugin<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(_options?: PermissionPluginOptions): Plugin;
+/**
+ * Returns the current permissions instance.
+ *
+ * @template Z The type of the permission ticket.
+ * @returns The current permissions instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { usePermissions } from '@vuetify/v0'
+ *
+ *   const { can } = usePermissions()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p v-if="can('admin', 'read', 'users')">Admin access</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function usePermissions<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(namespace?: string): E;
 //#endregion
 //#region src/composables/useProxyModel/index.d.ts
 interface ProxyModelOptions {
@@ -1986,9 +2532,9 @@ interface ProxyModelOptions {
  *
  * @example
  * ```ts
- * import { useSelection, useProxyModel } from '@vuetify/v0'
+ * import { createSelection, useProxyModel } from '@vuetify/v0'
  *
- * const registry = useSelection({ events: true })
+ * const registry = createSelection({ events: true })
  * registry.onboard([
  *   { id: 'item-1', value: 'Item 1' },
  *   { id: 'item-2', value: 'Item 2' },
@@ -1997,7 +2543,7 @@ interface ProxyModelOptions {
  * const model = useProxyModel(registry, 'Item 1')
  * ```
  */
-declare function useProxyModel<Z extends SelectionTicket>(registry: SelectionContext<Z>, initial?: unknown | unknown[], options?: ProxyModelOptions, _transformIn?: (val: unknown[] | unknown) => unknown[], _transformOut?: (val: unknown[]) => unknown | unknown[]): vue169.WritableComputedRef<unknown, unknown>;
+declare function useProxyModel<Z extends SelectionTicket>(registry: SelectionContext<Z>, initial?: unknown | unknown[], options?: ProxyModelOptions, _transformIn?: (val: unknown[] | unknown) => unknown[], _transformOut?: (val: unknown[]) => unknown | unknown[]): vue97.WritableComputedRef<unknown, unknown>;
 //#endregion
 //#region src/composables/useProxyRegistry/index.d.ts
 interface ProxyRegistryOptions {
@@ -2236,6 +2782,9 @@ interface QueueOptions extends RegistryOptions {
    */
   timeout?: number;
 }
+interface QueueContextOptions extends QueueOptions {
+  namespace: string;
+}
 /**
  * Creates a new queue instance
  *
@@ -2267,7 +2816,46 @@ interface QueueOptions extends RegistryOptions {
  * console.log(queue.size) // 2
  * ```
  */
-declare function useQueue<Z extends QueueTicket = QueueTicket, E extends QueueContext<Z> = QueueContext<Z>>(_options?: QueueOptions): E;
+declare function createQueue<Z extends QueueTicket = QueueTicket, E extends QueueContext<Z> = QueueContext<Z>>(_options?: QueueOptions): E;
+/**
+ * Creates a new queue context.
+ *
+ * @param namespace The namespace for the queue context.
+ * @param options The options for the queue context.
+ * @template Z The type of the queue ticket.
+ * @template E The type of the queue context.
+ * @returns A new queue context.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-queue
+ *
+ * @example
+ * ```ts
+ * import { createQueueContext } from '@vuetify/v0'
+ *
+ * export const [useQueue, provideQueue] = createQueueContext('v0:queue', {
+ *   timeout: 5000,
+ * })
+ * ```
+ */
+declare function createQueueContext<Z extends QueueTicket = QueueTicket, E extends QueueContext<Z> = QueueContext<Z>>(_options: QueueContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current queue instance.
+ *
+ * @param namespace The namespace for the queue context. Defaults to `'v0:queue'`.
+ * @returns The current queue instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-queue
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useQueue } from '@vuetify/v0'
+ *
+ *   const queue = useQueue()
+ * </script>
+ * ```
+ */
+declare function useQueue<Z extends QueueTicket = QueueTicket, E extends QueueContext<Z> = QueueContext<Z>>(namespace?: string): E;
 //#endregion
 //#region src/composables/useResizeObserver/index.d.ts
 interface ResizeObserverEntry {
@@ -2354,8 +2942,8 @@ declare function useResizeObserver(target: Ref<Element | undefined>, callback: (
  * ```
  */
 declare function useElementSize(target: Ref<Element | undefined>): {
-  width: vue169.ShallowRef<number, number>;
-  height: vue169.ShallowRef<number, number>;
+  width: vue97.ShallowRef<number, number>;
+  height: vue97.ShallowRef<number, number>;
   isPaused: Readonly<Ref<boolean, boolean>>;
   pause: () => void;
   resume: () => void;
@@ -2377,35 +2965,67 @@ interface StepContext<Z extends StepTicket> extends SingleContext<Z> {
   step: (count: number) => void;
 }
 interface StepOptions extends SingleOptions {}
+interface StepContextOptions extends SingleContextOptions {}
 /**
- * Creates a new step instance.
+ * Creates a new step instance with circular navigation through items.
+ *
+ * Extends `createSingle` with `first()`, `last()`, `next()`, `prev()`, and `step(count)` methods
+ * for sequential navigation. Automatically wraps around at boundaries (circular navigation).
  *
  * @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.
+ * @returns A new step instance with navigation methods.
+ *
+ * @remarks
+ * **Key Features:**
+ * - **Circular Navigation**: Wrapping at start/end boundaries
+ * - **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 to first)
+ * - `prev()`: Move to previous item (wraps to last)
+ * - `step(count)`: Move by `count` positions (negative for backward)
+ *
+ * **Wrapping Behavior:**
+ * - Uses modulo arithmetic for circular wrapping: `((index % length) + length) % length`
+ * - Works correctly with negative indexes and large step counts
+ * - Continues searching if landing on disabled items (up to registry length iterations)
+ * - Returns early if all items are disabled to prevent infinite loops
+ *
+ * **Inheritance Chain:**
+ * `useRegistry` → `createSelection` → `createSingle` → `createStep`
  *
  * @see https://0.vuetifyjs.com/composables/selection/use-step
  *
  * @example
  * ```ts
- * import { useStep } from '@vuetify/v0'
+ * import { createStep } from '@vuetify/v0'
  *
- * const stepper = useStep()
+ * const wizard = createStep({ mandatory: true })
  *
- * stepper.onboard([
- *   { id: 'step-1', value: 'Account Info' },
- *   { id: 'step-2', value: 'Payment' },
- *   { id: 'step-3', value: 'Confirmation' },
+ * wizard.onboard([
+ *   { id: 'account', value: 'Account Info' },
+ *   { id: 'payment', value: 'Payment Details' },
+ *   { id: 'review', value: 'Review', disabled: true },
+ *   { id: 'confirm', value: 'Confirmation' },
  * ])
  *
- * stepper.first()
- * stepper.next() // Move to step-2
+ * wizard.first() // Select 'account'
+ * console.log(wizard.selectedId.value) // 'account'
  *
- * console.log(stepper.selectedIndex.value) // 1
+ * wizard.next() // Move to 'payment'
+ * wizard.next() // Skip disabled 'review', move to 'confirm'
+ * wizard.next() // Wrap around to 'account'
+ *
+ * wizard.step(-2) // Go back 2 steps (wraps correctly)
  * ```
  */
-declare function useStep<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(options?: StepOptions): E;
+declare function createStep<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(options?: StepOptions): E;
 /**
  * Creates a new step context.
  *
@@ -2431,7 +3051,32 @@ declare function useStep<Z extends StepTicket = StepTicket, E extends StepContex
  * wizard.next() // Progress to next step
  * ```
  */
-declare function createStepContext<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(namespace: string, options?: StepOptions): ContextTrinity<E>;
+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;
 //#endregion
 //#region src/composables/useStorage/adapters/adapter.d.ts
 interface StorageAdapter$1 {
@@ -2491,6 +3136,11 @@ interface StorageOptions {
     write: (value: any) => string;
   };
 }
+interface StorageContextOptions extends StorageOptions {
+  /** The namespace for the storage context. Defaults to `v0:storage` */
+  namespace?: string;
+}
+interface StoragePluginOptions extends StorageContextOptions {}
 declare const useStorageContext: (key?: ContextKey<StorageContext>) => StorageContext, provideStorageContext: (context: StorageContext, app?: App) => StorageContext;
 /**
  * Creates a new storage instance.
@@ -2517,9 +3167,33 @@ declare const useStorageContext: (key?: ContextKey<StorageContext>) => StorageCo
  * ```
  */
 declare function createStorage<E extends StorageContext>(options?: StorageOptions): E;
+declare function createStorageContext<E extends StorageContext = StorageContext>(_options?: StorageContextOptions): ContextTrinity<E>;
+/**
+ * Creates a new storage plugin.
+ *
+ * @param options The options for the storage plugin.
+ * @returns A new storage plugin.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-storage
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { createStoragePlugin } from '@vuetify/v0'
+ * import App from './App.vue'
+ *
+ * const app = createApp(App)
+ *
+ * app.use(createStoragePlugin())
+ *
+ * app.mount('#app')
+ * ```
+ */
+declare function createStoragePlugin<E extends StorageContext = StorageContext>(_options?: StoragePluginOptions): Plugin;
 /**
  * Returns the current storage instance.
  *
+ * @param namespace The namespace for the storage context. Defaults to `'v0:storage'`.
  * @returns The current storage instance.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-storage
@@ -2540,29 +3214,7 @@ declare function createStorage<E extends StorageContext>(options?: StorageOption
  * </template>
  * ```
  */
-declare function useStorage(): StorageContext;
-/**
- * Creates a new storage plugin.
- *
- * @param options The options for the storage plugin.
- * @returns A new storage plugin.
- *
- * @see https://0.vuetifyjs.com/composables/plugins/use-storage
- *
- * @example
- * ```ts
- * import { createApp } from 'vue'
- * import { createStoragePlugin } from '@vuetify/v0'
- * import App from './App.vue'
- *
- * const app = createApp(App)
- *
- * app.use(createStoragePlugin())
- *
- * app.mount('#app')
- * ```
- */
-declare function createStoragePlugin(options?: StorageOptions): Plugin;
+declare function useStorage<E extends StorageContext = StorageContext>(namespace?: string): E;
 //#endregion
 //#region src/composables/useTheme/adapters/adapter.d.ts
 interface ThemeAdapterInterface {
@@ -2607,26 +3259,89 @@ type ThemeRecord = {
   lazy?: boolean;
   colors: ThemeColors;
 };
-type ThemeTicket = SingleTicket & {
-  lazy: boolean;
+interface ThemeTicket extends SingleTicket {
+  /**
+   * Indicates whether the theme is dark or light.
+   *
+   * @remarks Defaults to `false` (light theme).
+   */
   dark: boolean;
-};
+  /**
+   * Indicates whether the theme should be loaded lazily.
+   *
+   * @remarks Defaults to `false`.
+   */
+  lazy: boolean;
+}
 interface ThemeContext<Z extends ThemeTicket> extends SingleContext<Z> {
+  /**
+   * A computed reference to the resolved colors of the current theme.
+   *
+   * @remarks The colors are resolved by replacing any token aliases with their actual values.
+   *
+   * @see https://0.vuetifyjs.com/composables/plugins/use-theme#colors
+   *
+   * @example
+   * ```ts
+   * import { useTheme } from '@vuetify/v0'
+   *
+   * const theme = useTheme()
+   *
+   * console.log(theme.colors.value)
+   * ```
+   */
   colors: ComputedRef<Record<string, Colors>>;
-  cycle: (themes: ID[]) => void;
+  /**
+   * Cycles through the provided themes in order.
+   *
+   * @param themes An array of theme IDs to cycle through. Defaults to all registered themes.
+   *
+   * @see https://0.vuetifyjs.com/composables/plugins/use-theme#cycle
+   *
+   * @example
+   * ```ts
+   * import { useTheme } from '@vuetify/v0'
+   *
+   * const theme = useTheme()
+   *
+   * theme.cycle(['light', 'dark'])
+   * ```
+   */
+  cycle: (themes?: ID[]) => void;
 }
-interface ThemeOptions extends ThemePluginOptions {}
-interface ThemePluginOptions<Z extends ThemeRecord = ThemeRecord> {
+interface ThemeOptions<Z extends ThemeRecord = ThemeRecord> extends RegistryOptions {
+  /**
+   * The theme adapter to use.
+   *
+   * @remarks Defaults to `Vuetify0ThemeAdapter`.
+   */
   adapter?: ThemeAdapter;
+  /**
+   * The default theme ID to select on initialization.
+   */
   default?: ID;
+  /**
+   * A collection of tokens to use for resolving theme colors.
+   */
   palette?: TokenCollection;
+  /**
+   * A record of themes to register.
+   */
   themes?: Record<ID, Z>;
+  /**
+   * The target element or selector to apply theme classes to.
+   *
+   * @remarks If `null`, no classes will be applied.
+   */
   target?: string | HTMLElement | null;
 }
+interface ThemeContextOptions extends ThemeOptions {
+  namespace?: string;
+}
+interface ThemePluginOptions extends ThemeContextOptions {}
 /**
  * Creates a new theme instance.
  *
- * @param namespace The namespace for the theme instance.
  * @param options The options for the theme instance.
  * @template Z The type of the theme ticket.
  * @template E The type of the theme context.
@@ -2638,7 +3353,8 @@ interface ThemePluginOptions<Z extends ThemeRecord = ThemeRecord> {
  * ```ts
  * import { createTheme } from '@vuetify/v0'
  *
- * export const [useTheme, provideTheme] = createTheme('v0:theme', {
+ * export const [useTheme, provideTheme] = createTheme({
+ *   namespace: 'v0:theme',
  *   default: 'light',
  *   themes: {
  *     light: {
@@ -2657,34 +3373,46 @@ interface ThemePluginOptions<Z extends ThemeRecord = ThemeRecord> {
  * })
  * ```
  */
-declare function createTheme<Z extends ThemeTicket = ThemeTicket, E extends ThemeContext<Z> = ThemeContext<Z>>(namespace?: string, options?: ThemeOptions): ContextTrinity<E>;
+declare function createTheme<Z extends ThemeTicket = ThemeTicket, E extends ThemeContext<Z> = ThemeContext<Z>>(_options?: ThemeOptions): E;
 /**
- * Returns the current theme instance.
+ * Creates a new theme context trinity.
  *
- * @returns The current theme instance.
+ * @param options The options for the theme context.
+ * @template Z The type of the theme ticket.
+ * @template E The type of the theme context.
+ * @returns A new theme context trinity.
  *
  * @see https://0.vuetifyjs.com/composables/plugins/use-theme
  *
  * @example
- * ```vue
- * <script setup lang="ts">
- *   import { useTheme } from '@vuetify/v0'
- *
- *   const theme = useTheme()
- * </script>
+ * ```ts
+ * import { createThemeContext } from '@vuetify/v0'
  *
- * <template>
- *   <div>
- *     <p>Current theme: {{ theme.selected.value }}</p>
- *   </div>
- * </template>
+ * export const [useThemeContext, provideThemeContext, context] = createThemeContext({
+ *   namespace: 'v0:theme',
+ *   default: 'light',
+ *   themes: {
+ *     light: {
+ *       dark: false,
+ *       colors: {
+ *         primary: '#3b82f6',
+ *       },
+ *     },
+ *     dark: {
+ *       dark: true,
+ *       colors: {
+ *         primary: '#675496',
+ *       },
+ *     },
+ *   },
+ * })
  * ```
  */
-declare function useTheme(): ThemeContext<ThemeTicket>;
+declare function createThemeContext<Z extends ThemeTicket = ThemeTicket, E extends ThemeContext<Z> = ThemeContext<Z>>(_options?: ThemeContextOptions): ContextTrinity<E>;
 /**
  * Creates a new theme plugin.
  *
- * @param _options The options for the theme plugin.
+ * @param options The options for the theme plugin.
  * @template Z The type of the theme ticket.
  * @template E The type of the theme context.
  * @returns A new theme plugin.
@@ -2723,16 +3451,95 @@ declare function useTheme(): ThemeContext<ThemeTicket>;
  * ```
  */
 declare function createThemePlugin<Z extends ThemeTicket = ThemeTicket, E extends ThemeContext<Z> = ThemeContext<Z>>(_options?: ThemePluginOptions): Plugin;
+/**
+ * Returns the current theme instance.
+ *
+ * @param namespace The namespace for the theme context. Defaults to `v0:theme`.
+ * @returns The current theme instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-theme
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useTheme } from '@vuetify/v0'
+ *
+ *   const theme = useTheme()
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Current theme: {{ theme.selected.value }}</p>
+ *   </div>
+ * </template>
+ * ```
+ */
+declare function useTheme<Z extends ThemeTicket = ThemeTicket, E extends ThemeContext<Z> = ThemeContext<Z>>(namespace?: string): E;
 //#endregion
 //#region src/composables/useTimeline/index.d.ts
 interface TimelineContext<Z extends TimelineTicket> extends RegistryContext<Z> {
+  /**
+   * Removes the last registered ticket and stores it for redo
+   *
+   * @return The removed ticket, or undefined if there are no tickets to undo.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-timeline#undo
+   *
+   * @example
+   * ```ts
+   * import { useTimeline } from '@vuetify/v0'
+   *
+   * const timeline = useTimeline()
+   *
+   * timeline.register({ id: 'one' })
+   * timeline.register({ id: 'two' })
+   *
+   * console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }]
+   *
+   * timeline.undo()
+   * console.log(timeline.values()) // [{ id: 'one' }]
+   * ```
+   */
   undo: () => Z | undefined;
+  /**
+   * Restores the last undone ticket
+   *
+   * @returns The restored ticket, or undefined if there are no tickets to redo.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-timeline#redo
+   *
+   * @example
+   * ```ts
+   * import { useTimeline } from '@vuetify/v0'
+   *
+   * const timeline = useTimeline()
+   *
+   * timeline.register({ id: 'one' })
+   * timeline.register({ id: 'two' })
+   *
+   * console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }]
+   *
+   * timeline.undo()
+   * console.log(timeline.values()) // [{ id: 'one' }]
+   *
+   * timeline.redo()
+   * console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }]
+   * ```
+   */
   redo: () => Z | undefined;
 }
 interface TimelineTicket extends RegistryTicket {}
 interface TimelineOptions extends RegistryOptions {
+  /**
+   * The maximum size of the timeline.
+   *
+   * @default 10
+   */
   size?: number;
 }
+interface TimelineContextOptions extends TimelineOptions {
+  namespace: string;
+}
 /**
  * Creates a new timeline instance.
  *
@@ -2760,6 +3567,52 @@ interface TimelineOptions extends RegistryOptions {
  * console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }, { id: 'three' }]
  * ```
  */
-declare function useTimeline<Z extends TimelineTicket = TimelineTicket, E extends TimelineContext<Z> = TimelineContext<Z>>(_options?: TimelineOptions): E;
+declare function createTimeline<Z extends TimelineTicket = TimelineTicket, E extends TimelineContext<Z> = TimelineContext<Z>>(_options?: TimelineOptions): E;
+/**
+ * Creates a new timeline plugin.
+ *
+ * @param namespace The namespace for the timeline plugin.
+ * @param options The options for the timeline plugin.
+ * @template Z The type of the timeline ticket.
+ * @template E The type of the timeline context.
+ * @returns A new timeline plugin.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-timeline
+ *
+ * @example
+ * ```ts
+ * import { createTimelineContext } from '@vuetify/v0'
+ *
+ * export const [useTimeline, provideTimeline, context] = createTimelineContext('v0:timeline', { size: 5 })
+ * context.register({ id: 'example' })
+ *
+ * // In a parent component
+ * provideTimeline()
+ *
+ * // In a child component
+ * const timeline = useTimeline()
+ *
+ * console.log(timeline.values()) // [{ id: 'example' }]
+ * ```
+ */
+declare function createTimelineContext<Z extends TimelineTicket = TimelineTicket, E extends TimelineContext<Z> = TimelineContext<Z>>(_options: TimelineContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current timeline instance.
+ *
+ * @param namespace The namespace for the timeline context. Defaults to `'v0:timeline'`.
+ * @returns The current timeline instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-timeline
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useTimeline } from '@vuetify/v0'
+ *
+ *   const timeline = useTimeline()
+ * </script>
+ * ```
+ */
+declare function useTimeline<Z extends TimelineTicket = TimelineTicket, E extends TimelineContext<Z> = TimelineContext<Z>>(namespace?: string): E;
 //#endregion
-export { PermissionAdapterInterface as $, createContext as $n, UseFilterResult as $t, createStepContext as A, RegistryTicket as An, IntersectionObserverEntry as At, ProxyRegistryContext as B, BreakpointsOptions as Bn, FormContext as Bt, useStorageContext as C, SelectionContext as Cn, SingleContext as Ct, StepContext as D, useSelection as Dn, useSingle as Dt, MemoryAdapter as E, createSelectionContext as En, createSingleContext as Et, useResizeObserver as F, useDocumentEventListener as Fn, createHydration as Ft, PermissionContext as G, toReactive as Gn, FormValue as Gt, useProxyRegistry as H, createBreakpoints as Hn, FormTicket as Ht, QueueContext as I, useEventListener as In, createHydrationPlugin as It, PermissionTicket as J, createTrinity as Jn, FilterItem as Jt, PermissionOptions as K, toArray as Kn, useForm as Kt, QueueOptions as L, useWindowEventListener as Ln, provideHydrationContext as Lt, ResizeObserverEntry as M, useRegistry as Mn, useElementIntersection as Mt, ResizeObserverOptions as N, CleanupFunction as Nn, useIntersectionObserver as Nt, StepOptions as O, RegistryContext as On, KeyHandler as Ot, useElementSize as P, EventHandler as Pn, HydrationContext as Pt, PermissionAdapter as Q, ContextKey as Qn, UseFilterOptions as Qt, QueueTicket as R, BreakpointName as Rn, useHydration as Rt, useStorage as S, useGroup as Sn, LocaleAdapter as St, StorageType as T, SelectionTicket as Tn, SingleTicket as Tt, ProxyModelOptions as U, createBreakpointsPlugin as Un, FormValidationResult as Ut, ProxyRegistryOptions as V, BreakpointsPluginOptions as Vn, FormOptions as Vt, useProxyModel as W, useBreakpoints as Wn, FormValidationRule as Wt, createPermissionsPlugin as X, PluginOptions as Xn, FilterQuery as Xt, createPermissions as Y, Plugin as Yn, FilterMode as Yt, usePermissions as Z, createPlugin as Zn, Primitive as Zt, StorageContext as _, useTokens as _n, LocaleTicket as _t, Colors as a, createFeatures as an, createLogger as at, createStoragePlugin as b, GroupTicket as bn, useLocale as bt, ThemeOptions as c, FlatTokenCollection as cn, LogLevel as ct, ThemeTicket as d, TokenContext as dn, ConsolaLoggerAdapter as dt, useFilter as en, provideContext as er, MutationObserverRecord as et, createTheme as f, TokenOptions as fn, LoggerAdapter as ft, ThemeAdapter as g, createTokensContext as gn, LocaleRecord as gt, Vuetify0ThemeAdapter as h, TokenValue as hn, LocalePluginOptions as ht, useTimeline as i, FeatureTicket as in, LoggerOptions as it, useStep as j, createRegistryContext as jn, IntersectionObserverOptions as jt, StepTicket as k, RegistryOptions as kn, useKeydown as kt, ThemePluginOptions as l, TokenAlias as ln, Vuetify0LoggerAdapter as lt, useTheme as m, TokenTicket as mn, LocaleOptions as mt, TimelineOptions as n, FeatureOptions as nn, useMutationObserver as nt, ThemeColors as o, createFeaturesPlugin as on, createLoggerPlugin as ot, createThemePlugin as p, TokenPrimitive as pn, LocaleContext as pt, PermissionPluginOptions as q, ContextTrinity as qn, FilterFunction as qt, TimelineTicket as r, FeaturePluginOptions as rn, LoggerContext as rt, ThemeContext as s, useFeatures as sn, useLogger as st, TimelineContext as t, FeatureContext as tn, useContext as tr, UseMutationObserverOptions as tt, ThemeRecord as u, TokenCollection as un, PinoLoggerAdapter as ut, StorageOptions as v, GroupContext as vn, createLocale as vt, StorageAdapter as w, SelectionOptions as wn, SingleOptions as wt, provideStorageContext as x, createGroupContext as xn, Vuetify0LocaleAdapter as xt, createStorage as y, GroupOptions as yn, createLocalePlugin as yt, useQueue as z, BreakpointsContext as zn, useHydrationContext as zt };
+export { ProxyRegistryContext as $, createGroup as $n, IntersectionObserverOptions as $t, useStorage as A, FeatureOptions as An, toArray as Ar, LoggerAdapter as At, createStepContext as B, TokenContext as Bn, useLocale as Bt, StorageContextOptions as C, FilterQuery as Cn, BreakpointsOptions as Cr, createLoggerContext as Ct, createStorageContext as D, useFilter as Dn, createBreakpointsPlugin as Dr, Vuetify0LoggerAdapter as Dt, createStorage as E, UseFilterResult as En, createBreakpointsContext as Er, LogLevel as Et, StepContext as F, createFeaturesPlugin as Fn, createPlugin as Fr, 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, ContextKey as Ir, 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, createContext as Lr, createLocale as Lt, StorageAdapter as M, FeatureTicket as Mn, createTrinity as Mr, LocaleContextOptions as Mt, StorageType as N, createFeatures as Nn, Plugin as Nr, LocaleOptions as Nt, createStoragePlugin as O, FeatureContext as On, useBreakpoints as Or, PinoLoggerAdapter as Ot, MemoryAdapter as P, createFeaturesContext as Pn, PluginOptions as Pr, LocalePluginOptions as Pt, useQueue as Q, GroupTicket as Qn, IntersectionObserverEntry as Qt, StepTicket as R, TokenAlias as Rn, provideContext as Rr, createLocaleContext as Rt, StorageContext as S, FilterMode as Sn, BreakpointsContextOptions as Sr, createLogger as St, StoragePluginOptions as T, UseFilterOptions as Tn, createBreakpoints as Tr, 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, useDocumentEventListener as _r, useMutationObserver as _t, createTimeline as a, HydrationPluginOptions as an, SelectionTicket as ar, PermissionContextOptions as at, Vuetify0ThemeAdapter as b, FilterFunction as bn, BreakpointName as br, LoggerOptions as bt, Colors as c, createHydrationPlugin as cn, useSelection as cr, PermissionTicket as ct, ThemeContextOptions as d, FormContextOptions as dn, RegistryOptions as dr, createPermissionsPlugin as dt, useElementIntersection as en, createGroupContext as er, ProxyRegistryOptions as et, ThemeOptions as f, FormOptions as fn, RegistryTicket as fr, usePermissions as ft, createTheme as g, FormValue as gn, EventHandler as gr, UseMutationObserverOptions as gt, ThemeTicket as h, FormValidationRule as hn, CleanupFunction as hr, MutationObserverRecord as ht, TimelineTicket as i, HydrationOptions as in, SelectionOptions as ir, PermissionContext as it, useStorageContext as j, FeaturePluginOptions as jn, ContextTrinity as jr, LocaleContext as jt, provideStorageContext as k, FeatureContextOptions as kn, toReactive as kr, ConsolaLoggerAdapter as kt, ThemeColors as l, useHydration as ln, RegistryContext as lr, createPermissions as lt, ThemeRecord as m, FormValidationResult as mn, useRegistry as mr, PermissionAdapterInterface as mt, TimelineContextOptions as n, HydrationContext as nn, SelectionContext as nr, ProxyModelOptions as nt, createTimelineContext as o, createHydration as on, createSelection as or, PermissionOptions as ot, ThemePluginOptions as p, FormTicket as pn, createRegistryContext as pr, PermissionAdapter as pt, QueueContextOptions as q, createTokensContext as qn, createSingle as qt, TimelineOptions as r, HydrationContextOptions as rn, SelectionContextOptions as rr, useProxyModel as rt, useTimeline as s, createHydrationContext as sn, createSelectionContext as sr, PermissionPluginOptions as st, TimelineContext as t, useIntersectionObserver as tn, useGroup as tr, useProxyRegistry as tt, ThemeContext as u, FormContext as un, RegistryContextOptions as ur, createPermissionsContext as ut, createThemePlugin as v, createFormContext as vn, useEventListener as vr, LoggerContext as vt, StorageOptions as w, Primitive as wn, BreakpointsPluginOptions as wr, createLoggerPlugin as wt, ThemeAdapter as x, FilterItem as xn, BreakpointsContext as xr, LoggerPluginOptions as xt, useTheme as y, useForm as yn, useWindowEventListener as yr, LoggerContextOptions as yt, createStep as z, TokenCollection as zn, useContext as zr, createLocalePlugin as zt };