@vuetify/v0 0.0.14 → 0.0.16

package/dist/{index-D-EP6KrS.d.mts → index-BulceeMA.d.mts}

@@ -1,5 +1,5 @@
-import { i as ID } from "./index-DY7-T630.mjs";
-import { App, ComputedRef, InjectionKey, MaybeRef, Reactive, Ref } from "vue";
+import { i as ID } from "./index-Bd3J4RNS.mjs";
+import { App, ComputedRef, MaybeRef, MaybeRefOrGetter, Reactive, Ref, ShallowRef } from "vue";
 
 //#region src/composables/createTrinity/index.d.ts
 
@@ -46,7 +46,7 @@ type ContextTrinity<Z = unknown> = readonly [() => Z, (context?: Z, app?: App) =
 declare function createTrinity<Z = unknown>(useContext: () => Z, provideContext: (_context?: Z, app?: App) => Z, context: Z): ContextTrinity<Z>;
 //#endregion
 //#region src/composables/useRegistry/index.d.ts
-interface RegistryTicket {
+interface RegistryTicket<V = unknown> {
   /** The unique identifier. Is randomly generated if not provided. */
   id: ID;
   /**
@@ -56,7 +56,7 @@ interface RegistryTicket {
    */
   index: number;
   /** The value associated with the ticket. If not provided, it defaults to the index. */
-  value: any;
+  value: V;
   /**
    * Whether the value is derived from index.
    *
@@ -485,6 +485,32 @@ interface RegistryContext<Z extends RegistryTicket = RegistryTicket> {
    * ```
   */
   onboard: (registrations: Partial<Z>[]) => Z[];
+  /**
+   * Offboard multiple tickets at once
+   *
+   * @param ids An array of ticket IDs to unregister.
+   * @remarks Unregisters multiple tickets in a single operation with optimized reindexing.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#offboard
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.onboard([
+   *   { id: 'ticket-1', value: 'value-1' },
+   *   { id: 'ticket-2', value: 'value-2' },
+   *   { id: 'ticket-3', value: 'value-3' },
+   * ])
+   *
+   * registry.offboard(['ticket-1', 'ticket-3'])
+   *
+   * console.log(registry.size) // 1
+   * ```
+  */
+  offboard: (ids: ID[]) => void;
   /**
    * The number of tickets in the registry
    *
@@ -529,7 +555,7 @@ interface RegistryOptions {
   events?: boolean;
 }
 interface RegistryContextOptions extends RegistryOptions {
-  namespace: string;
+  namespace?: string;
 }
 /**
  * Creates a new registry instance.
@@ -570,7 +596,11 @@ declare function useRegistry<Z extends RegistryTicket = RegistryTicket, E extend
  * ```ts
  * import { createRegistryContext } from '@vuetify/v0'
  *
- * export const [useItems, provideItems, items] = createRegistryContext('items')
+ * // With default namespace 'v0:registry'
+ * export const [useItems, provideItems, items] = createRegistryContext()
+ *
+ * // Or with custom namespace
+ * export const [useItems, provideItems, items] = createRegistryContext({ namespace: 'my-items' })
  *
  * // In a parent component:
  * provideItems()
@@ -580,10 +610,10 @@ 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>>(_options: RegistryContextOptions): 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 {
+interface SelectionTicket<V = unknown> extends RegistryTicket<V> {
   /** Disabled state of the ticket */
   disabled: MaybeRef<boolean>;
   /** Whether the ticket is currently selected */
@@ -636,7 +666,7 @@ interface SelectionOptions extends RegistryOptions {
   multiple?: boolean;
 }
 interface SelectionContextOptions extends SelectionOptions {
-  namespace: string;
+  namespace?: string;
 }
 /**
  * Creates a new selection instance for managing multiple selected items.
@@ -688,7 +718,6 @@ declare function createSelection<Z extends SelectionTicket = SelectionTicket, E
 /**
  * Creates a new selection context.
  *
- * @param namespace The namespace for the selection context.
  * @param options The options for the selection context.
  * @template Z The type of the selection ticket.
  * @template E The type of the selection context.
@@ -700,7 +729,11 @@ declare function createSelection<Z extends SelectionTicket = SelectionTicket, E
  * ```ts
  * import { createSelectionContext } from '@vuetify/v0'
  *
- * export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext('checkboxes')
+ * // With default namespace 'v0:selection'
+ * export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext()
+ *
+ * // Or with custom namespace
+ * export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext({ namespace: 'checkboxes' })
  *
  * // In a parent component:
  * provideCheckboxes()
@@ -710,7 +743,7 @@ declare function createSelection<Z extends SelectionTicket = SelectionTicket, E
  * checkboxes.select('checkbox-1')
  * ```
  */
-declare function createSelectionContext<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(_options: SelectionContextOptions): ContextTrinity<E>;
+declare function createSelectionContext<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(_options?: SelectionContextOptions): ContextTrinity<E>;
 /**
  * Returns the current selection instance.
  *
@@ -736,77 +769,563 @@ declare function createSelectionContext<Z extends SelectionTicket = SelectionTic
  */
 declare function useSelection<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(namespace?: string): E;
 //#endregion
-//#region src/composables/createContext/index.d.ts
-type ContextKey<Z> = InjectionKey<Z> | string;
+//#region src/composables/useGroup/index.d.ts
+interface GroupTicket<V = unknown> extends SelectionTicket<V> {
+  /** Whether the ticket should start in mixed/indeterminate state */
+  indeterminate?: MaybeRef<boolean>;
+  /** Whether the ticket is in a mixed/indeterminate state */
+  isMixed: Readonly<Ref<boolean>>;
+  /** Set self to mixed/indeterminate state */
+  mix: () => void;
+  /** Clear mixed/indeterminate state from self */
+  unmix: () => void;
+}
+interface GroupContext<Z extends GroupTicket> extends SelectionContext<Z> {
+  selectedIndexes: ComputedRef<Set<number>>;
+  /** Select one or more Tickets by ID */
+  select: (ids: ID | ID[]) => void;
+  /** Unselect one or more Tickets by ID */
+  unselect: (ids: ID | ID[]) => void;
+  /** Toggle one or more Tickets ON and OFF by ID */
+  toggle: (ids: ID | ID[]) => void;
+  /** Set of mixed/indeterminate ticket IDs */
+  mixedIds: Reactive<Set<ID>>;
+  /** Set of mixed/indeterminate ticket instances */
+  mixedItems: ComputedRef<Set<Z>>;
+  /** Set one or more Tickets to mixed/indeterminate state by ID */
+  mix: (ids: ID | ID[]) => void;
+  /** Clear mixed/indeterminate state from one or more Tickets by ID */
+  unmix: (ids: ID | ID[]) => void;
+  /** Check if a ticket is in mixed/indeterminate state by ID */
+  mixed: (id: ID) => boolean;
+  /** Whether no items are currently selected */
+  isNoneSelected: ComputedRef<boolean>;
+  /** Whether all selectable (non-disabled) items are selected */
+  isAllSelected: ComputedRef<boolean>;
+  /** Whether some but not all selectable items are selected */
+  isMixed: ComputedRef<boolean>;
+  /** Select all selectable (non-disabled) items */
+  selectAll: () => void;
+  /** Unselect all items (respects mandatory option) */
+  unselectAll: () => void;
+  /** Toggle between all selected and none selected */
+  toggleAll: () => void;
+}
+interface GroupOptions extends SelectionOptions {}
+interface GroupContextOptions extends SelectionContextOptions {}
 /**
- * Injects a context provided by an ancestor component.
+ * Creates a new group instance with batch selection and tri-state support.
  *
- * @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.
+ * Extends `createSelection` to support selecting, unselecting, and toggling multiple items
+ * at once by passing an array of IDs. Adds tri-state (mixed/indeterminate) support for
+ * checkbox trees and similar use cases.
+ *
+ * @param options The options for the group instance.
+ * @template Z The type of the group ticket.
+ * @template E The type of the group context.
+ * @returns A new group instance with batch selection and tri-state support.
+ *
+ * @remarks
+ * **Key Differences from `createSelection`:**
+ * - `select()` accepts `ID | ID[]` for batch operations
+ * - `unselect()` accepts `ID | ID[]` for batch operations
+ * - `toggle()` accepts `ID | ID[]` for batch operations
+ * - Adds `selectedIndexes` computed Set for getting selected item indexes
+ * - Adds tri-state support via `mix()`, `unmix()`, `mixed()`, `mixedIds`, `mixedItems`
+ * - Perfect for checkbox trees, multi-select dropdowns, and bulk operations
  *
- * @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
- * @see https://0.vuetifyjs.com/composables/foundation/create-context#use-context
+ * **Tri-State Support:**
+ * - Items can be in one of three states: selected, mixed (indeterminate), or unselected
+ * - `mix(id)` sets item to mixed state (clears selected if set)
+ * - `unmix(id)` clears mixed state
+ * - `select(id)` clears mixed state before selecting
+ * - `toggle(id)` on a mixed item selects it (resolves the indeterminate state positively)
+ * - Mixed state works on disabled items (it's a computed state, not user action)
+ *
+ * **Batch Operations:**
+ * - Single ID: `group.select('item-1')`
+ * - Array of IDs: `group.select(['item-1', 'item-2', 'item-3'])`
+ * - Uses `toArray()` utility internally to normalize input
+ * - Disabled items are automatically skipped in select operations
+ * - Non-existent IDs are silently ignored
+ *
+ * **Inheritance Chain:**
+ * `useRegistry` → `createSelection` → `createGroup`
+ *
+ * **Used By:**
+ * - `createFeatures` for feature flag management with multiple selections
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-group
  *
  * @example
  * ```ts
- * // Without default value
- * const context = useContext<MyContext>('my-context')
+ * import { createGroup } from '@vuetify/v0'
+ *
+ * const checkboxes = createGroup()
  *
- * // With default value
- * const context = useContext<MyContext>('my-context', defaultContext)
+ * checkboxes.onboard([
+ *   { id: 'option-a', value: 'Option A' },
+ *   { id: 'option-b', value: 'Option B' },
+ *   { id: 'option-c', value: 'Option C' },
+ * ])
+ *
+ * // Select multiple items at once
+ * checkboxes.select(['option-a', 'option-c'])
+ *
+ * console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
+ * console.log(Array.from(checkboxes.selectedIndexes.value)) // [0, 2]
+ *
+ * // Set item to mixed/indeterminate state
+ * checkboxes.mix('option-a')
+ * console.log(checkboxes.mixedIds) // Set { 'option-a' }
+ * console.log(checkboxes.selectedIds) // Set { 'option-c' } (option-a removed)
+ *
+ * // Toggle a mixed item selects it
+ * checkboxes.toggle('option-a')
+ * console.log(checkboxes.selectedIds) // Set { 'option-a', 'option-c' }
+ * console.log(checkboxes.mixedIds) // Set {} (cleared)
  * ```
  */
-declare function useContext<Z>(key: ContextKey<Z>, defaultValue?: Z): Z & ({} | null);
+declare function createGroup<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(_options?: GroupOptions): E;
 /**
- * Provides a context to all descendant components.
+ * Creates a new group context.
  *
- * @param key The key of the context to provide.
- * @param context The context to provide.
- * @param app Optional Vue app instance to provide the context at app level instead of component level.
- * @template Z The type of the context.
- * @returns The provided context.
+ * @param 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'
+ *
+ * // With default namespace 'v0:group'
+ * export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext()
+ *
+ * // Or with custom namespace
+ * export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext({ namespace: 'my-group' })
+ *
+ * // In a parent component:
+ * provideMyGroup()
+ *
+ * // In a child component:
+ * const group = useMyGroup()
+ * ```
+ */
+declare function createGroupContext<Z extends 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/usePagination/index.d.ts
+interface PaginationItem {
+  type: 'page' | 'ellipsis';
+  value: number | string;
+}
+interface PaginationContext<Z extends PaginationItem = PaginationItem> {
+  /** Current page (1-indexed) */
+  page: ShallowRef<number>;
+  /** Items per page */
+  itemsPerPage: number;
+  /** Total number of items */
+  size: number;
+  /** Total number of pages (computed from size / itemsPerPage) */
+  pages: number;
+  /** Ellipsis character, or false if disabled */
+  ellipsis: string | false;
+  /** Visible page numbers and ellipsis for rendering */
+  items: ComputedRef<Z[]>;
+  /** Start index of items on current page (0-indexed) */
+  pageStart: ComputedRef<number>;
+  /** End index of items on current page (exclusive, 0-indexed) */
+  pageStop: ComputedRef<number>;
+  /** Whether current page is the first page */
+  isFirst: ComputedRef<boolean>;
+  /** Whether current page is the last page */
+  isLast: ComputedRef<boolean>;
+  /** Go to first page */
+  first: () => void;
+  /** Go to last page */
+  last: () => void;
+  /** Go to next page */
+  next: () => void;
+  /** Go to previous page */
+  prev: () => void;
+  /** Go to specific page */
+  select: (value: number) => void;
+}
+interface PaginationOptions {
+  /** Initial page or ref for v-model (1-indexed). @default 1 */
+  page?: number | ShallowRef<number>;
+  /** Items per page. @default 10 */
+  itemsPerPage?: MaybeRefOrGetter<number>;
+  /** Total number of items. @default 0 */
+  size?: MaybeRefOrGetter<number>;
+  /** Maximum visible page buttons. @default 5 */
+  visible?: MaybeRefOrGetter<number>;
+  /** Ellipsis character. @default '…' */
+  ellipsis?: string | false;
+}
+interface PaginationContextOptions extends PaginationOptions {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+/**
+ * Creates a pagination instance.
+ *
+ * @param options The options for the pagination instance.
+ * @returns A pagination context with navigation methods.
+ *
+ * @example
+ * ```ts
+ * import { createPagination } from '@vuetify/v0'
+ *
+ * // Basic usage
+ * const pagination = createPagination({ size: 100 })
+ * pagination.next()
+ * pagination.items.value // [{ type: 'page', value: 1 }, { type: 'page', value: 2 }, ...]
+ *
+ * // With v-model (pass a ref)
+ * const page = ref(1)
+ * const pagination = createPagination({ page, size: 100 })
+ * // Mutating pagination.page or the passed ref syncs both
+ * ```
+ */
+declare function createPagination<Z extends PaginationItem = PaginationItem, E extends PaginationContext<Z> = PaginationContext<Z>>(_options?: PaginationOptions): E;
+/**
+ * Creates a pagination context for dependency injection.
+ *
+ * @param options The options including namespace.
+ * @returns A trinity: [usePagination, providePagination, defaultContext]
+ *
+ * @example
+ * ```ts
+ * // With default namespace 'v0:pagination'
+ * const [usePagination, providePaginationContext] = createPaginationContext({ size: 50 })
+ *
+ * // Or with custom namespace
+ * const [usePagination, providePaginationContext] = createPaginationContext({
+ *   namespace: 'my-pagination',
+ *   size: 50,
+ * })
+ *
+ * // Parent component
+ * providePaginationContext()
+ *
+ * // Child component
+ * const pagination = usePagination()
+ * pagination.next()
+ * ```
+ */
+declare function createPaginationContext<Z extends PaginationItem = PaginationItem, E extends PaginationContext<Z> = PaginationContext<Z>>(_options?: PaginationContextOptions): ContextTrinity<E>;
+/**
+ * Returns the current pagination instance from context.
+ *
+ * @param namespace The namespace. @default 'v0:pagination'
+ * @returns The pagination context.
+ *
+ * @example
+ * ```vue
+ * <script setup>
+ *  import { usePagination } from '@vuetify/v0'
+ *
+ *  const pagination = usePagination()
+ * </script>
+ *
+ * <template>
+ *   <button @click="pagination.prev()" :disabled="pagination.isFirst.value">Prev</button>
+ *   <button @click="pagination.next()" :disabled="pagination.isLast.value">Next</button>
+ * </template>
+ * ```
+ */
+declare function usePagination<Z extends PaginationItem = PaginationItem, E extends PaginationContext<Z> = PaginationContext<Z>>(namespace?: string): E;
+//#endregion
+//#region src/composables/useSingle/index.d.ts
+interface SingleTicket<V = unknown> extends SelectionTicket<V> {}
+interface SingleContext<Z extends SingleTicket> extends SelectionContext<Z> {
+  selectedId: ComputedRef<ID | undefined>;
+  selectedIndex: ComputedRef<number>;
+  selectedItem: ComputedRef<Z | undefined>;
+  selectedValue: ComputedRef<Z['value'] | undefined>;
+}
+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
- * 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.
+ * **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)
  *
- * @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
- * @see https://0.vuetifyjs.com/composables/foundation/create-context#provide-context
+ * **Inheritance Chain:**
+ * `useRegistry` → `createSelection` → `createSingle` → `createStep`
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-single
  *
  * @example
  * ```ts
- * // Component-level provision
- * provideContext<MyContext>('my-context', context)
+ * import { createSingle } from '@vuetify/v0'
+ *
+ * const tabs = createSingle({ mandatory: true })
  *
- * // App-level provision (typically used in plugins)
- * const app = createApp()
- * provideContext<MyContext>('my-context', context, app)
+ * 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 provideContext<Z>(key: ContextKey<Z>, context: Z, app?: App): Z;
+declare function createSingle<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(_options?: SingleOptions): E;
 /**
- * Creates a new context for providing and injecting data.
+ * Creates a new single selection context.
  *
- * @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.
+ * @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'
+ *
+ * // With default namespace 'v0:single'
+ * export const [useSingle, provideSingle, context] = createSingleContext()
+ *
+ * // In a parent component:
+ * provideSingle()
+ *
+ * // In a child component:
+ * const single = useSingle()
+ * single.select('tab-1')
+ * ```
+ */
+declare function createSingleContext<Z extends 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/useStep/index.d.ts
+interface StepTicket<V = unknown> extends SingleTicket<V> {}
+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)
  *
- * @see https://vuejs.org/api/composition-api-dependency-injection.html
- * @see https://0.vuetifyjs.com/composables/foundation/create-context#create-context
+ * **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
- * // Without default value
- * const [useMyContext, provideMyContext] = createContext<MyContext>('my-context')
+ * 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 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.
  *
- * // With default value
- * const [useMyContext, provideMyContext] = createContext<MyContext>('my-context', defaultContext)
+ * @see https://0.vuetifyjs.com/composables/selection/use-step
+ *
+ * @example
+ * ```ts
+ * import { createStepContext } from '@vuetify/v0'
+ *
+ * // With default namespace 'v0:step'
+ * export const [useStep, provideStep, context] = createStepContext()
+ *
+ * // In a parent component:
+ * provideStep()
+ *
+ * // In a child component:
+ * const context = useStep()
+ * context.next() // Progress to next step
+ * ```
+ */
+declare function createStepContext<Z extends 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 createContext<Z>(_key: ContextKey<Z>, defaultValue?: Z): readonly [(key?: ContextKey<Z>) => Z & ({} | null), (context: Z, app?: App) => Z];
+declare function useStep<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(namespace?: string): E;
 //#endregion
-export { useRegistry as _, SelectionContext as a, SelectionTicket as c, useSelection as d, RegistryContext as f, createRegistryContext as g, RegistryTicket as h, useContext as i, createSelection as l, RegistryOptions as m, createContext as n, SelectionContextOptions as o, RegistryContextOptions as p, provideContext as r, SelectionOptions as s, ContextKey as t, createSelectionContext as u, ContextTrinity as v, createTrinity as y };
+export { SelectionContextOptions as A, createRegistryContext as B, GroupContextOptions as C, createGroupContext as D, createGroup as E, useSelection as F, ContextTrinity as H, RegistryContext as I, RegistryContextOptions as L, SelectionTicket as M, createSelection as N, useGroup as O, createSelectionContext as P, RegistryOptions as R, GroupContext as S, GroupTicket as T, createTrinity as U, useRegistry as V, PaginationItem as _, createStep as a, createPaginationContext as b, SingleContext as c, SingleTicket as d, createSingle as f, PaginationContextOptions as g, PaginationContext as h, StepTicket as i, SelectionOptions as j, SelectionContext as k, SingleContextOptions as l, useSingle as m, StepContextOptions as n, createStepContext as o, createSingleContext as p, StepOptions as r, useStep as s, StepContext as t, SingleOptions as u, PaginationOptions as v, GroupOptions as w, usePagination as x, createPagination as y, RegistryTicket as z };