@vuetify/v0 0.0.21 → 0.0.23

package/dist/index-_y91DmIS.d.mts

@@ -0,0 +1,4019 @@
+import { i as ID, t as DOMElement } from "./index-DYSwiS9k.mjs";
+import { B as RegistryTicket, 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 } from "./index-Bby5ljat.mjs";
+import * as vue453 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$42: <T extends Record<string, any> = {}>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$15<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$15<AtomPrivateProps> & vue453.PublicProps;
+  expose: (exposed: vue453.ShallowUnwrapRef<AtomExpose>) => void;
+  attrs: any;
+  slots: AtomSlots<T>;
+  emit: {};
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$42: typeof __VLS_export$42;
+type __VLS_PrettifyLocal$15<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?: vue453.App) => AvatarContext;
+declare const __VLS_export$41: __VLS_WithSlots$24<vue453.DefineComponent<AvatarRootProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default?: (props: {}) => any;
+}>;
+declare const _default$41: typeof __VLS_export$41;
+type __VLS_WithSlots$24<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$40: __VLS_WithSlots$23<vue453.DefineComponent<AvatarImageProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+  load: (e: Event) => any;
+  error: (e: Event) => any;
+}, string, vue453.PublicProps, Readonly<AvatarImageProps> & Readonly<{
+  onLoad?: ((e: Event) => any) | undefined;
+  onError?: ((e: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: AvatarImageSlotProps) => any;
+}>;
+declare const _default$40: typeof __VLS_export$40;
+type __VLS_WithSlots$23<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$39: __VLS_WithSlots$22<vue453.DefineComponent<AvatarFallbackProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: AvatarFallbackSlotProps) => any;
+}>;
+declare const _default$39: typeof __VLS_export$39;
+type __VLS_WithSlots$22<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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<AvatarImageProps> & Readonly<{
+      onLoad?: ((e: Event) => any) | undefined;
+      onError?: ((e: Event) => any) | undefined;
+    }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+      load: (e: Event) => any;
+      error: (e: Event) => any;
+    }, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.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;
+  } & vue453.ComponentOptionsBase<Readonly<AvatarImageProps> & Readonly<{
+    onLoad?: ((e: Event) => any) | undefined;
+    onError?: ((e: Event) => any) | undefined;
+  }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+    load: (e: Event) => any;
+    error: (e: Event) => any;
+  }, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: AvatarFallbackSlotProps) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Checkbox/CheckboxGroup.vue.d.ts
+interface CheckboxGroupProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Disables the entire checkbox group */
+  disabled?: boolean;
+  /** Auto-select non-disabled items on registration */
+  enroll?: boolean;
+  /**
+   * Controls mandatory checkbox behavior:
+   * - false (default): No mandatory enforcement
+   * - true: Prevents deselecting the last selected item
+   * - `force`: Automatically selects the first non-disabled item on registration
+   */
+  mandatory?: boolean | 'force';
+  /** Accessible name for the group */
+  label?: string;
+  /** ID of element that labels this group */
+  ariaLabelledby?: string;
+  /** ID of element that describes this group */
+  ariaDescribedby?: string;
+}
+interface CheckboxGroupSlotProps {
+  /** Whether the checkbox group 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 selection 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: {
+    'role': 'group';
+    'aria-label': string | undefined;
+    'aria-labelledby': string | undefined;
+    'aria-describedby': string | undefined;
+  };
+}
+declare const useCheckboxGroup: (key: string, defaultValue?: GroupContext<GroupTicket<unknown>> | undefined) => GroupContext<GroupTicket<unknown>>, provideCheckboxGroup: (key: string, context: GroupContext<GroupTicket<unknown>>, app?: vue453.App) => GroupContext<GroupTicket<unknown>>;
+declare const __VLS_export$38: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$14<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$14<(CheckboxGroupProps & {
+    modelValue?: T | T[];
+  }) & {
+    "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    "onUpdate:model-value"?: ((value: T | T[]) => any) | undefined;
+  }> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: CheckboxGroupSlotProps) => any;
+  };
+  emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$34: typeof __VLS_export$38;
+type __VLS_PrettifyLocal$14<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Checkbox/CheckboxHiddenInput.vue.d.ts
+interface CheckboxHiddenInputProps {
+  /** Namespace for context injection from parent Checkbox.Root */
+  namespace?: string;
+  /** Form field name (defaults to context value) */
+  name?: string;
+  /** Submitted value when checked (defaults to context value or 'on') */
+  value?: string;
+  /** Associate with form by ID (defaults to context value) */
+  form?: string;
+}
+declare const __VLS_export$37: vue453.DefineComponent<CheckboxHiddenInputProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<CheckboxHiddenInputProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>;
+declare const _default$35: typeof __VLS_export$37;
+//#endregion
+//#region src/components/Checkbox/CheckboxRoot.vue.d.ts
+/** Visual state of the checkbox for styling purposes */
+type CheckboxState = 'checked' | 'unchecked' | 'indeterminate';
+interface CheckboxRootContext<V = unknown> {
+  /** Unique identifier */
+  readonly id: ID;
+  /** Optional display label */
+  readonly label?: string;
+  /** Value associated with this checkbox */
+  readonly value: V | undefined;
+  /** Form field name (triggers auto hidden input when provided) */
+  readonly name?: string;
+  /** Associate with form by ID */
+  readonly form?: string;
+  /** Whether this checkbox is currently checked */
+  isChecked: Readonly<Ref<boolean>>;
+  /** Whether this checkbox is in a mixed/indeterminate state */
+  isMixed: Readonly<Ref<boolean>>;
+  /** Whether this checkbox is disabled */
+  isDisabled: Readonly<Ref<boolean>>;
+  /** Check this checkbox */
+  select: () => void;
+  /** Uncheck this checkbox */
+  unselect: () => void;
+  /** Toggle this checkbox's state */
+  toggle: () => void;
+  /** Set this checkbox to mixed/indeterminate state (group mode only) */
+  mix: () => void;
+  /** Clear mixed/indeterminate state (group mode only) */
+  unmix: () => void;
+}
+interface CheckboxRootProps<V = unknown> extends AtomProps {
+  /** Unique identifier (auto-generated if not provided) */
+  id?: ID;
+  /** Optional display label (passed through to slot) */
+  label?: string;
+  /** Value associated with this checkbox (used in group mode and form submission) */
+  value?: V;
+  /** Form field name - triggers auto hidden input when provided */
+  name?: string;
+  /** Associate with form by ID */
+  form?: string;
+  /** Disables this checkbox */
+  disabled?: MaybeRef<boolean>;
+  /** Sets the indeterminate state */
+  indeterminate?: MaybeRef<boolean>;
+  /** Namespace for context provision to children (Indicator, HiddenInput) */
+  namespace?: string;
+  /** Namespace for connecting to parent Checkbox.Group */
+  groupNamespace?: string;
+  /** ID of element that labels this checkbox */
+  ariaLabelledby?: string;
+  /** ID of element that describes this checkbox */
+  ariaDescribedby?: string;
+  /** Whether the checkbox has an invalid value */
+  ariaInvalid?: boolean;
+}
+interface CheckboxRootSlotProps<V = unknown> {
+  /** Unique identifier */
+  id: ID;
+  /** Optional display label */
+  label?: string;
+  /** Value associated with this checkbox */
+  value: V | undefined;
+  /** Whether this checkbox is currently checked */
+  isChecked: boolean;
+  /** Whether this checkbox is in a mixed/indeterminate state */
+  isMixed: boolean;
+  /** Whether this checkbox is disabled */
+  isDisabled: boolean;
+  /** Check this checkbox */
+  select: () => void;
+  /** Uncheck this checkbox */
+  unselect: () => void;
+  /** Toggle this checkbox's state */
+  toggle: () => void;
+  /** Set this checkbox to mixed/indeterminate state (group mode only) */
+  mix: () => void;
+  /** Clear mixed/indeterminate state (group mode only) */
+  unmix: () => void;
+  /** Attributes to bind to the checkbox element */
+  attrs: {
+    'type': 'button' | undefined;
+    'role': 'checkbox';
+    'aria-checked': boolean | 'mixed';
+    'aria-disabled': boolean | undefined;
+    'aria-label': string | undefined;
+    'aria-labelledby': string | undefined;
+    'aria-describedby': string | undefined;
+    'aria-invalid': boolean | undefined;
+    'tabindex': 0 | undefined;
+    'data-state': CheckboxState;
+    'data-disabled': true | undefined;
+  };
+}
+declare const useCheckboxRoot: (key: string, defaultValue?: CheckboxRootContext<unknown> | undefined) => CheckboxRootContext<unknown>, provideCheckboxRoot: (key: string, context: CheckboxRootContext<unknown>, app?: vue453.App) => CheckboxRootContext<unknown>;
+declare const __VLS_export$36: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$13<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$13<(CheckboxRootProps<V> & {
+    modelValue?: boolean;
+  }) & {
+    "onUpdate:modelValue"?: ((value: boolean | undefined) => any) | undefined;
+    "onUpdate:model-value"?: ((value: boolean) => any) | undefined;
+  }> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: CheckboxRootSlotProps<V>) => any;
+  };
+  emit: ((evt: "update:model-value", value: boolean) => void) & ((evt: "update:modelValue", value: boolean | undefined) => void);
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$37: typeof __VLS_export$36;
+type __VLS_PrettifyLocal$13<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Checkbox/CheckboxIndicator.vue.d.ts
+interface CheckboxIndicatorProps extends AtomProps {
+  /** Namespace for context injection from parent Checkbox.Root */
+  namespace?: string;
+}
+interface CheckboxIndicatorSlotProps {
+  /** Whether this checkbox is currently checked */
+  isChecked: boolean;
+  /** Whether this checkbox is in a mixed/indeterminate state */
+  isMixed: boolean;
+  /** Attributes to bind to the indicator element */
+  attrs: {
+    'data-state': CheckboxState;
+    'style': {
+      visibility: 'visible' | 'hidden';
+    };
+  };
+}
+declare const __VLS_export$35: __VLS_WithSlots$21<vue453.DefineComponent<CheckboxIndicatorProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<CheckboxIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: CheckboxIndicatorSlotProps) => any;
+}>;
+declare const _default$36: typeof __VLS_export$35;
+type __VLS_WithSlots$21<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Checkbox/CheckboxSelectAll.vue.d.ts
+interface CheckboxSelectAllProps extends AtomProps {
+  /** Optional display label (passed through to slot and aria-label) */
+  label?: string;
+  /** Disables this checkbox */
+  disabled?: boolean;
+  /** Namespace for context provision to children (Indicator) */
+  namespace?: string;
+  /** Namespace for connecting to parent Checkbox.Group */
+  groupNamespace?: string;
+  /** ID of element that labels this checkbox */
+  ariaLabelledby?: string;
+  /** ID of element that describes this checkbox */
+  ariaDescribedby?: string;
+}
+interface CheckboxSelectAllSlotProps {
+  /** Optional display label */
+  label?: string;
+  /** Whether all selectable items are selected */
+  isAllSelected: boolean;
+  /** Whether some but not all selectable items are selected */
+  isMixed: boolean;
+  /** Whether this checkbox is disabled */
+  isDisabled: boolean;
+  /** Select all selectable items */
+  selectAll: () => void;
+  /** Unselect all items */
+  unselectAll: () => void;
+  /** Toggle between all selected and none selected */
+  toggleAll: () => void;
+  /** Attributes to bind to the checkbox element */
+  attrs: {
+    'type': 'button' | undefined;
+    'role': 'checkbox';
+    'aria-checked': boolean | 'mixed';
+    'aria-disabled': boolean | undefined;
+    'aria-label': string | undefined;
+    'aria-labelledby': string | undefined;
+    'aria-describedby': string | undefined;
+    'tabindex': 0 | undefined;
+    'data-state': CheckboxState;
+    'data-disabled': true | undefined;
+  };
+}
+declare const __VLS_export$34: __VLS_WithSlots$20<vue453.DefineComponent<CheckboxSelectAllProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<CheckboxSelectAllProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: CheckboxSelectAllSlotProps) => any;
+}>;
+declare const _default$38: typeof __VLS_export$34;
+type __VLS_WithSlots$20<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Checkbox/index.d.ts
+/**
+ * Checkbox component with sub-components for checkbox controls.
+ *
+ * @see https://0.vuetifyjs.com/components/forms/checkbox
+ *
+ * @example
+ * ```vue
+ * <script lang="ts" setup>
+ *   import { Checkbox } from '@vuetify/v0'
+ * </script>
+ *
+ * <template>
+ *   <label>
+ *     <Checkbox.Root>
+ *       <Checkbox.Indicator>✓</Checkbox.Indicator>
+ *     </Checkbox.Root>
+ *     I agree to terms
+ *   </label>
+ * </template>
+ * ```
+ */
+declare const Checkbox: {
+  /**
+   * Group component for managing multiple checkboxes.
+   *
+   * @see https://0.vuetifyjs.com/components/forms/checkbox#group
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { Checkbox } from '@vuetify/v0'
+   *   import { ref } from 'vue'
+   *
+   *   const selected = ref<string[]>([])
+   * </script>
+   *
+   * <template>
+   *   <Checkbox.Group v-model="selected">
+   *     <Checkbox.Root value="a">
+   *       <Checkbox.Indicator>✓</Checkbox.Indicator>
+   *       Option A
+   *     </Checkbox.Root>
+   *     <Checkbox.Root value="b">
+   *       <Checkbox.Indicator>✓</Checkbox.Indicator>
+   *       Option B
+   *     </Checkbox.Root>
+   *   </Checkbox.Group>
+   * </template>
+   * ```
+   */
+  Group: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    slots: {
+      default: (props: CheckboxGroupSlotProps) => any;
+    };
+    attrs: any;
+    emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+  }, __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;
+      label?: string | undefined;
+      ariaLabelledby?: string | undefined;
+      ariaDescribedby?: string | undefined;
+      as?: (DOMElement | null) | undefined;
+      renderless?: boolean | undefined;
+      modelValue?: (T | T[]) | undefined;
+      "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+      "onUpdate:model-value"?: ((value: T | T[]) => any) | undefined;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: CheckboxGroupSlotProps) => any;
+    };
+    emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+  }>) => vue453.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * Hidden input component for form submission.
+   *
+   * Auto-rendered by Root when `name` prop is provided.
+   * Can also be used explicitly for custom form integration.
+   *
+   * @see https://0.vuetifyjs.com/components/forms/checkbox#hiddeninput
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { Checkbox } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Checkbox.Root>
+   *     <Checkbox.Indicator>✓</Checkbox.Indicator>
+   *     <Checkbox.HiddenInput name="agree" value="yes" />
+   *   </Checkbox.Root>
+   * </template>
+   * ```
+   */
+  HiddenInput: vue453.DefineComponent<CheckboxHiddenInputProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<CheckboxHiddenInputProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>;
+  /**
+   * Visual indicator component for checkboxes.
+   *
+   * Renders as a span and only displays when checked or indeterminate.
+   * Must be used within a Checkbox.Root component.
+   *
+   * @see https://0.vuetifyjs.com/components/forms/checkbox#indicator
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { Checkbox } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Checkbox.Root>
+   *     <Checkbox.Indicator>
+   *       <svg viewBox="0 0 24 24">
+   *         <path d="M9 16.17L4.83 12l-1.42 1.41L9 19 21 7l-1.41-1.41z" />
+   *       </svg>
+   *     </Checkbox.Indicator>
+   *   </Checkbox.Root>
+   * </template>
+   * ```
+   */
+  Indicator: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<CheckboxIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<CheckboxIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<CheckboxIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: CheckboxIndicatorSlotProps) => any;
+    };
+  });
+  /**
+   * Root component for individual checkboxes.
+   *
+   * Renders as a button with proper ARIA attributes and handles
+   * click/keyboard interactions. Supports standalone mode with
+   * v-model or group mode within Checkbox.Group. When `name` prop
+   * is provided, automatically renders a hidden input for form submission.
+   *
+   * @see https://0.vuetifyjs.com/components/forms/checkbox#root
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { Checkbox } from '@vuetify/v0'
+   *   import { ref } from 'vue'
+   *
+   *   const agreed = ref(false)
+   * </script>
+   *
+   * <template>
+   *   <label>
+   *     <Checkbox.Root v-model="agreed">
+   *       <Checkbox.Indicator>✓</Checkbox.Indicator>
+   *     </Checkbox.Root>
+   *     I agree to the terms
+   *   </label>
+   * </template>
+   * ```
+   */
+  Root: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    slots: {
+      default: (props: CheckboxRootSlotProps<V>) => any;
+    };
+    attrs: any;
+    emit: ((evt: "update:model-value", value: boolean) => void) & ((evt: "update:modelValue", value: boolean | undefined) => void);
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: ID | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      name?: string | undefined;
+      form?: string | undefined;
+      disabled?: vue453.MaybeRef<boolean> | undefined;
+      indeterminate?: vue453.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+      groupNamespace?: string | undefined;
+      ariaLabelledby?: string | undefined;
+      ariaDescribedby?: string | undefined;
+      ariaInvalid?: boolean | undefined;
+      as?: (DOMElement | null) | undefined;
+      renderless?: boolean | undefined;
+      modelValue?: boolean | undefined;
+      "onUpdate:modelValue"?: ((value: boolean | undefined) => any) | undefined;
+      "onUpdate:model-value"?: ((value: boolean) => any) | undefined;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: CheckboxRootSlotProps<V>) => any;
+    };
+    emit: ((evt: "update:model-value", value: boolean) => void) & ((evt: "update:modelValue", value: boolean | undefined) => void);
+  }>) => vue453.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * Select all checkbox for group multi-selection.
+   *
+   * Binds to parent Checkbox.Group's aggregate state. Reflects
+   * isAllSelected/isMixed and calls toggleAll on click. Does NOT
+   * register as a group item. Must be used within a Checkbox.Group.
+   *
+   * @see https://0.vuetifyjs.com/components/forms/checkbox#selectall
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { Checkbox } from '@vuetify/v0'
+   *   import { ref } from 'vue'
+   *
+   *   const selected = ref<string[]>([])
+   * </script>
+   *
+   * <template>
+   *   <Checkbox.Group v-model="selected">
+   *     <Checkbox.SelectAll>
+   *       <Checkbox.Indicator v-slot="{ isMixed }">
+   *         <span v-if="isMixed">−</span>
+   *         <span v-else>✓</span>
+   *       </Checkbox.Indicator>
+   *     </Checkbox.SelectAll>
+   *
+   *     <Checkbox.Root value="a">
+   *       <Checkbox.Indicator>✓</Checkbox.Indicator>
+   *     </Checkbox.Root>
+   *   </Checkbox.Group>
+   * </template>
+   * ```
+   */
+  SelectAll: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<CheckboxSelectAllProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<CheckboxSelectAllProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<CheckboxSelectAllProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: CheckboxSelectAllSlotProps) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Dialog/DialogRoot.vue.d.ts
+interface DialogContext {
+  isOpen: ShallowRef<boolean>;
+  id: string;
+  titleId: string;
+  descriptionId: string;
+  open: () => void;
+  close: () => void;
+}
+interface DialogRootProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Unique identifier for the dialog (auto-generated if not provided) */
+  id?: string;
+}
+interface DialogRootSlotProps {
+  /** Unique identifier */
+  id: string;
+  /** Whether the dialog is currently open */
+  isOpen: boolean;
+  /** Open the dialog */
+  open: () => void;
+  /** Close the dialog */
+  close: () => void;
+}
+declare const useDialogContext: (key: string, defaultValue?: DialogContext | undefined) => DialogContext, provideDialogContext: (key: string, context: DialogContext, app?: vue453.App) => DialogContext;
+declare const __VLS_export$33: __VLS_WithSlots$19<vue453.DefineComponent<DialogRootProps & {
+  modelValue?: boolean;
+}, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+  "update:modelValue": (...args: unknown[]) => any;
+}, string, vue453.PublicProps, Readonly<DialogRootProps & {
+  modelValue?: boolean;
+}> & Readonly<{
+  "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: DialogRootSlotProps) => any;
+}>;
+declare const _default$31: typeof __VLS_export$33;
+type __VLS_WithSlots$19<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Dialog/DialogActivator.vue.d.ts
+interface DialogActivatorProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface DialogActivatorSlotProps {
+  /** Whether the dialog is currently open */
+  isOpen: boolean;
+  /** Attributes to bind to the trigger element */
+  attrs: {
+    'type': 'button' | undefined;
+    'aria-haspopup': 'dialog';
+    'aria-expanded': boolean;
+    'data-dialog-open': '' | undefined;
+  };
+}
+declare const __VLS_export$32: __VLS_WithSlots$18<vue453.DefineComponent<DialogActivatorProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<DialogActivatorProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: DialogActivatorSlotProps) => any;
+}>;
+declare const _default$33: typeof __VLS_export$32;
+type __VLS_WithSlots$18<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Dialog/DialogContent.vue.d.ts
+interface DialogContentProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /** Close dialog when clicking outside content @default true */
+  closeOnClickOutside?: boolean;
+}
+interface DialogContentEmits {
+  cancel: [e: Event];
+  close: [e: Event];
+}
+interface DialogContentSlotProps {
+  /** Whether the dialog is currently open */
+  isOpen: boolean;
+  /** Attributes to bind to the dialog element */
+  attrs: {
+    'id': string;
+    'role': 'dialog';
+    'aria-modal': 'true';
+    'aria-labelledby': string;
+    'aria-describedby': string;
+  };
+}
+declare const __VLS_export$31: __VLS_WithSlots$17<vue453.DefineComponent<DialogContentProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+  cancel: (e: Event) => any;
+  close: (e: Event) => any;
+}, string, vue453.PublicProps, Readonly<DialogContentProps> & Readonly<{
+  onCancel?: ((e: Event) => any) | undefined;
+  onClose?: ((e: Event) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: DialogContentSlotProps) => any;
+}>;
+declare const _default$29: typeof __VLS_export$31;
+type __VLS_WithSlots$17<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Dialog/DialogTitle.vue.d.ts
+interface DialogTitleProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface DialogTitleSlotProps {
+  /** Attributes to bind to the title element */
+  attrs: {
+    id: string;
+  };
+}
+declare const __VLS_export$30: __VLS_WithSlots$16<vue453.DefineComponent<DialogTitleProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<DialogTitleProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: DialogTitleSlotProps) => any;
+}>;
+declare const _default$32: typeof __VLS_export$30;
+type __VLS_WithSlots$16<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Dialog/DialogDescription.vue.d.ts
+interface DialogDescriptionProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface DialogDescriptionSlotProps {
+  /** Attributes to bind to the description element */
+  attrs: {
+    id: string;
+  };
+}
+declare const __VLS_export$29: __VLS_WithSlots$15<vue453.DefineComponent<DialogDescriptionProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<DialogDescriptionProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: DialogDescriptionSlotProps) => any;
+}>;
+declare const _default$30: typeof __VLS_export$29;
+type __VLS_WithSlots$15<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Dialog/DialogClose.vue.d.ts
+interface DialogCloseProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+}
+interface DialogCloseSlotProps {
+  /** Whether the dialog is currently open */
+  isOpen: boolean;
+  /** Attributes to bind to the close button element */
+  attrs: {
+    'type': 'button' | undefined;
+    'aria-label': 'Close';
+  };
+}
+declare const __VLS_export$28: __VLS_WithSlots$14<vue453.DefineComponent<DialogCloseProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: DialogCloseSlotProps) => any;
+}>;
+declare const _default$28: typeof __VLS_export$28;
+type __VLS_WithSlots$14<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Dialog/index.d.ts
+/**
+ * Dialog component with sub-components for building modal dialogs.
+ *
+ * @see https://0.vuetifyjs.com/components/dialog
+ *
+ * @example
+ * ```vue
+ * <script lang="ts" setup>
+ *   import { Dialog } from '@vuetify/v0'
+ * </script>
+ *
+ * <template>
+ *   <Dialog.Root>
+ *     <Dialog.Activator>
+ *       Open Dialog
+ *     </Dialog.Activator>
+ *
+ *     <Dialog.Content>
+ *       <Dialog.Title>Dialog Title</Dialog.Title>
+ *       <Dialog.Description>Dialog description text.</Dialog.Description>
+ *
+ *       <p>Dialog content goes here.</p>
+ *
+ *       <Dialog.Close>Close</Dialog.Close>
+ *     </Dialog.Content>
+ *   </Dialog.Root>
+ * </template>
+ * ```
+ */
+declare const Dialog: {
+  /**
+   * Root component for dialogs.
+   *
+   * @see https://0.vuetifyjs.com/components/dialog
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Dialog } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Dialog.Root>
+   *     <Dialog.Activator>Open</Dialog.Activator>
+   *     <Dialog.Content>
+   *       <Dialog.Title>Title</Dialog.Title>
+   *       <Dialog.Close>Close</Dialog.Close>
+   *     </Dialog.Content>
+   *   </Dialog.Root>
+   * </template>
+   * ```
+   */
+  Root: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<DialogRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+    }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+      "update:modelValue": (...args: unknown[]) => any;
+    }, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<DialogRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<DialogRootProps & {
+    modelValue?: boolean;
+  }> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: unknown[]) => any) | undefined;
+  }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+    "update:modelValue": (...args: unknown[]) => any;
+  }, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: DialogRootSlotProps) => any;
+    };
+  });
+  /**
+   * Activator component that opens the dialog.
+   *
+   * @see https://0.vuetifyjs.com/components/dialog#dialogactivator
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Dialog } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Dialog.Activator>
+   *     Open Dialog
+   *   </Dialog.Activator>
+   * </template>
+   * ```
+   */
+  Activator: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<DialogActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<DialogActivatorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<DialogActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: DialogActivatorSlotProps) => any;
+    };
+  });
+  /**
+   * Content container for the dialog using native `<dialog>` element.
+   *
+   * @see https://0.vuetifyjs.com/components/dialog#dialogcontent
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Dialog } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Dialog.Content>
+   *     <Dialog.Title>Title</Dialog.Title>
+   *     <p>Content goes here.</p>
+   *     <Dialog.Close>Close</Dialog.Close>
+   *   </Dialog.Content>
+   * </template>
+   * ```
+   */
+  Content: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<DialogContentProps> & Readonly<{
+      onCancel?: ((e: Event) => any) | undefined;
+      onClose?: ((e: Event) => any) | undefined;
+    }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+      cancel: (e: Event) => any;
+      close: (e: Event) => any;
+    }, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<DialogContentProps> & Readonly<{
+      onCancel?: ((e: Event) => any) | undefined;
+      onClose?: ((e: Event) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<DialogContentProps> & Readonly<{
+    onCancel?: ((e: Event) => any) | undefined;
+    onClose?: ((e: Event) => any) | undefined;
+  }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+    cancel: (e: Event) => any;
+    close: (e: Event) => any;
+  }, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: DialogContentSlotProps) => any;
+    };
+  });
+  /**
+   * Title component for accessible dialog labeling.
+   *
+   * @see https://0.vuetifyjs.com/components/dialog#dialogtitle
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Dialog } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Dialog.Title>Dialog Title</Dialog.Title>
+   * </template>
+   * ```
+   */
+  Title: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<DialogTitleProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<DialogTitleProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<DialogTitleProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: DialogTitleSlotProps) => any;
+    };
+  });
+  /**
+   * Description component for accessible dialog description.
+   *
+   * @see https://0.vuetifyjs.com/components/dialog#dialogdescription
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Dialog } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Dialog.Description>
+   *     This dialog allows you to configure settings.
+   *   </Dialog.Description>
+   * </template>
+   * ```
+   */
+  Description: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<DialogDescriptionProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<DialogDescriptionProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<DialogDescriptionProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: DialogDescriptionSlotProps) => any;
+    };
+  });
+  /**
+   * Close button component for closing the dialog.
+   *
+   * @see https://0.vuetifyjs.com/components/dialog#dialogclose
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Dialog } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Dialog.Close>Close</Dialog.Close>
+   * </template>
+   * ```
+   */
+  Close: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<DialogCloseProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: DialogCloseSlotProps) => 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?: vue453.App) => SelectionContext<SelectionTicket<unknown>>;
+declare const __VLS_export$27: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal$12<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal$12<(ExpansionPanelRootProps & {
+    modelValue?: T | T[];
+  }) & {
+    [x: `on${Capitalize<string>}`]: ((...args: any) => any) | undefined;
+  }> & vue453.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);
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$27: typeof __VLS_export$27;
+type __VLS_PrettifyLocal$12<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?: vue453.App) => ExpansionPanelItemContext;
+declare const __VLS_export$26: <V = unknown>(__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<ExpansionPanelItemProps<V>> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: ExpansionPanelItemSlotProps) => any;
+  };
+  emit: {};
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$26: typeof __VLS_export$26;
+type __VLS_PrettifyLocal$11<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$25: __VLS_WithSlots$13<vue453.DefineComponent<ExpansionPanelHeaderProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<ExpansionPanelHeaderProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: ExpansionPanelHeaderSlotProps) => any;
+}>;
+declare const _default$25: typeof __VLS_export$25;
+type __VLS_WithSlots$13<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$24: __VLS_WithSlots$12<vue453.DefineComponent<ExpansionPanelActivatorProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: ExpansionPanelActivatorSlotProps) => any;
+}>;
+declare const _default$23: typeof __VLS_export$24;
+type __VLS_WithSlots$12<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$23: __VLS_WithSlots$11<vue453.DefineComponent<ExpansionPanelContentProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: ExpansionPanelContentSlotProps) => any;
+}>;
+declare const _default$24: typeof __VLS_export$23;
+type __VLS_WithSlots$11<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?: {
+    slots: {
+      default: (props: ExpansionPanelRootSlotProps) => any;
+    };
+    attrs: any;
+    emit: ((evt: "update:model-value", ...args: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+  }, __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;
+    } & vue453.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);
+  }>) => vue453.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?: {
+    slots: {
+      default: (props: ExpansionPanelItemSlotProps) => any;
+    };
+    attrs: any;
+    emit: {};
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue453.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+      as?: (DOMElement | null) | undefined;
+      renderless?: boolean | undefined;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: ExpansionPanelItemSlotProps) => any;
+    };
+    emit: {};
+  }>) => vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<ExpansionPanelHeaderProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ExpansionPanelHeaderProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<ExpansionPanelHeaderProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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?: vue453.App) => GroupContext<GroupTicket<unknown>>;
+declare const __VLS_export$22: <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<(GroupRootProps & {
+    modelValue?: T | T[];
+  }) & {
+    "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    "onUpdate:model-value"?: ((value: T | T[]) => any) | undefined;
+  }> & vue453.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);
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$22: typeof __VLS_export$22;
+type __VLS_PrettifyLocal$10<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$21: <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<GroupItemProps<V>> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: GroupItemSlotProps<V>) => unknown;
+  };
+  emit: {};
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$21: typeof __VLS_export$21;
+type __VLS_PrettifyLocal$9<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?: {
+    slots: {
+      default: (props: GroupRootSlotProps) => any;
+    };
+    attrs: any;
+    emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+  }, __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;
+    } & vue453.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);
+  }>) => vue453.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?: {
+    slots: {
+      default: (props: GroupItemSlotProps<V>) => unknown;
+    };
+    attrs: any;
+    emit: {};
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue453.MaybeRef<boolean> | undefined;
+      indeterminate?: vue453.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: GroupItemSlotProps<V>) => unknown;
+    };
+    emit: {};
+  }>) => vue453.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?: vue453.App) => PaginationContext;
+declare const usePaginationControls: (key: string, defaultValue?: RegistryContext<RegistryTicket<unknown>> | undefined) => RegistryContext<RegistryTicket<unknown>>, providePaginationControls: (key: string, context: RegistryContext<RegistryTicket<unknown>>, app?: vue453.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?: vue453.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$20: <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<(PaginationRootProps & {
+    modelValue?: number;
+  }) & {
+    [x: `on${Capitalize<string>}`]: ((...args: any) => any) | undefined;
+  }> & vue453.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);
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$19: typeof __VLS_export$20;
+type __VLS_PrettifyLocal$8<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$19: __VLS_WithSlots$10<vue453.DefineComponent<PaginationItemProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<PaginationItemProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationItemSlotProps) => any;
+}>;
+declare const _default$15: typeof __VLS_export$19;
+type __VLS_WithSlots$10<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$18: __VLS_WithSlots$9<vue453.DefineComponent<PaginationFirstProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<PaginationFirstProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationFirstSlotProps) => any;
+}>;
+declare const _default$14: typeof __VLS_export$18;
+type __VLS_WithSlots$9<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$17: __VLS_WithSlots$8<vue453.DefineComponent<PaginationPrevProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<PaginationPrevProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationPrevSlotProps) => any;
+}>;
+declare const _default$18: typeof __VLS_export$17;
+type __VLS_WithSlots$8<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$16: __VLS_WithSlots$7<vue453.DefineComponent<PaginationEllipsisProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<PaginationEllipsisProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationEllipsisSlotProps) => any;
+}>;
+declare const _default$13: typeof __VLS_export$16;
+type __VLS_WithSlots$7<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$15: __VLS_WithSlots$6<vue453.DefineComponent<PaginationNextProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<PaginationNextProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationNextSlotProps) => any;
+}>;
+declare const _default$17: typeof __VLS_export$15;
+type __VLS_WithSlots$6<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$14: __VLS_WithSlots$5<vue453.DefineComponent<PaginationLastProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<PaginationLastProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationLastSlotProps) => any;
+}>;
+declare const _default$16: typeof __VLS_export$14;
+type __VLS_WithSlots$5<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$13: __VLS_WithSlots$4<vue453.DefineComponent<PaginationStatusProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<PaginationStatusProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PaginationStatusSlotProps) => any;
+}>;
+declare const _default$20: typeof __VLS_export$13;
+type __VLS_WithSlots$4<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?: {
+    slots: {
+      default: (props: PaginationRootSlotProps) => any;
+    };
+    attrs: any;
+    emit: ((evt: "update:model-value", ...args: T | T[]) => void) & ((evt: "update:modelValue", value: number) => void);
+  }, __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;
+    } & vue453.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);
+  }>) => vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PaginationItemProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PaginationItemProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PaginationFirstProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationFirstProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PaginationFirstProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PaginationPrevProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationPrevProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PaginationPrevProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PaginationEllipsisProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationEllipsisProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PaginationEllipsisProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PaginationNextProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationNextProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PaginationNextProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PaginationLastProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationLastProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PaginationLastProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PaginationStatusProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PaginationStatusProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PaginationStatusProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.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?: vue453.App) => PopoverContext;
+declare const __VLS_export$12: __VLS_WithSlots$3<vue453.DefineComponent<PopoverRootProps & {
+  modelValue?: boolean;
+}, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+  "update:modelValue": (value: boolean) => any;
+}, string, vue453.PublicProps, Readonly<PopoverRootProps & {
+  modelValue?: boolean;
+}> & Readonly<{
+  "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PopoverRootSlotProps) => any;
+}>;
+declare const _default$12: typeof __VLS_export$12;
+type __VLS_WithSlots$3<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Popover/PopoverActivator.vue.d.ts
+interface PopoverActivatorProps extends AtomProps {
+  /** Target popover ID (defaults to parent PopoverRoot id) */
+  target?: string;
+}
+interface PopoverActivatorSlotProps {
+  /** 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$11: __VLS_WithSlots$2<vue453.DefineComponent<PopoverActivatorProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<PopoverActivatorProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PopoverActivatorSlotProps) => any;
+}>;
+declare const _default$10: typeof __VLS_export$11;
+type __VLS_WithSlots$2<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$10: __VLS_WithSlots$1<vue453.DefineComponent<PopoverContentProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+  beforetoggle: (e: ToggleEvent) => any;
+}, string, vue453.PublicProps, Readonly<PopoverContentProps> & Readonly<{
+  onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  default: (props: PopoverContentSlotProps) => any;
+}>;
+declare const _default$11: typeof __VLS_export$10;
+type __VLS_WithSlots$1<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.Activator>
+   *       Click to toggle
+   *     </Popover.Activator>
+   *
+   *     <Popover.Content>
+   *       Popover content goes here.
+   *     </Popover.Content>
+   *   </Popover.Root>
+   * </template>
+   * ```
+   */
+  Root: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PopoverRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+      "update:modelValue": (value: boolean) => any;
+    }, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PopoverRootProps & {
+    modelValue?: boolean;
+  }> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+  }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+  }, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PopoverRootSlotProps) => any;
+    };
+  });
+  /**
+   * Activator component that opens the popover.
+   *
+   * @see https://0.vuetifyjs.com/components/popover#popoveractivator
+   *
+   * @example
+   * ```vue
+   * <script lang="ts" setup>
+   *   import { Popover } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Popover.Activator>
+   *     Click to toggle
+   *   </Popover.Activator>
+   * </template>
+   * ```
+   */
+  Activator: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PopoverActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverActivatorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PopoverActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PopoverActivatorSlotProps) => 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[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<PopoverContentProps> & Readonly<{
+      onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+      beforetoggle: (e: ToggleEvent) => any;
+    }, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverContentProps> & Readonly<{
+      onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<PopoverContentProps> & Readonly<{
+    onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+  }>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {
+    beforetoggle: (e: ToggleEvent) => any;
+  }, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: PopoverContentSlotProps) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Radio/RadioGroup.vue.d.ts
+/** Ticket for radio items with element reference for focus management */
+interface RadioTicket extends SingleTicket {
+  /** Element reference for roving tabindex focus management */
+  el?: MaybeRef<HTMLElement | null | undefined>;
+}
+interface RadioGroupContext extends SingleContext<RadioTicket> {
+  /** Form field name shared by all radios in the group */
+  name?: string;
+}
+interface RadioGroupProps extends AtomProps {
+  /** Namespace for dependency injection */
+  namespace?: string;
+  /**
+   * Disables the entire radio group
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Group disabled>
+   *     <Radio.Root value="a">Option A</Radio.Root>
+   *   </Radio.Group>
+   * </template>
+   * ```
+   */
+  disabled?: boolean;
+  /**
+   * Auto-selects the first non-disabled item on mount.
+   * Radio groups are inherently mandatory (selection can only be changed, not cleared),
+   * so `mandatory="force"` is the only meaningful option.
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Group v-model="selected" mandatory="force">
+   *     <Radio.Root value="small">Small</Radio.Root>
+   *     <Radio.Root value="medium">Medium</Radio.Root>
+   *   </Radio.Group>
+   * </template>
+   * ```
+   */
+  mandatory?: boolean | 'force';
+  /**
+   * Accessible name for the group
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Group label="Select size">
+   *     <Radio.Root value="s">Small</Radio.Root>
+   *     <Radio.Root value="m">Medium</Radio.Root>
+   *   </Radio.Group>
+   * </template>
+   * ```
+   */
+  label?: string;
+  /** ID of element that labels this group */
+  ariaLabelledby?: string;
+  /** ID of element that describes this group */
+  ariaDescribedby?: string;
+  /** Whether a selection is required before form submission */
+  ariaRequired?: boolean;
+  /**
+   * Form field name - enables native form submission for all radios in group
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Group v-model="size" name="product_size">
+   *     <Radio.Root value="small">Small</Radio.Root>
+   *     <Radio.Root value="large">Large</Radio.Root>
+   *   </Radio.Group>
+   * </template>
+   * ```
+   */
+  name?: string;
+}
+interface RadioGroupSlotProps {
+  /** Whether the radio group is disabled */
+  isDisabled: boolean;
+  /** Whether no items are currently selected */
+  isNoneSelected: boolean;
+  /** Attributes to bind to the root element */
+  attrs: {
+    'role': 'radiogroup';
+    'aria-label': string | undefined;
+    'aria-labelledby': string | undefined;
+    'aria-describedby': string | undefined;
+    'aria-required': boolean | undefined;
+  };
+}
+declare const useRadioGroup: (key: string, defaultValue?: RadioGroupContext | undefined) => RadioGroupContext, provideRadioGroup: (key: string, context: RadioGroupContext, app?: vue453.App) => RadioGroupContext;
+declare const __VLS_export$9: <T = 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<(RadioGroupProps & {
+    modelValue?: T;
+  }) & {
+    "onUpdate:modelValue"?: ((value: T | undefined) => any) | undefined;
+    "onUpdate:model-value"?: ((value: T) => any) | undefined;
+  }> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    /**
+     * Default slot with group state and ARIA attributes
+     *
+     * @example
+     * ```vue
+     * <template>
+     *   <Radio.Group v-slot="{ isNoneSelected, attrs }">
+     *     <div v-bind="attrs">
+     *       <p v-if="isNoneSelected">Please select an option</p>
+     *       <Radio.Root value="a">Option A</Radio.Root>
+     *     </div>
+     *   </Radio.Group>
+     * </template>
+     * ```
+     */
+    default: (props: RadioGroupSlotProps) => any;
+  };
+  emit: ((evt: "update:model-value", value: T) => void) & ((evt: "update:modelValue", value: T | undefined) => void);
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$6: typeof __VLS_export$9;
+type __VLS_PrettifyLocal$7<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Radio/RadioHiddenInput.vue.d.ts
+interface RadioHiddenInputProps {
+  /** Namespace for context injection from parent Radio.Root */
+  namespace?: string;
+  /**
+   * Form field name (defaults to context value from Radio.Group)
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Root value="a">
+   *     <Radio.HiddenInput name="choice" />
+   *     <Radio.Indicator />
+   *   </Radio.Root>
+   * </template>
+   * ```
+   */
+  name?: string;
+  /**
+   * Submitted value when checked (defaults to context value or 'on').
+   * Use to override the Radio.Root value for form submission.
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Root value="internal-id">
+   *     <Radio.HiddenInput name="choice" value="user-friendly-value" />
+   *   </Radio.Root>
+   * </template>
+   * ```
+   */
+  value?: string;
+  /**
+   * Associate with form by ID (for inputs outside the form element)
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Root value="a">
+   *     <Radio.HiddenInput name="choice" form="external-form" />
+   *   </Radio.Root>
+   * </template>
+   * ```
+   */
+  form?: string;
+}
+declare const __VLS_export$8: vue453.DefineComponent<RadioHiddenInputProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<RadioHiddenInputProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>;
+declare const _default$7: typeof __VLS_export$8;
+//#endregion
+//#region src/components/Radio/RadioRoot.vue.d.ts
+/** Visual state of the radio for styling purposes */
+type RadioState = 'checked' | 'unchecked';
+interface RadioRootContext {
+  /** Unique identifier */
+  readonly id: ID;
+  /** Optional display label */
+  readonly label?: string;
+  /** Value associated with this radio */
+  readonly value: unknown;
+  /** Form field name (triggers auto hidden input when provided) */
+  readonly name?: string;
+  /** Associate with form by ID */
+  readonly form?: string;
+  /** Whether this radio is currently checked */
+  isChecked: Readonly<Ref<boolean>>;
+  /** Whether this radio is disabled */
+  isDisabled: Readonly<Ref<boolean>>;
+  /** Check this radio */
+  select: () => void;
+}
+interface RadioRootProps<V = unknown> extends AtomProps {
+  /** Unique identifier (auto-generated if not provided) */
+  id?: ID;
+  /** Optional display label (passed through to slot) */
+  label?: string;
+  /**
+   * Value associated with this radio for group selection and form submission
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Group v-model="size">
+   *     <Radio.Root value="small">Small</Radio.Root>
+   *     <Radio.Root value="large">Large</Radio.Root>
+   *   </Radio.Group>
+   * </template>
+   * ```
+   */
+  value?: V;
+  /** Form field name - triggers auto hidden input when provided */
+  name?: string;
+  /**
+   * Associate with a form by ID (for radios outside the form element)
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <form id="my-form">...</form>
+   *   <Radio.Root value="a" form="my-form">Option</Radio.Root>
+   * </template>
+   * ```
+   */
+  form?: string;
+  /**
+   * Disables this radio (prevents selection and keyboard focus)
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Root value="premium" disabled>
+   *     Premium (Coming soon)
+   *   </Radio.Root>
+   * </template>
+   * ```
+   */
+  disabled?: MaybeRef<boolean>;
+  /** Namespace for context provision to children (Indicator, HiddenInput) */
+  namespace?: string;
+  /** Namespace for connecting to parent Radio.Group */
+  groupNamespace?: string;
+  /** ID of element that labels this radio */
+  ariaLabelledby?: string;
+  /** ID of element that describes this radio */
+  ariaDescribedby?: string;
+  /**
+   * Marks the radio as invalid for form validation
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Root :aria-invalid="hasError" value="a">
+   *     Option A
+   *   </Radio.Root>
+   * </template>
+   * ```
+   */
+  ariaInvalid?: boolean;
+}
+interface RadioRootSlotProps<V = unknown> {
+  /** Unique identifier */
+  id: ID;
+  /** Optional display label */
+  label?: string;
+  /** Value associated with this radio */
+  value: V | undefined;
+  /** Whether this radio is currently checked */
+  isChecked: boolean;
+  /** Whether this radio is disabled */
+  isDisabled: boolean;
+  /** Check this radio */
+  select: () => void;
+  /** Attributes to bind to the radio element */
+  attrs: {
+    'type': 'button' | undefined;
+    'role': 'radio';
+    'aria-checked': boolean;
+    'aria-disabled': boolean | undefined;
+    'aria-label': string | undefined;
+    'aria-labelledby': string | undefined;
+    'aria-describedby': string | undefined;
+    'aria-invalid': boolean | undefined;
+    'tabindex': 0 | -1;
+    'data-state': RadioState;
+    'data-disabled': true | undefined;
+    'data-radio-id': ID;
+  };
+}
+declare const useRadioRoot: (key: string, defaultValue?: RadioRootContext | undefined) => RadioRootContext, provideRadioRoot: (key: string, context: RadioRootContext, app?: vue453.App) => RadioRootContext;
+declare const __VLS_export$7: <V = 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<RadioRootProps<V>> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    /**
+     * Default slot with radio state, actions, and ARIA attributes
+     *
+     * @example
+     * ```vue
+     * <template>
+     *   <Radio.Root v-slot="{ isChecked, select, attrs }" value="a">
+     *     <div v-bind="attrs" v-on:click="select">
+     *       <span :class="{ 'font-bold': isChecked }">Option A</span>
+     *     </div>
+     *   </Radio.Root>
+     * </template>
+     * ```
+     */
+    default: (props: RadioRootSlotProps<V>) => any;
+  };
+  emit: {};
+}>) => vue453.VNode & {
+  __ctx?: Awaited<typeof __VLS_setup>;
+};
+declare const _default$9: typeof __VLS_export$7;
+type __VLS_PrettifyLocal$6<T> = { [K in keyof T as K]: T[K] } & {};
+//#endregion
+//#region src/components/Radio/RadioIndicator.vue.d.ts
+interface RadioIndicatorProps extends AtomProps {
+  /** Namespace for context injection from parent Radio.Root */
+  namespace?: string;
+}
+interface RadioIndicatorSlotProps {
+  /** Whether this radio is currently checked */
+  isChecked: boolean;
+  /** Attributes to bind to the indicator element */
+  attrs: {
+    'data-state': RadioState;
+    'style': {
+      visibility: 'visible' | 'hidden';
+    };
+  };
+}
+declare const __VLS_export$6: __VLS_WithSlots<vue453.DefineComponent<RadioIndicatorProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<RadioIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>, {
+  /**
+   * Default slot for custom indicator content
+   *
+   * @example
+   * ```vue
+   * <template>
+   *   <Radio.Indicator v-slot="{ isChecked }">
+   *     <CheckIcon v-if="isChecked" />
+   *   </Radio.Indicator>
+   * </template>
+   * ```
+   */
+  default: (props: RadioIndicatorSlotProps) => any;
+}>;
+declare const _default$8: typeof __VLS_export$6;
+type __VLS_WithSlots<T, S> = T & {
+  new (): {
+    $slots: S;
+  };
+};
+//#endregion
+//#region src/components/Radio/index.d.ts
+/**
+ * Radio component with sub-components for radio button controls.
+ *
+ * @see https://0.vuetifyjs.com/components/forms/radio
+ *
+ * @example
+ * ```vue
+ * <script lang="ts" setup>
+ *   import { Radio } from '@vuetify/v0'
+ *   import { ref } from 'vue'
+ *
+ *   const selected = ref<string>()
+ * </script>
+ *
+ * <template>
+ *   <Radio.Group v-model="selected">
+ *     <label>
+ *       <Radio.Root value="a">
+ *         <Radio.Indicator>●</Radio.Indicator>
+ *       </Radio.Root>
+ *       Option A
+ *     </label>
+ *     <label>
+ *       <Radio.Root value="b">
+ *         <Radio.Indicator>●</Radio.Indicator>
+ *       </Radio.Root>
+ *       Option B
+ *     </label>
+ *   </Radio.Group>
+ * </template>
+ * ```
+ */
+declare const Radio: {
+  /**
+   * Group component for managing radio buttons with single-selection.
+   *
+   * @see https://0.vuetifyjs.com/components/forms/radio#group
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { Radio } from '@vuetify/v0'
+   *   import { ref } from 'vue'
+   *
+   *   const selected = ref<string>()
+   * </script>
+   *
+   * <template>
+   *   <Radio.Group v-model="selected" mandatory>
+   *     <Radio.Root value="a">
+   *       <Radio.Indicator>●</Radio.Indicator>
+   *       Option A
+   *     </Radio.Root>
+   *     <Radio.Root value="b">
+   *       <Radio.Indicator>●</Radio.Indicator>
+   *       Option B
+   *     </Radio.Root>
+   *   </Radio.Group>
+   * </template>
+   * ```
+   */
+  Group: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    slots: {
+      default: (props: RadioGroupSlotProps) => any;
+    };
+    attrs: any;
+    emit: ((evt: "update:model-value", value: T) => void) & ((evt: "update:modelValue", value: T | undefined) => void);
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      label?: string | undefined;
+      ariaLabelledby?: string | undefined;
+      ariaDescribedby?: string | undefined;
+      ariaRequired?: boolean | undefined;
+      name?: string | undefined;
+      as?: (DOMElement | null) | undefined;
+      renderless?: boolean | undefined;
+      modelValue?: T | undefined;
+      "onUpdate:modelValue"?: ((value: T | undefined) => any) | undefined;
+      "onUpdate:model-value"?: ((value: T) => any) | undefined;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: RadioGroupSlotProps) => any;
+    };
+    emit: ((evt: "update:model-value", value: T) => void) & ((evt: "update:modelValue", value: T | undefined) => void);
+  }>) => vue453.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  /**
+   * Hidden input component for form submission.
+   *
+   * Auto-rendered by Root when Group has a `name` prop.
+   * Can also be used explicitly for custom form integration.
+   *
+   * @see https://0.vuetifyjs.com/components/forms/radio#hiddeninput
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { Radio } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Radio.Group v-model="selected">
+   *     <Radio.Root value="yes">
+   *       <Radio.Indicator>●</Radio.Indicator>
+   *       <Radio.HiddenInput name="choice" />
+   *     </Radio.Root>
+   *   </Radio.Group>
+   * </template>
+   * ```
+   */
+  HiddenInput: vue453.DefineComponent<RadioHiddenInputProps, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, vue453.PublicProps, Readonly<RadioHiddenInputProps> & Readonly<{}>, {}, {}, {}, {}, string, vue453.ComponentProvideOptions, false, {}, any>;
+  /**
+   * Visual indicator component for radio buttons.
+   *
+   * Renders as a span and only displays when checked.
+   * Must be used within a Radio.Root component.
+   *
+   * @see https://0.vuetifyjs.com/components/forms/radio#indicator
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { Radio } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Radio.Group v-model="selected">
+   *     <Radio.Root value="a">
+   *       <Radio.Indicator>
+   *         <svg viewBox="0 0 24 24">
+   *           <circle cx="12" cy="12" r="6" />
+   *         </svg>
+   *       </Radio.Indicator>
+   *     </Radio.Root>
+   *   </Radio.Group>
+   * </template>
+   * ```
+   */
+  Indicator: {
+    new (...args: any[]): vue453.CreateComponentPublicInstanceWithMixins<Readonly<RadioIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, vue453.PublicProps, {}, false, {}, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, {}, any, vue453.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<RadioIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue453.ComponentOptionsBase<Readonly<RadioIndicatorProps> & Readonly<{}>, {}, {}, {}, {}, vue453.ComponentOptionsMixin, vue453.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue453.GlobalComponents, vue453.GlobalDirectives, string, vue453.ComponentProvideOptions> & vue453.VNodeProps & vue453.AllowedComponentProps & vue453.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: RadioIndicatorSlotProps) => any;
+    };
+  });
+  /**
+   * Root component for individual radio buttons.
+   *
+   * Must be used within a Radio.Group. Renders as a button with proper
+   * ARIA attributes and handles click/keyboard interactions. When the
+   * group has a `name` prop, automatically renders a hidden input for
+   * form submission.
+   *
+   * @see https://0.vuetifyjs.com/components/forms/radio#root
+   *
+   * @example
+   * ```vue
+   * <script setup lang="ts">
+   *   import { Radio } from '@vuetify/v0'
+   * </script>
+   *
+   * <template>
+   *   <Radio.Group v-model="selected">
+   *     <Radio.Root value="option1">
+   *       <Radio.Indicator>●</Radio.Indicator>
+   *       Option 1
+   *     </Radio.Root>
+   *   </Radio.Group>
+   * </template>
+   * ```
+   */
+  Root: <V = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    slots: {
+      default: (props: RadioRootSlotProps<V>) => any;
+    };
+    attrs: any;
+    emit: {};
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: ID | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      name?: string | undefined;
+      form?: string | undefined;
+      disabled?: vue453.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+      groupNamespace?: string | undefined;
+      ariaLabelledby?: string | undefined;
+      ariaDescribedby?: string | undefined;
+      ariaInvalid?: boolean | undefined;
+      as?: (DOMElement | null) | undefined;
+      renderless?: boolean | undefined;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: RadioRootSlotProps<V>) => any;
+    };
+    emit: {};
+  }>) => vue453.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+};
+//#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?: vue453.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;
+  }> & vue453.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);
+}>) => vue453.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>> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: SelectionItemSlotProps<V>) => unknown;
+  };
+  emit: {};
+}>) => vue453.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?: {
+    slots: {
+      default: (props: SelectionRootSlotProps) => any;
+    };
+    attrs: any;
+    emit: ((evt: "update:model-value", value: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+  }, __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;
+    } & vue453.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);
+  }>) => vue453.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?: {
+    slots: {
+      default: (props: SelectionItemSlotProps<V>) => unknown;
+    };
+    attrs: any;
+    emit: {};
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue453.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: SelectionItemSlotProps<V>) => unknown;
+    };
+    emit: {};
+  }>) => vue453.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?: vue453.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;
+  }> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: SingleRootSlotProps) => any;
+  };
+  emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+}>) => vue453.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>> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: SingleItemSlotProps<V>) => unknown;
+  };
+  emit: {};
+}>) => vue453.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?: {
+    slots: {
+      default: (props: SingleRootSlotProps) => any;
+    };
+    attrs: any;
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }, __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;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: SingleRootSlotProps) => any;
+    };
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }>) => vue453.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?: {
+    slots: {
+      default: (props: SingleItemSlotProps<V>) => unknown;
+    };
+    attrs: any;
+    emit: {};
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue453.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: SingleItemSlotProps<V>) => unknown;
+    };
+    emit: {};
+  }>) => vue453.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?: vue453.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;
+  }> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: StepRootSlotProps) => any;
+  };
+  emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+}>) => vue453.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>> & vue453.PublicProps;
+  expose: (exposed: {}) => void;
+  attrs: any;
+  slots: {
+    default: (props: StepItemSlotProps<V>) => unknown;
+  };
+  emit: {};
+}>) => vue453.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?: {
+    slots: {
+      default: (props: StepRootSlotProps) => any;
+    };
+    attrs: any;
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }, __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;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: StepRootSlotProps) => any;
+    };
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }>) => vue453.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?: {
+    slots: {
+      default: (props: StepItemSlotProps<V>) => unknown;
+    };
+    attrs: any;
+    emit: {};
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      id?: string | undefined;
+      label?: string | undefined;
+      value?: V | undefined;
+      disabled?: vue453.MaybeRef<boolean> | undefined;
+      namespace?: string | undefined;
+    } & vue453.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: StepItemSlotProps<V>) => unknown;
+    };
+    emit: {};
+  }>) => vue453.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+};
+//#endregion
+export { PopoverActivatorProps as $, CheckboxHiddenInputProps as $n, ExpansionPanelActivatorSlotProps as $t, RadioIndicatorSlotProps as A, DialogActivatorProps as An, PaginationRootProps as At, _default$7 as B, CheckboxSelectAllProps as Bn, GroupItemProps as Bt, SelectionRootProps as C, DialogTitleProps as Cn, _default$42 as Cr, _default$18 as Ct, useSelectionRoot as D, DialogContentProps as Dn, PaginationItemProps as Dt, provideSelectionRoot as E, DialogContentEmits as En, _default$14 as Et, RadioState as F, DialogRootSlotProps as Fn, providePaginationRoot as Ft, _default$6 as G, _default$36 as Gn, _default$22 as Gt, RadioGroupProps as H, _default$38 as Hn, _default$21 as Ht, _default$9 as I, _default$31 as In, usePaginationControls as It, Popover as J, CheckboxRootSlotProps as Jn, ExpansionPanel as Jt, provideRadioGroup as K, CheckboxRootContext as Kn, provideGroupRoot as Kt, provideRadioRoot as L, provideDialogContext as Ln, usePaginationItems as Lt, RadioRootContext as M, _default$33 as Mn, _default$19 as Mt, RadioRootProps as N, DialogContext as Nn, providePaginationControls as Nt, Radio as O, DialogContentSlotProps as On, PaginationItemSlotProps as Ot, RadioRootSlotProps as P, DialogRootProps as Pn, providePaginationItems as Pt, _default$11 as Q, useCheckboxRoot as Qn, ExpansionPanelActivatorProps as Qt, useRadioRoot as R, useDialogContext as Rn, usePaginationRoot as Rt, _default$4 as S, _default$30 as Sn, AtomSlots as Sr, PaginationPrevSlotProps as St, _default$5 as T, _default$32 as Tn, PaginationFirstSlotProps as Tt, RadioGroupSlotProps as U, CheckboxIndicatorProps as Un, GroupRootProps as Ut, RadioGroupContext as V, CheckboxSelectAllSlotProps as Vn, GroupItemSlotProps as Vt, RadioTicket as W, CheckboxIndicatorSlotProps as Wn, GroupRootSlotProps as Wt, PopoverContentProps as X, _default$37 as Xn, ExpansionPanelContentSlotProps as Xt, PopoverContentEmits as Y, CheckboxState as Yn, ExpansionPanelContentProps as Yt, PopoverContentSlotProps as Z, provideCheckboxRoot as Zn, _default$24 as Zt, provideSingleRoot as _, DialogCloseProps as _n, _default$41 as _r, _default$17 as _t, StepRootProps as a, ExpansionPanelItemProps as an, useCheckboxGroup as ar, _default$12 as at, SelectionItemProps as b, DialogDescriptionProps as bn, AtomExpose as br, _default$13 as bt, provideStepRoot as c, provideExpansionPanelItem as cn, AvatarFallbackSlotProps as cr, Pagination as ct, SingleItemProps as d, ExpansionPanelRootProps as dn, AvatarImageProps as dr, _default$20 as dt, _default$23 as en, _default$35 as er, PopoverActivatorSlotProps as et, SingleItemSlotProps as f, ExpansionPanelRootSlotProps as fn, AvatarImageSlotProps as fr, PaginationLastProps as ft, _default$3 as g, Dialog as gn, AvatarTicket as gr, PaginationNextSlotProps as gt, SingleRootSlotProps as h, useExpansionPanelRoot as hn, AvatarRootProps as hr, PaginationNextProps as ht, _default as i, ExpansionPanelItemContext as in, provideCheckboxGroup as ir, PopoverRootSlotProps as it, _default$8 as j, DialogActivatorSlotProps as jn, PaginationRootSlotProps as jt, RadioIndicatorProps as k, _default$29 as kn, _default$15 as kt, useStepRoot as l, useExpansionPanelItem as ln, _default$39 as lr, PaginationStatusProps as lt, SingleRootProps as m, provideExpansionPanelSelection as mn, AvatarContext as mr, _default$16 as mt, StepItemProps as n, ExpansionPanelHeaderSlotProps as nn, CheckboxGroupSlotProps as nr, PopoverContext as nt, StepRootSlotProps as o, ExpansionPanelItemSlotProps as on, Avatar as or, providePopoverContext as ot, _default$2 as p, _default$27 as pn, _default$40 as pr, PaginationLastSlotProps as pt, useRadioGroup as q, CheckboxRootProps as qn, useGroupRoot as qt, StepItemSlotProps as r, _default$25 as rn, _default$34 as rr, PopoverRootProps as rt, _default$1 as s, _default$26 as sn, AvatarFallbackProps as sr, usePopoverContext as st, Step as t, ExpansionPanelHeaderProps as tn, CheckboxGroupProps as tr, _default$10 as tt, Single as u, ExpansionPanelOptionsContext as un, AvatarImageEmits as ur, PaginationStatusSlotProps as ut, useSingleRoot as v, DialogCloseSlotProps as vn, provideAvatarContext as vr, PaginationEllipsisProps as vt, SelectionRootSlotProps as w, DialogTitleSlotProps as wn, PaginationFirstProps as wt, SelectionItemSlotProps as x, DialogDescriptionSlotProps as xn, AtomProps as xr, PaginationPrevProps as xt, Selection as y, _default$28 as yn, useAvatarRoot as yr, PaginationEllipsisSlotProps as yt, RadioHiddenInputProps as z, Checkbox as zn, Group as zt };