@vuetify/v0 0.0.3 → 0.0.7

package/dist/index-BoDCUSPn.d.ts

@@ -0,0 +1,2765 @@
+import { a as MaybeArray, i as ID } from "./index-C_lAPFXS.js";
+import * as vue169 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.
+ * @template Z The type of the context.
+ * @returns The injected context.
+ * @throws An error if the context is not found.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context
+ *
+ * @example
+ * ```ts
+ * const myContext = useContext<MyContext>('my-context')
+ * ```
+ */
+declare function useContext<Z>(key: ContextKey<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.
+ * @template Z The type of the context.
+ * @returns The provided context.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context
+ *
+ * @example
+ * ```ts
+ * provideContext<MyContext>('my-context', myContext)
+ * ```
+ */
+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.
+ * @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
+ *
+ * @example
+ * ```ts
+ * const [provideMyContext, useMyContext] = createContext<MyContext>('my-context')
+ * ```
+ */
+declare function createContext<Z>(_key: ContextKey<Z>): readonly [(key?: ContextKey<Z>) => Z & ({} | null), (context: Z, app?: App) => Z];
+//#endregion
+//#region src/composables/createPlugin/index.d.ts
+interface PluginOptions {
+  namespace: string;
+  provide: (app: App) => void;
+  setup?: (app: App) => void;
+}
+interface Plugin {
+  install: (app: App, ...options: any[]) => void;
+}
+/**
+ * Creates a new Vue 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
+ *
+ * @example
+ * ```ts
+ * export const [useContext, provideContext] = createContext<MyContext>('my-plugin')
+ *
+ * const context = {}
+ *
+ * export const MyPlugin = createPlugin({
+ *   namespace: 'my-plugin',
+ *   provide: (app) => {
+ *     provideContext(context, app)
+ *   },
+ *   setup: (app) => {
+ *     // Optional setup logic
+ *   },
+ * })
+ */
+declare function createPlugin<Z extends Plugin = Plugin>(options: PluginOptions): Z;
+//#endregion
+//#region src/composables/createTrinity/index.d.ts
+type ContextTrinity<Z = unknown> = readonly [() => Z, (context?: Z, app?: App) => Z, Z];
+/**
+ * Creates a new trinity for a context composable and its provider.
+ *
+ * @param createContext The function that creates the context.
+ * @param provideContext The function that provides the context.
+ * @param context The context to provide.
+ * @template Z The type of the context.
+ * @returns A new trinity.
+ *
+ * @see https://0.vuetifyjs.com/composables/foundation/create-trinity
+ *
+ * @example
+ * ```ts
+ * interface MyContext {
+ *   foo: string
+ *   bar: number
+ * }
+ *
+ * export function createMyFeature<E extends MyContext = MyContext>() {
+ *   const [useContext, _provideContext] = createContext<E>('my-context')
+ *
+ *   const context = { foo: 'hello', bar: 42 }
+ *
+ *   function provideContext (_context: E = context, app?: App): E {
+ *     return _provideContext(_context, app)
+ *   }
+ *
+ *   return createTrinity<E>(useContext, provideContext, context)
+ * }
+ */
+declare function createTrinity<Z = unknown>(createContext: () => Z, provideContext: (_context?: Z, app?: App) => Z, context: Z): ContextTrinity<Z>;
+//#endregion
+//#region src/composables/toArray/index.d.ts
+/**
+ * Converts a value to an array.
+ *
+ * @param value The value to convert.
+ * @template Z The type of the value.
+ * @returns The converted array.
+ *
+ * @see https://0.vuetifyjs.com/composables/transformers/to-array
+ *
+ * @example
+ * ```ts
+ * import { toArray } from '@vuetify/v0'
+ *
+ * const value = 'Example Value'
+ * const valueAsArray = toArray(value)
+ *
+ * console.log(valueAsArray) // ['Example Value']
+ * ```
+ */
+declare function toArray<Z>(value: Z | Z[]): Z[];
+//#endregion
+//#region src/composables/toReactive/index.d.ts
+/**
+ * Converts a `MaybeRef` to a `UnwrapNestedRefs`.
+ *
+ * @param objectRef The object to convert.
+ * @template Z The type of the object.
+ * @returns The converted object.
+ *
+ * @see https://vuejs.org/api/reactivity-utilities.html#toreactive
+ *
+ * @example
+ * ```ts
+ * import { ref } from 'vue'
+ * import { toReactive } from '@vuetify/v0'
+ *
+ * const state = ref({ name: 'John', age: 30 })
+ * const rstate = toReactive(state)
+ *
+ * console.log(rstate.name) // John
+ * ```
+ */
+declare function toReactive<Z extends object>(objectRef: MaybeRef<Z>): UnwrapNestedRefs<Z>;
+//#endregion
+//#region src/composables/useBreakpoints/index.d.ts
+type BreakpointName = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+interface BreakpointsContext {
+  breakpoints: Readonly<Record<BreakpointName, number>>;
+  name: Readonly<ShallowRef<BreakpointName>>;
+  width: Readonly<ShallowRef<number>>;
+  height: Readonly<ShallowRef<number>>;
+  isMobile: Readonly<ShallowRef<boolean>>;
+  xs: Readonly<ShallowRef<boolean>>;
+  sm: Readonly<ShallowRef<boolean>>;
+  md: Readonly<ShallowRef<boolean>>;
+  lg: Readonly<ShallowRef<boolean>>;
+  xl: Readonly<ShallowRef<boolean>>;
+  xxl: Readonly<ShallowRef<boolean>>;
+  smAndUp: Readonly<ShallowRef<boolean>>;
+  mdAndUp: Readonly<ShallowRef<boolean>>;
+  lgAndUp: Readonly<ShallowRef<boolean>>;
+  xlAndUp: Readonly<ShallowRef<boolean>>;
+  xxlAndUp: Readonly<ShallowRef<boolean>>;
+  smAndDown: Readonly<ShallowRef<boolean>>;
+  mdAndDown: Readonly<ShallowRef<boolean>>;
+  lgAndDown: Readonly<ShallowRef<boolean>>;
+  xlAndDown: Readonly<ShallowRef<boolean>>;
+  xxlAndDown: Readonly<ShallowRef<boolean>>;
+  update: () => void;
+}
+interface BreakpointsOptions extends BreakpointsPluginOptions {}
+interface BreakpointsPluginOptions {
+  mobileBreakpoint?: BreakpointName | number;
+  breakpoints?: Partial<Record<BreakpointName, number>>;
+}
+/**
+ * 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.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
+ *
+ * @example
+ * ```ts
+ * import { createBreakpoints } from '@vuetify/v0'
+ *
+ * export const [useBreakpoints, provideBreakpoints] = createBreakpoints('v0:breakpoints', {
+ *   mobileBreakpoint: 'sm',
+ *   breakpoints: {
+ *     xs: 0,
+ *     sm: 680,
+ *     md: 1024,
+ *     lg: 1280,
+ *     xl: 1920,
+ *     xxl: 2560,
+ *   },
+ * })
+ * ```
+ */
+declare function createBreakpoints<E extends BreakpointsContext = BreakpointsContext>(namespace?: string, options?: BreakpointsOptions): ContextTrinity<E>;
+/**
+ * Returns the current breakpoints instance.
+ *
+ * @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(): BreakpointsContext;
+/**
+ * Creates a new breakpoints plugin.
+ *
+ * @param options The options for the breakpoints plugin.
+ * @template E The type of the breakpoints context.
+ * @returns A new breakpoints plugin.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-breakpoints
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { createBreakpointsPlugin } from '@vuetify/v0'
+ * import App from './App.vue'
+ *
+ * const app = createApp(App)
+ *
+ * app.use(
+ *   createBreakpointsPlugin({
+ *     mobileBreakpoint: 'sm',
+ *     breakpoints: {
+ *       xs: 0,
+ *       sm: 680,
+ *       md: 1024,
+ *       lg: 1280,
+ *       xl: 1920,
+ *       xxl: 2560,
+ *     },
+ *   })
+ * )
+ *
+ * app.mount('#app')
+ * ```
+ */
+declare function createBreakpointsPlugin<E extends BreakpointsContext = BreakpointsContext>(options?: BreakpointsPluginOptions): Plugin;
+//#endregion
+//#region src/composables/useEventListener/index.d.ts
+type CleanupFunction = () => void;
+type EventHandler<E = Event> = (event: E) => void;
+/**
+ * Attaches an event listener to the window.
+ *
+ * @param target The window object.
+ * @param event The event to listen for.
+ * @param listener The event listener.
+ * @param options The event listener options.
+ * @template E The event type.
+ * @returns A function to remove the event listener.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-event-listener
+ */
+declare function useEventListener<E extends keyof WindowEventMap>(target: Window, event: MaybeRefOrGetter<MaybeArray<E>>, listener: MaybeRef<MaybeArray<(this: Window, event: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CleanupFunction;
+/**
+ * Attaches an event listener to the document.
+ *
+ * @param target The document object.
+ * @param event The event to listen for.
+ * @param listener The event listener.
+ * @param options The event listener options.
+ * @template E The event type.
+ * @returns A function to remove the event listener.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-event-listener
+ */
+declare function useEventListener<E extends keyof DocumentEventMap>(target: Document, event: MaybeRefOrGetter<MaybeArray<E>>, listener: MaybeRef<MaybeArray<(this: Document, event: DocumentEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CleanupFunction;
+/**
+ * Attaches an event listener to an HTML element.
+ *
+ * @param target The HTML element.
+ * @param event The event to listen for.
+ * @param listener The event listener.
+ * @param options The event listener options.
+ * @template E The event type.
+ * @returns A function to remove the event listener.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-event-listener
+ */
+declare function useEventListener<E extends keyof HTMLElementEventMap>(target: MaybeRefOrGetter<HTMLElement | null | undefined>, event: MaybeRefOrGetter<MaybeArray<E>>, listener: MaybeRef<MaybeArray<(this: HTMLElement, event: HTMLElementEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CleanupFunction;
+/**
+ * Attaches an event listener to an event target.
+ *
+ * @param target The event target.
+ * @param event The event to listen for.
+ * @param listener The event listener.
+ * @param options The event listener options.
+ * @template EventType The event type.
+ * @returns A function to remove the event listener.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-event-listener
+ */
+declare function useEventListener<EventType = Event>(target: MaybeRefOrGetter<EventTarget | null | undefined>, event: MaybeRefOrGetter<MaybeArray<string>>, listener: MaybeRef<MaybeArray<EventHandler<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CleanupFunction;
+/**
+ * Attaches an event listener to the window.
+ *
+ * @param event The event to listen for.
+ * @param listener The event listener.
+ * @param options The event listener options.
+ * @template E The event type.
+ * @returns A function to remove the event listener.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-event-listener
+ */
+declare function useWindowEventListener<E extends keyof WindowEventMap>(event: MaybeRefOrGetter<MaybeArray<E>>, listener: MaybeRef<MaybeArray<(this: Window, event: WindowEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CleanupFunction;
+/**
+ * Attaches an event listener to the document.
+ *
+ * @param event The event to listen for.
+ * @param listener The event listener.
+ * @param options The event listener options.
+ * @template E The event type.
+ * @returns A function to remove the event listener.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-event-listener
+ */
+declare function useDocumentEventListener<E extends keyof DocumentEventMap>(event: MaybeRefOrGetter<MaybeArray<E>>, listener: MaybeRef<MaybeArray<(this: Document, event: DocumentEventMap[E]) => any>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CleanupFunction;
+//#endregion
+//#region src/composables/useRegistry/index.d.ts
+interface RegistryTicket {
+  /** The unique identifier. Is randomly generated if not provided. */
+  id: ID;
+  /**
+   * The index of the ticket in the registry.
+   *
+   * @remarks Automatically managed by the registry. Updated during reindexing. It's not recommended to manually set this.
+   */
+  index: number;
+  /** The value associated with the ticket. If not provided, it defaults to the index. */
+  value: unknown;
+  /**
+   * Whether the value is derived from index.
+   *
+   * @remarks Set to true when no explicit value is provided during registration. It's not recommended to manually set this.
+   */
+  valueIsIndex: boolean;
+}
+interface RegistryContext<Z extends RegistryTicket = RegistryTicket> {
+  /**
+   * The collection of tickets in the registry
+   *
+   * @template ID The type of the ticket ID.
+   * @template Z The type of the registry ticket.
+   *
+   * @remarks Exposed for read-only access and advanced use cases. **Warning:** Direct mutation may cause inconsistencies in indexes, catalogs, and caches. Always prefer using the provided methods (`register`, `unregister`, etc.) to maintain internal consistency.
+   */
+  collection: Map<ID, Z>;
+  /**
+   * Clear the entire registry
+   *
+   * @remarks Removes all tickets from the registry. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#clear
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * console.log(registry.size) // 2
+   *
+   * registry.clear()
+   *
+   * console.log(registry.size) // 0
+   * ```
+   */
+  clear: () => void;
+  /**
+   * Check if a ticket exists by ID
+   *
+   * @param id The ID of the ticket to check.
+   * @remarks Calls `collection.has` internally.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#has
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-id' })
+   *
+   * const exists = registry.has('ticket-id') // true
+   * ```
+   */
+  has: (id: ID) => boolean;
+  /**
+   * Get all registered IDs
+   *
+   * @remarks Calls `collection.keys` internally with caching. First call is O(n), subsequent calls are O(1) until cache invalidation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#keys
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * const ids = registry.keys() // ['ticket-1', 'ticket-2']
+   * ```
+   */
+  keys: () => ID[];
+  /**
+   * Browse for an ID(s) by value
+   *
+   * @param value The value to browse for.
+   * @remarks Returns a single ID or an array of IDs if multiple tickets share the same value.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#browse
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1', value: 'common-value' })
+   * registry.register({ id: 'ticket-2', value: 'common-value' })
+   * registry.register({ id: 'ticket-3', value: 'unique-value' })
+   *
+   * const common = registry.browse('common-value') // ['ticket-1', 'ticket-2']
+   * const unique = registry.browse('unique-value') // 'ticket-3'
+   * ```
+   */
+  browse: (value: unknown) => ID | ID[] | undefined;
+  /**
+   * lookup a ticket by index number
+   *
+   * @param index The index number to lookup.
+   * @remarks Maps do not support indexing by default, this method provides a way to retrieve an ID based on its index in the registry.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#lookup
+   *
+   * @example
+   * ```ts
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * const ticket1 = registry.lookup(0) // 'ticket-1'
+   * const ticket2 = registry.lookup(1) // 'ticket-2'
+   * ```
+   */
+  lookup: (index: number) => ID | undefined;
+  /**
+   * Get a ticket by ID
+   *
+   * @param id The ID of the ticket to retrieve.
+   * @remarks Calls `collection.get` internally.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#get
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-id', value: 'some-value' })
+   *
+   * const ticket = registry.get('ticket-id') // { id: 'ticket-id', index: 0, value: 'some-value', ... }
+   * ```
+   */
+  get: (id: ID) => Z | undefined;
+  /**
+   * Update or insert a ticket by ID
+   *
+   * @param id The ID of the ticket to upsert.
+   * @param ticket The partial ticket data to update or insert.
+   * @remarks If the ticket exists, it will be updated with the provided data. If it doesn't exist, a new ticket will be created with the given ID and data. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#upsert
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * // Insert a new ticket
+   * const ticket = registry.upsert('ticket-id', { value: 'initial-value' })
+   *
+   * // Update the existing ticket
+   * const patched = registry.upsert('ticket-id', { value: 'updated-value' })
+   * ```
+  */
+  upsert: (id: ID, ticket?: Partial<Z>) => Z;
+  /**
+   * Get all values of registered tickets
+   *
+   * @remarks Calls `collection.values` internally with caching. First call is O(n), subsequent calls are O(1) until cache invalidation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#values
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1', value: 'value-1' })
+   * registry.register({ id: 'ticket-2', value: 'value-2' })
+   *
+   * const values = registry.values() // [{ id: 'ticket-1', ... }, { id: 'ticket-2', ... }]
+   * ```
+   */
+  values: () => Z[];
+  /**
+   * Get all entries of registered tickets
+   *
+   * @remarks Calls `collection.entries` internally with caching. First call is O(n), subsequent calls are O(1) until cache invalidation.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#entries
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1', value: 'value-1' })
+   * registry.register({ id: 'ticket-2', value: 'value-2' })
+   *
+   * const entries = registry.entries() // [['ticket-1', { id: 'ticket-1', ... }], ['ticket-2', { id: 'ticket-2', ... }]]
+   * ```
+  */
+  entries: () => [ID, Z][];
+  /**
+   * Register a new ticket
+   *
+   * @param ticket The partial ticket data to register.
+   * @remarks If no ID is provided, a unique ID will be generated automatically. If no value is provided, it defaults to the ticket's index. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#register
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * const ticket = registry.register()
+   *
+   * console.log(ticket) // { id: 'generated-id', index: 0, value: 0, valueIsIndex: true }
+   * ```
+  */
+  register: (ticket?: Partial<Z>) => Z;
+  /**
+   * Unregister an ticket by ID
+   *
+   * @param id The ID of the ticket to unregister.
+   * @remarks Removes the ticket from the registry and reindexes the remaining tickets. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#unregister
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-id' })
+   *
+   * registry.unregister('ticket-id')
+   * ```
+  */
+  unregister: (id: ID) => void;
+  /**
+   * Reset the index directory and update all tickets
+   *
+   * @remarks Rebuilds the internal index mapping and ensures all tickets have correct index values. This operation invalidates cached results from `keys()`, `values()`, and `entries()`.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#reindex
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * // After some operations that may affect indexing
+   * registry.reindex()
+   * ```
+  */
+  reindex: () => void;
+  /**
+   * Seek for a ticket based on direction and optional predicate
+   *
+   * @param direction The direction to seek ('first' or 'last'). Defaults to 'first'.
+   * @param from The index to start seeking from. Defaults to the beginning or end based on direction.
+   * @param predicate An optional function to test each ticket. The first ticket that satisfies the predicate will be returned.
+   * @remarks This method allows for flexible searching within the registry, either from the start or end, and can filter tickets based on custom criteria.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#seek
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1', value: 'apple' })
+   * registry.register({ id: 'ticket-2', value: 'banana' })
+   * registry.register({ id: 'ticket-3', value: 'cherry' })
+   *
+   * // Seek the first ticket
+   * const first = registry.seek('first')
+   *
+   * // Seek the last ticket
+   * const last = registry.seek('last')
+   *
+   * // Seek the first ticket with value 'banana'
+   * const banana = registry.seek('first', undefined, ticket => ticket.value === 'banana')
+   *
+   * // Seek from index 1 to find the next ticket with value starting with 'c'
+   * const cherry = registry.seek('first', 1, ticket => (ticket.value as string).startsWith('c'))
+   * ```
+  */
+  seek: (direction?: 'first' | 'last', from?: number, predicate?: (ticket: Z) => boolean) => Z | undefined;
+  /**
+   * Listen for registry events
+   *
+   * @param event The name of the event to listen for.
+   * @param cb The callback function to invoke when the event is emitted.
+   * @remarks Must be enabled via the `events` option when creating the registry.
+   * Supported events:
+   * - `register:ticket` - Emitted when a ticket is registered, receives the ticket as argument
+   * - `unregister:ticket` - Emitted when a ticket is unregistered, receives the ticket as argument
+   * - `update:ticket` - Emitted when a ticket is updated, receives the updated ticket as argument
+   * - `clear:registry` - Emitted when the registry is cleared
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#on
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ events: true })
+   *
+   * registry.on('register:ticket', (ticket) => {
+   *   console.log('Ticket registered:', ticket)
+   * })
+   *
+   * registry.register({ id: 'ticket-id' }) // Console: Ticket registered: { id: 'ticket-id', ... }
+   * ```
+  */
+  on: (event: string, cb: Function) => void;
+  /**
+   * Stop listening for registry events
+   *
+   * @param event The name of the event to stop listening for.
+   * @param cb The callback function to remove.
+   * @remarks Must be enabled via the `events` option when creating the registry.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#off
+   *
+   * @example
+   * ```ts
+   * import { onScopeDispose } from 'vue'
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ events: true })
+   *
+   * function onRegister(ticket) {
+   *   console.log('Ticket registered:', ticket)
+   * }
+   *
+   * registry.on('register:ticket', onRegister)
+   *
+   * registry.register({ id: 'ticket-id' }) // Console: Ticket registered: { id: 'ticket-id', ... }
+   *
+   * onScopeDispose(() => {
+   *   registry.off('register:ticket', onRegister)
+   * })
+   * ```
+  */
+  off: (event: string, cb: Function) => void;
+  /**
+   * Emit an event with data
+   *
+   * @param event The name of the event to emit.
+   * @param data The data to pass to event listeners.
+   * @remarks Must be enabled via the `events` option when creating the registry.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#emit
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ events: true })
+   *
+   * registry.on('custom-event', (data) => {
+   *   console.log('Custom event received:', data)
+   * })
+   *
+   * registry.emit('custom-event', { message: 'Hello, World!' }) // Console: Custom event received: { message: 'Hello, World!' }
+   * ```
+  */
+  emit: (event: string, data: any) => void;
+  /**
+   * Clears the registry and removes all listeners
+   *
+   * @remarks Disposes of the registry by clearing all tickets and removing all event listeners.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#dispose
+   *
+   * @example
+   * ```ts
+   * import { onScopeDispose } from 'vue'
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ events: true })
+   *
+   * registry.register({ id: 'ticket-id' })
+   *
+   * onScopeDispose(() => {
+   *   registry.dispose()
+   * })
+   * ```
+  */
+  dispose: () => void;
+  /**
+   * Onboard multiple tickets at once
+   *
+   * @param registrations An array of partial ticket data to register.
+   * @remarks Registers multiple tickets in a single operation and returns the array of registered tickets.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#onboard
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * const tickets = registry.onboard([
+   *   { id: 'ticket-1', value: 'value-1' },
+   *   { id: 'ticket-2', value: 'value-2' },
+   * ])
+   *
+   * console.log(tickets) // [{ id: 'ticket-1', ... }, { id: 'ticket-2', ... }]
+   * ```
+  */
+  onboard: (registrations: Partial<Z>[]) => Z[];
+  /**
+   * The number of tickets in the registry
+   *
+   * @remarks Reflects the current size of the internal ticket collection.
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-registry#size
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry()
+   *
+   * registry.register({ id: 'ticket-1' })
+   * registry.register({ id: 'ticket-2' })
+   *
+   * console.log(registry.size) // 2
+   * ```
+  */
+  size: number;
+}
+interface RegistryOptions {
+  /**
+   * Enable event emission for registry operations
+   *
+   * @default false
+   * @remarks When enabled, the registry will emit events for operations like registration and unregistration. Listeners can be added using the `on` method.
+   *
+   * @example
+   * ```ts
+   * import { useRegistry } from '@vuetify/v0'
+   *
+   * const registry = useRegistry({ events: true })
+   *
+   * registry.on('register:ticket', (ticket) => {
+   *   console.log('Ticket registered:', ticket)
+   * })
+   *
+   * registry.register({ id: 'ticket-id' }) // Console: Ticket registered: { id: 'ticket-id', ... }
+   * ```
+  */
+  events?: boolean;
+}
+/**
+ * Creates a new registry instance.
+ *
+ * @param options The options for the registry instance.
+ * @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
+ * @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
+ * @returns A new registry instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-registry
+ *
+ * @example
+ * ```ts
+ * import { useRegistry } from '@vuetify/v0'
+ *
+ * const registry = useRegistry()
+ *
+ * const ticket1 = registry.register({ id: 'user-1', value: { name: 'John' } })
+ * const ticket2 = registry.register({ id: 'user-2', value: { name: 'Jane' } })
+ *
+ * console.log(registry.size) // 2
+ * console.log(registry.get('user-1')) // { id: 'user-1', index: 0, value: { name: 'John' }, ... }
+ * ```
+ */
+declare function useRegistry<Z extends RegistryTicket = RegistryTicket, E extends RegistryContext<Z> = RegistryContext<Z>>(options?: RegistryOptions): E;
+/**
+ * Creates a new registry context.
+ *
+ * @param namespace The namespace for the registry context.
+ * @param options The options for the registry context.
+ *
+ * @template Z The type of registry ticket that extends RegistryTicket. Use this to add custom properties to tickets.
+ * @template E The type of registry context that extends RegistryContext<Z>. Use this when extending the registry with additional methods.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-registry
+ *
+ * @example
+ * ```ts
+ * import { createRegistryContext } from '@vuetify/v0'
+ *
+ * export const [useItems, provideItems, items] = createRegistryContext('items')
+ *
+ * // In a parent component:
+ * provideItems()
+ *
+ * // In a child component:
+ * const items = useItems()
+ * items.register({ id: 'item-1', value: 'Value 1' })
+ * ```
+ */
+declare function createRegistryContext<Z extends RegistryTicket = RegistryTicket, E extends RegistryContext<Z> = RegistryContext<Z>>(namespace: string, options?: RegistryOptions): ContextTrinity<E>;
+//#endregion
+//#region src/composables/useSelection/index.d.ts
+interface SelectionTicket extends RegistryTicket {
+  disabled: boolean;
+  isSelected: Readonly<Ref<boolean, boolean>>;
+  /** Select self */
+  select: () => void;
+  /** Unselect self */
+  unselect: () => void;
+  /** Toggle self on and off */
+  toggle: () => void;
+}
+interface SelectionContext<Z extends SelectionTicket> extends RegistryContext<Z> {
+  selectedIds: Reactive<Set<ID>>;
+  selectedItems: ComputedRef<Set<Z>>;
+  selectedValues: ComputedRef<Set<unknown>>;
+  /** Clear all selected IDs and reindexes */
+  reset: () => void;
+  /** Select a ticket by ID (Toggle ON) */
+  select: (id: ID) => void;
+  /** Unselect a ticket by ID (Toggle OFF) */
+  unselect: (id: ID) => void;
+  /** Toggles a ticket ON and OFF by ID */
+  toggle: (id: ID) => void;
+  /** Check if a ticket is selected by ID */
+  selected: (id: ID) => boolean;
+  /** Mandates selected ID based on "mandatory" Option */
+  mandate: () => void;
+}
+interface SelectionOptions extends RegistryOptions {
+  /** When true, newly registered items are automatically selected if not disabled */
+  enroll?: boolean;
+  mandatory?: boolean | 'force';
+}
+/**
+ * Creates a new selection instance.
+ *
+ * @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.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-selection
+ *
+ * @example
+ * ```ts
+ * import { useSelection } from '@vuetify/v0'
+ *
+ * const selection = useSelection({ mandatory: true })
+ *
+ * selection.onboard([
+ *   { id: 'item-1', value: 'Item 1' },
+ *   { id: 'item-2', value: 'Item 2', disabled: true },
+ *   { id: 'item-3', value: 'Item 3' },
+ * ])
+ *
+ * selection.select('item-1')
+ * selection.select('item-3')
+ *
+ * console.log(selection.selectedIds) // Set { 'item-1', 'item-3' }
+ * ```
+ */
+declare function useSelection<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(options?: SelectionOptions): 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.
+ * @returns A new selection context.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-selection
+ *
+ * @example
+ * ```ts
+ * import { createSelectionContext } from '@vuetify/v0'
+ *
+ * export const [useCheckboxes, provideCheckboxes, checkboxes] = createSelectionContext('checkboxes')
+ *
+ * // In a parent component:
+ * provideCheckboxes()
+ *
+ * // In a child component:
+ * const checkboxes = useCheckboxes()
+ * checkboxes.select('checkbox-1')
+ * ```
+ */
+declare function createSelectionContext<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(namespace: string, options?: SelectionOptions): ContextTrinity<E>;
+//#endregion
+//#region src/composables/useGroup/index.d.ts
+interface GroupTicket extends SelectionTicket {}
+interface GroupContext<Z extends GroupTicket> extends SelectionContext<Z> {
+  selectedIndexes: ComputedRef<Set<number>>;
+  /** Select one or more Tickets by ID */
+  select: (ids: ID | ID[]) => void;
+  /** Unselect one or more Tickets by ID */
+  unselect: (ids: ID | ID[]) => void;
+  /** Toggle one or more Tickets ON and OFF by ID */
+  toggle: (ids: ID | ID[]) => void;
+}
+interface GroupOptions extends SelectionOptions {}
+/**
+ * Creates a new group instance.
+ *
+ * @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.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-group
+ *
+ * @example
+ * ```ts
+ * import { useGroup } from '@vuetify/v0'
+ *
+ * const group = useGroup()
+ *
+ * group.onboard([
+ *   { id: 'item-1', value: 'Item 1' },
+ *   { id: 'item-2', value: 'Item 2' },
+ *   { id: 'item-3', value: 'Item 3' },
+ * ])
+ *
+ * group.select(['item-1', 'item-2'])
+ *
+ * console.log(group.selectedIds) // Set { 'item-1', 'item-2' }
+ * ```
+ */
+declare function useGroup<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(options?: GroupOptions): E;
+/**
+ * Creates a new group context.
+ *
+ * @param namespace The namespace for the group context.
+ * @param options The options for the group context.
+ * @template Z The type of the group ticket.
+ * @template E The type of the group context.
+ * @returns A new group context.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-group
+ *
+ * @example
+ * ```ts
+ * import { createGroupContext } from '@vuetify/v0'
+ *
+ * export const [useMyGroup, provideMyGroup, myGroup] = createGroupContext('my-group')
+ *
+ * // In a parent component:
+ * provideMyGroup()
+ *
+ * // In a child component:
+ * const group = useMyGroup()
+ * ```
+ */
+declare function createGroupContext<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(namespace: string, options?: GroupOptions): ContextTrinity<E>;
+//#endregion
+//#region src/composables/useTokens/index.d.ts
+interface TokenAlias<T = unknown> {
+  [key: string]: unknown;
+  $value: T;
+  $type?: string;
+  $description?: string;
+  $extensions?: Record<string, unknown>;
+  $deprecated?: boolean | string;
+}
+type TokenPrimitive = string | number | boolean;
+type TokenValue = TokenPrimitive | TokenAlias;
+interface TokenCollection {
+  [key: string]: TokenValue | TokenCollection;
+}
+type FlatTokenCollection = {
+  id: string;
+  value: TokenValue;
+};
+interface TokenTicket extends RegistryTicket {}
+interface TokenContext<Z extends TokenTicket> extends RegistryContext<Z> {
+  isAlias: (token: unknown) => token is string;
+  resolve: (token: string | TokenAlias) => unknown | undefined;
+}
+interface TokenOptions {
+  flat?: boolean;
+  prefix?: string;
+}
+/**
+ * Creates a new token instance.
+ *
+ * @param tokens The tokens to use.
+ * @param options The options for the token instance.
+ * @template Z The type of the token ticket.
+ * @template E The type of the token context.
+ * @returns A new token instance.
+ *
+ * @see https://www.designtokens.org/tr/drafts/format/
+ * @see https://0.vuetifyjs.com/composables/registration/use-tokens
+ *
+ * @example
+ * ```ts
+ * import { useTokens } from '@vuetify/v0'
+ *
+ * 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'
+ * ```
+ */
+declare function useTokens<Z extends TokenTicket = TokenTicket, E extends TokenContext<Z> = TokenContext<Z>>(tokens?: TokenCollection, options?: TokenOptions): E;
+/**
+ * Creates a new token context.
+ *
+ * @param namespace The namespace for the token context.
+ * @param tokens The tokens to use.
+ * @template Z The type of the token ticket.
+ * @template E The type of the token context.
+ * @returns A new token context.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-tokens
+ *
+ * @example
+ * ```ts
+ * import { createTokensContext } from '@vuetify/v0'
+ *
+ * const myTokens = {
+ *   spacing: {
+ *     sm: '8px',
+ *     md: '16px',
+ *     lg: '24px',
+ *   },
+ * }
+ *
+ * export const [useDesignTokens, provideDesignTokens, designTokens] = createTokensContext('design-tokens', myTokens)
+ *
+ * // In a parent component:
+ * provideDesignTokens()
+ *
+ * // In a child component:
+ * const tokens = useDesignTokens()
+ *
+ * console.log(tokens.resolve('{spacing.md}')) // '16px'
+ * ```
+ */
+declare function createTokensContext<Z extends TokenTicket = TokenTicket, E extends TokenContext<Z> = TokenContext<Z>>(namespace: string, tokens?: TokenCollection): ContextTrinity<E>;
+//#endregion
+//#region src/composables/useFeatures/index.d.ts
+interface FeatureTicket extends GroupTicket {
+  value: TokenValue;
+}
+interface FeatureContext<Z extends FeatureTicket = FeatureTicket> extends GroupContext<Z> {
+  variation: (id: ID, fallback?: any) => any;
+}
+interface FeatureOptions extends FeaturePluginOptions {}
+interface FeaturePluginOptions {
+  features?: Record<ID, boolean | TokenCollection>;
+}
+/**
+ * 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
+ *
+ * @example
+ * ```ts
+ * import { createFeatures } from '@vuetify/v0'
+ *
+ * const [useFeatures, provideFeaturesContext] = createFeatures('v0:features', {
+ *   features: {
+ *     'dark-mode': true,
+ *     'theme-color': { $variation: 'blue' },
+ *   },
+ * })
+ * ```
+ */
+declare function createFeatures<Z extends FeatureTicket = FeatureTicket, E extends FeatureContext<Z> = FeatureContext<Z>>(namespace?: string, options?: FeatureOptions): ContextTrinity<E>;
+/**
+ * Returns the current features instance.
+ *
+ * @template Z The type of the feature ticket.
+ * @returns The current features instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/create-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>(): FeatureContext<Z>;
+/**
+ * Creates a new features plugin.
+ *
+ * @param options The options for the features plugin.
+ * @template Z The type of the feature ticket.
+ * @template E The type of the feature context.
+ * @returns A new features plugin.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/create-features
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { createFeaturesPlugin } from '@vuetify/v0'
+ * import App from './App.vue'
+ *
+ * const app = createApp(App)
+ *
+ * app.use(
+ *   createFeaturesPlugin({
+ *     features: {
+ *       'dark-mode': true,
+ *       'theme-color': { $variation: 'blue' },
+ *     },
+ *   })
+ * )
+ *
+ * app.mount('#app')
+ * ```
+ */
+declare function createFeaturesPlugin<Z extends FeatureTicket = FeatureTicket, E extends FeatureContext<Z> = FeatureContext<Z>>(options?: FeaturePluginOptions): Plugin;
+//#endregion
+//#region src/composables/useFilter/index.d.ts
+type Primitive = string | number | boolean;
+type FilterQuery = MaybeRefOrGetter<Primitive | Primitive[]>;
+type FilterItem = Primitive | Record<string, any>;
+type FilterMode = 'some' | 'every' | 'union' | 'intersection';
+type FilterFunction = (query: Primitive | Primitive[], item: FilterItem) => boolean;
+interface UseFilterOptions {
+  customFilter?: FilterFunction;
+  keys?: string[];
+  mode?: FilterMode;
+}
+interface UseFilterResult<Z extends FilterItem = FilterItem> {
+  items: ComputedRef<Z[]>;
+}
+/**
+ * A reusable function for filtering an array of items.
+ *
+ * @param query The query to filter by.
+ * @param items The items to filter.
+ * @param options The filter options.
+ * @template Z The type of the items.
+ * @returns The filtered items.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-filter
+ *
+ * @example
+ * ```ts
+ * import { ref } from 'vue'
+ * import { useFilter } from '@vuetify/v0'
+ *
+ * const items = ref([
+ *   { name: 'John Doe', age: 30 },
+ *   { name: 'Jane Doe', age: 25 },
+ *   { name: 'Peter Jones', age: 40 },
+ * ])
+ *
+ * const query = ref('doe')
+ * const { items: filtered } = useFilter(query, items, { keys: ['name'] })
+ *
+ * console.log(filtered.value) // [ { name: 'John Doe', age: 30 }, { name: 'Jane Doe', age: 25 } ]
+ * ```
+ */
+declare function useFilter<Z extends FilterItem>(query: FilterQuery, items: MaybeRef<Z[]>, options?: UseFilterOptions): UseFilterResult<Z>;
+//#endregion
+//#region src/composables/useForm/index.d.ts
+type FormValidationResult = string | true | Promise<string | true>;
+type FormValidationRule = (value: any) => FormValidationResult;
+type FormValue = Ref<any> | ShallowRef<any>;
+interface FormTicket extends RegistryTicket {
+  validate: (silent?: boolean) => Promise<boolean>;
+  reset: () => void;
+  validateOn: 'submit' | 'change' | string;
+  disabled: boolean;
+  errors: ShallowRef<string[]>;
+  rules: FormValidationRule[];
+  isPristine: ShallowRef<boolean>;
+  isValid: ShallowRef<boolean | null>;
+  isValidating: ShallowRef<boolean>;
+}
+interface FormContext<Z extends FormTicket = FormTicket> extends RegistryContext<Z> {
+  submit: (id?: ID | ID[]) => Promise<boolean>;
+  reset: () => void;
+  validateOn: 'submit' | 'change' | string;
+  isValid: ComputedRef<boolean | null>;
+  isValidating: ComputedRef<boolean>;
+}
+interface FormOptions extends RegistryOptions {
+  validateOn?: 'submit' | 'change' | string;
+}
+/**
+ * Creates a new form instance.
+ *
+ * @param options The options for the form instance.
+ * @template Z The type of the form ticket.
+ * @template E The type of the form context.
+ * @returns A new form instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/forms/use-form
+ *
+ * @example
+ * ```ts
+ * import { useForm } from '@vuetify/v0'
+ *
+ * const form = useForm()
+ *
+ * const username = form.register({
+ *   id: 'username',
+ *   value: '',
+ *   rules: [(v) => v.length > 0 || 'Username is required'],
+ * })
+ *
+ * await form.submit()
+ *
+ * console.log(username.errors.value) // ['Username is required']
+ *
+ * form.reset()
+ * ```
+ */
+declare function useForm<Z extends FormTicket = FormTicket, E extends FormContext<Z> = FormContext<Z>>(options?: FormOptions): 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;
+/**
+ * Creates a new hydration instance.
+ *
+ * @returns A new hydration instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+ *
+ * @example
+ * ```ts
+ * import { createHydration } from '@vuetify/v0'
+ *
+ * const [useHydration, provideHydration] = createHydration()
+ * ```
+ */
+declare function createHydration(): HydrationContext;
+/**
+ * Returns the current hydration instance.
+ *
+ * @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(): HydrationContext;
+/**
+ * Creates a new hydration plugin.
+ *
+ * @returns A new hydration plugin.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-hydration
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { createHydrationPlugin } from '@vuetify/v0'
+ * import App from './App.vue'
+ *
+ * const plugin = createHydrationPlugin()
+ *
+ * const app = createApp(App)
+ *
+ * app.use(plugin)
+ *
+ * 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;
+  target: Element;
+  time: number;
+}
+interface IntersectionObserverOptions {
+  immediate?: boolean;
+  root?: Element | null;
+  rootMargin?: string;
+  threshold?: number | number[];
+}
+/**
+ * A composable that uses the Intersection Observer API to detect when an element
+ * is visible in the viewport.
+ *
+ * @param target The element to observe.
+ * @param callback The callback to execute when the element's intersection changes.
+ * @param options The options for the Intersection Observer.
+ * @returns An object with methods to control the observer.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/IntersectionObserver
+ * @see https://0.vuetifyjs.com/composables/system/use-intersection-observer
+ *
+ * @example
+ * ```ts
+ * import { ref } from 'vue'
+ * import { useIntersectionObserver } from '@vuetify/v0'
+ *
+ * const target = ref<HTMLElement>()
+ * const isVisible = ref(false)
+ *
+ * const { isIntersecting, pause, resume } = useIntersectionObserver(
+ *   target,
+ *   (entries) => {
+ *     const entry = entries[0]
+ *     if (entry) {
+ *       isVisible.value = entry.isIntersecting
+ *       console.log('Element is visible:', entry.isIntersecting)
+ *     }
+ *   },
+ *   { threshold: 0.5 }
+ * )
+ *
+ * // Pause observation
+ * pause()
+ *
+ * // Resume observation
+ * resume()
+ * ```
+ */
+declare function useIntersectionObserver(target: Ref<Element | undefined>, callback: (entries: IntersectionObserverEntry[]) => void, options?: IntersectionObserverOptions): {
+  isIntersecting: Readonly<Ref<boolean, boolean>>;
+  isPaused: Readonly<Ref<boolean, boolean>>;
+  pause: () => void;
+  resume: () => void;
+  stop: () => void;
+};
+/**
+ * A convenience composable that uses the Intersection Observer API to detect
+ * when an element is visible in the viewport.
+ *
+ * @param target The element to observe.
+ * @param options The options for the Intersection Observer.
+ * @returns An object with the intersection state.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-intersection-observer
+ *
+ * @example
+ * ```ts
+ * import { ref } from 'vue'
+ * import { useElementIntersection } from '@vuetify/v0'
+ *
+ * const myElement = ref<HTMLElement>()
+ * const { isIntersecting, intersectionRatio } = useElementIntersection(myElement, {
+ *   threshold: 0.5
+ * })
+ *
+ * // Use in template to conditionally render or animate
+ * watchEffect(() => {
+ *   if (isIntersecting.value) {
+ *     console.log('Element is visible!', intersectionRatio.value)
+ *   }
+ * })
+ * ```
+ */
+declare function useElementIntersection(target: Ref<Element | undefined>, options?: IntersectionObserverOptions): {
+  isIntersecting: Readonly<Ref<boolean, boolean>>;
+  intersectionRatio: Readonly<Ref<number, number>>;
+  isPaused: Readonly<Ref<boolean, boolean>>;
+  pause: () => void;
+  resume: () => void;
+  stop: () => void;
+};
+//#endregion
+//#region src/composables/useKeydown/index.d.ts
+interface KeyHandler {
+  key: string;
+  handler: (event: KeyboardEvent) => void;
+  preventDefault?: boolean;
+  stopPropagation?: boolean;
+}
+/**
+ * A composable that adds a keydown event listener to the document.
+ *
+ * @param handlers The key handlers to add.
+ * @returns An object with methods to start and stop listening.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-keydown
+ *
+ * @example
+ * ```ts
+ * import { useKeydown } from '@vuetify/v0'
+ *
+ * const { startListening, stopListening } = useKeydown([
+ *   { key: 'Enter', handler: () => console.log('Enter pressed') },
+ *   { key: 'Escape', handler: () => console.log('Escape pressed'), preventDefault: true },
+ * ])
+ *
+ * startListening()
+ * stopListening()
+ * ```
+ */
+declare function useKeydown(handlers: KeyHandler[] | KeyHandler): {
+  startListening: () => void;
+  stopListening: () => void;
+};
+//#endregion
+//#region src/composables/useSingle/index.d.ts
+interface SingleTicket extends SelectionTicket {}
+interface SingleContext<Z extends SingleTicket> extends SelectionContext<Z> {
+  selectedId: ComputedRef<ID | undefined>;
+  selectedIndex: ComputedRef<number>;
+  selectedItem: ComputedRef<Z | undefined>;
+  selectedValue: ComputedRef<unknown>;
+}
+interface SingleOptions extends SelectionOptions {}
+/**
+ * Creates a new single selection instance.
+ *
+ * @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.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-single
+ *
+ * @example
+ * ```ts
+ * import { useSingle } from '@vuetify/v0'
+ *
+ * const single = useSingle()
+ *
+ * single.onboard([
+ *   { id: 'option-1', value: 'Option 1' },
+ *   { id: 'option-2', value: 'Option 2' },
+ * ])
+ *
+ * single.select('option-1')
+ *
+ * console.log(single.selectedId.value) // 'option-1'
+ * ```
+ */
+declare function useSingle<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(options?: SingleOptions): E;
+/**
+ * Creates a new single selection context.
+ *
+ * @param namespace The namespace for the single selection context.
+ * @param options The options for the single selection context.
+ * @template Z The type of the single selection ticket.
+ * @template E The type of the single selection context.
+ * @returns A new single selection context.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-single
+ *
+ * @example
+ * ```ts
+ * import { createSingleContext } from '@vuetify/v0'
+ *
+ * export const [useTabs, provideTabs, tabs] = createSingleContext('tabs', { mandatory: true })
+ *
+ * // In a parent component:
+ * provideTabs()
+ *
+ * // In a child component:
+ * const tabs = useTabs()
+ * tabs.select('tab-1')
+ * ```
+ */
+declare function createSingleContext<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(namespace: string, options?: SingleOptions): ContextTrinity<E>;
+//#endregion
+//#region src/composables/useLocale/adapters/adapter.d.ts
+interface LocaleAdapter {
+  t: (message: string, ...params: unknown[]) => string;
+  n: (value: number, locale: ID | undefined, ...params: unknown[]) => string;
+}
+//#endregion
+//#region src/composables/useLocale/adapters/v0.d.ts
+/**
+ * Vuetify0.x locale adapter implementation
+ *
+ * This adapter provides translation and number formatting
+ * capabilities using the Intl API and supports both
+ * numbered and named variables in translation strings.
+ */
+declare class Vuetify0LocaleAdapter implements LocaleAdapter {
+  t(message: string, ...params: unknown[]): string;
+  n(value: number, locale: ID | undefined, ...params: unknown[]): string;
+}
+//#endregion
+//#region src/composables/useLocale/index.d.ts
+type LocaleRecord = TokenCollection;
+type LocaleTicket = SingleTicket;
+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> {
+  adapter?: LocaleAdapter;
+  default?: ID;
+  fallback?: ID;
+  messages?: Record<ID, Z>;
+}
+/**
+ * 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.
+ * @returns A new locale instance.
+ *
+ * @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>;
+/**
+ * Returns the current locale instance.
+ *
+ * @returns The current locale instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-locale
+ */
+declare function useLocale(): LocaleContext<LocaleTicket>;
+/**
+ * Creates a new locale plugin.
+ *
+ * @param options The options for the locale plugin.
+ * @template Z The type of the locale ticket.
+ * @template E The type of the locale context.
+ * @template R The type of the token ticket.
+ * @template O The type of the token context.
+ * @returns A new locale plugin.
+ *
+ * @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;
+//#endregion
+//#region src/composables/useLogger/adapters/adapter.d.ts
+interface LoggerAdapter {
+  debug: (message: string, ...args: unknown[]) => void;
+  info: (message: string, ...args: unknown[]) => void;
+  warn: (message: string, ...args: unknown[]) => void;
+  error: (message: string, ...args: unknown[]) => void;
+  trace?: (message: string, ...args: unknown[]) => void;
+  fatal?: (message: string, ...args: unknown[]) => void;
+}
+//#endregion
+//#region src/composables/useLogger/adapters/consola.d.ts
+declare class ConsolaLoggerAdapter implements LoggerAdapter {
+  private consola;
+  constructor(consolaInstance: any);
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  trace(message: string, ...args: unknown[]): void;
+  fatal(message: string, ...args: unknown[]): void;
+}
+//#endregion
+//#region src/composables/useLogger/adapters/pino.d.ts
+/**
+ * Pino logger adapter implementation
+ *
+ * This adapter integrates with the Pino logging library,
+ * providing high-performance structured logging optimized
+ * for Node.js applications with minimal overhead.
+ */
+declare class PinoLoggerAdapter implements LoggerAdapter {
+  private pino;
+  constructor(pinoInstance: any);
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  trace(message: string, ...args: unknown[]): void;
+  fatal(message: string, ...args: unknown[]): void;
+  private format;
+}
+//#endregion
+//#region src/composables/useLogger/adapters/v0.d.ts
+/**
+ * Vuetify0.x logger adapter implementation
+ *
+ * This adapter provides console-based logging with proper formatting,
+ * color coding, timestamps, and log level filtering for development
+ * and production environments.
+ */
+declare class Vuetify0LoggerAdapter implements LoggerAdapter {
+  private prefix;
+  private colors;
+  private timestamps;
+  constructor(options?: {
+    prefix?: string;
+    colors?: boolean;
+    timestamps?: boolean;
+  });
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+  trace(message: string, ...args: unknown[]): void;
+  fatal(message: string, ...args: unknown[]): void;
+  private format;
+  private timestamp;
+  private style;
+  private log;
+}
+//#endregion
+//#region src/composables/useLogger/types.d.ts
+type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal' | 'silent';
+//#endregion
+//#region src/composables/useLogger/index.d.ts
+interface LoggerContext {
+  debug: (message: string, ...args: unknown[]) => void;
+  info: (message: string, ...args: unknown[]) => void;
+  warn: (message: string, ...args: unknown[]) => void;
+  error: (message: string, ...args: unknown[]) => void;
+  trace: (message: string, ...args: unknown[]) => void;
+  fatal: (message: string, ...args: unknown[]) => void;
+  level: (level: LogLevel) => void;
+  current: () => LogLevel;
+  enabled: () => boolean;
+  enable: () => void;
+  disable: () => void;
+}
+interface LoggerOptions {
+  adapter?: LoggerAdapter;
+  level?: LogLevel;
+  prefix?: string;
+  enabled?: boolean;
+}
+/**
+ * Creates a new logger instance.
+ *
+ * @param options The options for the logger instance.
+ * @returns A new logger instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-logger
+ */
+declare function createLogger(options?: LoggerOptions): LoggerContext;
+/**
+ * Uses an existing or creates a new logger instance.
+ *
+ * @param namespace The namespace for the logger context.
+ * @returns The logger instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-logger
+ */
+declare function useLogger(namespace?: string): LoggerContext;
+/**
+ * Creates a new logger plugin.
+ *
+ * @param options The options for the logger plugin.
+ * @returns A new logger plugin.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-logger
+ */
+declare function createLoggerPlugin(options?: LoggerOptions): Plugin;
+//#endregion
+//#region src/composables/useMutationObserver/index.d.ts
+interface MutationObserverRecord {
+  type: 'attributes' | 'childList' | 'characterData';
+  target: Node;
+  addedNodes: NodeList;
+  removedNodes: NodeList;
+  previousSibling: Node | null;
+  nextSibling: Node | null;
+  attributeName: string | null;
+  attributeNamespace: string | null;
+  oldValue: string | null;
+}
+interface UseMutationObserverOptions {
+  immediate?: boolean;
+  childList?: boolean;
+  attributes?: boolean;
+  characterData?: boolean;
+  subtree?: boolean;
+  attributeOldValue?: boolean;
+  characterDataOldValue?: boolean;
+  attributeFilter?: string[];
+}
+/**
+ * A composable that uses the Mutation Observer API to detect changes in the DOM.
+ *
+ * @param target The element to observe.
+ * @param callback The callback to execute when a mutation is observed.
+ * @param options The options for the Mutation Observer.
+ * @returns An object with methods to control the observer.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver
+ * @see https://0.vuetifyjs.com/composables/system/use-mutation-observer
+ *
+ * @example
+ * ```ts
+ * import { ref } from 'vue'
+ * import { useMutationObserver } from '@vuetify/v0'
+ *
+ * const container = ref<HTMLElement>()
+ *
+ * const { pause, resume, isPaused } = useMutationObserver(
+ *   container,
+ *   (mutations) => {
+ *     mutations.forEach((mutation) => {
+ *       if (mutation.type === 'childList') {
+ *         console.log('Children changed:', mutation.addedNodes, mutation.removedNodes)
+ *       } else if (mutation.type === 'attributes') {
+ *         console.log('Attribute changed:', mutation.attributeName)
+ *       }
+ *     })
+ *   },
+ *   {
+ *     childList: true,
+ *     attributes: true,
+ *     subtree: true
+ *   }
+ * )
+ *
+ * // Pause observation
+ * pause()
+ *
+ * // Resume observation
+ * resume()
+ * ```
+ */
+declare function useMutationObserver(target: Ref<Element | undefined>, callback: (entries: MutationObserverRecord[]) => void, options?: UseMutationObserverOptions): {
+  isPaused: Readonly<Ref<boolean, boolean>>;
+  pause: () => void;
+  resume: () => void;
+  stop: () => void;
+};
+//#endregion
+//#region src/composables/usePermissions/adapters/adapter.d.ts
+interface PermissionAdapterInterface {
+  can: <Z extends PermissionTicket = PermissionTicket>(role: ID, action: string, subject: string, context: Record<string, any>, permissions: PermissionContext<Z>) => boolean;
+}
+declare abstract class PermissionAdapter implements PermissionAdapterInterface {
+  abstract can<Z extends PermissionTicket = PermissionTicket>(role: ID, action: string, subject: string, context: Record<string, any>, permissions: PermissionContext<Z>): boolean;
+}
+//#endregion
+//#region src/composables/usePermissions/index.d.ts
+interface PermissionTicket extends TokenTicket {
+  value: boolean | ((context: Record<string, any>) => boolean);
+}
+interface PermissionContext<Z extends PermissionTicket = PermissionTicket> extends TokenContext<Z> {
+  can: (id: ID, action: string, subject: string, context?: Record<string, any>) => boolean;
+}
+interface PermissionOptions extends PermissionPluginOptions {}
+interface PermissionPluginOptions {
+  adapter?: PermissionAdapter;
+  permissions?: Record<ID, any>;
+}
+/**
+ * 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
+ *
+ * @example
+ * ```ts
+ * import { createPermissions } from '@vuetify/v0'
+ *
+ * const [usePermissions, providePermissions] = createPermissions('v0:permissions', {
+ *   permissions: {
+ *     admin: [['read', 'users']],
+ *     editor: [['edit', 'posts']],
+ *   },
+ * })
+ * ```
+ */
+declare function createPermissions<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(namespace?: string, options?: PermissionOptions): ContextTrinity<E>;
+/**
+ * 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>(): PermissionContext<Z>;
+/**
+ * Creates a new permissions plugin.
+ *
+ * @param options The options for the permissions plugin.
+ * @template Z The type of the permission ticket.
+ * @template E The type of the permission context.
+ * @returns A new permissions plugin.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-permissions
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { createPermissionsPlugin } from '@vuetify/v0'
+ * import App from './App.vue'
+ *
+ * const app = createApp(App)
+ *
+ * app.use(
+ *   createPermissionsPlugin({
+ *     permissions: {
+ *       admin: [['read', 'users']],
+ *       editor: [['edit', 'posts']],
+ *     },
+ *   })
+ * )
+ *
+ * app.mount('#app')
+ * ```
+ */
+declare function createPermissionsPlugin<Z extends PermissionTicket = PermissionTicket, E extends PermissionContext<Z> = PermissionContext<Z>>(options?: PermissionOptions): Plugin;
+//#endregion
+//#region src/composables/useProxyModel/index.d.ts
+interface ProxyModelOptions {
+  /** Whether to use deep reactivity for the model */
+  deep?: boolean;
+}
+/**
+ * Creates a proxy model that can be used to bind to a selection.
+ *
+ * @param registry The selection registry to bind to.
+ * @param initial The initial value of the model.
+ * @param options The options for the proxy model.
+ * @param transformIn A function to transform the value before setting it.
+ * @param transformOut A function to transform the value before getting it.
+ * @template Z The type of the selection ticket.
+ * @returns A proxy model that can be used to bind to a selection.
+ *
+ * @see https://0.vuetifyjs.com/composables/forms/use-proxy-model
+ *
+ * @example
+ * ```ts
+ * import { useSelection, useProxyModel } from '@vuetify/v0'
+ *
+ * const registry = useSelection({ events: true })
+ * registry.onboard([
+ *   { id: 'item-1', value: 'Item 1' },
+ *   { id: 'item-2', value: 'Item 2' },
+ * ])
+ *
+ * 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>;
+//#endregion
+//#region src/composables/useProxyRegistry/index.d.ts
+interface ProxyRegistryOptions {
+  deep?: boolean;
+}
+interface ProxyRegistryContext<Z extends RegistryTicket = RegistryTicket> {
+  keys: ID[];
+  values: Z[];
+  entries: [ID, Z][];
+  size: number;
+}
+/**
+ * Creates a proxy registry that provides reactive objects for registry data.
+ *
+ * @param registry The registry instance to proxy.
+ * @param options The options for the proxy registry.
+ * @template Z The type of the registry ticket.
+ * @returns A proxy registry with reactive objects.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-proxy-registry
+ *
+ * @example
+ * ```ts
+ * import { useRegistry, useProxyRegistry } from '@vuetify/v0'
+ *
+ * const registry = useRegistry({ events: true })
+ * const proxy = useProxyRegistry(registry)
+ *
+ * registry.register({ value: 'Item 1' })
+ * console.log(proxy.size) // 1
+ * ```
+ */
+declare function useProxyRegistry<Z extends RegistryTicket = RegistryTicket>(registry: RegistryContext<Z>, options?: ProxyRegistryOptions): ProxyRegistryContext<Z>;
+//#endregion
+//#region src/composables/useQueue/index.d.ts
+interface QueueTicket extends RegistryTicket {
+  /**
+   * Timeout in milliseconds
+   *
+   * @remarks
+   * - If `undefined`: Uses the default timeout from queue options (default: 3000ms)
+   * - If `-1`: Ticket persists indefinitely until manually dismissed
+   * - If a number: Ticket will be automatically removed after the specified milliseconds
+   */
+  timeout?: number;
+  /**
+   * Whether the timeout is currently paused
+   *
+   * @remarks
+   * - Set to `true` when the ticket is not the first in the queue or when manually paused
+   * - When `true`, the timeout does not progress
+   * - Automatically managed by the queue system
+   */
+  isPaused: boolean;
+  /**
+   * Convenience method to dismiss this ticket from the queue
+   *
+   * @remarks
+   * Equivalent to calling `queue.unregister(ticket.id)`
+   */
+  dismiss: () => void;
+}
+interface QueueContext<Z extends QueueTicket = QueueTicket> extends RegistryContext<Z> {
+  /**
+   * Register a new ticket in the queue
+   *
+   * @param ticket The partial ticket data to register
+   * @remarks
+   * - If no ID is provided, a unique ID will be generated automatically
+   * - If no timeout is provided, uses the default timeout from queue options (3000ms)
+   * - First ticket in queue starts its timeout immediately
+   * - Subsequent tickets are paused until they become first in queue
+   * - Each ticket receives a `dismiss()` method for convenience
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-queue#register
+   *
+   * @example
+   * ```ts
+   * import { useQueue } from '@vuetify/v0'
+   *
+   * const queue = useQueue()
+   *
+   * // Register with default timeout (3000ms)
+   * const ticket1 = queue.register({ value: 'First' })
+   *
+   * // Register with custom timeout
+   * const ticket2 = queue.register({ value: 'Second', timeout: 5000 })
+   *
+   * // Register persistent ticket (must be manually dismissed)
+   * const ticket3 = queue.register({ value: 'Persistent', timeout: -1 })
+   * ```
+   */
+  register: (ticket?: Partial<Z>) => Z;
+  /**
+   * Unregister a ticket from the queue
+   *
+   * @param id The ID of the ticket to unregister. If not provided, the first ticket in the queue will be unregistered.
+   * @remarks
+   * - Removes the ticket from the queue and clears its timeout
+   * - If the removed ticket was first in queue, automatically resumes the next ticket
+   * - Returns the unregistered ticket or `undefined` if not found
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-queue#unregister
+   *
+   * @example
+   * ```ts
+   * import { useQueue } from '@vuetify/v0'
+   *
+   * const queue = useQueue()
+   *
+   * const ticket1 = queue.register({ value: 'First' })
+   * const ticket2 = queue.register({ value: 'Second' })
+   *
+   * // Unregister specific ticket
+   * queue.unregister(ticket2.id)
+   *
+   * // Unregister first ticket in queue
+   * const removed = queue.unregister()
+   * console.log(removed?.value) // 'First'
+   * ```
+   */
+  unregister: (id?: ID) => Z | undefined;
+  /**
+   * Pause the timeout of the first ticket in the queue
+   *
+   * @remarks
+   * - Pauses the timeout for the first ticket if it exists and is not already paused
+   * - Returns the paused ticket or `undefined` if no pausable ticket exists
+   * - The timeout will not progress while paused
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-queue#pause
+   *
+   * @example
+   * ```ts
+   * import { useQueue } from '@vuetify/v0'
+   *
+   * const queue = useQueue({ timeout: 5000 })
+   *
+   * const ticket = queue.register({ value: 'Pausable ticket' })
+   *
+   * // Pause the first ticket's timeout
+   * const paused = queue.pause()
+   *
+   * console.log(paused?.isPaused) // true
+   * ```
+   */
+  pause: () => Z | undefined;
+  /**
+   * Resume the timeout of the first paused ticket in the queue
+   *
+   * @remarks
+   * - Resumes the timeout for the first ticket if it exists, is at index 0, and is currently paused
+   * - Returns the resumed ticket or `undefined` if no resumable ticket exists
+   * - The timeout will continue from its full duration (not from where it was paused)
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-queue#resume
+   *
+   * @example
+   * ```ts
+   * import { useQueue } from '@vuetify/v0'
+   *
+   * const queue = useQueue({ timeout: 5000 })
+   *
+   * const ticket = queue.register({ value: 'Ticket' })
+   * queue.pause()
+   *
+   * // Later, resume the paused ticket
+   * const resumed = queue.resume()
+   *
+   * console.log(resumed?.isPaused) // false
+   * ```
+   */
+  resume: () => Z | undefined;
+  /**
+   * Clear the entire queue
+   *
+   * @remarks
+   * - Removes all tickets from the queue
+   * - Clears all active timeouts
+   * - Resets the queue to an empty state
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-queue#clear
+   *
+   * @example
+   * ```ts
+   * import { useQueue } from '@vuetify/v0'
+   *
+   * const queue = useQueue()
+   *
+   * queue.register({ value: 'First' })
+   * queue.register({ value: 'Second' })
+   *
+   * console.log(queue.size) // 2
+   *
+   * queue.clear()
+   *
+   * console.log(queue.size) // 0
+   * ```
+   */
+  clear: () => void;
+  /**
+   * Dispose of the queue and clean up resources
+   *
+   * @remarks
+   * - Clears all tickets and timeouts
+   * - Removes all event listeners
+   * - Should be called when the queue is no longer needed
+   * - Automatically called on scope disposal
+   *
+   * @see https://0.vuetifyjs.com/composables/registration/use-queue#dispose
+   *
+   * @example
+   * ```ts
+   * import { onScopeDispose } from 'vue'
+   * import { useQueue } from '@vuetify/v0'
+   *
+   * const queue = useQueue()
+   *
+   * queue.register({ value: 'Ticket' })
+   *
+   * onScopeDispose(() => {
+   *   queue.dispose()
+   * })
+   * ```
+   */
+  dispose: () => void;
+}
+interface QueueOptions extends RegistryOptions {
+  /**
+   * Default timeout in milliseconds for tickets without explicit timeout
+   *
+   * @default 3000
+   * @remarks
+   * - Applied to tickets that don't specify their own timeout
+   * - Can be overridden per ticket during registration
+   */
+  timeout?: number;
+}
+/**
+ * Creates a new queue instance
+ *
+ * @param options The options for the queue instance
+ * @template Z The type of queue ticket that extends QueueTicket. Use this to add custom properties to tickets.
+ * @template E The type of queue context that extends QueueContext<Z>. Use this when extending the queue with additional methods.
+ * @returns A new queue instance
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-queue
+ *
+ * @example
+ * ```ts
+ * import { useQueue } from '@vuetify/v0'
+ *
+ * const queue = useQueue()
+ *
+ * // Register an ticket with default timeout (3000ms)
+ * const ticket1 = queue.register({ value: 'Ticket 1' })
+ *
+ * // Register an ticket with custom timeout
+ * const ticket2 = queue.register({ value: 'Ticket 2', timeout: 5000 })
+ *
+ * // Register a persistent ticket that must be manually dismissed
+ * const ticket3 = queue.register({ value: 'Ticket 3', timeout: -1 })
+ *
+ * // Dismiss an ticket using the convenience method
+ * ticket3.dismiss()
+ *
+ * console.log(queue.size) // 2
+ * ```
+ */
+declare function useQueue<Z extends QueueTicket = QueueTicket, E extends QueueContext<Z> = QueueContext<Z>>(_options?: QueueOptions): E;
+//#endregion
+//#region src/composables/useResizeObserver/index.d.ts
+interface ResizeObserverEntry {
+  contentRect: {
+    width: number;
+    height: number;
+    top: number;
+    left: number;
+  };
+  target: Element;
+}
+interface ResizeObserverOptions {
+  immediate?: boolean;
+  box?: 'content-box' | 'border-box';
+}
+/**
+ * A composable that uses the Resize Observer API to detect when an element's
+ * size changes.
+ *
+ * @param target The element to observe.
+ * @param callback The callback to execute when the element's size changes.
+ * @param options The options for the Resize Observer.
+ * @returns An object with methods to control the observer.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/ResizeObserver
+ * @see https://0.vuetifyjs.com/composables/system/use-resize-observer
+ *
+ * @example
+ * ```ts
+ * import { ref } from 'vue'
+ * import { useResizeObserver } from '@vuetify/v0'
+ *
+ * const el = ref<HTMLElement>()
+ * const width = ref(0)
+ * const height = ref(0)
+ *
+ * const { pause, resume, isPaused } = useResizeObserver(
+ *   el,
+ *   (entries) => {
+ *     const entry = entries[0]
+ *     if (entry) {
+ *       width.value = entry.contentRect.width
+ *       height.value = entry.contentRect.height
+ *       console.log('Size changed:', width.value, 'x', height.value)
+ *     }
+ *   },
+ *   { immediate: true }
+ * )
+ *
+ * // Pause observation
+ * pause()
+ *
+ * // Resume observation
+ * resume()
+ * ```
+ */
+declare function useResizeObserver(target: Ref<Element | undefined>, callback: (entries: ResizeObserverEntry[]) => void, options?: ResizeObserverOptions): {
+  isPaused: Readonly<Ref<boolean, boolean>>;
+  pause: () => void;
+  resume: () => void;
+  stop: () => void;
+};
+/**
+ * A convenience composable that uses the Resize Observer API to track an
+ * element's size.
+ *
+ * @param target The element to observe.
+ * @returns An object with the element's width and height.
+ *
+ * @see https://0.vuetifyjs.com/composables/system/use-resize-observer#use-element-size
+ *
+ * @example
+ * ```ts
+ * import { ref, watchEffect } from 'vue'
+ * import { useElementSize } from '@vuetify/v0'
+ *
+ * const box = ref<HTMLElement>()
+ * const { width, height } = useElementSize(box)
+ *
+ * // Width and height are reactive refs
+ * watchEffect(() => {
+ *   console.log('Box size:', width.value, 'x', height.value)
+ * })
+ * ```
+ */
+declare function useElementSize(target: Ref<Element | undefined>): {
+  width: vue169.ShallowRef<number, number>;
+  height: vue169.ShallowRef<number, number>;
+  isPaused: Readonly<Ref<boolean, boolean>>;
+  pause: () => void;
+  resume: () => void;
+  stop: () => void;
+};
+//#endregion
+//#region src/composables/useStep/index.d.ts
+interface StepTicket extends SingleTicket {}
+interface StepContext<Z extends StepTicket> extends SingleContext<Z> {
+  /** Select the first Ticket in the collection */
+  first: () => void;
+  /** Select the last Ticket in the collection */
+  last: () => void;
+  /** Select the next Ticket based on current index */
+  next: () => void;
+  /** Select the previous Ticket based on current index */
+  prev: () => void;
+  /** Step through the collection by a given count */
+  step: (count: number) => void;
+}
+interface StepOptions extends SingleOptions {}
+/**
+ * Creates a new step instance.
+ *
+ * @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.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-step
+ *
+ * @example
+ * ```ts
+ * import { useStep } from '@vuetify/v0'
+ *
+ * const stepper = useStep()
+ *
+ * stepper.onboard([
+ *   { id: 'step-1', value: 'Account Info' },
+ *   { id: 'step-2', value: 'Payment' },
+ *   { id: 'step-3', value: 'Confirmation' },
+ * ])
+ *
+ * stepper.first()
+ * stepper.next() // Move to step-2
+ *
+ * console.log(stepper.selectedIndex.value) // 1
+ * ```
+ */
+declare function useStep<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(options?: StepOptions): E;
+/**
+ * Creates a new step context.
+ *
+ * @param namespace The namespace for the step context.
+ * @param options The options for the step context.
+ * @template Z The type of the step ticket.
+ * @template E The type of the step context.
+ * @returns A new step context.
+ *
+ * @see https://0.vuetifyjs.com/composables/selection/use-step
+ *
+ * @example
+ * ```ts
+ * import { createStepContext } from '@vuetify/v0'
+ *
+ * export const [useWizard, provideWizard, wizard] = createStepContext('wizard')
+ *
+ * // In a parent component:
+ * provideWizard()
+ *
+ * // In a child component:
+ * const wizard = useWizard()
+ * wizard.next() // Progress to next step
+ * ```
+ */
+declare function createStepContext<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(namespace: string, options?: StepOptions): ContextTrinity<E>;
+//#endregion
+//#region src/composables/useStorage/adapters/adapter.d.ts
+interface StorageAdapter$1 {
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+  removeItem: (key: string) => void;
+  readonly length?: number;
+  key?: (index: number) => string | null;
+}
+//#endregion
+//#region src/composables/useStorage/adapters/memory.d.ts
+/**
+ * In-memory storage adapter that implements the StorageAdapter interface.
+ * This adapter provides temporary storage that persists only for the current
+ * session and is useful for testing or when persistent storage is not available.
+ */
+declare class MemoryAdapter implements StorageAdapter$1 {
+  private store;
+  get length(): number;
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+  removeItem(key: string): void;
+  key(index: number): string;
+}
+//#endregion
+//#region src/composables/useStorage/adapters/index.d.ts
+type StorageType = 'localStorage' | 'sessionStorage' | 'memory';
+interface StorageAdapter {
+  getItem: (key: string) => string | null;
+  setItem: (key: string, value: string) => void;
+  removeItem: (key: string) => void;
+  readonly length?: number;
+  key?: (index: number) => string | null;
+}
+//#endregion
+//#region src/composables/useStorage/index.d.ts
+interface StorageContext {
+  /** Check if a key exists in storage */
+  has: (key: string) => boolean;
+  /** Get a reactive ref for a storage key */
+  get: <T>(key: string, defaultValue?: T) => Ref<T>;
+  /** Set a value for a storage key */
+  set: <T>(key: string, value: T) => void;
+  /** Remove a key from storage */
+  remove: (key: string) => void;
+  /** Clear all keys from storage */
+  clear: () => void;
+}
+interface StorageOptions {
+  /** The storage adapter to use. Defaults to localStorage in browser, MemoryAdapter otherwise */
+  adapter?: StorageAdapter;
+  /** The prefix to use for all storage keys. Defaults to 'v0:' */
+  prefix?: string;
+  /** Custom serializer for reading and writing values. Defaults to JSON.parse/stringify */
+  serializer?: {
+    read: (value: string) => any;
+    write: (value: any) => string;
+  };
+}
+declare const useStorageContext: (key?: ContextKey<StorageContext>) => StorageContext, provideStorageContext: (context: StorageContext, app?: App) => StorageContext;
+/**
+ * Creates a new storage instance.
+ *
+ * @param options The options for the storage instance.
+ * @template E The type of the storage context.
+ * @returns A new storage instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-storage
+ *
+ * @example
+ * ```ts
+ * import { createStorage } from '@vuetify/v0'
+ *
+ * const storage = createStorage()
+ *
+ * storage.set('username', 'MyUsername')
+ *
+ * const username = storage.get('username')
+ *
+ * console.log(username.value) // MyUsername
+ *
+ * storage.clear()
+ * ```
+ */
+declare function createStorage<E extends StorageContext>(options?: StorageOptions): E;
+/**
+ * Returns the current storage instance.
+ *
+ * @returns The current storage instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-storage
+ *
+ * @example
+ * ```vue
+ * <script setup lang="ts">
+ *   import { useStorage } from '@vuetify/v0'
+ *
+ *   const storage = useStorage()
+ *   const username = storage.get('username', 'Guest')
+ * </script>
+ *
+ * <template>
+ *   <div>
+ *     <p>Username: {{ username }}</p>
+ *   </div>
+ * </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;
+//#endregion
+//#region src/composables/useTheme/adapters/adapter.d.ts
+interface ThemeAdapterInterface {
+  update: (colors: Record<string, Colors>) => void;
+}
+declare abstract class ThemeAdapter implements ThemeAdapterInterface {
+  stylesheetId: string;
+  prefix: string;
+  constructor(prefix: string);
+  generate(colors: Record<string, Colors>): string;
+  abstract update(colors: Record<string, Colors>): void;
+}
+//#endregion
+//#region src/composables/useTheme/adapters/v0.d.ts
+interface Vuetify0ThemeOptions {
+  cspNonce?: string;
+  stylesheetId?: string;
+  prefix?: string;
+}
+/**
+ * Theme adapter implementation for Vuetify v0 design system.
+ * This adapter generates CSS custom properties and injects them into the DOM
+ * as a stylesheet, allowing themes to be applied globally.
+ */
+declare class Vuetify0ThemeAdapter extends ThemeAdapter {
+  cspNonce?: string;
+  constructor(options?: Vuetify0ThemeOptions);
+  update(colors: Record<ID, Colors>): void;
+  upsert(styles: string): void;
+}
+//#endregion
+//#region src/composables/useTheme/index.d.ts
+type Colors = {
+  [key: string]: string;
+};
+type ThemeColors = {
+  [key: string]: Colors | string;
+};
+type ThemeRecord = {
+  [key: string]: any;
+  dark?: boolean;
+  lazy?: boolean;
+  colors: ThemeColors;
+};
+type ThemeTicket = SingleTicket & {
+  lazy: boolean;
+  dark: boolean;
+};
+interface ThemeContext<Z extends ThemeTicket> extends SingleContext<Z> {
+  colors: ComputedRef<Record<string, Colors>>;
+  cycle: (themes: ID[]) => void;
+}
+interface ThemeOptions extends ThemePluginOptions {}
+interface ThemePluginOptions<Z extends ThemeRecord = ThemeRecord> {
+  adapter?: ThemeAdapter;
+  default?: ID;
+  palette?: TokenCollection;
+  themes?: Record<ID, Z>;
+  target?: string | HTMLElement | null;
+}
+/**
+ * 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.
+ * @returns A new theme instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-theme
+ *
+ * @example
+ * ```ts
+ * import { createTheme } from '@vuetify/v0'
+ *
+ * export const [useTheme, provideTheme] = createTheme('v0:theme', {
+ *   default: 'light',
+ *   themes: {
+ *     light: {
+ *       dark: false,
+ *       colors: {
+ *         primary: '#3b82f6',
+ *       },
+ *     },
+ *     dark: {
+ *       dark: true,
+ *       colors: {
+ *         primary: '#675496',
+ *       },
+ *     },
+ *   },
+ * })
+ * ```
+ */
+declare function createTheme<Z extends ThemeTicket = ThemeTicket, E extends ThemeContext<Z> = ThemeContext<Z>>(namespace?: string, options?: ThemeOptions): ContextTrinity<E>;
+/**
+ * Returns the current theme instance.
+ *
+ * @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(): ThemeContext<ThemeTicket>;
+/**
+ * Creates a new 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.
+ *
+ * @see https://0.vuetifyjs.com/composables/plugins/use-theme
+ *
+ * @example
+ * ```ts
+ * import { createApp } from 'vue'
+ * import { createThemePlugin } from '@vuetify/v0'
+ * import App from './App.vue'
+ *
+ * const app = createApp(App)
+ *
+ * app.use(
+ *   createThemePlugin({
+ *     default: 'light',
+ *     themes: {
+ *       light: {
+ *         dark: false,
+ *         colors: {
+ *           primary: '#3b82f6',
+ *         },
+ *       },
+ *       dark: {
+ *         dark: true,
+ *         colors: {
+ *           primary: '#675496',
+ *         },
+ *       },
+ *     },
+ *   })
+ * )
+ *
+ * app.mount('#app')
+ * ```
+ */
+declare function createThemePlugin<Z extends ThemeTicket = ThemeTicket, E extends ThemeContext<Z> = ThemeContext<Z>>(_options?: ThemePluginOptions): Plugin;
+//#endregion
+//#region src/composables/useTimeline/index.d.ts
+interface TimelineContext<Z extends TimelineTicket> extends RegistryContext<Z> {
+  undo: () => Z | undefined;
+  redo: () => Z | undefined;
+}
+interface TimelineTicket extends RegistryTicket {}
+interface TimelineOptions extends RegistryOptions {
+  size?: number;
+}
+/**
+ * Creates a new timeline instance.
+ *
+ * @param _options The options for the timeline instance.
+ * @template Z The type of the timeline ticket.
+ * @template E The type of the timeline context.
+ * @returns A new timeline instance.
+ *
+ * @see https://0.vuetifyjs.com/composables/registration/use-timeline
+ *
+ * @example
+ * ```ts
+ * import { useTimeline } from '@vuetify/v0'
+ *
+ * const timeline = useTimeline({ size: 3 })
+ *
+ * timeline.onboard([{ id: 'one' }, { id: 'two' }, { id: 'three' }])
+ *
+ * console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }, { id: 'three' }]
+ *
+ * timeline.undo()
+ * console.log(timeline.values()) // [{ id: 'one' }, { id: 'two' }]
+ *
+ * timeline.redo()
+ * 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;
+//#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 };