@vuetify/v0 0.0.15 → 0.0.18

package/dist/index-oQuVnpOj.d.mts

@@ -0,0 +1,2442 @@
+import { i as ID, t as DOMElement } from "./index-C5LQZd3v.mjs";
+import { I as RegistryContext, M as SelectionTicket, S as GroupContext, T as GroupTicket, c as SingleContext, d as SingleTicket, h as PaginationContext, i as StepTicket, k as SelectionContext, t as StepContext, v as PaginationTicket, z as RegistryTicket } from "./index-DaX9-kmY.mjs";
+import * as vue319 from "vue";
+import { MaybeRef, Ref, ShallowRef, TemplateRef } from "vue";
+
+//#region src/components/Atom/Atom.vue.d.ts
+/**
+ * Props for the Atom component
+ */
+interface AtomProps {
+  /**
+   * The HTML element to render as, or null for renderless mode
+   * @default 'div'
+   */
+  as?: DOMElement | null;
+  /**
+   * When true, renders slot content directly without a wrapper element
+   * @default false
+   */
+  renderless?: boolean;
+}
+/**
+ * Slot types for the Atom component
+ * @template T - The type of props passed to the slot
+ */
+interface AtomSlots<T> {
+  /**
+   * Default slot that receives all forwarded attributes as props
+   */
+  default: (props: T) => any;
+}
+/**
+ * Values exposed by the Atom component via defineExpose
+ */
+interface AtomExpose {
+  /**
+   * Template ref to the rendered HTML element (null in renderless mode)
+   */
+  element: TemplateRef<HTMLElement | null>;
+}
+interface AtomPrivateProps extends AtomProps {}
+declare const __VLS_export$27: <T extends Record<string, any> = {}>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$11<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$11<AtomPrivateProps> & vue319.PublicProps;
+  expose: (exposed: vue319.ShallowUnwrapRef<AtomExpose>) => void;
+  attrs: any;
+  slots: AtomSlots<T>;
+  emit: {};
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$27: typeof __VLS_export$27;
+type __VLS_PrettifyLocal$11<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Avatar/AvatarRoot.vue.d.ts
+interface AvatarRootProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface AvatarTicket extends SelectionTicket {
+  type?: 'image' | 'fallback';
+  priority?: number;
+}
+interface AvatarContext extends SelectionContext<AvatarTicket> {}
+declare const useAvatarRoot: (key: string, defaultValue?: AvatarContext | undefined) => AvatarContext, provideAvatarContext: (key: string, context: AvatarContext, app?: vue319.App) => AvatarContext;
+declare const __VLS_export$26: __VLS_WithSlots$15<vue319.DefineComponent<AvatarRootProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+declare const _default$26: typeof __VLS_export$26;
+type __VLS_WithSlots$15<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Avatar/AvatarImage.vue.d.ts
+interface AvatarImageProps extends AtomProps {
+  /** Image source URL */
+  src?: string;
+  /** Priority for display order (higher = more preferred) */
+  priority?: number;
+  /** Namespace for retrieving avatar context */
+  namespace?: string;
+}
+interface AvatarImageEmits {
+  load: [e: Event];
+  error: [e: Event];
+}
+interface AvatarImageSlotProps {
+  /** Whether this image is currently visible */
+  isSelected: boolean;
+  /** Attributes to bind to the image element */
+  attrs: {
+    role: 'img';
+    src?: string;
+    onLoad: (e: Event) => void;
+    onError: (e: Event) => void;
+  };
+}
+declare const __VLS_export$25: __VLS_WithSlots$14<vue319.DefineComponent<AvatarImageProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {
+  load: (e: Event) => any;
+  error: (e: Event) => any;
+}, string, vue319.PublicProps, Readonly<AvatarImageProps> & Readonly<{
+  onLoad?: ((e: Event) => any) | undefined;
+  onError?: ((e: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: AvatarImageSlotProps) => any;
+}>;
+declare const _default$25: typeof __VLS_export$25;
+type __VLS_WithSlots$14<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Avatar/AvatarFallback.vue.d.ts
+interface AvatarFallbackProps extends AtomProps {
+  /** Namespace for retrieving avatar context */
+  namespace?: string;
+}
+interface AvatarFallbackSlotProps {
+  /** Whether this fallback is currently visible */
+  isSelected: boolean;
+}
+declare const __VLS_export$24: __VLS_WithSlots$13<vue319.DefineComponent<AvatarFallbackProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: AvatarFallbackSlotProps) => any;
+}>;
+declare const _default$24: typeof __VLS_export$24;
+type __VLS_WithSlots$13<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Avatar/index.d.ts
+/**
+ * Avatar component with sub-components for building avatars.
+ *
+ * @see https://0.vuetifyjs.com/components/avatar
+ */
+declare const Avatar: {
+  /**
+   * Root component for avatars.
+   *
+   * @see https://0.vuetifyjs.com/components/avatar
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Avatar } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Avatar.Root>
+   *     <Avatar.Image src="/avatar.jpg" />
+   *
+   *     <Avatar.Fallback>JD</Avatar.Fallback>
+   *   </Avatar.Root>
+   * </template>
+   * ```
+   */
+  Root: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  });
+  /**
+   * Component for displaying the avatar image.
+   *
+   * @see https://0.vuetifyjs.com/components/avatar#avatarimage
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Avatar } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Avatar.Image src="/avatar.jpg" alt="User avatar" />
+   * </template>
+   * ```
+   */
+  Image: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<AvatarImageProps> & Readonly<{
+      onLoad?: ((e: Event) => any) | undefined;
+      onError?: ((e: Event) => any) | undefined;
+    }>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {
+      load: (e: Event) => any;
+      error: (e: Event) => any;
+    }, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<AvatarImageProps> & Readonly<{
+      onLoad?: ((e: Event) => any) | undefined;
+      onError?: ((e: Event) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<AvatarImageProps> & Readonly<{
+    onLoad?: ((e: Event) => any) | undefined;
+    onError?: ((e: Event) => any) | undefined;
+  }>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {
+    load: (e: Event) => any;
+    error: (e: Event) => any;
+  }, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: AvatarImageSlotProps) => any;
+    };
+  });
+  /**
+   * Component for displaying fallback content when image fails to load.
+   *
+   * @see https://0.vuetifyjs.com/components/avatar#avatarfallback
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Avatar } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Avatar.Fallback>
+   *     JD
+   *   </Avatar.Fallback>
+   * </template>
+   * ```
+   */
+  Fallback: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: AvatarFallbackSlotProps) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelRoot.vue.d.ts
+interface ExpansionPanelOptionsContext {
+  /** Disabled state of the entire expansion panel */
+  isDisabled: Readonly<Ref<boolean>>;
+}
+interface ExpansionPanelRootProps extends AtomProps {
+  /** Namespace for dependency injection (default: 'v0:expansion-panel') */
+  namespace?: string;
+  /** Disables the entire expansion panel instance and all items */
+  disabled?: boolean;
+  /** Auto-expand non-disabled items when registered */
+  enroll?: boolean;
+  /**
+   * Mandatory expansion behavior:
+   * - false (default): All panels can be collapsed
+   * - true: Prevents collapsing the last expanded panel
+   * - 'force': Automatically expands the first non-disabled panel
+   */
+  mandatory?: boolean | 'force';
+  /**
+   * Enable multi-expansion mode
+   * - false (default): Single panel expanded at a time (accordion mode)
+   * - true: Multiple panels can be expanded simultaneously
+   * Note: Changes v-model type from T to T[]
+   */
+  multiple?: boolean;
+}
+interface ExpansionPanelRootSlotProps {
+  /** Disables the entire expansion panel instance and all registered items */
+  isDisabled: Readonly<Ref<boolean>>;
+  /** Select a panel by ID */
+  select: (id: ID) => void;
+  /** Unselect a panel by ID */
+  unselect: (id: ID) => void;
+  /** Toggle a panel's expansion state by ID */
+  toggle: (id: ID) => void;
+}
+declare const useExpansionPanelRoot: (key: string, defaultValue?: SelectionContext<SelectionTicket<unknown>> | undefined) => SelectionContext<SelectionTicket<unknown>>, provideExpansionPanelSelection: (key: string, context: SelectionContext<SelectionTicket<unknown>>, app?: vue319.App) => SelectionContext<SelectionTicket<unknown>>;
+declare const __VLS_export$23: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$10<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$10<(ExpansionPanelRootProps & {
+    modelValue?: T | T[];
+  }) & {
+    [x: `on${Capitalize<string>}`]: ((...args: any) => any) | undefined;
+  }> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: ExpansionPanelRootSlotProps) => any;
+  };
+  emit: ((evt: "update:model-value", ...args: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$23: typeof __VLS_export$23;
+type __VLS_PrettifyLocal$10<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelItem.vue.d.ts
+interface ExpansionPanelItemProps<V = unknown> extends AtomProps {
+  /** Unique identifier for the panel item (auto-generated if not provided) */
+  id?: string;
+  /** Value associated with this panel item for v-model binding */
+  value?: V;
+  /** Disables this specific panel item */
+  disabled?: MaybeRef<boolean>;
+  /** Namespace to retrieve the parent ExpansionPanelRoot context (default: 'v0:expansion-panel') */
+  namespace?: string;
+}
+/**
+ * Context provided to child components (ExpansionPanelActivator and ExpansionPanelContent)
+ * via dependency injection using the itemNamespace.
+ */
+interface ExpansionPanelItemContext {
+  /** Selection ticket from the parent ExpansionPanel registry */
+  ticket: SelectionTicket;
+  /** Unique ID for the header/activator element (for aria-controls) */
+  headerId: Readonly<Ref<string>>;
+  /** Unique ID for the content region (for aria-labelledby) */
+  contentId: Readonly<Ref<string>>;
+  /** Combined disabled state from item and parent */
+  isDisabled: Readonly<Ref<boolean>>;
+}
+/**
+ * Slot props provided to the default slot of ExpansionPanelItem
+ */
+interface ExpansionPanelItemSlotProps {
+  /** Whether this panel is currently selected/expanded */
+  isSelected: boolean;
+  /** Combined disabled state from item and parent */
+  isDisabled: boolean;
+  /** Attributes to bind to the root element for accessibility */
+  attrs: {
+    /** Data attribute for selected state */
+    'data-selected': true | undefined;
+  };
+}
+declare const useExpansionPanelItem: (key: string, defaultValue?: ExpansionPanelItemContext | undefined) => ExpansionPanelItemContext, provideExpansionPanelItem: (key: string, context: ExpansionPanelItemContext, app?: vue319.App) => ExpansionPanelItemContext;
+declare const __VLS_export$22: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$9<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$9<ExpansionPanelItemProps<V>> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: ExpansionPanelItemSlotProps) => any;
+  };
+  emit: {};
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$22: typeof __VLS_export$22;
+type __VLS_PrettifyLocal$9<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelHeader.vue.d.ts
+interface ExpansionPanelHeaderProps extends AtomProps {
+  /** Namespace for retrieving the parent ExpansionPanelItem context (default: 'v0:expansion-panel') */
+  namespace?: string;
+}
+interface ExpansionPanelHeaderSlotProps {
+  /** Whether this panel is currently selected/expanded */
+  isSelected: boolean;
+  /** Attributes to bind to the root element for accessibility */
+  attrs: {
+    /** Data attribute for selected state */
+    'data-selected': true | undefined;
+  };
+}
+declare const __VLS_export$21: __VLS_WithSlots$12<vue319.DefineComponent<ExpansionPanelHeaderProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<ExpansionPanelHeaderProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: ExpansionPanelHeaderSlotProps) => any;
+}>;
+declare const _default$21: typeof __VLS_export$21;
+type __VLS_WithSlots$12<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelActivator.vue.d.ts
+interface ExpansionPanelActivatorProps extends AtomProps {
+  namespace?: string;
+}
+interface ExpansionPanelActivatorSlotProps {
+  /** Disabled state */
+  isDisabled: boolean;
+  /** Whether this panel is currently selected/expanded */
+  isSelected: boolean;
+  /** Toggle the panels expansion state */
+  toggle: () => void;
+  /** Attributes to bind to the activator element for accessibility */
+  attrs: {
+    /** Unique ID for the header/activator element */
+    'id': string;
+    /** ARIA role for accessibility (only set when not using native button) */
+    'role': 'button' | undefined;
+    /** Tab index for keyboard navigation */
+    'tabindex': number;
+    /** ARIA expanded state */
+    'aria-expanded': boolean;
+    /** ARIA controls attribute pointing to content region */
+    'aria-controls': string;
+    /** ARIA disabled state */
+    'aria-disabled': boolean;
+    /** Data attribute for disabled state */
+    'data-disabled': true | undefined;
+    /** Data attribute for selected state */
+    'data-selected': true | undefined;
+    /** Disabled attribute for native button elements */
+    'disabled': boolean | undefined;
+    /** Type attribute for native button elements */
+    'type': 'button' | undefined;
+    /** Click handler to toggle panel */
+    'onClick': () => void;
+    /** Keyboard handler for Enter and Space keys */
+    'onKeydown': (e: KeyboardEvent) => void;
+  };
+}
+declare const __VLS_export$20: __VLS_WithSlots$11<vue319.DefineComponent<ExpansionPanelActivatorProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: ExpansionPanelActivatorSlotProps) => any;
+}>;
+declare const _default$19: typeof __VLS_export$20;
+type __VLS_WithSlots$11<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelContent.vue.d.ts
+interface ExpansionPanelContentProps extends AtomProps {
+  namespace?: string;
+}
+interface ExpansionPanelContentSlotProps {
+  /** Whether this panel is currently selected/expanded */
+  isSelected: boolean;
+  /** Attributes to bind to the content element for accessibility */
+  attrs: {
+    /** Data attribute for selected state */
+    'data-selected': boolean;
+    /** Unique ID for the content region */
+    'id': string;
+    /** ARIA role for accessibility */
+    'role': 'region';
+    /** ARIA labelledby attribute pointing to header element */
+    'aria-labelledby': string;
+    /** Whether the content is hidden */
+    'hidden': boolean;
+  };
+}
+declare const __VLS_export$19: __VLS_WithSlots$10<vue319.DefineComponent<ExpansionPanelContentProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: ExpansionPanelContentSlotProps) => any;
+}>;
+declare const _default$20: typeof __VLS_export$19;
+type __VLS_WithSlots$10<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/ExpansionPanel/index.d.ts
+/**
+ * ExpansionPanel component with sub-components for building expansion panels.
+ *
+ * @see https://0.vuetifyjs.com/components/expansion-panels
+ */
+declare const ExpansionPanel: {
+  /**
+   * Root component for expansion panels.
+   *
+   * @see https://0.vuetifyjs.com/components/expansion-panels
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { ExpansionPanel } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <ExpansionPanel.Root>
+   *     <ExpansionPanel.Item>
+   *       <ExpansionPanel.Header>
+   *         <ExpansionPanel.Activator>
+   *          Click to expand
+   *         </ExpansionPanel.Activator>
+   *       </ExpansionPanel.Header>
+   *
+   *       <ExpansionPanel.Content>
+   *         Content goes here.
+   *       </ExpansionPanel.Content>
+   *     </ExpansionPanel.Item>
+   *   </ExpansionPanel.Root>
+   * </template>
+   * ```
+  */
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: ((evt: "update:model-value", ...args: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+    slots: {
+      default: (props: ExpansionPanelRootSlotProps) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      [x: `on${Capitalize<string>}`]: ((...args: any) => any) | undefined;
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      multiple?: boolean | undefined;
+      as?: (DOMElement | null) | undefined;
+      renderless?: boolean | undefined;
+      modelValue?: (T | T[]) | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: ExpansionPanelRootSlotProps) => any;
+    };
+    emit: ((evt: "update:model-value", ...args: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * Component representing a single expansion panel item.
+   *
+   * @see https://0.vuetifyjs.com/components/expansion-panels#expansionpanelitem
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { ExpansionPanel } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <ExpansionPanel.Item>
+   *     <ExpansionPanel.Header>
+   *       <ExpansionPanel.Activator>
+   *        Click to expand
+   *       </ExpansionPanel.Activator>
+   *     </ExpansionPanel.Header>
+   *
+   *     <ExpansionPanel.Content>
+   *       Content goes here.
+   *     </ExpansionPanel.Content>
+   *   </ExpansionPanel.Item>
+   * </template>
+   * ```
+   */
+  Item: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: {};
+    slots: {
+      default: (props: ExpansionPanelItemSlotProps) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue319.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+      as?: (DOMElement | null) | undefined;
+      renderless?: boolean | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: ExpansionPanelItemSlotProps) => any;
+    };
+    emit: {};
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * (optional) Component for the header section of an expansion panel item.
+   *
+   * @see https://0.vuetifyjs.com/components/expansion-panels#expansionpanelheader
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { ExpansionPanel } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <ExpansionPanel.Header>
+   *     <ExpansionPanel.Activator>
+   *      Click to expand
+   *     </ExpansionPanel.Activator>
+   *   </ExpansionPanel.Header>
+   * </template>
+   * ```
+   */
+  Header: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<ExpansionPanelHeaderProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ExpansionPanelHeaderProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<ExpansionPanelHeaderProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: ExpansionPanelHeaderSlotProps) => any;
+    };
+  });
+  /**
+   * Component for the activator section of an expansion panel header.
+   *
+   * @see https://0.vuetifyjs.com/components/expansion-panels#expansionpanelactivator
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { ExpansionPanel } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <ExpansionPanel.Activator>
+   *    Click to expand
+   *   </ExpansionPanel.Activator>
+   * </template>
+   * ```
+   */
+  Activator: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: ExpansionPanelActivatorSlotProps) => any;
+    };
+  });
+  /**
+   * Component for the content section of an expansion panel item.
+   *
+   * @see https://0.vuetifyjs.com/components/expansion-panels#expansionpanelcontent
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { ExpansionPanel } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <ExpansionPanel.Content>
+   *     Content goes here.
+   *   </ExpansionPanel.Content>
+   * </template>
+   * ```
+   */
+  Content: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: ExpansionPanelContentSlotProps) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Group/GroupRoot.vue.d.ts
+interface GroupRootProps {
+  /** Namespace for dependency injection (must match GroupItem namespace) */
+  namespace?: string;
+  /** Disables the entire group instance */
+  disabled?: boolean;
+  /** Auto-select non-disabled items on registration */
+  enroll?: boolean;
+  /**
+   * Controls mandatory group behavior:
+   * - false (default): No mandatory group enforcement
+   * - true: Prevents deselecting the last selected item
+   * - `force`: Automatically selects the first non-disabled item on registration
+   */
+  mandatory?: boolean | 'force';
+}
+interface GroupRootSlotProps {
+  /** Whether the group instance is disabled */
+  isDisabled: boolean;
+  /** Whether no items are currently selected */
+  isNoneSelected: boolean;
+  /** Whether all selectable (non-disabled) items are selected */
+  isAllSelected: boolean;
+  /** Whether some but not all selectable items are selected */
+  isMixed: boolean;
+  /** Select an item by ID */
+  select: (id: ID | ID[]) => void;
+  /** Unselect an item by ID */
+  unselect: (id: ID | ID[]) => void;
+  /** Toggle an item's group state by ID */
+  toggle: (id: ID | ID[]) => void;
+  /** Select all selectable (non-disabled) items */
+  selectAll: () => void;
+  /** Unselect all items (respects mandatory option) */
+  unselectAll: () => void;
+  /** Toggle between all selected and none selected */
+  toggleAll: () => void;
+  /** Attributes to bind to the root element */
+  attrs: {
+    'aria-multiselectable': true;
+  };
+}
+declare const useGroupRoot: (key: string, defaultValue?: GroupContext<GroupTicket<unknown>> | undefined) => GroupContext<GroupTicket<unknown>>, provideGroupRoot: (key: string, context: GroupContext<GroupTicket<unknown>>, app?: vue319.App) => GroupContext<GroupTicket<unknown>>;
+declare const __VLS_export$18: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$8<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$8<(GroupRootProps & {
+    modelValue?: T | T[];
+  }) & {
+    "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    "onUpdate:model-value"?: ((value: T | T[]) => any) | undefined;
+  }> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: GroupRootSlotProps) => any;
+  };
+  emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$18: typeof __VLS_export$18;
+type __VLS_PrettifyLocal$8<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Group/GroupItem.vue.d.ts
+interface GroupItemProps<V = unknown> {
+  /** Unique identifier (auto-generated if not provided) */
+  id?: string;
+  /** Optional display label (passed through to slot, not used in registration) */
+  label?: string;
+  /** Value associated with this item */
+  value?: V;
+  /** Disables this specific item */
+  disabled?: MaybeRef<boolean>;
+  /** Sets the indeterminate state (for checkboxes) */
+  indeterminate?: MaybeRef<boolean>;
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface GroupItemSlotProps<V = unknown> {
+  /** Unique identifier */
+  id: string;
+  /** Optional display label */
+  label?: string;
+  /** Value associated with this item */
+  value: V | undefined;
+  /** Whether this item is currently selected */
+  isSelected: boolean;
+  /** Whether this item is in a mixed/indeterminate state */
+  isMixed: boolean;
+  /** Whether this item is disabled */
+  isDisabled: boolean;
+  /** Select this item */
+  select: () => void;
+  /** Unselect this item */
+  unselect: () => void;
+  /** Toggle this item's group state */
+  toggle: () => void;
+  /** Set this item to mixed/indeterminate state */
+  mix: () => void;
+  /** Clear mixed/indeterminate state from this item */
+  unmix: () => void;
+  /** Attributes to bind to the item element */
+  attrs: {
+    'role': 'checkbox';
+    'aria-checked': boolean | 'mixed';
+    'aria-disabled': boolean;
+    'data-selected': true | undefined;
+    'data-disabled': true | undefined;
+    'data-mixed': true | undefined;
+  };
+}
+declare const __VLS_export$17: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$7<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$7<GroupItemProps<V>> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: GroupItemSlotProps<V>) => unknown;
+  };
+  emit: {};
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$17: typeof __VLS_export$17;
+type __VLS_PrettifyLocal$7<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Group/index.d.ts
+/**
+ * Group component with sub-components for multi-selection.
+ *
+ * @see https://0.vuetifyjs.com/components/group
+ */
+declare const Group: {
+  /**
+   * Root component for multi-selection groups.
+   *
+   * @see https://0.vuetifyjs.com/components/group
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Group } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Group.Root v-model="selected">
+   *     <Group.Item value="a">Option A</Group.Item>
+   *
+   *     <Group.Item value="b">Option B</Group.Item>
+   *   </Group.Root>
+   * </template>
+   * ```
+   */
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+    slots: {
+      default: (props: GroupRootSlotProps) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      modelValue?: (T | T[]) | undefined;
+      "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+      "onUpdate:model-value"?: ((value: T | T[]) => any) | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: GroupRootSlotProps) => any;
+    };
+    emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * Item component for multi-selection groups.
+   *
+   * @see https://0.vuetifyjs.com/components/group#groupitem
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Group } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Group.Item value="a">
+   *     Option A
+   *   </Group.Item>
+   * </template>
+   * ```
+   */
+  Item: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: {};
+    slots: {
+      default: (props: GroupItemSlotProps<V>) => unknown;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue319.MaybeRef<boolean> | undefined;
+      indeterminate?: vue319.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: GroupItemSlotProps<V>) => unknown;
+    };
+    emit: {};
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+};
+//#endregion
+//#region src/components/Pagination/PaginationRoot.vue.d.ts
+declare const usePaginationRoot: (key: string, defaultValue?: PaginationContext | undefined) => PaginationContext, providePaginationRoot: (key: string, context: PaginationContext, app?: vue319.App) => PaginationContext;
+declare const usePaginationControls: (key: string, defaultValue?: RegistryContext<RegistryTicket<unknown>> | undefined) => RegistryContext<RegistryTicket<unknown>>, providePaginationControls: (key: string, context: RegistryContext<RegistryTicket<unknown>>, app?: vue319.App) => RegistryContext<RegistryTicket<unknown>>;
+declare const usePaginationItems: (key: string, defaultValue?: RegistryContext<RegistryTicket<unknown>> | undefined) => RegistryContext<RegistryTicket<unknown>>, providePaginationItems: (key: string, context: RegistryContext<RegistryTicket<unknown>>, app?: vue319.App) => RegistryContext<RegistryTicket<unknown>>;
+interface PaginationRootProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Total number of items */
+  size?: number;
+  /**
+   * Number of visible page buttons.
+   * If undefined, auto-calculates based on container width.
+   */
+  totalVisible?: number;
+  /** Number of items per page */
+  itemsPerPage?: number;
+  /** Ellipsis character */
+  ellipsis?: string | false;
+}
+interface PaginationRootSlotProps {
+  /** Current page (1-indexed) */
+  page: number;
+  /** Total number of items */
+  size: number;
+  /** Total number of pages */
+  pages: number;
+  /** Items per page */
+  itemsPerPage: number;
+  /** Visible page items for rendering */
+  items: PaginationTicket[];
+  /** Start index of items on current page (0-indexed) */
+  pageStart: number;
+  /** End index of items on current page (exclusive) */
+  pageStop: number;
+  /** Whether on first page */
+  isFirst: boolean;
+  /** Whether on last page */
+  isLast: boolean;
+  /** Go to first page */
+  first: () => void;
+  /** Go to last page */
+  last: () => void;
+  /** Go to next page */
+  next: () => void;
+  /** Go to previous page */
+  prev: () => void;
+  /** Go to specific page */
+  select: (page: number) => void;
+  /** Attributes to bind to the root element */
+  attrs: {
+    'aria-label': string;
+    'role': 'navigation' | undefined;
+  };
+}
+declare const __VLS_export$16: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$6<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$6<(PaginationRootProps & {
+    modelValue?: number;
+  }) & {
+    [x: `on${Capitalize<string>}`]: ((...args: any) => any) | undefined;
+  }> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: PaginationRootSlotProps) => any;
+  };
+  emit: ((evt: "update:model-value", ...args: T | T[]) => void) & ((evt: "update:modelValue", value: number) => void);
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$15: typeof __VLS_export$16;
+type __VLS_PrettifyLocal$6<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Pagination/PaginationItem.vue.d.ts
+interface PaginationItemProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Page number this item represents */
+  value: number;
+  /** Override disabled state */
+  disabled?: boolean;
+  /** Unique identifier for registration */
+  id?: string;
+}
+interface PaginationItemSlotProps {
+  /** Page number */
+  page: number;
+  /** Whether this page is currently selected */
+  isSelected: boolean;
+  /** Whether this item is disabled */
+  isDisabled: boolean;
+  /** Go to this page */
+  select: () => void;
+  /** Attributes to bind to the item element */
+  attrs: {
+    'aria-label': string;
+    'aria-current': 'page' | undefined;
+    'aria-disabled': boolean;
+    'data-selected': true | undefined;
+    'data-disabled': true | undefined;
+    'disabled': boolean | undefined;
+    'tabindex': number;
+    'type': 'button' | undefined;
+    'onClick': () => void;
+  };
+}
+declare const __VLS_export$15: __VLS_WithSlots$9<vue319.DefineComponent<PaginationItemProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<PaginationItemProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationItemSlotProps) => any;
+}>;
+declare const _default$11: typeof __VLS_export$15;
+type __VLS_WithSlots$9<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Pagination/PaginationFirst.vue.d.ts
+interface PaginationFirstProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Override disabled state */
+  disabled?: boolean;
+  /** Unique identifier for registration */
+  id?: string;
+}
+interface PaginationFirstSlotProps {
+  /** Whether button is disabled */
+  isDisabled: boolean;
+  /** Go to first page */
+  first: () => void;
+  /** Attributes to bind to the button element */
+  attrs: {
+    'aria-label': string;
+    'aria-disabled': boolean;
+    'data-disabled': true | undefined;
+    'disabled': boolean | undefined;
+    'tabindex': number;
+    'type': 'button' | undefined;
+    'onClick': () => void;
+  };
+}
+declare const __VLS_export$14: __VLS_WithSlots$8<vue319.DefineComponent<PaginationFirstProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<PaginationFirstProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationFirstSlotProps) => any;
+}>;
+declare const _default$10: typeof __VLS_export$14;
+type __VLS_WithSlots$8<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Pagination/PaginationPrev.vue.d.ts
+interface PaginationPrevProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Override disabled state */
+  disabled?: boolean;
+  /** Unique identifier for registration */
+  id?: string;
+}
+interface PaginationPrevSlotProps {
+  /** Whether button is disabled */
+  isDisabled: boolean;
+  /** Go to previous page */
+  prev: () => void;
+  /** Attributes to bind to the button element */
+  attrs: {
+    'aria-label': string;
+    'aria-disabled': boolean;
+    'data-disabled': true | undefined;
+    'disabled': boolean | undefined;
+    'tabindex': number;
+    'type': 'button' | undefined;
+    'onClick': () => void;
+  };
+}
+declare const __VLS_export$13: __VLS_WithSlots$7<vue319.DefineComponent<PaginationPrevProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<PaginationPrevProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationPrevSlotProps) => any;
+}>;
+declare const _default$14: typeof __VLS_export$13;
+type __VLS_WithSlots$7<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Pagination/PaginationEllipsis.vue.d.ts
+interface PaginationEllipsisProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Ellipsis character to display (overrides context) */
+  ellipsis?: string;
+  /** Unique identifier for registration */
+  id?: string;
+}
+interface PaginationEllipsisSlotProps {
+  /** Ellipsis character */
+  ellipsis: string | false;
+  /** Attributes to bind to the ellipsis element */
+  attrs: {
+    'aria-hidden': 'true';
+  };
+}
+declare const __VLS_export$12: __VLS_WithSlots$6<vue319.DefineComponent<PaginationEllipsisProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<PaginationEllipsisProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationEllipsisSlotProps) => any;
+}>;
+declare const _default$9: typeof __VLS_export$12;
+type __VLS_WithSlots$6<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Pagination/PaginationNext.vue.d.ts
+interface PaginationNextProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Override disabled state */
+  disabled?: boolean;
+  /** Unique identifier for registration */
+  id?: string;
+}
+interface PaginationNextSlotProps {
+  /** Whether button is disabled */
+  isDisabled: boolean;
+  /** Go to next page */
+  next: () => void;
+  /** Attributes to bind to the button element */
+  attrs: {
+    'aria-label': string;
+    'aria-disabled': boolean;
+    'data-disabled': true | undefined;
+    'disabled': boolean | undefined;
+    'tabindex': number;
+    'type': 'button' | undefined;
+    'onClick': () => void;
+  };
+}
+declare const __VLS_export$11: __VLS_WithSlots$5<vue319.DefineComponent<PaginationNextProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<PaginationNextProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationNextSlotProps) => any;
+}>;
+declare const _default$13: typeof __VLS_export$11;
+type __VLS_WithSlots$5<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Pagination/PaginationLast.vue.d.ts
+interface PaginationLastProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Override disabled state */
+  disabled?: boolean;
+  /** Unique identifier for registration */
+  id?: string;
+}
+interface PaginationLastSlotProps {
+  /** Whether button is disabled */
+  isDisabled: boolean;
+  /** Go to last page */
+  last: () => void;
+  /** Attributes to bind to the button element */
+  attrs: {
+    'aria-label': string;
+    'aria-disabled': boolean;
+    'data-disabled': true | undefined;
+    'disabled': boolean | undefined;
+    'tabindex': number;
+    'type': 'button' | undefined;
+    'onClick': () => void;
+  };
+}
+declare const __VLS_export$10: __VLS_WithSlots$4<vue319.DefineComponent<PaginationLastProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<PaginationLastProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationLastSlotProps) => any;
+}>;
+declare const _default$12: typeof __VLS_export$10;
+type __VLS_WithSlots$4<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Pagination/PaginationStatus.vue.d.ts
+interface PaginationStatusProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface PaginationStatusSlotProps {
+  /** Current page (1-indexed) */
+  page: number;
+  /** Total number of pages */
+  pages: number;
+  /** Announcement text */
+  text: string;
+  /** Attributes to bind to the status element */
+  attrs: {
+    'aria-atomic': true;
+    'aria-live': 'polite';
+    'role': 'status';
+  };
+}
+declare const __VLS_export$9: __VLS_WithSlots$3<vue319.DefineComponent<PaginationStatusProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<PaginationStatusProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationStatusSlotProps) => any;
+}>;
+declare const _default$16: typeof __VLS_export$9;
+type __VLS_WithSlots$3<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Pagination/index.d.ts
+/**
+ * Pagination component with sub-components for building pagination controls.
+ *
+ * @see https://0.vuetifyjs.com/components/pagination
+ */
+declare const Pagination: {
+  /**
+   * Root component for pagination controls.
+   *
+   * @see https://0.vuetifyjs.com/components/pagination
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Pagination } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Pagination.Root v-model="page" :size="100">
+   *     <Pagination.First />
+   *
+   *     <Pagination.Prev />
+   *
+   *     <template v-for="item in items" :key="item.value">
+   *       <Pagination.Item v-if="item.type === 'page'" :value="item.value" />
+   *
+   *       <Pagination.Ellipsis v-else />
+   *     </template>
+   *
+   *     <Pagination.Next />
+   *
+   *     <Pagination.Last />
+   *   </Pagination.Root>
+   * </template>
+   * ```
+   */
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: ((evt: "update:model-value", ...args: T | T[]) => void) & ((evt: "update:modelValue", value: number) => void);
+    slots: {
+      default: (props: PaginationRootSlotProps) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      [x: `on${Capitalize<string>}`]: ((...args: any) => any) | undefined;
+      namespace?: string | undefined;
+      size?: number | undefined;
+      totalVisible?: number | undefined;
+      itemsPerPage?: number | undefined;
+      ellipsis?: string | false | undefined;
+      as?: (DOMElement | null) | undefined;
+      renderless?: boolean | undefined;
+      modelValue?: number | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: PaginationRootSlotProps) => any;
+    };
+    emit: ((evt: "update:model-value", ...args: T | T[]) => void) & ((evt: "update:modelValue", value: number) => void);
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * Individual page button that navigates to a specific page number.
+   *
+   * @see https://0.vuetifyjs.com/components/pagination#paginationitem
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Pagination } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Pagination.Item :value="1">1</Pagination.Item>
+   *
+   *   <!-- With slot props -->
+   *   <Pagination.Item :value="2" v-slot="{ isSelected }">
+   *     <span :class="{ 'font-bold': isSelected }">2</span>
+   *   </Pagination.Item>
+   * </template>
+   * ```
+   */
+  Item: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PaginationItemProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PaginationItemProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PaginationItemSlotProps) => any;
+    };
+  });
+  /**
+   * Navigation button that jumps to the first page. Automatically
+   * disables when already on the first page.
+   *
+   * @see https://0.vuetifyjs.com/components/pagination#paginationfirst
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Pagination } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Pagination.First>First</Pagination.First>
+   *
+   *   <!-- With slot props -->
+   *   <Pagination.First v-slot="{ isDisabled }">
+   *     <span :class="{ 'opacity-50': isDisabled }">«</span>
+   *   </Pagination.First>
+   *
+   *   <!-- With data attributes -->
+   *   <Pagination.First class="data-[disabled]:opacity-50">
+   *     First
+   *   </Pagination.First>
+   * </template>
+   * ```
+   */
+  First: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PaginationFirstProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationFirstProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PaginationFirstProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PaginationFirstSlotProps) => any;
+    };
+  });
+  /**
+   * Navigation button that moves to the previous page. Automatically
+   * disables when already on the first page.
+   *
+   * @see https://0.vuetifyjs.com/components/pagination#paginationprev
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Pagination } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Pagination.Prev>Prev</Pagination.Prev>
+   *
+   *   <!-- With slot props -->
+   *   <Pagination.Prev v-slot="{ isDisabled }">
+   *     <span :class="{ 'opacity-50': isDisabled }">‹</span>
+   *   </Pagination.Prev>
+   *
+   *  <!-- With data attributes -->
+   *  <Pagination.Prev class="data-[disabled]:opacity-50">
+   *    Prev
+   *  </Pagination.Prev>
+   * </template>
+   * ```
+   */
+  Prev: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PaginationPrevProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationPrevProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PaginationPrevProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PaginationPrevSlotProps) => any;
+    };
+  });
+  /**
+   * Visual indicator for omitted page numbers. Hidden from screen
+   * readers via aria-hidden. Inherits ellipsis character from Root
+   * or can be overridden via prop.
+   *
+   * @see https://0.vuetifyjs.com/components/pagination#paginationellipsis
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Pagination } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <!-- Uses default "..." from Root -->
+   *   <Pagination.Ellipsis />
+   *
+   *   <!-- Override ellipsis character -->
+   *   <Pagination.Ellipsis ellipsis="…" />
+   * </template>
+   * ```
+   */
+  Ellipsis: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PaginationEllipsisProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationEllipsisProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PaginationEllipsisProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PaginationEllipsisSlotProps) => any;
+    };
+  });
+  /**
+   * Navigation button that moves to the next page. Automatically
+   * disables when already on the last page.
+   *
+   * @see https://0.vuetifyjs.com/components/pagination#paginationnext
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Pagination } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Pagination.Next>Next</Pagination.Next>
+   *
+   *   <!-- With slot props -->
+   *   <Pagination.Next v-slot="{ isDisabled }">
+   *     <span :class="{ 'opacity-50': isDisabled }">›</span>
+   *   </Pagination.Next>
+   *
+   *   <!-- With data attributes -->
+   *   <Pagination.Next class="data-[disabled]:opacity-50">
+   *     Next
+   *   </Pagination.Next>
+   * </template>
+   * ```
+   */
+  Next: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PaginationNextProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationNextProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PaginationNextProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PaginationNextSlotProps) => any;
+    };
+  });
+  /**
+   * Navigation button that jumps to the last page. Automatically
+   * disables when already on the last page.
+   *
+   * @see https://0.vuetifyjs.com/components/pagination#paginationlast
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Pagination } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Pagination.Last>Last</Pagination.Last>
+   *
+   *   <!-- With slot props -->
+   *   <Pagination.Last v-slot="{ isDisabled }">
+   *     <span :class="{ 'opacity-50': isDisabled }">»</span>
+   *   </Pagination.Last>
+   *
+   *   <!-- With data attributes -->
+   *   <Pagination.Last class="data-[disabled]:opacity-50">
+   *     Last
+   *   </Pagination.Last>
+   * </template>
+   * ```
+   */
+  Last: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PaginationLastProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationLastProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PaginationLastProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PaginationLastSlotProps) => any;
+    };
+  });
+  /**
+   * Visually-hidden live region that announces page changes to screen
+   * readers. Should be styled with sr-only/visually-hidden CSS.
+   *
+   * @see https://0.vuetifyjs.com/components/pagination#paginationstatus
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Pagination } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Pagination.Root v-model="page" :size="100">
+   *     <Pagination.Status class="sr-only" />
+   *     <!-- other pagination items -->
+   *   </Pagination.Root>
+   * </template>
+   * ```
+   */
+  Status: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PaginationStatusProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationStatusProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PaginationStatusProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PaginationStatusSlotProps) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Popover/PopoverRoot.vue.d.ts
+interface PopoverContext {
+  isSelected: ShallowRef<boolean>;
+  id: string;
+  toggle: () => void;
+}
+interface PopoverRootProps extends AtomProps {
+  /** Unique identifier for the popover (auto-generated if not provided) */
+  id?: string;
+}
+interface PopoverRootSlotProps {
+  /** Unique identifier */
+  id: string;
+  /** Whether the popover is currently open */
+  isSelected: boolean;
+  /** Toggle the popover open/closed state */
+  toggle: () => void;
+}
+declare const usePopoverContext: () => PopoverContext, providePopoverContext: (context: PopoverContext, app?: vue319.App) => PopoverContext;
+declare const __VLS_export$8: __VLS_WithSlots$2<vue319.DefineComponent<PopoverRootProps & {
+  modelValue?: boolean;
+}, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {
+  "update:modelValue": (value: boolean) => any;
+}, string, vue319.PublicProps, Readonly<PopoverRootProps & {
+  modelValue?: boolean;
+}> & Readonly<{
+  "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PopoverRootSlotProps) => any;
+}>;
+declare const _default$8: typeof __VLS_export$8;
+type __VLS_WithSlots$2<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Popover/PopoverAnchor.vue.d.ts
+interface PopoverAnchorProps extends AtomProps {
+  /** Target popover ID (defaults to parent PopoverRoot id) */
+  target?: string;
+}
+interface PopoverAnchorSlotProps {
+  /** Whether the popover is currently open */
+  isOpen: boolean;
+  /** Attributes to bind to the anchor element */
+  attrs: {
+    'popovertarget': string;
+    'type': 'button' | undefined;
+    'data-popover-open': '' | undefined;
+  };
+}
+declare const __VLS_export$7: __VLS_WithSlots$1<vue319.DefineComponent<PopoverAnchorProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, vue319.PublicProps, Readonly<PopoverAnchorProps> & Readonly<{}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PopoverAnchorSlotProps) => any;
+}>;
+declare const _default$6: typeof __VLS_export$7;
+type __VLS_WithSlots$1<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Popover/PopoverContent.vue.d.ts
+interface PopoverContentProps extends AtomProps {
+  /** Unique identifier (defaults to parent PopoverRoot id) */
+  id?: string;
+  /** CSS position-area value for anchor positioning */
+  positionArea?: string;
+  /** CSS position-try value for fallback positioning */
+  positionTry?: string;
+}
+interface PopoverContentEmits {
+  beforetoggle: [e: ToggleEvent];
+}
+interface PopoverContentSlotProps {
+  /** Whether the popover is currently open */
+  isOpen: boolean;
+  /** Attributes to bind to the content element */
+  attrs: {
+    id: string;
+    popover: '';
+  };
+}
+declare const __VLS_export$6: __VLS_WithSlots<vue319.DefineComponent<PopoverContentProps, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {
+  beforetoggle: (e: ToggleEvent) => any;
+}, string, vue319.PublicProps, Readonly<PopoverContentProps> & Readonly<{
+  onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue319.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PopoverContentSlotProps) => any;
+}>;
+declare const _default$7: typeof __VLS_export$6;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Popover/index.d.ts
+/**
+ * Popover component with sub-components for building popovers.
+ *
+ * @see https://0.vuetifyjs.com/components/popover
+ */
+declare const Popover: {
+  /**
+   * Root component for popovers.
+   *
+   * @see https://0.vuetifyjs.com/components/popover
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Popover } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Popover.Root>
+   *     <Popover.Anchor>
+   *       Click to toggle
+   *     </Popover.Anchor>
+   *
+   *     <Popover.Content>
+   *       Popover content goes here.
+   *     </Popover.Content>
+   *   </Popover.Root>
+   * </template>
+   * ```
+   */
+  Root: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PopoverRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {
+      "update:modelValue": (value: boolean) => any;
+    }, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PopoverRootProps & {
+    modelValue?: boolean;
+  }> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+  }>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+  }, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PopoverRootSlotProps) => any;
+    };
+  });
+  /**
+   * Component for the anchor/trigger of a popover.
+   *
+   * @see https://0.vuetifyjs.com/components/popover#popoveranchor
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Popover } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Popover.Anchor>
+   *     Click to toggle
+   *   </Popover.Anchor>
+   * </template>
+   * ```
+   */
+  Anchor: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PopoverAnchorProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverAnchorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PopoverAnchorProps> & Readonly<{}>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PopoverAnchorSlotProps) => any;
+    };
+  });
+  /**
+   * Component for the content section of a popover.
+   *
+   * @see https://0.vuetifyjs.com/components/popover#popovercontent
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Popover } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Popover.Content>
+   *     Popover content goes here.
+   *   </Popover.Content>
+   * </template>
+   * ```
+   */
+  Content: {
+    new (...args: any[]): vue319.CreateComponentPublicInstanceWithMixins<Readonly<PopoverContentProps> & Readonly<{
+      onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {
+      beforetoggle: (e: ToggleEvent) => any;
+    }, vue319.PublicProps, {}, false, {}, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, {}, any, vue319.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverContentProps> & Readonly<{
+      onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue319.ComponentOptionsBase<Readonly<PopoverContentProps> & Readonly<{
+    onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+  }>, {}, {}, {}, {}, vue319.ComponentOptionsMixin, vue319.ComponentOptionsMixin, {
+    beforetoggle: (e: ToggleEvent) => any;
+  }, string, {}, {}, string, {}, vue319.GlobalComponents, vue319.GlobalDirectives, string, vue319.ComponentProvideOptions> & vue319.VNodeProps & vue319.AllowedComponentProps & vue319.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PopoverContentSlotProps) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Selection/SelectionRoot.vue.d.ts
+interface SelectionRootProps {
+  /** Namespace for dependency injection (must match SelectionItem namespace) */
+  namespace?: string;
+  /** Disables the entire selection instance */
+  disabled?: boolean;
+  /** Auto-select non-disabled items on registration */
+  enroll?: boolean;
+  /**
+   * Controls mandatory selection behavior:
+   * - false (default): No mandatory selection enforcement
+   * - true: Prevents deselecting the last selected item
+   * - `force`: Automatically selects the first non-disabled item on registration
+   */
+  mandatory?: boolean | 'force';
+  /** Enable multi-selection mode (array v-model) */
+  multiple?: boolean;
+}
+interface SelectionRootSlotProps {
+  /** Whether the selection instance is disabled */
+  isDisabled: boolean;
+  /** Enable multi-selection mode (array v-model) */
+  multiple: boolean;
+  /** Select an item by ID */
+  select: (id: ID) => void;
+  /** Unselect an item by ID */
+  unselect: (id: ID) => void;
+  /** Toggle an item's selection state by ID */
+  toggle: (id: ID) => void;
+  /** Attributes to bind to the root element */
+  attrs: {
+    'aria-multiselectable': boolean;
+  };
+}
+declare const useSelectionRoot: (key: string, defaultValue?: SelectionContext<SelectionTicket<unknown>> | undefined) => SelectionContext<SelectionTicket<unknown>>, provideSelectionRoot: (key: string, context: SelectionContext<SelectionTicket<unknown>>, app?: vue319.App) => SelectionContext<SelectionTicket<unknown>>;
+declare const __VLS_export$5: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$5<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$5<(SelectionRootProps & {
+    modelValue?: T | T[];
+  }) & {
+    "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    "onUpdate:model-value"?: ((value: T | T[]) => any) | undefined;
+  }> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: SelectionRootSlotProps) => any;
+  };
+  emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$5: typeof __VLS_export$5;
+type __VLS_PrettifyLocal$5<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Selection/SelectionItem.vue.d.ts
+interface SelectionItemProps<V = unknown> {
+  /** Unique identifier (auto-generated if not provided) */
+  id?: string;
+  /** Optional display label (passed through to slot, not used in registration) */
+  label?: string;
+  /** Value associated with this item */
+  value?: V;
+  /** Disables this specific item */
+  disabled?: MaybeRef<boolean>;
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface SelectionItemSlotProps<V = unknown> {
+  /** Unique identifier */
+  id: string;
+  /** Optional display label */
+  label?: string;
+  /** Value associated with this item */
+  value: V | undefined;
+  /** Whether this item is currently selected */
+  isSelected: boolean;
+  /** Whether this item is disabled */
+  isDisabled: boolean;
+  /** Select this item */
+  select: () => void;
+  /** Unselect this item */
+  unselect: () => void;
+  /** Toggle this item's selection state */
+  toggle: () => void;
+  /** Attributes to bind to the item element */
+  attrs: {
+    'aria-selected': boolean;
+    'aria-disabled': boolean;
+    'data-selected': true | undefined;
+    'data-disabled': true | undefined;
+  };
+}
+declare const __VLS_export$4: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$4<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$4<SelectionItemProps<V>> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: SelectionItemSlotProps<V>) => unknown;
+  };
+  emit: {};
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$4: typeof __VLS_export$4;
+type __VLS_PrettifyLocal$4<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Selection/index.d.ts
+/**
+ * Selection component with sub-components for managing item selection state.
+ *
+ * @see https://0.vuetifyjs.com/components/selection
+ */
+declare const Selection: {
+  /**
+   * Root component for selection contexts.
+   *
+   * @see https://0.vuetifyjs.com/components/selection#selectionroot
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Selection } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Selection.Root v-model="selected" multiple>
+   *     <Selection.Item value="a" v-slot="{ attrs }">
+   *       <button v-bind="attrs">Option A</button>
+   *     </Selection.Item>
+   *
+   *     <Selection.Item value="b" v-slot="{ attrs }">
+   *       <button v-bind="attrs">Option B</button>
+   *     </Selection.Item>
+   *   </Selection.Root>
+   * </template>
+   * ```
+   */
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+    slots: {
+      default: (props: SelectionRootSlotProps) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      multiple?: boolean | undefined;
+      modelValue?: (T | T[]) | undefined;
+      "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+      "onUpdate:model-value"?: ((value: T | T[]) => any) | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: SelectionRootSlotProps) => any;
+    };
+    emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * Item component for selection contexts.
+   *
+   * @see https://0.vuetifyjs.com/components/selection#selectionitem
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Selection } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Selection.Item value="a" v-slot="{ attrs }">
+   *     <button v-bind="attrs">Option A</button>
+   *   </Selection.Item>
+   * </template>
+   * ```
+   */
+  Item: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: {};
+    slots: {
+      default: (props: SelectionItemSlotProps<V>) => unknown;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue319.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: SelectionItemSlotProps<V>) => unknown;
+    };
+    emit: {};
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+};
+//#endregion
+//#region src/components/Single/SingleRoot.vue.d.ts
+interface SingleRootProps {
+  /** Namespace for dependency injection (must match SingleItem namespace) */
+  namespace?: string;
+  /** Disables the entire single instance */
+  disabled?: boolean;
+  /** Auto-select non-disabled items on registration */
+  enroll?: boolean;
+  /**
+   * Controls mandatory single behavior:
+   * - false (default): No mandatory single enforcement
+   * - true: Prevents deselecting the last selected item
+   * - `force`: Automatically selects the first non-disabled item on registration
+   */
+  mandatory?: boolean | 'force';
+}
+interface SingleRootSlotProps {
+  /** Whether the single instance is disabled */
+  isDisabled: boolean;
+  /** Select an item by ID */
+  select: (id: ID) => void;
+  /** Unselect an item by ID */
+  unselect: (id: ID) => void;
+  /** Toggle an item's single state by ID */
+  toggle: (id: ID) => void;
+  /** Attributes to bind to the root element */
+  attrs: {
+    'aria-multiselectable': false;
+  };
+}
+declare const useSingleRoot: (key: string, defaultValue?: SingleContext<SingleTicket<unknown>> | undefined) => SingleContext<SingleTicket<unknown>>, provideSingleRoot: (key: string, context: SingleContext<SingleTicket<unknown>>, app?: vue319.App) => SingleContext<SingleTicket<unknown>>;
+declare const __VLS_export$3: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$3<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$3<(SingleRootProps & {
+    modelValue?: T | T[];
+  }) & {
+    "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+  }> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: SingleRootSlotProps) => any;
+  };
+  emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$3: typeof __VLS_export$3;
+type __VLS_PrettifyLocal$3<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Single/SingleItem.vue.d.ts
+interface SingleItemProps<V = unknown> {
+  /** Unique identifier (auto-generated if not provided) */
+  id?: string;
+  /** Optional display label (passed through to slot, not used in registration) */
+  label?: string;
+  /** Value associated with this item */
+  value?: V;
+  /** Disables this specific item */
+  disabled?: MaybeRef<boolean>;
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface SingleItemSlotProps<V = unknown> {
+  /** Unique identifier */
+  id: string;
+  /** Optional display label */
+  label?: string;
+  /** Value associated with this item */
+  value: V | undefined;
+  /** Whether this item is currently selected */
+  isSelected: boolean;
+  /** Whether this item is disabled */
+  isDisabled: boolean;
+  /** Select this item */
+  select: () => void;
+  /** Unselect this item */
+  unselect: () => void;
+  /** Toggle this item's single state */
+  toggle: () => void;
+  /** Attributes to bind to the item element */
+  attrs: {
+    'aria-selected': boolean;
+    'aria-disabled': boolean;
+    'data-selected': true | undefined;
+    'data-disabled': true | undefined;
+  };
+}
+declare const __VLS_export$2: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$2<SingleItemProps<V>> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: SingleItemSlotProps<V>) => unknown;
+  };
+  emit: {};
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$2: typeof __VLS_export$2;
+type __VLS_PrettifyLocal$2<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Single/index.d.ts
+/**
+ * Single component with sub-components for building single-selection interfaces.
+ *
+ * @see https://0.vuetifyjs.com/components/single
+ */
+declare const Single: {
+  /**
+   * Root component for single-selection. Only one item can be selected at a time.
+   *
+   * @see https://0.vuetifyjs.com/components/single#singleroot
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Single } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Single.Root v-model="selected">
+   *     <Single.Item value="option1">
+   *       Option 1
+   *     </Single.Item>
+   *
+   *     <Single.Item value="option2">
+   *       Option 2
+   *     </Single.Item>
+   *   </Single.Root>
+   * </template>
+   * ```
+   */
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+    slots: {
+      default: (props: SingleRootSlotProps) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      modelValue?: (T | T[]) | undefined;
+      "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: SingleRootSlotProps) => any;
+    };
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * Component representing a selectable item within Single.Root.
+   *
+   * @see https://0.vuetifyjs.com/components/single#singleitem
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Single } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Single.Item value="option1" #default="{ isSelected }">
+   *     <div :class="{ selected: isSelected }">
+   *       Option 1
+   *     </div>
+   *   </Single.Item>
+   * </template>
+   * ```
+   */
+  Item: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: {};
+    slots: {
+      default: (props: SingleItemSlotProps<V>) => unknown;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue319.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: SingleItemSlotProps<V>) => unknown;
+    };
+    emit: {};
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+};
+//#endregion
+//#region src/components/Step/StepRoot.vue.d.ts
+interface StepRootProps {
+  /** Namespace for dependency injection (must match StepItem namespace) */
+  namespace?: string;
+  /** Disables the entire step instance */
+  disabled?: boolean;
+  /** Auto-select non-disabled items on registration */
+  enroll?: boolean;
+  /**
+   * Controls mandatory step behavior:
+   * - false (default): No mandatory step enforcement
+   * - true: Prevents deselecting the last selected item
+   * - `force`: Automatically selects the first non-disabled item on registration
+   */
+  mandatory?: boolean | 'force';
+}
+interface StepRootSlotProps {
+  /** Whether the step instance is disabled */
+  isDisabled: boolean;
+  /** Select the first item */
+  first: () => void;
+  /** Select the last item */
+  last: () => void;
+  /** Select the next item */
+  next: () => void;
+  /** Select the previous item */
+  prev: () => void;
+  /** Step forward or backward by a specific count */
+  step: (count: number) => void;
+  /** Select an item by ID */
+  select: (id: ID) => void;
+  /** Unselect an item by ID */
+  unselect: (id: ID) => void;
+  /** Toggle an item's step state by ID */
+  toggle: (id: ID) => void;
+  /** Attributes to bind to the root element */
+  attrs: {
+    'aria-multiselectable': false;
+  };
+}
+declare const useStepRoot: (key: string, defaultValue?: StepContext<StepTicket<unknown>> | undefined) => StepContext<StepTicket<unknown>>, provideStepRoot: (key: string, context: StepContext<StepTicket<unknown>>, app?: vue319.App) => StepContext<StepTicket<unknown>>;
+declare const __VLS_export$1: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$1<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$1<(StepRootProps & {
+    modelValue?: T | T[];
+  }) & {
+    "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+  }> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: StepRootSlotProps) => any;
+  };
+  emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$1: typeof __VLS_export$1;
+type __VLS_PrettifyLocal$1<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Step/StepItem.vue.d.ts
+interface StepItemProps<V = unknown> {
+  /** Unique identifier (auto-generated if not provided) */
+  id?: string;
+  /** Optional display label (passed through to slot, not used in registration) */
+  label?: string;
+  /** Value associated with this item */
+  value?: V;
+  /** Disables this specific item */
+  disabled?: MaybeRef<boolean>;
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface StepItemSlotProps<V = unknown> {
+  /** Unique identifier */
+  id: string;
+  /** Optional display label */
+  label?: string;
+  /** Value associated with this item */
+  value: V | undefined;
+  /** Whether this item is currently selected */
+  isSelected: boolean;
+  /** Whether this item is disabled */
+  isDisabled: boolean;
+  /** Select this item */
+  select: () => void;
+  /** Unselect this item */
+  unselect: () => void;
+  /** Toggle this item's step state */
+  toggle: () => void;
+  /** Attributes to bind to the item element */
+  attrs: {
+    'aria-selected': boolean;
+    'aria-disabled': boolean;
+    'data-selected': true | undefined;
+    'data-disabled': true | undefined;
+  };
+}
+declare const __VLS_export: <V = unknown>(__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<StepItemProps<V>> & vue319.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: StepItemSlotProps<V>) => unknown;
+  };
+  emit: {};
+}>) => vue319.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default: typeof __VLS_export;
+type __VLS_PrettifyLocal<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Step/index.d.ts
+/**
+ * Step component with sub-components for building stepper navigation.
+ *
+ * @see https://0.vuetifyjs.com/components/step
+ */
+declare const Step: {
+  /**
+   * Root component for step navigation.
+   *
+   * @see https://0.vuetifyjs.com/components/step
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Step } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Step.Root>
+   *     <Step.Item value="account">Account</Step.Item>
+   *
+   *     <Step.Item value="profile">Profile</Step.Item>
+   *
+   *     <Step.Item value="review">Review</Step.Item>
+   *   </Step.Root>
+   * </template>
+   * ```
+   */
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+    slots: {
+      default: (props: StepRootSlotProps) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      modelValue?: (T | T[]) | undefined;
+      "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: StepRootSlotProps) => any;
+    };
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * Component representing a single step item.
+   *
+   * @see https://0.vuetifyjs.com/components/step#stepitem
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Step } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Step.Item value="account">
+   *     Account Setup
+   *   </Step.Item>
+   * </template>
+   * ```
+   */
+  Item: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: {};
+    slots: {
+      default: (props: StepItemSlotProps<V>) => unknown;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue319.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+    } & vue319.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: StepItemSlotProps<V>) => unknown;
+    };
+    emit: {};
+  }>) => vue319.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+};
+//#endregion
+export { PaginationEllipsisSlotProps as $, _default$24 as $t, PopoverContentProps as A, ExpansionPanelContentSlotProps as At, providePopoverContext as B, ExpansionPanelItemSlotProps as Bt, SelectionRootProps as C, GroupRootProps as Ct, useSelectionRoot as D, useGroupRoot as Dt, provideSelectionRoot as E, provideGroupRoot as Et, _default$6 as F, ExpansionPanelHeaderProps as Ft, _default$16 as G, ExpansionPanelRootProps as Gt, Pagination as H, provideExpansionPanelItem as Ht, PopoverContext as I, ExpansionPanelHeaderSlotProps as It, _default$12 as J, provideExpansionPanelSelection as Jt, PaginationLastProps as K, ExpansionPanelRootSlotProps as Kt, PopoverRootProps as L, _default$21 as Lt, _default$7 as M, ExpansionPanelActivatorProps as Mt, PopoverAnchorProps as N, ExpansionPanelActivatorSlotProps as Nt, Popover as O, ExpansionPanel as Ot, PopoverAnchorSlotProps as P, _default$19 as Pt, PaginationEllipsisProps as Q, AvatarFallbackSlotProps as Qt, PopoverRootSlotProps as R, ExpansionPanelItemContext as Rt, _default$4 as S, _default$17 as St, _default$5 as T, _default$18 as Tt, PaginationStatusProps as U, useExpansionPanelItem as Ut, usePopoverContext as V, _default$22 as Vt, PaginationStatusSlotProps as W, ExpansionPanelOptionsContext as Wt, PaginationNextSlotProps as X, Avatar as Xt, PaginationNextProps as Y, useExpansionPanelRoot as Yt, _default$13 as Z, AvatarFallbackProps as Zt, provideSingleRoot as _, usePaginationItems as _t, StepRootProps as a, AvatarRootProps as an, PaginationFirstSlotProps as at, SelectionItemProps as b, GroupItemProps as bt, provideStepRoot as c, provideAvatarContext as cn, PaginationItemSlotProps as ct, SingleItemProps as d, AtomProps as dn, PaginationRootSlotProps as dt, AvatarImageEmits as en, _default$9 as et, SingleItemSlotProps as f, AtomSlots as fn, _default$15 as ft, _default$3 as g, usePaginationControls as gt, SingleRootSlotProps as h, providePaginationRoot as ht, _default as i, AvatarContext as in, PaginationFirstProps as it, PopoverContentSlotProps as j, _default$20 as jt, PopoverContentEmits as k, ExpansionPanelContentProps as kt, useStepRoot as l, useAvatarRoot as ln, _default$11 as lt, SingleRootProps as m, providePaginationItems as mt, StepItemProps as n, AvatarImageSlotProps as nn, PaginationPrevSlotProps as nt, StepRootSlotProps as o, AvatarTicket as on, _default$10 as ot, _default$2 as p, _default$27 as pn, providePaginationControls as pt, PaginationLastSlotProps as q, _default$23 as qt, StepItemSlotProps as r, _default$25 as rn, _default$14 as rt, _default$1 as s, _default$26 as sn, PaginationItemProps as st, Step as t, AvatarImageProps as tn, PaginationPrevProps as tt, Single as u, AtomExpose as un, PaginationRootProps as ut, useSingleRoot as v, usePaginationRoot as vt, SelectionRootSlotProps as w, GroupRootSlotProps as wt, SelectionItemSlotProps as x, GroupItemSlotProps as xt, Selection as y, Group as yt, _default$8 as z, ExpansionPanelItemProps as zt };