@vuetify/v0 0.1.5 → 0.1.6

package/dist/{index-BTMzRHep.d.mts → index-De0SQt1w.d.mts}

@@ -1,5 +1,5 @@
 import { i as Extensible, o as ID, s as MaybeArray } from "./index-BFBN5Zl3.mjs";
-import { E as ContextTrinity } from "./adapter-D2JoR-4d.mjs";
+import { E as ContextTrinity } from "./adapter-CLs-OrSN.mjs";
 import { t as DateAdapter } from "./adapter-DcwxFryd.mjs";
 import { n as FeaturesAdapterFlags, r as FeaturesAdapterInterface } from "./index-BuOz3Rgm.mjs";
 import { n as LocaleAdapter } from "./v0-DHMoZ7dS.mjs";
@@ -352,6 +352,36 @@ interface RegistryContext<Z extends RegistryTicketInput = RegistryTicketInput, E
    * const cherry = registry.seek('first', 1, ticket => (ticket.value as string).startsWith('c'))
    * ```
   */
+  /**
+   * Move a ticket to a new index position
+   *
+   * @param id The ID of the ticket to move.
+   * @param toIndex The target index position. Clamped to valid range.
+   * @returns The moved ticket, or undefined if the ticket was not found.
+   *
+   * @remarks Rebuilds the internal collection order by removing and reinserting the entry at the target position. Triggers a full reindex after the move. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/create-registry#move
+   *
+   * @example
+   * ```ts
+   * import { createRegistry } from '@vuetify/v0'
+   *
+   * const registry = createRegistry()
+   *
+   * registry.onboard([
+   *   { id: 'a', value: 'alpha' },
+   *   { id: 'b', value: 'beta' },
+   *   { id: 'c', value: 'gamma' },
+   * ])
+   *
+   * // Move 'a' from index 0 to index 2
+   * registry.move('a', 2)
+   *
+   * console.log(registry.keys()) // ['b', 'c', 'a']
+   * ```
+  */
+  move: (id: ID, toIndex: number) => E | undefined;
   seek: (direction?: 'first' | 'last', from?: number, predicate?: (ticket: E) => boolean) => E | undefined;
   /**
    * Listen for registry events
@@ -672,6 +702,323 @@ declare function createRegistryContext<Z extends RegistryTicketInput = RegistryT
  */
 declare function useRegistry<Z extends RegistryTicketInput = RegistryTicketInput, E extends RegistryTicket & Z = RegistryTicket & Z>(namespace?: string): RegistryContext<Z, E>;
 //#endregion
+//#region src/composables/createModel/index.d.ts
+/**
+ * Input type for model tickets - what users provide to register().
+ *
+ * @template V The type of the ticket value.
+ */
+interface ModelTicketInput<V = unknown> extends RegistryTicketInput<V> {
+  /** Disabled state of the ticket (optional on input, defaults to false) */
+  disabled?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * Output type for model tickets - what users receive from get().
+ *
+ * @template Z The input ticket type that extends ModelTicketInput.
+ */
+type ModelTicket<Z extends ModelTicketInput = ModelTicketInput> = RegistryTicket & Z & {
+  /** Disabled state of the ticket (guaranteed to exist on output) */
+  disabled: MaybeRefOrGetter<boolean>;
+  /** Whether the ticket is currently selected */
+  isSelected: Readonly<Ref<boolean, boolean>>;
+};
+/**
+ * Context returned by createModel.
+ *
+ * @template Z The input ticket type (what users provide to register).
+ * @template E The output ticket type (what users receive from get). Defaults to ModelTicket<Z>.
+ */
+interface ModelContext<Z extends ModelTicketInput = ModelTicketInput, E extends ModelTicket<Z> = ModelTicket<Z>> extends Omit<RegistryContext<Z, E>, 'register'> {
+  /**
+   * Set of currently selected ticket IDs
+   *
+   * @remarks Reactive via `shallowReactive(new Set())`. Mutating this Set directly is supported —
+   * `selectedItems` and `selectedValues` will update accordingly. Ghost IDs (IDs not in the registry)
+   * are silently filtered out by the computed properties.
+   *
+   * @example
+   * ```ts
+   * const model = createModel()
+   * model.register({ id: 'a', value: 'Apple' })
+   * console.log(model.selectedIds.has('a')) // true (enrolled on register)
+   * ```
+   */
+  selectedIds: Reactive<Set<ID>>;
+  /**
+   * Computed Set of selected ticket instances
+   *
+   * @remarks Derived from `selectedIds`. Maps each ID to its ticket via `registry.get()` and
+   * filters out any IDs that no longer exist in the registry.
+   *
+   * @example
+   * ```ts
+   * const model = createModel()
+   * model.register({ id: 'a', value: 'Apple' })
+   * model.select('a')
+   * const items = Array.from(model.selectedItems.value)
+   * console.log(items[0].id) // 'a'
+   * ```
+   */
+  selectedItems: ComputedRef<Set<E>>;
+  /**
+   * Computed Set of selected ticket values
+   *
+   * @remarks Derived from `selectedItems`. Unwraps ref values via `toValue()` — if a ticket's
+   * value is `ref('Apple')`, the Set contains `'Apple'`, not the Ref wrapper.
+   *
+   * @example
+   * ```ts
+   * import { shallowRef } from 'vue'
+   * import { createModel } from '@vuetify/v0'
+   *
+   * const model = createModel()
+   * model.register({ id: 'a', value: shallowRef('Apple') })
+   * model.select('a')
+   * console.log([...model.selectedValues.value]) // ['Apple']
+   * ```
+   */
+  selectedValues: ComputedRef<Set<E['value'] extends Ref<infer U> ? U : E['value']>>;
+  /**
+   * Disabled state for the entire model instance
+   *
+   * @remarks When truthy, all selection operations (`select`, `unselect`, `toggle`) are silently
+   * skipped. Accepts a static boolean, a ref, or a getter for reactive disabled state.
+   *
+   * @see https://0.vuetifyjs.com/composables/selection/create-model
+   */
+  disabled: MaybeRefOrGetter<boolean>;
+  /**
+   * Reset selection state without destroying the registry
+   *
+   * @remarks Clears `selectedIds` only — registered tickets are preserved.
+   * Use `clear()` to destroy both selection state and the registry.
+   *
+   * @example
+   * ```ts
+   * const model = createModel()
+   * model.register({ id: 'a', value: 'Apple' })
+   * model.select('a')
+   * model.reset()
+   * console.log(model.size) // 1 (tickets preserved)
+   * console.log(model.selectedIds.size) // 0
+   * ```
+   */
+  reset: () => void;
+  /**
+   * Select a ticket by ID
+   *
+   * @param id The ID of the ticket to select.
+   * @remarks When `multiple` is `false` (default), clears `selectedIds` before adding the new ID.
+   * When `multiple` is `true`, accumulates without clearing.
+   * No-op if the model instance is disabled, the ticket doesn't exist, or the ticket is disabled.
+   *
+   * @see https://0.vuetifyjs.com/composables/selection/create-model
+   *
+   * @example
+   * ```ts
+   * const model = createModel()
+   * model.register({ id: 'a', value: 'Apple' })
+   * model.register({ id: 'b', value: 'Banana' })
+   * model.select('a')
+   * model.select('b') // clears 'a', selects 'b'
+   * console.log(model.selectedIds.size) // 1
+   * ```
+   */
+  select: (id: ID) => void;
+  /**
+   * Unselect a ticket by ID
+   *
+   * @param id The ID of the ticket to unselect.
+   * @remarks Removes the ID from `selectedIds`. No-op if the model instance is disabled.
+   *
+   * @example
+   * ```ts
+   * model.select('a')
+   * model.unselect('a')
+   * console.log(model.selectedIds.size) // 0
+   * ```
+   */
+  unselect: (id: ID) => void;
+  /**
+   * Toggle a ticket's selection state
+   *
+   * @param id The ID of the ticket to toggle.
+   * @remarks Calls `select(id)` if not selected, `unselect(id)` if already selected.
+   * No-op if the model instance is disabled.
+   *
+   * @example
+   * ```ts
+   * model.toggle('a') // selects
+   * model.toggle('a') // unselects
+   * ```
+   */
+  toggle: (id: ID) => void;
+  /**
+   * Check if a ticket is currently selected
+   *
+   * @param id The ID of the ticket to check.
+   * @returns `true` if the ID is in `selectedIds`.
+   *
+   * @example
+   * ```ts
+   * model.select('a')
+   * console.log(model.selected('a')) // true
+   * console.log(model.selected('b')) // false
+   * ```
+   */
+  selected: (id: ID) => boolean;
+  /**
+   * Apply external values to the model
+   *
+   * @param values Array of values to apply. Only `values[0]` is used (single-value store).
+   * @param options Options for API compatibility with createSelection. The `multiple` field is accepted but ignored.
+   * @remarks Used internally by `useProxyModel` to sync a ref with the model. Executes two steps sequentially:
+   * 1. **Ref write**: Writes `values[0]` to any selected ticket whose value is a ref.
+   * 2. **Browse resolution**: Clears `selectedIds`, resolves `values[0]` via `registry.browse()`, and selects the match.
+   *
+   * For ref-valued tickets, browse typically finds no match (the catalog indexes by the ref object,
+   * not the unwrapped value), so `selectedIds` will be empty after apply.
+   *
+   * @see https://0.vuetifyjs.com/composables/selection/create-model
+   *
+   * @example
+   * ```ts
+   * import { shallowRef } from 'vue'
+   * import { createModel } from '@vuetify/v0'
+   *
+   * const value = shallowRef('Apple')
+   * const model = createModel()
+   * model.register({ id: 'fruit', value }) // enrolled automatically
+   *
+   * model.apply(['Banana']) // value.value is now 'Banana'
+   * ```
+   */
+  apply: (values: unknown[], options?: {
+    multiple?: boolean;
+  }) => void;
+  /**
+   * Register a new ticket
+   *
+   * @param ticket Partial ticket data. ID is auto-generated if not provided. Disabled defaults to `false`.
+   * @returns The registered ticket with `isSelected` computed ref attached.
+   * @remarks Delegates to `registry.register()` after adding model-specific fields (`disabled`, `isSelected`).
+   *
+   * @see https://0.vuetifyjs.com/composables/selection/create-model
+   *
+   * @example
+   * ```ts
+   * import { shallowRef } from 'vue'
+   * import { createModel } from '@vuetify/v0'
+   *
+   * const model = createModel()
+   * const ticket = model.register({ id: 'fruit', value: shallowRef('Apple') })
+   *
+   * console.log(ticket.id) // 'fruit'
+   * console.log(ticket.isSelected.value) // true (enrolled by default)
+   * console.log(ticket.disabled) // false
+   * ```
+   */
+  register: (registration?: Partial<Z>) => E;
+  /**
+   * Onboard multiple tickets at once
+   *
+   * @param registrations An array of partial ticket data to register.
+   * @returns The registered tickets with model-specific fields attached.
+   * @remarks Delegates to the model's `register` (not the registry's) so each ticket
+   * receives `disabled` and `isSelected`. Runs inside `registry.batch()` for performance.
+   */
+  onboard: (registrations: Partial<Z>[]) => E[];
+}
+interface ModelOptions extends RegistryOptions {
+  /**
+   * Disabled state for the entire model instance
+   *
+   * @default false
+   * @remarks When truthy, all selection operations are silently skipped. Accepts a static
+   * boolean, a ref, or a getter for reactive disabled state.
+   *
+   * @example
+   * ```ts
+   * import { createModel } from '@vuetify/v0'
+   *
+   * // Static
+   * const model = createModel({ disabled: true })
+   *
+   * // Reactive
+   * const disabled = ref(false)
+   * const model = createModel({ disabled })
+   * ```
+   */
+  disabled?: MaybeRefOrGetter<boolean>;
+  /**
+   * Auto-select tickets on registration
+   *
+   * @default true
+   * @remarks When truthy, newly registered tickets are automatically selected via `select()`,
+   * subject to disabled guards (both instance-level and ticket-level). With single-value
+   * semantics, only the most recently registered ticket remains active.
+   *
+   * `createSelection` overrides this to `false` and handles enrollment with its own
+   * `multiple`-aware logic.
+   */
+  enroll?: MaybeRefOrGetter<boolean>;
+  /**
+   * Allow multiple tickets to be selected simultaneously
+   *
+   * @default false
+   * @remarks When `true`, `select()` accumulates IDs instead of clearing before adding.
+   * Used by createSlider where all thumbs must stay selected.
+   */
+  multiple?: MaybeRefOrGetter<boolean>;
+}
+/**
+ * Creates a new model instance for storing a single value.
+ *
+ * @param options The options for the model instance.
+ * @template Z The input ticket type. Extend {@link ModelTicketInput} to add custom properties.
+ * @template E The output ticket type. Automatically includes `disabled` and `isSelected`.
+ * @template R The context type. Defaults to {@link ModelContext}<Z, E>.
+ * @returns A new model instance with selection tracking and disabled guards.
+ *
+ * @remarks
+ * Extends createRegistry with value tracking via a reactive Set of selected IDs.
+ * Provides the shared model-value concept used by both Selection and Slider.
+ *
+ * **Enrollment**: Tickets are auto-selected on registration by default (`enroll: true`).
+ * With single-value semantics, only the most recently registered ticket is active.
+ * Pass `enroll: false` to opt out. `createSelection` overrides this to `false`.
+ *
+ * **Apply bridge**: `useProxyModel` calls `apply()` to sync a ref with the model.
+ * When the active ticket's value is a ref, `apply` writes to it directly. Otherwise,
+ * it resolves via `registry.browse()`.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/create-model
+ *
+ * @example
+ * ```ts
+ * import { shallowRef } from 'vue'
+ * import { createModel, useProxyModel } from '@vuetify/v0'
+ *
+ * const value = shallowRef('Apple')
+ * const model = createModel({ events: true })
+ *
+ * model.register({ id: 'fruit', value })
+ * useProxyModel(model, value)
+ *
+ * // value and model stay in sync bidirectionally
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Disabled model — all selection operations are no-ops
+ * const model = createModel({ disabled: true })
+ * model.register({ id: 'a', value: shallowRef('Apple') })
+ * model.select('a') // no-op
+ * ```
+ */
+declare function createModel<Z extends ModelTicketInput = ModelTicketInput, E extends ModelTicket<Z> = ModelTicket<Z>, R extends ModelContext<Z, E> = ModelContext<Z, E>>(_options?: ModelOptions): R;
+//#endregion
 //#region src/composables/createSelection/index.d.ts
 /**
  * Input type for selection tickets - what users provide to register().
@@ -691,10 +1038,7 @@ declare function useRegistry<Z extends RegistryTicketInput = RegistryTicketInput
  * selection.register({ label: 'Item 1' })
  * ```
  */
