@vuetify/v0 0.0.2-beta.1

package/dist/index.d.mts

@@ -0,0 +1,1378 @@
+import * as vue199 from "vue";
+import { App, ComputedRef, InjectionKey, MaybeRef, MaybeRefOrGetter, ModelRef, Reactive, Ref, ShallowReactive, ShallowRef, TemplateRef, UnwrapNestedRefs, h } from "vue";
+import { AnyARecord } from "node:dns";
+
+//#region src/types/index.d.ts
+type DOMElement = Parameters<typeof h>[0];
+type ID = string | number;
+type DeepPartial<T> = T extends object ? { [P in keyof T]?: DeepPartial<T[P]> } : T;
+type MaybeArray<T> = T | T[];
+//#endregion
+//#region src/components/Atom/Atom.vue.d.ts
+interface AtomProps {
+  as?: DOMElement | null;
+  renderless?: boolean;
+}
+interface AtomSlots<T> {
+  default: (props: T) => any;
+}
+interface AtomExpose {
+  element: TemplateRef<HTMLElement | null>;
+}
+interface AtomPrivateProps extends AtomProps {}
+declare const _default: <T extends Record<string, any> = {}>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{} & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps, never>, never> & AtomPrivateProps & Partial<{}>> & vue199.PublicProps;
+  expose(exposed: vue199.ShallowUnwrapRef<AtomExpose>): void;
+  attrs: any;
+  slots: AtomSlots<T>;
+  emit: {};
+}>) => vue199.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+type __VLS_PrettifyLocal<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/composables/useBreakpoints/index.d.ts
+type BreakpointName = 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+interface BreakpointsContext {
+  breakpoints: Readonly<Record<BreakpointName, number>>;
+  name: BreakpointName;
+  width: number;
+  height: number;
+  isMobile: boolean;
+  xs: boolean;
+  sm: boolean;
+  md: boolean;
+  lg: boolean;
+  xl: boolean;
+  xxl: boolean;
+  smAndUp: boolean;
+  mdAndUp: boolean;
+  lgAndUp: boolean;
+  xlAndUp: boolean;
+  xxlAndUp: boolean;
+  smAndDown: boolean;
+  mdAndDown: boolean;
+  lgAndDown: boolean;
+  xlAndDown: boolean;
+  xxlAndDown: boolean;
+  update: () => void;
+}
+interface BreakpointsOptions {
+  mobileBreakpoint?: BreakpointName | number;
+  breakpoints?: Partial<Record<BreakpointName, number>>;
+}
+interface BreakpointsPlugin {
+  install: (app: App, ...options: any[]) => any;
+}
+declare const useBreakpointsContext: (namespace?: string) => BreakpointsContext, provideBreakpointsContext: (context: BreakpointsContext, app?: App) => BreakpointsContext;
+/**
+ * Simple hook to access the breakpoints context.
+ *
+ * @returns The breakpoints context containing current breakpoint information.
+ */
+declare function useBreakpoints(): BreakpointsContext;
+/**
+ * Creates a reactive breakpoints system for responsive behavior management.
+ * This function provides access to viewport dimensions, breakpoint detection, and helper flags
+ * for determining current screen size and implementing responsive logic.
+ *
+ * @param options Optional configuration for breakpoint thresholds and mobile breakpoint.
+ * @returns A breakpoints context object with reactive state and utility methods.
+ */
+declare function createBreakpoints(options?: BreakpointsOptions): vue199.ShallowReactive<{
+  breakpoints: {
+    readonly xs: 0;
+    readonly sm: 600;
+    readonly md: 960;
+    readonly lg: 1280;
+    readonly xl: 1920;
+    readonly xxl: 2560;
+  };
+  name: BreakpointName;
+  width: number;
+  height: number;
+  isMobile: boolean;
+  xs: boolean;
+  sm: boolean;
+  md: boolean;
+  lg: boolean;
+  xl: boolean;
+  xxl: boolean;
+  smAndUp: boolean;
+  mdAndUp: boolean;
+  lgAndUp: boolean;
+  xlAndUp: boolean;
+  xxlAndUp: boolean;
+  smAndDown: boolean;
+  mdAndDown: boolean;
+  lgAndDown: boolean;
+  xlAndDown: boolean;
+  xxlAndDown: boolean;
+  update: () => void;
+}>;
+/**
+ * Creates a Vue plugin for managing responsive breakpoints with automatic updates.
+ * This plugin sets up breakpoint tracking and updates the context when the window
+ * is resized, providing reactive breakpoint state throughout the application.
+ *
+ * @param options Optional configuration for breakpoint thresholds and mobile breakpoint.
+ * @returns A Vue plugin object with install method.
+ */
+declare function createBreakpointsPlugin(options?: BreakpointsOptions): BreakpointsPlugin;
+//#endregion
+//#region src/components/Breakpoints/BreakpointsItem.vue.d.ts
+interface BreakpointsSlots {
+  default: (scope: BreakpointsContext) => any;
+  xs?: (scope: BreakpointsContext) => any;
+  sm?: (scope: BreakpointsContext) => any;
+  md?: (scope: BreakpointsContext) => any;
+  lg?: (scope: BreakpointsContext) => any;
+  xl?: (scope: BreakpointsContext) => any;
+  xxl?: (scope: BreakpointsContext) => any;
+}
+//#endregion
+//#region src/components/Breakpoints/BreakpointsRoot.vue.d.ts
+interface BreakpointsRootProps extends BreakpointsOptions {}
+interface BreakpointsRootSlots {
+  default: (scope: BreakpointsContext) => any;
+}
+//#endregion
+//#region src/components/Breakpoints/index.d.ts
+declare const Breakpoints: {
+  Item: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, vue199.PublicProps, {}, true, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<{}> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: BreakpointsSlots;
+  });
+  Root: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<BreakpointsRootProps> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, vue199.PublicProps, {}, false, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<BreakpointsRootProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<BreakpointsRootProps> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: BreakpointsRootSlots;
+  });
+};
+//#endregion
+//#region src/components/Context/ContextItem.vue.d.ts
+interface ContextSlots<T> {
+  default: (props: {
+    value: T;
+  }) => any;
+}
+//#endregion
+//#region src/components/Context/ContextRoot.vue.d.ts
+interface ContextRootSlots {
+  default: () => any;
+}
+//#endregion
+//#region src/components/Context/index.d.ts
+declare const Context: {
+  Item: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: {};
+    slots: ContextSlots<T>;
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      contextKey?: string | vue199.InjectionKey<T> | undefined;
+      value?: T | undefined;
+    } & vue199.PublicProps;
+    expose(exposed: vue199.ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: ContextSlots<T>;
+    emit: {};
+  }>) => vue199.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  Root: <T>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: {};
+    slots: ContextRootSlots;
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      contextKey: string | vue199.InjectionKey<T>;
+      value: T;
+    } & vue199.PublicProps;
+    expose(exposed: vue199.ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: ContextRootSlots;
+    emit: {};
+  }>) => vue199.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+};
+//#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. 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. It's not recommended to manually set this. */
+  valueIsIndex: boolean;
+}
+interface RegistryContext<Z extends RegistryTicket = RegistryTicket> {
+  /** The collection of tickets */
+  collection: Map<ID, Z>;
+  /** Clear the entire registry */
+  clear: () => void;
+  /** Check if an item exists by id */
+  has: (id: ID) => boolean;
+  /** Returns an array of registered IDs */
+  keys: () => ID[];
+  /** Browse for an ID by value */
+  browse: (value: unknown) => ID | ID[] | undefined;
+  /** lookup a ticket by index number */
+  lookup: (index: number) => ID | undefined;
+  /** Get a ticket by id */
+  get: (id: ID) => Z | undefined;
+  /** Get all registered tickets */
+  values: () => Z[];
+  /** Get all entries as [id, ticket] pairs */
+  entries: () => [ID, Z][];
+  /** Register a new item */
+  register: (item?: Partial<Z>) => Z;
+  /** Unregister an item by id */
+  unregister: (id: ID) => void;
+  /** Reset the index directory and update all tickets */
+  reindex: () => void;
+  /** Listen for registry events */
+  on: (event: string, cb: Function) => void;
+  /** Stop listening for registry events */
+  off: (event: string, cb: Function) => void;
+  /** Emit an event with data */
+  emit: (event: string, data: any) => void;
+  /** Clears the registry and listeners */
+  dispose: () => void;
+  /** Onboard multiple new items */
+  onboard: (registrations: Partial<Z>[]) => Z[];
+  /** The size of the registry */
+  size: number;
+}
+interface RegistryOptions {
+  /** Enable event emission for registry operations */
+  events?: boolean;
+}
+/**
+ * Creates a registry for managing collections of items with registration and lookup capabilities.
+ * This function provides the foundation for item management systems with ID-based, value-based,
+ * and index-based access patterns.
+ *
+ * @param options Optional configuration for enabling events.
+ * @template Z The type of items managed by the registry.
+ * @template E The type of the registry context.
+ * @returns The registry context object.
+ */
+declare function useRegistry<Z extends RegistryTicket = RegistryTicket, E extends RegistryContext<Z> = RegistryContext<Z>>(options?: RegistryOptions): E;
+//#endregion
+//#region src/composables/useSelection/index.d.ts
+interface SelectionTicket extends RegistryTicket {
+  disabled: boolean;
+  isActive: 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;
+  /** 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 selection context for managing collections of selectable items.
+ * This function extends the registry functionality with selection state management.
+ *
+ * @param options Optional configuration for selection behavior.
+ * @template Z The type of items managed by the selection.
+ * @template E The type of the selection context.
+ * @returns The selection context object.
+ */
+declare function useSelection<Z extends SelectionTicket = SelectionTicket, E extends SelectionContext<Z> = SelectionContext<Z>>(options?: SelectionOptions): 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 group selection context for managing collections of items where multiple selections can be made.
+ * This function extends the selection functionality with group selection capabilities.
+ *
+ * @param options Optional configuration for group selection behavior.
+ * @template Z The type of items managed by the group selection.
+ * @template E The type of the group selection context.
+ * @returns The group selection context object.
+ */
+declare function useGroup<Z extends GroupTicket = GroupTicket, E extends GroupContext<Z> = GroupContext<Z>>(options?: GroupOptions): E;
+//#endregion
+//#region src/components/Group/GroupItem.vue.d.ts
+interface GroupItemProps {
+  id?: string;
+  value?: any;
+  disabled?: boolean;
+  namespace?: string;
+}
+interface GroupItemSlots {
+  default: (scope: UnwrapNestedRefs<GroupTicket>) => any;
+}
+//#endregion
+//#region src/components/Group/GroupRoot.vue.d.ts
+interface GroupRootProps extends GroupOptions {
+  namespace?: string;
+}
+interface GroupRootSlots {
+  default: (scope: GroupContext & {
+    model: ModelRef<any>;
+  }) => any;
+}
+//#endregion
+//#region src/components/Group/index.d.ts
+declare const Group: {
+  Item: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<GroupItemProps> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, vue199.PublicProps, {}, false, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<GroupItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<GroupItemProps> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: GroupItemSlots;
+  });
+  Root: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<GroupRootProps & {
+      modelValue?: any;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+      "update:modelValue": (value: any) => any;
+    }, vue199.PublicProps, {}, false, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<GroupRootProps & {
+      modelValue?: any;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<GroupRootProps & {
+    modelValue?: any;
+  }> & Readonly<{
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+  }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+    "update:modelValue": (value: any) => any;
+  }, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: GroupRootSlots;
+  });
+};
+//#endregion
+//#region src/composables/useHydration/index.d.ts
+interface HydrationContext {
+  isHydrated: Readonly<ShallowRef<boolean>>;
+  hydrate: () => void;
+}
+interface HydrationPlugin {
+  install: (app: App, ...options: any[]) => any;
+}
+declare const useHydrationContext: (namespace?: string) => HydrationContext, provideHydrationContext: (context: HydrationContext, app?: App) => HydrationContext;
+/**
+ * Creates a hydration context for tracking client-side hydration state in SSR applications.
+ * This function provides a way to determine when the application has been fully hydrated
+ * on the client side, which is essential for SSR/SSG compatibility.
+ *
+ * @returns A hydration context object with reactive state and hydration control.
+ */
+declare function createHydration(): HydrationContext;
+/**
+ * Simple hook to access the hydration context.
+ *
+ * @returns The hydration context containing hydration state and controls.
+ */
+declare function useHydration(): HydrationContext;
+/**
+ * Creates a Vue plugin for hydration state management in SSR/SSG applications.
+ * This plugin automatically detects when the root component is mounted and
+ * triggers the hydration process, ensuring proper client-side hydration timing.
+ *
+ * @returns A Vue plugin object with install method.
+ */
+declare function createHydrationPlugin(): HydrationPlugin;
+//#endregion
+//#region src/components/Hydration/Hydration.vue.d.ts
+interface HydrationSlots {
+  default: (scope: HydrationContext) => any;
+}
+declare const _default$1: __VLS_WithSlots$1<vue199.DefineComponent<{}, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, string, vue199.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue199.ComponentProvideOptions, true, {}, any>, HydrationSlots>;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Hydration/HydrationRoot.vue.d.ts
+interface HydrationRootSlots {
+  default: (scope: HydrationContext) => any;
+}
+declare const _default$2: __VLS_WithSlots<vue199.DefineComponent<{}, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, string, vue199.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue199.ComponentProvideOptions, true, {}, any>, HydrationRootSlots>;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Popover/PopoverRoot.vue.d.ts
+interface PopoverContext {
+  isActive: ShallowRef<boolean>;
+  id: string;
+  toggle: () => void;
+}
+interface PopoverRootProps extends AtomProps {
+  id?: string;
+}
+declare const usePopoverContext: (namespace?: string) => PopoverContext, providePopoverContext: (context: PopoverContext, app?: vue199.App) => PopoverContext;
+//#endregion
+//#region src/components/Popover/PopoverAnchor.vue.d.ts
+interface PopoverAnchorProps extends AtomProps {
+  target?: string;
+}
+//#endregion
+//#region src/components/Popover/PopoverContent.vue.d.ts
+interface PopoverContentProps extends AtomProps {
+  id?: string;
+  positionArea?: string;
+  positionTry?: string;
+}
+interface PopoverContentEmits {
+  beforetoggle: [e: ToggleEvent];
+}
+//#endregion
+//#region src/components/Popover/index.d.ts
+declare const Popover: {
+  Root: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<PopoverRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+      "update:modelValue": (value: boolean) => any;
+    }, vue199.PublicProps, {}, false, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<PopoverRootProps & {
+    modelValue?: boolean;
+  }> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+  }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+  }, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: {
+        id: Readonly<vue199.Ref<string, string>>;
+        isActive: vue199.ModelRef<boolean, string, boolean, boolean>;
+        toggle: () => void;
+      }) => any;
+    };
+  });
+  Anchor: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<PopoverAnchorProps> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, vue199.PublicProps, {}, false, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverAnchorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<PopoverAnchorProps> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  });
+  Content: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<PopoverContentProps> & Readonly<{
+      onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+    }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+      beforetoggle: (e: ToggleEvent) => any;
+    }, vue199.PublicProps, {}, false, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverContentProps> & Readonly<{
+      onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<PopoverContentProps> & Readonly<{
+    onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+  }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+    beforetoggle: (e: ToggleEvent) => any;
+  }, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Step/StepItem.vue.d.ts
+interface StepItemProps {
+  id?: string;
+  value?: any;
+  disabled?: boolean;
+  namespace?: string;
+}
+interface StepItemSlots {
+  default: (scope: UnwrapNestedRefs<GroupTicket>) => any;
+}
+//#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 single selection context for managing collections where only one item can be selected.
+ * This function extends the selection functionality with single-selection constraints.
+ *
+ * @param options Optional configuration for single selection behavior.
+ * @template Z The type of items managed by the single selection.
+ * @template E The type of the single selection context.
+ * @returns The single selection context object.
+ */
+declare function useSingle<Z extends SingleTicket = SingleTicket, E extends SingleContext<Z> = SingleContext<Z>>(options?: SingleOptions): E;
+//#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 step selection context for managing collections where users can navigate through items sequentially.
+ * This function extends the single selection functionality with stepping navigation.
+ *
+ * @param options Optional configuration for step behavior.
+ * @template Z The type of items managed by the step selection.
+ * @template E The type of the step selection context.
+ * @returns The step selection context object.
+ */
+declare function useStep<Z extends StepTicket = StepTicket, E extends StepContext<Z> = StepContext<Z>>(options?: StepOptions): E;
+//#endregion
+//#region src/components/Step/StepRoot.vue.d.ts
+interface StepRootProps extends StepOptions {
+  namespace?: string;
+}
+interface StepRootSlots {
+  default: (scope: StepContext & {
+    model: ModelRef<any>;
+  }) => any;
+}
+//#endregion
+//#region src/components/Step/index.d.ts
+declare const Step: {
+  Item: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<StepItemProps> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, vue199.PublicProps, {}, false, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<StepItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<StepItemProps> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: StepItemSlots;
+  });
+  Root: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<StepRootProps & {
+      modelValue?: any;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+      "update:modelValue": (value: any) => any;
+    }, vue199.PublicProps, {}, false, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<StepRootProps & {
+      modelValue?: any;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<StepRootProps & {
+    modelValue?: any;
+  }> & Readonly<{
+    "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+  }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+    "update:modelValue": (value: any) => any;
+  }, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: StepRootSlots;
+  });
+};
+//#endregion
+//#region src/composables/useTheme/adapters/adapter.d.ts
+interface ThemeAdapterInterface {
+  update: (colors: Record<string, Colors>) => void;
+}
+declare abstract class ThemeAdapter implements ThemeAdapterInterface {
+  protected prefix: string;
+  constructor(prefix: string);
+  generate(colors: Record<string, Colors>): string;
+  abstract update(colors: Record<string, Colors>): void;
+}
+//#endregion
+//#region src/factories/createTrinity/index.d.ts
+type ContextTrinity<Z = unknown> = readonly [() => Z, (context?: Z, app?: App) => Z, Z];
+/**
+ * A tuple containing Vue's provide/inject and a context object
+ * @param createContext The function that creates the context
+ * @param provideContext The function that provides context
+ * @param context The underlying context object singleton
+ * @template Z The type parameter for the context value
+ * @template E The vmodel type for the context state.
+ * @returns [createContext, provideContext, context]
+ *
+ * @see https://0.vuetifyjs.com/composables/foundation/create-trinity
+ */
+declare function createTrinity<Z = unknown>(createContext: () => Z, provideContext: (_context?: Z, app?: App) => Z, context: Z): ContextTrinity<Z>;
+//#endregion
+//#region src/composables/useTokens/index.d.ts
+interface TokenAlias {
+  [key: string]: any;
+  $value: string;
+  $type?: string;
+  $description?: string;
+}
+type TokenValue = string | number | boolean | 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> {
+  resolve: (token: string) => string | undefined;
+}
+/**
+ * Creates a token registry for managing design token collections with alias resolution.
+ * Returns the token context directly for simple usage.
+ *
+ * @param tokens A collection of tokens to initialize with
+ * @template Z The structure of the registry token items.
+ * @template E The available methods for the token's context.
+ * @returns The token context object.
+ */
+declare function useTokens<Z extends TokenTicket = TokenTicket, E extends TokenContext<Z> = TokenContext<Z>>(tokens?: TokenCollection): E;
+/**
+ * Creates a token registry context with full injection/provision control.
+ * Returns the complete trinity for advanced usage scenarios.
+ *
+ * @param namespace The namespace for the token registry context
+ * @param tokens An optional collection of tokens to initialize
+ * @template Z The structure of the registry token items.
+ * @template E The available methods for the token's context.
+ * @returns A tuple containing the inject function, provide function, and the token context.
+ */
+declare function createTokensContext<Z extends TokenTicket = TokenTicket, E extends TokenContext<Z> = TokenContext<Z>>(namespace: string, tokens?: TokenCollection): ContextTrinity<E>;
+//#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>;
+}
+interface ThemePlugin {
+  install: (app: App, ...options: any[]) => any;
+}
+/**
+ * Creates a theme registry for managing theme selections with dynamic color resolution.
+ * Supports token-based color systems and lazy theme loading for optimal performance.
+ *
+ * @param namespace The namespace for the theme context.
+ * @param options Configuration including adapter and themes.
+ * @template Z The type of theme context.
+ * @template E The type of theme items managed by the registry.
+ * @returns A tuple containing inject, provide functions and the theme context.
+ */
+declare function createTheme<Z extends ThemeTicket = ThemeTicket, E extends ThemeContext<Z> = ThemeContext<Z>>(namespace?: string, options?: ThemeOptions): ContextTrinity<E>;
+/**
+ * Simple hook to access the theme context.
+ *
+ * @returns The theme context containing current theme state and utilities.
+ */
+declare function useTheme(): ThemeContext<ThemeTicket>;
+/**
+ * Creates a Vue plugin for theme management with automatic color system updates.
+ * Integrates with token system for dynamic color resolution and provides reactive
+ * theme switching capabilities throughout the application.
+ *
+ * @param options Configuration for themes, palette, and adapter.
+ * @template Z The type of theme context.
+ * @template E The type of theme items.
+ * @template R The type of token context.
+ * @template O The type of token items.
+ * @returns A Vue plugin object with install method.
+ */
+declare function createThemePlugin<Z extends ThemeTicket = ThemeTicket, E extends ThemeContext<Z> = ThemeContext<Z>, R extends TokenTicket = TokenTicket, O extends TokenContext<R> = TokenContext<R>>(_options?: ThemePluginOptions): ThemePlugin;
+//#endregion
+//#region src/components/Theme/ThemeItem.vue.d.ts
+interface ThemeSlots {
+  default: (scope: ThemeContext) => any;
+}
+//#endregion
+//#region src/components/Theme/ThemeRoot.vue.d.ts
+interface ThemeRootProps {
+  namespace?: string;
+  themes?: ThemeItem[];
+}
+interface ThemeRootSlots {
+  default: (scope: ThemeContext) => any;
+}
+//#endregion
+//#region src/components/Theme/index.d.ts
+declare const Theme: {
+  Item: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<{}> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, vue199.PublicProps, {}, true, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<{}> & Readonly<{}>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: ThemeSlots;
+  });
+  Root: {
+    new (...args: any[]): vue199.CreateComponentPublicInstanceWithMixins<Readonly<ThemeRootProps & {
+      modelValue?: ID;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: ID) => any) | undefined;
+    }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+      "update:modelValue": (value: ID) => any;
+    }, vue199.PublicProps, {}, false, {}, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, {}, any, vue199.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ThemeRootProps & {
+      modelValue?: ID;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: ID) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue199.ComponentOptionsBase<Readonly<ThemeRootProps & {
+    modelValue?: ID;
+  }> & Readonly<{
+    "onUpdate:modelValue"?: ((value: ID) => any) | undefined;
+  }>, void, {}, {}, {}, vue199.ComponentOptionsMixin, vue199.ComponentOptionsMixin, {
+    "update:modelValue": (value: ID) => any;
+  }, string, {}, {}, string, {}, vue199.GlobalComponents, vue199.GlobalDirectives, string, vue199.ComponentProvideOptions> & vue199.VNodeProps & vue199.AllowedComponentProps & vue199.ComponentCustomProps & (new () => {
+    $slots: ThemeRootSlots;
+  });
+};
+//#endregion
+//#region src/composables/useEventListener/index.d.ts
+type CleanupFunction = () => void;
+type EventHandler<E = Event> = (event: E) => void;
+/**
+ * Attaches event listeners to the window object with automatic cleanup.
+ * This overload provides type-safe event handling for window-specific events
+ * with proper event map typing and automatic listener removal on scope disposal.
+ *
+ * @param target Window object to attach listeners to.
+ * @param event Event name(s) to listen for from WindowEventMap.
+ * @param listener Event handler function(s) with proper window event typing.
+ * @param options Optional event listener configuration.
+ * @returns Function to manually remove all attached listeners.
+ */
+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 event listeners to the document object with automatic cleanup.
+ * This overload provides type-safe event handling for document-specific events
+ * with proper event map typing and automatic listener removal on scope disposal.
+ *
+ * @param target Document object to attach listeners to.
+ * @param event Event name(s) to listen for from DocumentEventMap.
+ * @param listener Event handler function(s) with proper document event typing.
+ * @param options Optional event listener configuration.
+ * @returns Function to manually remove all attached listeners.
+ */
+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 event listeners to HTML elements with automatic cleanup.
+ * This overload provides type-safe event handling for HTML element events
+ * with reactive target support and automatic listener removal on scope disposal.
+ *
+ * @param target HTML element or reactive reference to element.
+ * @param event Event name(s) to listen for from HTMLElementEventMap.
+ * @param listener Event handler function(s) with proper HTML element event typing.
+ * @param options Optional event listener configuration.
+ * @returns Function to manually remove all attached listeners.
+ */
+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 event listeners to any EventTarget with automatic cleanup.
+ * This overload provides flexible event handling for any EventTarget implementation
+ * with reactive target support and automatic listener removal on scope disposal.
+ *
+ * @param target EventTarget or reactive reference to target.
+ * @param event Event name(s) to listen for as string identifiers.
+ * @param listener Event handler function(s) with customizable event typing.
+ * @param options Optional event listener configuration.
+ * @returns Function to manually remove all attached listeners.
+ */
+declare function useEventListener<EventType = Event>(target: MaybeRefOrGetter<EventTarget | null | undefined>, event: MaybeRefOrGetter<MaybeArray<string>>, listener: MaybeRef<MaybeArray<EventHandler<EventType>>>, options?: MaybeRefOrGetter<boolean | AddEventListenerOptions>): CleanupFunction;
+/**
+ * Convenience function for attaching event listeners to the window object.
+ * This function provides a simplified API by pre-binding the window target,
+ * making it easier to handle window-specific events with automatic cleanup.
+ *
+ * @param event Event name(s) to listen for from WindowEventMap.
+ * @param listener Event handler function(s) with proper window event typing.
+ * @param options Optional event listener configuration.
+ * @returns Function to manually remove all attached listeners.
+ */
+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;
+/**
+ * Convenience function for attaching event listeners to the document object.
+ * This function provides a simplified API by pre-binding the document target,
+ * making it easier to handle document-specific events with automatic cleanup.
+ *
+ * @param event Event name(s) to listen for from DocumentEventMap.
+ * @param listener Event handler function(s) with proper document event typing.
+ * @param options Optional event listener configuration.
+ * @returns Function to manually remove all attached listeners.
+ */
+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/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[]>;
+}
+/**
+ * Creates a reactive filter for arrays based on query matching with configurable search modes.
+ * Supports 'some' (any field matches), 'every' (all fields match), 'union' (any query matches),
+ * and 'intersection' (all queries match) filtering strategies.
+ *
+ * @param query Filter query to match against items.
+ * @param items Collection of items to filter.
+ * @param options Optional configuration for the filter behavior.
+ * @template Z The type of the items being filtered.
+ * @returns A computed reference to the filtered items based on the query and options.
+ */
+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: AnyARecord) => 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: ShallowRef<boolean | null>;
+  isValidating: ShallowRef<boolean>;
+}
+interface FormOptions extends RegistryOptions {
+  validateOn?: 'submit' | 'change' | string;
+}
+declare function useForm<Z extends FormTicket = FormTicket, E extends FormContext<Z> = FormContext<Z>>(options?: FormOptions): E;
+//#endregion
+//#region src/composables/useKeydown/index.d.ts
+interface KeyHandler {
+  key: string;
+  handler: (event: KeyboardEvent) => void;
+  preventDefault?: boolean;
+  stopPropagation?: boolean;
+}
+/**
+ * Sets up global keyboard event listeners for specified key handlers with automatic cleanup.
+ * This composable automatically starts listening when mounted and cleans up when the scope
+ * is disposed, providing a clean way to handle global keyboard interactions.
+ *
+ * @param handlers A single handler or array of handlers to register for keydown events.
+ * @returns Object with methods to manually start and stop listening for keydown events.
+ */
+declare function useKeydown(handlers: KeyHandler[] | KeyHandler): {
+  startListening: () => void;
+  stopListening: () => void;
+};
+//#endregion
+//#region src/composables/useLayout/index.d.ts
+type LayoutLocation = 'top' | 'bottom' | 'left' | 'right';
+interface LayoutTicket extends GroupTicket {
+  order: number;
+  position: LayoutLocation;
+  value: number;
+}
+interface LayoutContext<Z extends LayoutTicket> extends GroupContext<Z> {
+  bounds: {
+    top: ComputedRef<number>;
+    bottom: ComputedRef<number>;
+    left: ComputedRef<number>;
+    right: ComputedRef<number>;
+  };
+  main: {
+    x: ComputedRef<number>;
+    y: ComputedRef<number>;
+    width: ComputedRef<number>;
+    height: ComputedRef<number>;
+  };
+  sizes: ShallowReactive<Map<ID, number>>;
+  height: ShallowRef<number>;
+  width: ShallowRef<number>;
+}
+interface LayoutOptions extends GroupOptions {}
+declare function useLayout<Z extends LayoutTicket = LayoutTicket, E extends LayoutContext<Z> = LayoutContext<Z>>(_options?: LayoutOptions): 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/index.d.ts
+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 TokenCollection = TokenCollection> {
+  adapter?: LocaleAdapter;
+  default?: ID;
+  fallback?: ID;
+  messages?: Record<ID, Z>;
+}
+interface LocalePlugin {
+  install: (app: App, ...options: any[]) => any;
+}
+/**
+ * Creates a locale registry for managing internationalization with translations and number formatting.
+ * Supports message resolution with token references and locale-specific number formatting.
+ *
+ * @param namespace The namespace for the locale context.
+ * @param options Configuration including adapter and messages.
+ * @template Z The type of the locale context.
+ * @template E The type of the locale items managed by the registry.
+ * @returns An array containing the inject function, provide function, and the locale context.
+ */
+declare function createLocale<Z extends LocaleTicket = LocaleTicket, E extends LocaleContext<Z> = LocaleContext<Z>>(namespace?: string, options?: LocaleOptions): ContextTrinity<E>;
+/**
+ * Simple hook to access the locale context.
+ *
+ * @returns The locale context containing translation and formatting functions.
+ */
+declare function useLocale(): LocaleContext<LocaleTicket>;
+/**
+ * Creates a Vue plugin for internationalization with locale management and translation support.
+ * Integrates with token system for message resolution and provides app-wide locale context.
+ *
+ * @param options Configuration for adapter, default locale, and messages.
+ * @template Z The type of the locale context.
+ * @template E The type of the locale items managed by the registry.
+ * @template R The type of the token context.
+ * @template O The type of the token items managed by the registry.
+ * @returns Vue install function for the plugin
+ */
+declare function createLocalePlugin<Z extends LocaleTicket = LocaleTicket, E extends LocaleContext<Z> = LocaleContext<Z>, R extends TokenTicket = TokenTicket, O extends TokenContext<R> = TokenContext<R>>(options?: LocalePluginOptions): LocalePlugin;
+//#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;
+}
+interface LoggerPlugin {
+  install: (app: App, ...options: any[]) => any;
+}
+/**
+ * Creates a logger context for application logging with configurable adapters and levels.
+ * This function provides a consistent logging interface that can be configured with
+ * different adapters and optimized for production builds with conditional compilation.
+ *
+ * @param options Configuration for the logger adapter, level, and behavior.
+ * @returns A logger context object with logging methods and controls.
+ */
+declare function createLogger(options?: LoggerOptions): LoggerContext;
+declare function useLogger(namespace?: string): LoggerContext;
+declare function createLoggerPlugin(options?: LoggerOptions): LoggerPlugin;
+//#endregion
+//#region src/composables/useProxyModel/index.d.ts
+interface ProxyModelOptions {
+  /** Whether to use deep reactivity for the model */
+  deep?: boolean;
+}
+/**
+ * Creates a proxy model for two-way binding with a selection context.
+ *
+ * @param registry SelectionContext | GroupContext | SingleContext | StepContext
+ * @template Z The type of items managed by the selection.
+ * @template E The type of the selection context.
+ * @returns The proxy model for two-way binding with the selection context.
+ */
+declare function useProxyModel<Z extends SelectionTicket>(registry: SelectionContext<Z>, initial?: Z | Z[], options?: ProxyModelOptions, _transformIn?: (val: Z[] | Z) => Z[], _transformOut?: (val: Z[]) => Z | Z[]): vue199.WritableComputedRef<Z | Z[] | undefined, Z[]>;
+//#endregion
+//#region src/composables/useStorage/adapters/index.d.ts
+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 {
+  get: <T>(key: string, defaultValue?: T) => Ref<T>;
+  set: <T>(key: string, value: T) => void;
+  remove: (key: string) => void;
+  clear: () => void;
+}
+interface StorageOptions {
+  adapter?: StorageAdapter;
+  prefix?: string;
+  serializer?: {
+    read: (value: string) => any;
+    write: (value: any) => string;
+  };
+}
+interface StoragePlugin {
+  install: (app: App, ...options: any[]) => any;
+}
+declare const useStorageContext: (namespace?: string) => StorageContext, provideStorageContext: (context: StorageContext, app?: App) => StorageContext;
+/**
+ * Creates a reactive storage system with automatic persistence and cross-adapter support.
+ * This function provides a consistent interface for storing and retrieving reactive values
+ * that automatically sync with the underlying storage adapter (localStorage, memory, etc.).
+ *
+ * @param options Optional configuration for storage adapter, prefix, and serialization.
+ * @template E The type of the storage context.
+ * @returns A storage context object with get, set, remove, and clear methods.
+ */
+declare function createStorage<E extends StorageContext>(options?: StorageOptions): E;
+/**
+ * Simple hook to access the storage context.
+ *
+ * @returns The storage context containing reactive storage methods.
+ */
+declare function useStorage(): StorageContext;
+/**
+ * Creates a Vue plugin for reactive storage capabilities with automatic persistence.
+ * Provides app-wide access to reactive storage that syncs with the configured adapter.
+ *
+ * @param options Optional configuration for the storage system.
+ * @returns A Vue plugin object with install method.
+ */
+declare function createStoragePlugin(options?: StorageOptions): StoragePlugin;
+//#endregion
+//#region src/factories/createContext/index.d.ts
+type ContextKey<Z> = InjectionKey<Z> | string;
+/**
+ * A simple wrapper for tapping into a v0 namespace
+ * @param key The provided string or InjectionKey
+ * @template Z The type values for the context.
+ * @returns A function that retrieves context
+ * @throws Error if namespace is not found.
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#inject
+ */
+declare function useContext<Z>(key: ContextKey<Z>): (namespace?: string) => Z;
+/**
+ * A simple wrapper for Vues provide & inject systems
+ * to create context for managing application state
+ * @param key The provided string or InjectionKey
+ * @template Z The type values for the context.
+ * @returns A tuple containing provide/inject
+ *
+ * @see https://vuejs.org/api/composition-api-dependency-injection.html#provide
+ * @see https://0.vuetifyjs.com/composables/foundation/create-context
+ */
+declare function createContext<Z>(key: ContextKey<Z>): readonly [(namespace?: string) => Z, (context: Z, app?: App) => Z];
+//#endregion
+//#region src/factories/createPlugin/index.d.ts
+interface PluginOptions {
+  namespace: string;
+  provide: (app: App) => void;
+  setup?: (app: App) => void;
+}
+/**
+ * A universal plugin factory to reduce boilerplate code for Vue plugin creation
+ * @param options Configurable object with namespace and provide/setup methods
+ * @returns A Vue plugin object with install method that runs app w/ context
+ *
+ * @see https://vuejs.org/api/application.html#app-runwithcontext
+ * @see https://0.vuetifyjs.com/factories/create-plugin
+ */
+declare function createPlugin<Z>(options: PluginOptions): Z;
+//#endregion
+//#region src/transformers/toArray/index.d.ts
+declare function toArray<T>(value: T | T[]): T[];
+//#endregion
+//#region src/transformers/toReactive/index.d.ts
+/**
+ * Converts an object to a reactive reference using Vue's reactivity system.
+ * This function creates a reactive version of the provided object,
+ * making its properties automatically track dependencies and trigger re-renders
+ * when they change.
+ *
+ * @param objectRef - A reference to an object that should be made reactive.
+ * @template Z The type of the object that extends object.
+ * @returns A reactive reference to the object.
+ */
+declare function toReactive<Z extends object>(objectRef: MaybeRef<Z>): UnwrapNestedRefs<Z>;
+//#endregion
+//#region src/utilities/benchmark.d.ts
+interface BenchmarkResult {
+  readonly name: string;
+  readonly duration: number;
+  readonly ops: number;
+}
+declare function run(name: string, fn: () => void, samples?: number): Promise<BenchmarkResult>;
+//#endregion
+//#region src/utilities/helpers.d.ts
+declare function isFunction(item: unknown): item is Function;
+declare function isString(item: unknown): item is string;
+declare function isNumber(item: unknown): item is number;
+declare function isBoolean(item: unknown): item is boolean;
+declare function isObject(item: unknown): item is Record<string, unknown>;
+declare function isArray(item: unknown): item is unknown[];
+declare function isNullOrUndefined(item: unknown): item is null;
+declare function isPrimitive(item: unknown): item is string | number | boolean;
+declare function mergeDeep<T extends object>(target: T, ...sources: DeepPartial<T>[]): T;
+declare function genId(): string;
+//#endregion
+export { _default as Atom, AtomExpose, AtomProps, AtomSlots, BreakpointName, Breakpoints, BreakpointsContext, BreakpointsOptions, BreakpointsPlugin, CleanupFunction, Colors, ConsolaLoggerAdapter, Context, ContextKey, ContextTrinity, EventHandler, FilterFunction, FilterItem, FilterMode, FilterQuery, FlatTokenCollection, FormContext, FormOptions, FormTicket, FormValidationResult, FormValidationRule, FormValue, Group, GroupContext, type GroupItemProps, type GroupItemSlots, GroupOptions, type GroupRootProps, type GroupRootSlots, GroupTicket, _default$1 as Hydration, HydrationContext, HydrationPlugin, _default$2 as HydrationRoot, KeyHandler, LayoutContext, LayoutLocation, LayoutOptions, LayoutTicket, LocaleContext, LocaleOptions, LocalePlugin, LocalePluginOptions, LocaleTicket, type LogLevel, type LoggerAdapter, LoggerContext, LoggerOptions, LoggerPlugin, PinoLoggerAdapter, PluginOptions, Popover, type PopoverAnchorProps, type PopoverContentEmits, type PopoverContentProps, type PopoverContext, type PopoverRootProps, Primitive, ProxyModelOptions, RegistryContext, RegistryOptions, RegistryTicket, SelectionContext, SelectionOptions, SelectionTicket, SingleContext, SingleOptions, SingleTicket, Step, StepContext, type StepItemProps, type StepItemSlots, StepOptions, type StepRootProps, type StepRootSlots, StepTicket, StorageContext, StorageOptions, StoragePlugin, Theme, ThemeColors, ThemeContext, ThemeOptions, ThemePlugin, ThemePluginOptions, ThemeRecord, type ThemeRootProps, type ThemeRootSlots, type ThemeSlots, ThemeTicket, TokenAlias, TokenCollection, TokenContext, TokenTicket, TokenValue, UseFilterOptions, UseFilterResult, Vuetify0LoggerAdapter, createBreakpoints, createBreakpointsPlugin, createContext, createHydration, createHydrationPlugin, createLocale, createLocalePlugin, createLogger, createLoggerPlugin, createPlugin, createStorage, createStoragePlugin, createTheme, createThemePlugin, createTokensContext, createTrinity, genId, isArray, isBoolean, isFunction, isNullOrUndefined, isNumber, isObject, isPrimitive, isString, mergeDeep, provideBreakpointsContext, provideHydrationContext, providePopoverContext, provideStorageContext, run, toArray, toReactive, useBreakpoints, useBreakpointsContext, useContext, useDocumentEventListener, useEventListener, useFilter, useForm, useGroup, useHydration, useHydrationContext, useKeydown, useLayout, useLocale, useLogger, usePopoverContext, useProxyModel, useRegistry, useSelection, useSingle, useStep, useStorage, useStorageContext, useTheme, useTokens, useWindowEventListener };