-interface SelectionTicketInput<V = unknown> extends RegistryTicketInput<V> {
-  /** Disabled state of the ticket (optional on input, defaults to false) */
-  disabled?: MaybeRef<boolean>;
-}
+interface SelectionTicketInput<V = unknown> extends ModelTicketInput<V> {}
 /**
  * Output type for selection tickets - what users receive from get().
  * Includes registry-added methods for self-selection.
@@ -709,11 +1053,7 @@ interface SelectionTicketInput<V = unknown> extends RegistryTicketInput<V> {
  * - `unselect()` - Method to unselect this ticket
  * - `toggle()` - Method to toggle selection state
  */
-type SelectionTicket<Z extends SelectionTicketInput = SelectionTicketInput> = RegistryTicket & Z & {
-  /** Disabled state of the ticket (guaranteed to exist on output) */
-  disabled: MaybeRef<boolean>;
-  /** Whether the ticket is currently selected */
-  isSelected: Readonly<Ref<boolean, boolean>>;
+type SelectionTicket<Z extends SelectionTicketInput = SelectionTicketInput> = ModelTicket<Z> & {
   /** Select self */
   select: () => void;
   /** Unselect self */
@@ -727,49 +1067,36 @@ type SelectionTicket<Z extends SelectionTicketInput = SelectionTicketInput> = Re
  * @template Z The input ticket type (what users provide to register).
  * @template E The output ticket type (what users receive from get). Defaults to SelectionTicket<Z>.
  */
-interface SelectionContext<Z extends SelectionTicketInput = SelectionTicketInput, E extends SelectionTicket<Z> = SelectionTicket<Z>> extends Omit<RegistryContext<E>, 'register' | 'onboard'> {
-  /** Set of selected ticket IDs */
-  selectedIds: Reactive<Set<ID>>;
-  /** Set of selected ticket instances */
-  selectedItems: ComputedRef<Set<E>>;
-  /** Set of selected ticket values */
-  selectedValues: ComputedRef<Set<unknown>>;
-  /** Disable state for the entire selection instance */
-  disabled: MaybeRef<boolean>;
-  /** Clear all selected IDs and reindexes */
-  reset: () => void;
-  /** Select a ticket by ID (Toggle ON) */
-  select: (id: ID) => void;
-  /** Unselect a ticket by ID (Toggle OFF) */
-  unselect: (id: ID) => void;
-  /** Toggles a ticket ON and OFF by ID */
-  toggle: (id: ID) => void;
-  /** Check if a ticket is selected by ID */
-  selected: (id: ID) => boolean;
-  /** Mandates selected ID based on "mandatory" Option */
-  mandate: () => void;
+interface SelectionContext<Z extends SelectionTicketInput = SelectionTicketInput, E extends SelectionTicket<Z> = SelectionTicket<Z>> extends Omit<ModelContext<Z, E>, 'register'> {
+  /** Whether the selection allows multiple selections */
+  multiple: MaybeRefOrGetter<boolean>;
   /** Register a new ticket (accepts input type, returns output type) */
   register: (ticket?: Partial<Z>) => E;
   /** Onboard multiple tickets at once */
   onboard: (registrations: Partial<Z>[]) => E[];
+  /** Mandate selected ID based on "mandatory" option */
+  mandate: () => void;
+  /** Seek for the first/last non-disabled ticket */
+  seek: (direction?: 'first' | 'last', from?: number) => E | undefined;
 }
-interface SelectionOptions extends RegistryOptions {
-  /** When true, the entire selection instance is disabled. */
-  disabled?: MaybeRefOrGetter<boolean>;
-  /**
-   * When true, newly registered items are automatically selected if not disabled.
-   * Useful for pre-selecting items in multi-select scenarios.
-   */
-  enroll?: MaybeRefOrGetter<boolean>;
+interface SelectionOptions extends ModelOptions {
   /**
    * Controls mandatory selection behavior:
    * - `false` (default): No mandatory selection enforcement
-   * - `true`: Prevents deselecting the last selected item (user must always have one selected)
+   * - `true`: Prevents deselecting the last selected item
    * - `'force'`: Automatically selects the first non-disabled item on registration
    */
   mandatory?: MaybeRefOrGetter<boolean | 'force'>;
   /** When true, treats the selection as an array */
   multiple?: MaybeRefOrGetter<boolean>;
+  /**
+   * Auto-select tickets on registration
+   *
+   * @default false
+   * @remarks Overrides createModel's default of `true`. When truthy, newly registered
+   * items are automatically selected if not disabled. Respects `multiple` mode.
+   */
+  enroll?: MaybeRefOrGetter<boolean>;
 }
 interface SelectionContextOptions extends SelectionOptions {
   namespace?: string;
@@ -777,7 +1104,8 @@ interface SelectionContextOptions extends SelectionOptions {
 /**
  * Creates a new selection instance for managing multiple selected items.
  *
- * Extends `useRegistry` with selection tracking via a reactive `Set` of selected IDs.
+ * Extends `createModel` with multi-select, mandatory enforcement,
+ * auto-enrollment, and ticket self-methods.
  * Supports disabled items, mandatory selection enforcement, and auto-enrollment.
  *
  * @param options The options for the selection instance.
@@ -798,7 +1126,7 @@ interface SelectionContextOptions extends SelectionOptions {
  * - Enroll option auto-selects all non-disabled items on registration
  *
  * **Inheritance Chain:**
- * `useRegistry` → `createSelection` → `createSingle`/`createGroup` → `createStep`
+ * `createRegistry` → `createModel` → `createSelection` → `createSingle`/`createGroup` → `createStep`
  *
  * @see https://0.vuetifyjs.com/composables/selection/use-selection
  *
@@ -1165,7 +1493,7 @@ declare function useBreadcrumbs<Z extends BreadcrumbTicketInput = BreadcrumbTick
  */
 interface GroupTicketInput<V = unknown> extends SelectionTicketInput<V> {
   /** Whether the ticket should start in mixed/indeterminate state */
-  indeterminate?: MaybeRef<boolean>;
+  indeterminate?: MaybeRefOrGetter<boolean>;
 }
 /**
  * Output type for group tickets.
@@ -1782,12 +2110,17 @@ interface BreakpointsContext {
   lgAndDown: Readonly<ShallowRef<boolean>>;
   xlAndDown: Readonly<ShallowRef<boolean>>;
   xxlAndDown: Readonly<ShallowRef<boolean>>;
+  ssr: boolean;
   update: () => void;
 }
 interface BreakpointsOptions {
   namespace?: string;
   mobileBreakpoint?: BreakpointName | number;
   breakpoints?: Partial<Record<BreakpointName, number>>;
+  ssr?: {
+    clientWidth: number;
+    clientHeight?: number;
+  };
 }
 interface BreakpointsPluginOptions extends BreakpointsOptions {}
 interface BreakpointsContextOptions extends BreakpointsOptions {}
@@ -3607,12 +3940,27 @@ interface ProxyModelOptions {
   transformOut?: (val: unknown) => unknown;
 }
 /**
- * Syncs a ref with a selection registry bidirectionally.
+ * Minimal interface for useProxyModel's context parameter.
+ * Both ModelContext (Set-based) and SliderContext (Array-based) satisfy this.
+ */
+interface ProxyModelTarget {
+  selectedValues: {
+    readonly value: Iterable<unknown>;
+  };
+  apply: (values: unknown[], options?: {
+    multiple?: boolean;
+  }) => void;
+  select?: (id: string | number) => void;
+  multiple?: MaybeRefOrGetter<boolean>;
+  on?: (event: string, cb: (data: unknown) => void) => void;
+  off?: (event: string, cb: (data: unknown) => void) => void;
+}
+/**
+ * Syncs a ref with a model context bidirectionally.
  *
- * @param registry The selection registry to bind to.
+ * @param context The model context to bind to.
  * @param model The ref to sync.
  * @param options The options for the proxy model.
- * @template Z The type of the selection ticket.
  * @returns A function to stop the sync.
  *
  * @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
@@ -3631,7 +3979,7 @@ interface ProxyModelOptions {
  * const stop = useProxyModel(registry, model)
  * ```
  */
-declare function useProxyModel<Z extends SelectionTicket = SelectionTicket>(registry: SelectionContext<Z>, model: Ref<unknown>, options?: ProxyModelOptions): () => void;
+declare function useProxyModel(context: ProxyModelTarget, model: Ref<unknown>, options?: ProxyModelOptions): () => void;
 //#endregion
 //#region src/composables/useProxyRegistry/index.d.ts
 interface ProxyRegistryOptions {
@@ -3648,7 +3996,8 @@ interface ProxyRegistryContext<Z extends RegistryTicket = RegistryTicket> {
  *
  * @param registry The registry instance to proxy.
  * @param options The options for the proxy registry.
- * @template Z The type of the registry ticket.
+ * @template Z The input ticket type (what users provide to register).
+ * @template E The output ticket type (what users receive from get/values).
  * @returns A proxy registry with reactive objects.
  *
  * @see https://0.vuetifyjs.com/composables/registration/use-proxy-registry
@@ -3664,7 +4013,7 @@ interface ProxyRegistryContext<Z extends RegistryTicket = RegistryTicket> {
  * console.log(proxy.size) // 1
  * ```
  */
-declare function useProxyRegistry<Z extends RegistryTicket = RegistryTicket>(registry: RegistryContext<Z>, options?: ProxyRegistryOptions): ProxyRegistryContext<Z>;
+declare function useProxyRegistry<Z extends RegistryTicketInput = RegistryTicketInput, E extends RegistryTicket & Z = RegistryTicket & Z>(registry: RegistryContext<Z, E>, options?: ProxyRegistryOptions): ProxyRegistryContext<E>;
 //#endregion
 //#region src/composables/createQueue/index.d.ts
 /**
@@ -4065,6 +4414,406 @@ interface UseElementSizeReturn extends UseResizeObserverReturn {
  */
 declare function useElementSize(target: MaybeElementRef): UseElementSizeReturn;
 //#endregion
+//#region src/composables/createSlider/index.d.ts
+interface SliderTicketInput extends ModelTicketInput<ShallowRef<number>> {
+  value: ShallowRef<number>;
+}
+/**
+ * Configuration options for createSlider.
+ *
+ * @see https://0.vuetifyjs.com/composables/forms/create-slider
+ */
+interface SliderOptions {
+  /**
+   * Minimum value.
+   * @default 0
+   */
+  min?: number;
+  /**
+   * Maximum value.
+   * @default 100
+   */
+  max?: number;
+  /**
+   * Step increment. Values are snapped to the nearest multiple of `step` above `min`.
+   *
+   * @remarks Use decimal steps for fine-grained control (e.g., `0.1` for a media scrubber).
+   * A step of `0` disables snapping — values are only clamped to min/max.
+   *
+   * @default 1
+   */
+  step?: number;
+  /**
+   * Whether the slider is disabled.
+   *
+   * @remarks Accepts a reactive getter or ref. When disabled, all thumb operations (`set`, `up`, `down`) are no-ops.
+   */
+  disabled?: MaybeRefOrGetter<boolean>;
+  /**
+   * Whether the slider is readonly (focusable but not editable).
+   *
+   * @remarks Thumbs can receive focus for accessibility, but `set`, `up`, `down`, `floor`, and `ceil` are no-ops.
+   */
+  readonly?: MaybeRefOrGetter<boolean>;
+  /**
+   * Slider orientation.
+   *
+   * @remarks Affects `fromValue` and `fromPercent` axis mapping in Slider components.
+   * When using createSlider standalone, orientation is informational only.
+   */
+  orientation?: MaybeRefOrGetter<'horizontal' | 'vertical'>;
+  /**
+   * Flip the percent axis.
+   *
+   * @remarks When `true`, `fromValue(min)` returns `100` and `fromValue(max)` returns `0`.
+   * Useful for vertical sliders where the visual bottom is the minimum.
+   */
+  inverted?: MaybeRefOrGetter<boolean>;
+  /**
+   * Minimum steps required between adjacent thumbs.
+   *
+   * @remarks Enforced by `set` and `apply`. The gap in value units is `minStepsBetweenThumbs * step`.
+   *
+   * @default 0
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ step: 5, minStepsBetweenThumbs: 2 })
+   * // Thumbs must be at least 10 units apart (2 × 5)
+   * ```
+   */
+  minStepsBetweenThumbs?: number;
+  /**
+   * Allow thumbs to pass through each other.
+   *
+   * @remarks When `false` (default), `set` constrains values so thumbs maintain their order.
+   * When `true`, thumbs can freely overlap and swap positions.
+   *
+   * @default false
+   */
+  crossover?: boolean;
+  /**
+   * Range mode — expects two thumbs.
+   *
+   * @remarks Informational flag used by Slider components to adjust track/range rendering.
+   * Does not enforce the number of registered thumbs.
+   *
+   * @default false
+   */
+  range?: boolean;
+}
+/**
+ * Context returned by {@link createSlider}.
+ *
+ * @remarks
+ * Extends `createModel` with slider-specific math and thumb operations.
+ *
+ * **Inheritance chain:**
+ * `createRegistry` → `createModel` → `createSlider`
+ *
+ * **Ticket-per-thumb model:**
+ * Each thumb is a model ticket whose value is a `shallowRef<number>`.
+ * `values` is derived from the ordered tickets, not a standalone ref.
+ * Register/unregister thumbs to add/remove values dynamically.
+ *
+ * @see https://0.vuetifyjs.com/composables/forms/create-slider
+ * @see {@link createModel} for the base model API (collection, selectedIds, etc.)
+ */
+interface SliderContext extends Omit<ModelContext<SliderTicketInput, ModelTicket<SliderTicketInput>>, 'values' | 'selectedValues' | 'apply' | 'disabled' | 'register'> {
+  /**
+   * Ordered thumb values derived from model tickets.
+   *
+   * @remarks Reactive — updates when any thumb's `shallowRef<number>` changes.
+   * Order matches ticket registration order (sorted by index).
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider()
+   * slider.register({ value: 25 })
+   * slider.register({ value: 75 })
+   * console.log(slider.values.value) // [25, 75]
+   * ```
+   */
+  values: ComputedRef<number[]>;
+  /**
+   * Alias for `values` — provides useProxyModel compatibility.
+   *
+   * @remarks Returns an array (not a Set) to preserve duplicate values across thumbs.
+   *
+   * @see {@link values}
+   */
+  selectedValues: ComputedRef<number[]>;
+  /**
+   * Apply external values — snaps, constrains, and writes to ticket refs.
+   *
+   * @param values Array of raw values (coerced to numbers).
+   * @param options Options object (reserved for useProxyModel compatibility).
+   *
+   * @remarks
+   * If no thumbs are registered yet, values are stored as pending and
+   * consumed as thumbs register. Each value is snapped to step and
+   * constrained by `minStepsBetweenThumbs`.
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ step: 10 })
+   * slider.register({ value: 0 })
+   * slider.register({ value: 0 })
+   * slider.apply([33, 67]) // values: [30, 70]
+   * ```
+   */
+  apply: (values: unknown[], options?: {
+    multiple?: boolean;
+  }) => void;
+  /** Whether disabled. Reactive ref derived from the `disabled` option. */
+  disabled: Readonly<Ref<boolean>>;
+  /** Whether readonly. Reactive ref derived from the `readonly` option. */
+  readonly: Readonly<Ref<boolean>>;
+  /** Slider orientation. Reactive ref derived from the `orientation` option. */
+  orientation: Readonly<Ref<'horizontal' | 'vertical'>>;
+  /** Whether inverted. Reactive ref derived from the `inverted` option. */
+  inverted: Readonly<Ref<boolean>>;
+  /** Minimum value. */
+  readonly min: number;
+  /** Maximum value. */
+  readonly max: number;
+  /** Step increment. */
+  readonly step: number;
+  /** Minimum steps required between adjacent thumbs. */
+  readonly minStepsBetweenThumbs: number;
+  /** Whether thumbs can cross each other. */
+  readonly crossover: boolean;
+  /** Whether this is a range slider. */
+  readonly range: boolean;
+  /**
+   * Register a new thumb and return its ticket.
+   *
+   * @param input Starting value as a number or `{ value }` object. Defaults to `min`.
+   *
+   * @remarks
+   * The thumb is automatically selected in the model (all thumbs stay selected).
+   * If `apply` was called before any thumbs registered, the pending value at this
+   * thumb's index is used instead of the provided value.
+   *
+   * @see {@link unregister}
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ min: 0, max: 100 })
+   * const thumb = slider.register({ value: 50 })
+   * console.log(thumb.index) // 0
+   * console.log(slider.values.value) // [50]
+   * ```
+   */
+  register: (input?: number | {
+    value: number;
+  }) => ModelTicket<SliderTicketInput>;
+  /**
+   * Unregister a thumb by ticket ID.
+   *
+   * @param id The ticket ID returned from `register()`.
+   *
+   * @see {@link register}
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider()
+   * const thumb = slider.register({ value: 50 })
+   * slider.unregister(thumb.id) // values: []
+   * ```
+   */
+  unregister: (id: ID) => void;
+  /**
+   * Round a value to the nearest step, clamped to min/max.
+   *
+   * @param value Raw value to snap.
+   * @returns Snapped value.
+   *
+   * @remarks Pure function — does not modify slider state.
+   * When `step` is `0`, only clamps without snapping.
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ min: 0, max: 100, step: 5 })
+   * slider.snap(47) // 45
+   * slider.snap(48) // 50
+   * slider.snap(-5) // 0  (clamped)
+   * ```
+   */
+  snap: (value: number) => number;
+  /**
+   * Convert a value to a 0–100 percentage.
+   *
+   * @param value The slider value to convert.
+   * @returns Percentage between 0 and 100.
+   *
+   * @remarks Pure function. Respects `inverted` — when inverted,
+   * `fromValue(min)` returns `100` and `fromValue(max)` returns `0`.
+   *
+   * @see {@link fromPercent} for the inverse operation.
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ min: 0, max: 200 })
+   * slider.fromValue(100) // 50
+   * slider.fromValue(0)   // 0
+   * slider.fromValue(200) // 100
+   * ```
+   */
+  fromValue: (value: number) => number;
+  /**
+   * Convert a 0–100 percentage to a snapped value.
+   *
+   * @param percent Percentage between 0 and 100.
+   * @returns Snapped slider value.
+   *
+   * @remarks Pure function. Respects `inverted`. The returned value
+   * is snapped to the nearest step and clamped to min/max.
+   *
+   * @see {@link fromValue} for the inverse operation.
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ min: 0, max: 100, step: 10 })
+   * slider.fromPercent(33) // 30
+   * slider.fromPercent(50) // 50
+   * ```
+   */
+  fromPercent: (percent: number) => number;
+  /**
+   * Set the value at a thumb index with step snapping and neighbor constraints.
+   *
+   * @param index Zero-based thumb index.
+   * @param value Raw value to set.
+   *
+   * @remarks
+   * No-op when `readonly` is `true`. The value is snapped to step, clamped to min/max,
+   * and constrained by adjacent thumbs when `crossover` is `false`.
+   *
+   * @see {@link up} and {@link down} for relative adjustments.
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ min: 0, max: 100, step: 5 })
+   * slider.register({ value: 50 })
+   * slider.set(0, 73) // values: [75] (snapped)
+   * ```
+   */
+  set: (index: number, value: number) => void;
+  /**
+   * Increment a thumb's value by `step × multiplier`.
+   *
+   * @param index Zero-based thumb index.
+   * @param multiplier Number of steps to increment. Defaults to `1`.
+   *
+   * @see {@link down} for the inverse. {@link set} for absolute positioning.
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ min: 0, max: 100, step: 5 })
+   * slider.register({ value: 50 })
+   * slider.up(0)     // values: [55]
+   * slider.up(0, 3)  // values: [70]
+   * ```
+   */
+  up: (index: number, multiplier?: number) => void;
+  /**
+   * Decrement a thumb's value by `step × multiplier`.
+   *
+   * @param index Zero-based thumb index.
+   * @param multiplier Number of steps to decrement. Defaults to `1`.
+   *
+   * @see {@link up} for the inverse. {@link set} for absolute positioning.
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ min: 0, max: 100, step: 5 })
+   * slider.register({ value: 50 })
+   * slider.down(0)     // values: [45]
+   * slider.down(0, 3)  // values: [30]
+   * ```
+   */
+  down: (index: number, multiplier?: number) => void;
+  /**
+   * Set a thumb to the minimum value.
+   *
+   * @param index Zero-based thumb index.
+   *
+   * @see {@link ceil} for the inverse.
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ min: 10, max: 90 })
+   * slider.register({ value: 50 })
+   * slider.floor(0) // values: [10]
+   * ```
+   */
+  floor: (index: number) => void;
+  /**
+   * Set a thumb to the maximum value.
+   *
+   * @param index Zero-based thumb index.
+   *
+   * @see {@link floor} for the inverse.
+   *
+   * @example
+   * ```ts
+   * const slider = createSlider({ min: 10, max: 90 })
+   * slider.register({ value: 50 })
+   * slider.ceil(0) // values: [90]
+   * ```
+   */
+  ceil: (index: number) => void;
+}
+/**
+ * Creates slider state with value math, step snapping, and multi-thumb support.
+ *
+ * Extends createModel for useProxyModel compatibility. Each thumb is a model
+ * ticket with a shallowRef<number> value. Values are derived from the ordered
+ * tickets, enabling proper registration/unregistration lifecycle.
+ *
+ * @param options Slider configuration.
+ * @returns Slider context with values, math functions, and thumb operations.
+ *
+ * @see https://0.vuetifyjs.com/composables/forms/create-slider
+ * @see {@link createModel} for the base model composable.
+ *
+ * @example Single thumb
+ * ```ts
+ * import { createSlider } from '@vuetify/v0'
+ *
+ * const slider = createSlider({ min: 0, max: 100, step: 5 })
+ * const ticket = slider.register({ value: 50 })
+ * slider.up(0)           // values: [55]
+ * slider.fromValue(50)   // 50
+ * ```
+ *
+ * @example Range slider
+ * ```ts
+ * import { createSlider } from '@vuetify/v0'
+ *
+ * const slider = createSlider({ min: 0, max: 100, step: 1, range: true })
+ * slider.register({ value: 25 })
+ * slider.register({ value: 75 })
+ * slider.set(0, 30)      // values: [30, 75]
+ * slider.set(1, 60)      // values: [30, 60]
+ * ```
+ *
+ * @example Custom pointer interaction (media scrubber)
+ * ```ts
+ * import { createSlider } from '@vuetify/v0'
+ *
+ * const slider = createSlider({ min: 0, max: 217, step: 0.1 })
+ * slider.register({ value: 0 })
+ *
+ * // pointer → fromPercent → set → fromValue → UI
+ * const percent = (clientX - rect.left) / rect.width * 100
+ * slider.set(0, slider.fromPercent(percent))
+ * const position = slider.fromValue(slider.values.value[0])
+ * ```
+ */
+declare function createSlider(options?: SliderOptions): SliderContext;
+//#endregion
 //#region src/composables/useStack/index.d.ts
 /**
  * Input type for stack tickets - what users provide to register().
@@ -4493,6 +5242,8 @@ interface StorageOptions {
     read: (value: string) => unknown;
     write: (value: unknown) => string;
   };
+  /** Time-to-live in milliseconds. When set, expired entries return the default value on `get()` and `set()` automatically timestamps entries. */
+  ttl?: number;
 }
 interface StorageContextOptions extends StorageOptions {
   /** The namespace for the storage context. Defaults to `v0:storage` */
@@ -5320,4 +6071,4 @@ declare function createVirtualContext<T = unknown>(items: Ref<readonly T[]>, _op
  */
 declare function useVirtual<T = unknown>(namespace?: string): VirtualContext<T>;
 //#endregion
-export { useStep as $, SelectionContextOptions as $i, UseHotkeyReturn as $n, BreakpointName as $r, NestedTicketInput as $t, createTheme as A, GroupOptions as Ai, createLocaleFallback as An, TokenValue as Ar, PermissionContextOptions as At, StorageOptions as B, BreadcrumbsOptions as Bi, useElementIntersection as Bn, DateContextOptions as Br, createNested as Bt, ThemeContext as C, OverflowContextOptions as Ci, LocaleOptions as Cn, TokenAlias as Cr, useQueue as Ct, ThemeRecord as D, useOverflow as Di, LocaleTicketInput as Dn, TokenOptions as Dr, ProxyModelOptions as Dt, ThemePluginOptions as E, createOverflowContext as Ei, LocaleTicket as En, TokenContextOptions as Er, useProxyRegistry as Et, Vuetify0ThemeOptions as F, useGroup as Fi, useLazy as Fn, EventHandler as Fr, createPermissionsContext as Ft, useStorage as G, SingleContextOptions as Gi, HydrationPluginOptions as Gn, createDatePlugin as Gr, NestedActiveMode as Gt, createStorage as H, createBreadcrumbsContext as Hi, HydrationContext as Hn, DatePluginOptions as Hr, useNested as Ht, ThemeAdapter as I, BreadcrumbTicket as Ii, IntersectionObserverEntry as In, useDocumentEventListener as Ir, createPermissionsPlugin as It, StepOptions as J, SingleTicketInput as Ji, createHydrationContext as Jn, ClickOutsideIgnoreTarget as Jr, NestedOpenMode as Jt, StepContext as K, SingleOptions as Ki, createFallbackHydration as Kn, useDate as Kr, NestedContext as Kt, ThemeAdapterInterface as L, BreadcrumbTicketInput as Li, IntersectionObserverOptions as Ln, useEventListener as Lr, usePermissions as Lt, createThemePlugin as M, GroupTicketInput as Mi, useLocale as Mn, createTokensContext as Mr, PermissionPluginOptions as Mt, useTheme as N, createGroup as Ni, LazyContext as Nn, useTokens as Nr, PermissionTicket as Nt, ThemeTicket as O, GroupContext as Oi, createLocale as On, TokenPrimitive as Or, useProxyModel as Ot, Vuetify0ThemeAdapter as P, createGroupContext as Pi, LazyOptions as Pn, CleanupFunction as Pr, createPermissions as Pt, createStepContext as Q, SelectionContext as Qi, UseHotkeyOptions as Qn, useClickOutside as Qr, NestedTicket as Qt, StorageContext as R, BreadcrumbsContext as Ri, UseElementIntersectionReturn as Rn, useWindowEventListener as Rr, PermissionAdapter as Rt, ThemeColors as S, OverflowContext as Si, LocaleContextOptions as Sn, FlatTokenCollection as Sr, createQueueContext as St, ThemeOptions as T, createOverflow as Ti, LocaleRecord as Tn, TokenContext as Tr, ProxyRegistryOptions as Tt, createStorageContext as U, useBreadcrumbs as Ui, HydrationContextOptions as Un, createDate as Ur, multipleOpenStrategy as Ut, StoragePluginOptions as V, createBreadcrumbs as Vi, useIntersectionObserver as Vn, DateOptions as Vr, createNestedContext as Vt, createStoragePlugin as W, SingleContext as Wi, HydrationOptions as Wn, createDateContext as Wr, singleOpenStrategy as Wt, StepTicketInput as X, createSingleContext as Xi, useHydration as Xn, UseClickOutsideOptions as Xr, NestedRegistration as Xt, StepTicket as Y, createSingle as Yi, createHydrationPlugin as Yn, ClickOutsideTarget as Yr, NestedOptions as Yt, createStep as Z, useSingle as Zi, PlatformContext as Zn, UseClickOutsideReturn as Zr, NestedSelectionMode as Zt, TimelineTicket as _, ContextKey as _i, createLoggerContext as _n, FeatureTicketInput as _r, QueueContextOptions as _t, VirtualDirection as a, useSelection as aa, createBreakpointsContext as ai, UseMutationObserverReturn as an, FormTicketInput as ar, StackTicketInput as at, useTimeline as b, provideContext as bi, LogLevel as bn, createFeaturesPlugin as br, QueueTicketInput as bt, VirtualState as c, RegistryEventCallback as ca, toReactive as ci, useMediaQuery as cn, FormValue as cr, createStackPlugin as ct, useVirtual as d, RegistryOptions as da, toArray as di, usePrefersReducedMotion as dn, useForm as dr, ResizeObserverOptions as dt, SelectionOptions as ea, BreakpointsContext as ei, OpenStrategy as en, useHotkey as er, StackContext as et, ToggleScopeControls as f, RegistryTicket as fa, Plugin as fi, LoggerContext as fn, FeatureContext as fr, UseElementSizeReturn as ft, TimelineOptions as g, useRegistry as ga, createPluginContext as gi, createLogger as gn, FeatureTicket as gr, QueueContext as gt, TimelineContextOptions as h, createRegistryContext as ha, createPlugin as hi, LoggerPluginOptions as hn, FeaturePluginOptions as hr, useResizeObserver as ht, VirtualContextOptions as i, createSelectionContext as ia, createBreakpoints as ii, UseMutationObserverOptions as in, FormTicket as ir, StackTicket as it, createThemeContext as j, GroupTicket as ji, createLocalePlugin as jn, createTokens as jr, PermissionOptions as jt, ThemeTicketInput as k, GroupContextOptions as ki, createLocaleContext as kn, TokenTicket as kr, PermissionContext as kt, createVirtual as l, RegistryEventMap as la, MaybeElementRef as li, usePrefersContrast as ln, createForm as lr, useStack as lt, TimelineContext as m, createRegistry as ma, PluginOptions as mi, LoggerOptions as mn, FeatureOptions as mr, useElementSize as mt, VirtualAnchor as n, SelectionTicketInput as na, BreakpointsOptions as ni, MutationObserverRecord as nn, FormContextOptions as nr, StackOptions as nt, VirtualItem as o, RegistryContext as oa, createBreakpointsPlugin as oi, useMutationObserver as on, FormValidationResult as or, createStack as ot, useToggleScope as p, RegistryTicketInput as pa, PluginContextConfig as pi, LoggerContextOptions as pn, FeatureContextOptions as pr, UseResizeObserverReturn as pt, StepContextOptions as q, SingleTicket as qi, createHydration as qn, ClickOutsideElement as qr, NestedContextOptions as qt, VirtualContext as r, createSelection as ra, BreakpointsPluginOptions as ri, ObservableNodeList as rn, FormOptions as rr, StackPluginOptions as rt, VirtualOptions as s, RegistryContextOptions as sa, useBreakpoints as si, MediaQueryContext as sn, FormValidationRule as sr, createStackContext as st, ScrollToOptions as t, SelectionTicket as ta, BreakpointsContextOptions as ti, OpenStrategyContext as tn, FormContext as tr, StackContextOptions as tt, createVirtualContext as u, RegistryEventName as ua, toElement as ui, usePrefersDark as un, createFormContext as ur, ResizeObserverEntry as ut, createTimeline as v, CreateContextOptions as vi, createLoggerPlugin as vn, createFeatures as vr, QueueOptions as vt, ThemeContextOptions as w, OverflowOptions as wi, LocalePluginOptions as wn, TokenCollection as wr, ProxyRegistryContext as wt, Colors as x, useContext as xi, LocaleContext as xn, useFeatures as xr, createQueue as xt, createTimelineContext as y, createContext as yi, useLogger as yn, createFeaturesContext as yr, QueueTicket as yt, StorageContextOptions as z, BreadcrumbsContextOptions as zi, UseIntersectionObserverReturn as zn, DateContext as zr, PermissionAdapterInterface as zt };
+export { useStep as $, SingleTicketInput as $i, createHydrationContext as $n, ClickOutsideIgnoreTarget as $r, NestedOpenMode as $t, createTheme as A, createOverflow as Ai, LocaleRecord as An, TokenContext as Ar, useProxyRegistry as At, StorageOptions as B, useGroup as Bi, useLazy as Bn, EventHandler as Br, createPermissionsContext as Bt, ThemeContext as C, RegistryTicketInput as Ca, CreateContextOptions as Ci, createLoggerPlugin as Cn, createFeatures as Cr, QueueTicket as Ct, ThemeRecord as D, OverflowContext as Di, LocaleContextOptions as Dn, FlatTokenCollection as Dr, useQueue as Dt, ThemePluginOptions as E, useRegistry as Ea, useContext as Ei, LocaleContext as En, useFeatures as Er, createQueueContext as Et, Vuetify0ThemeOptions as F, GroupOptions as Fi, createLocaleFallback as Fn, TokenValue as Fr, PermissionContextOptions as Ft, useStorage as G, BreadcrumbsOptions as Gi, useElementIntersection as Gn, DateContextOptions as Gr, createNested as Gt, createStorage as H, BreadcrumbTicketInput as Hi, IntersectionObserverOptions as Hn, useEventListener as Hr, usePermissions as Ht, ThemeAdapter as I, GroupTicket as Ii, createLocalePlugin as In, createTokens as Ir, PermissionOptions as It, StepOptions as J, useBreadcrumbs as Ji, HydrationContextOptions as Jn, createDate as Jr, multipleOpenStrategy as Jt, StepContext as K, createBreadcrumbs as Ki, useIntersectionObserver as Kn, DateOptions as Kr, createNestedContext as Kt, ThemeAdapterInterface as L, GroupTicketInput as Li, useLocale as Ln, createTokensContext as Lr, PermissionPluginOptions as Lt, createThemePlugin as M, useOverflow as Mi, LocaleTicketInput as Mn, TokenOptions as Mr, ProxyModelTarget as Mt, useTheme as N, GroupContext as Ni, createLocale as Nn, TokenPrimitive as Nr, useProxyModel as Nt, ThemeTicket as O, OverflowContextOptions as Oi, LocaleOptions as On, TokenAlias as Or, ProxyRegistryContext as Ot, Vuetify0ThemeAdapter as P, GroupContextOptions as Pi, createLocaleContext as Pn, TokenTicket as Pr, PermissionContext as Pt, createStepContext as Q, SingleTicket as Qi, createHydration as Qn, ClickOutsideElement as Qr, NestedContextOptions as Qt, StorageContext as R, createGroup as Ri, LazyContext as Rn, useTokens as Rr, PermissionTicket as Rt, ThemeColors as S, RegistryTicket as Sa, ContextKey as Si, createLoggerContext as Sn, FeatureTicketInput as Sr, QueueOptions as St, ThemeOptions as T, createRegistryContext as Ta, provideContext as Ti, LogLevel as Tn, createFeaturesPlugin as Tr, createQueue as Tt, createStorageContext as U, BreadcrumbsContext as Ui, UseElementIntersectionReturn as Un, useWindowEventListener as Ur, PermissionAdapter as Ut, StoragePluginOptions as V, BreadcrumbTicket as Vi, IntersectionObserverEntry as Vn, useDocumentEventListener as Vr, createPermissionsPlugin as Vt, createStoragePlugin as W, BreadcrumbsContextOptions as Wi, UseIntersectionObserverReturn as Wn, DateContext as Wr, PermissionAdapterInterface as Wt, StepTicketInput as X, SingleContextOptions as Xi, HydrationPluginOptions as Xn, createDatePlugin as Xr, NestedActiveMode as Xt, StepTicket as Y, SingleContext as Yi, HydrationOptions as Yn, createDateContext as Yr, singleOpenStrategy as Yt, createStep as Z, SingleOptions as Zi, createFallbackHydration as Zn, useDate as Zr, NestedContext as Zt, TimelineTicket as _, RegistryContextOptions as _a, Plugin as _i, LoggerContext as _n, FeatureContext as _r, UseResizeObserverReturn as _t, VirtualDirection as a, SelectionOptions as aa, BreakpointsContext as ai, OpenStrategy as an, useHotkey as ar, StackTicketInput as at, useTimeline as b, RegistryEventName as ba, createPlugin as bi, LoggerPluginOptions as bn, FeaturePluginOptions as br, QueueContext as bt, VirtualState as c, createSelection as ca, BreakpointsPluginOptions as ci, ObservableNodeList as cn, FormOptions as cr, createStackPlugin as ct, useVirtual as d, ModelContext as da, createBreakpointsPlugin as di, useMutationObserver as dn, FormValidationResult as dr, SliderOptions as dt, createSingle as ea, ClickOutsideTarget as ei, NestedOptions as en, createHydrationPlugin as er, StackContext as et, ToggleScopeControls as f, ModelOptions as fa, useBreakpoints as fi, MediaQueryContext as fn, FormValidationRule as fr, SliderTicketInput as ft, TimelineOptions as g, RegistryContext as ga, toArray as gi, usePrefersReducedMotion as gn, useForm as gr, UseElementSizeReturn as gt, TimelineContextOptions as h, createModel as ha, toElement as hi, usePrefersDark as hn, createFormContext as hr, ResizeObserverOptions as ht, VirtualContextOptions as i, SelectionContextOptions as ia, BreakpointName as ii, NestedTicketInput as in, UseHotkeyReturn as ir, StackTicket as it, createThemeContext as j, createOverflowContext as ji, LocaleTicket as jn, TokenContextOptions as jr, ProxyModelOptions as jt, ThemeTicketInput as k, OverflowOptions as ki, LocalePluginOptions as kn, TokenCollection as kr, ProxyRegistryOptions as kt, createVirtual as l, createSelectionContext as la, createBreakpoints as li, UseMutationObserverOptions as ln, FormTicket as lr, useStack as lt, TimelineContext as m, ModelTicketInput as ma, MaybeElementRef as mi, usePrefersContrast as mn, createForm as mr, ResizeObserverEntry as mt, VirtualAnchor as n, useSingle as na, UseClickOutsideReturn as ni, NestedSelectionMode as nn, PlatformContext as nr, StackOptions as nt, VirtualItem as o, SelectionTicket as oa, BreakpointsContextOptions as oi, OpenStrategyContext as on, FormContext as or, createStack as ot, useToggleScope as p, ModelTicket as pa, toReactive as pi, useMediaQuery as pn, FormValue as pr, createSlider as pt, StepContextOptions as q, createBreadcrumbsContext as qi, HydrationContext as qn, DatePluginOptions as qr, useNested as qt, VirtualContext as r, SelectionContext as ra, useClickOutside as ri, NestedTicket as rn, UseHotkeyOptions as rr, StackPluginOptions as rt, VirtualOptions as s, SelectionTicketInput as sa, BreakpointsOptions as si, MutationObserverRecord as sn, FormContextOptions as sr, createStackContext as st, ScrollToOptions as t, createSingleContext as ta, UseClickOutsideOptions as ti, NestedRegistration as tn, useHydration as tr, StackContextOptions as tt, createVirtualContext as u, useSelection as ua, createBreakpointsContext as ui, UseMutationObserverReturn as un, FormTicketInput as ur, SliderContext as ut, createTimeline as v, RegistryEventCallback as va, PluginContextConfig as vi, LoggerContextOptions as vn, FeatureContextOptions as vr, useElementSize as vt, ThemeContextOptions as w, createRegistry as wa, createContext as wi, useLogger as wn, createFeaturesContext as wr, QueueTicketInput as wt, Colors as x, RegistryOptions as xa, createPluginContext as xi, createLogger as xn, FeatureTicket as xr, QueueContextOptions as xt, createTimelineContext as y, RegistryEventMap as ya, PluginOptions as yi, LoggerOptions as yn, FeatureOptions as yr, useResizeObserver as yt, StorageContextOptions as z, createGroupContext as zi, LazyOptions as zn, CleanupFunction as zr, createPermissions as zt };