@vuetify/v0 0.0.9 → 0.0.11

package/dist/index-DbBHGczA.d.mts

@@ -0,0 +1,815 @@
+import { i as ID, t as DOMElement } from "./index-DY7-T630.mjs";
+import { a as SelectionContext, c as SelectionTicket, t as ContextKey } from "./index-D-EP6KrS.mjs";
+import * as vue233 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: <T extends Record<string, any> = {}>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+  props: __VLS_PrettifyLocal<AtomPrivateProps> & vue233.PublicProps;
+  expose: (exposed: vue233.ShallowUnwrapRef<AtomExpose>) => void;
+  attrs: any;
+  slots: AtomSlots<T>;
+  emit: {};
+}>) => vue233.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/Avatar/AvatarFallback.vue.d.ts
+interface AvatarFallbackProps extends AtomProps {
+  namespace?: string;
+}
+//#endregion
+//#region src/components/Avatar/AvatarImage.vue.d.ts
+interface AvatarImageProps extends AtomProps {
+  src?: string;
+  priority?: number;
+  namespace?: string;
+}
+interface AvatarImageEmits {
+  load: [e: Event];
+  error: [e: Event];
+}
+//#endregion
+//#region src/components/Avatar/AvatarRoot.vue.d.ts
+interface AvatarRootProps extends AtomProps {
+  namespace?: string;
+}
+interface AvatarTicket extends SelectionTicket {
+  type?: 'image' | 'fallback';
+  priority?: number;
+}
+interface AvatarContext extends SelectionContext<AvatarTicket> {}
+//#endregion
+//#region src/components/Avatar/index.d.ts
+declare const Avatar: {
+  Fallback: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<AvatarFallbackProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  });
+  Image: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<AvatarImageProps> & Readonly<{
+      onLoad?: ((e: Event) => any) | undefined;
+      onError?: ((e: Event) => any) | undefined;
+    }>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {
+      load: (e: Event) => any;
+      error: (e: Event) => any;
+    }, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.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;
+  } & vue233.ComponentOptionsBase<Readonly<AvatarImageProps> & Readonly<{
+    onLoad?: ((e: Event) => any) | undefined;
+    onError?: ((e: Event) => any) | undefined;
+  }>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {
+    load: (e: Event) => any;
+    error: (e: Event) => any;
+  }, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: {
+        src: string;
+        onError: (e: Event) => void;
+        onLoad: (e: Event) => void;
+        role: string;
+      }) => any;
+    };
+  });
+  Root: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<AvatarRootProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelRoot.vue.d.ts
+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 */
+  disabled: boolean;
+  /** Whether multiple panels can be expanded */
+  multiple: 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;
+  /** ARIA multiselectable state */
+  ariaMultiselectable: boolean;
+}
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelItem.vue.d.ts
+interface ExpansionPanelItemProps 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?: any;
+  /** Disables this specific panel item */
+  disabled?: MaybeRef<boolean>;
+  /** Namespace to retrieve the parent ExpansionPanelRoot context (default: 'v0:expansion-panel') */
+  namespace?: string;
+  /** Namespace for providing context to child components (default: 'v0:expansion-panel-item') */
+  itemNamespace?: 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>>;
+}
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelActivator.vue.d.ts
+interface ExpansionPanelActivatorProps extends AtomProps {
+  /** Namespace for retrieving the parent ExpansionPanelItem context (default: 'v0:expansion-panel-item') */
+  itemNamespace?: string;
+}
+interface ExpansionPanelActivatorSlotProps {
+  /** Unique ID for the header/activator element */
+  'id': string;
+  /** ARIA role for accessibility */
+  'role': 'button';
+  /** 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;
+  /** Whether this panel is currently selected/expanded */
+  'isSelected': boolean;
+  /** Toggle the panel's expansion state */
+  'toggle': () => void;
+  /** Click handler to toggle panel */
+  'onClick': () => void;
+  /** Keyboard handler for Enter and Space keys */
+  'onKeydown': (e: KeyboardEvent) => void;
+}
+//#endregion
+//#region src/components/ExpansionPanel/ExpansionPanelContent.vue.d.ts
+interface ExpansionPanelContentProps extends AtomProps {
+  /** Namespace for retrieving the parent ExpansionPanelItem context (default: 'v0:expansion-panel-item') */
+  itemNamespace?: string;
+}
+interface ExpansionPanelContentSlotProps {
+  /** 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 this panel is currently selected/expanded */
+  'isSelected': boolean;
+}
+//#endregion
+//#region src/components/ExpansionPanel/index.d.ts
+declare const ExpansionPanel: {
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: ((evt: "update:model-value", ...args: T | T[]) => void) & ((evt: "update:modelValue", value: T | T[] | undefined) => void);
+    slots: {
+      default: (props: ExpansionPanelRootSlotProps) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      [x: `on${Capitalize<string>}`]: ((...args: any) => any) | undefined;
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      multiple?: boolean | undefined;
+      as?: (DOMElement | null) | undefined;
+      renderless?: boolean | undefined;
+      modelValue?: (T | T[]) | undefined;
+    } & vue233.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);
+  }>) => vue233.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  Item: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<ExpansionPanelItemProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ExpansionPanelItemProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<ExpansionPanelItemProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default: () => any;
+    };
+  });
+  Activator: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<ExpansionPanelActivatorProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: ExpansionPanelActivatorSlotProps) => any;
+    };
+  });
+  Content: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<ExpansionPanelContentProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: ExpansionPanelContentSlotProps) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Group/index.d.ts
+declare const Group: {
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+    slots: {
+      default: (props: {
+        disabled: boolean;
+        select: (id: ID | ID[]) => void;
+        unselect: (id: ID | ID[]) => void;
+        toggle: (id: ID | ID[]) => void;
+        ariaMultiselectable: boolean;
+      }) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      modelValue?: (T | T[]) | undefined;
+      "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    } & vue233.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: {
+        disabled: boolean;
+        select: (id: ID | ID[]) => void;
+        unselect: (id: ID | ID[]) => void;
+        toggle: (id: ID | ID[]) => void;
+        ariaMultiselectable: boolean;
+      }) => any;
+    };
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }>) => vue233.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  Item: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<{
+      label?: string;
+      id?: string;
+      disabled?: vue233.MaybeRef<boolean>;
+      value?: any;
+      namespace?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<{
+      label?: string;
+      id?: string;
+      disabled?: vue233.MaybeRef<boolean>;
+      value?: any;
+      namespace?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<{
+    label?: string;
+    id?: string;
+    disabled?: vue233.MaybeRef<boolean>;
+    value?: any;
+    namespace?: string;
+  }> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: {
+        id: string;
+        label?: string;
+        value: any;
+        isSelected: boolean;
+        disabled: boolean;
+        ariaSelected: boolean;
+        ariaDisabled: boolean;
+        select: () => void;
+        unselect: () => void;
+        toggle: () => void;
+      }) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Popover/PopoverRoot.vue.d.ts
+interface PopoverContext {
+  isSelected: ShallowRef<boolean>;
+  id: string;
+  toggle: () => void;
+}
+interface PopoverRootProps extends AtomProps {
+  id?: string;
+}
+declare const usePopoverContext: (key?: ContextKey<PopoverContext>) => PopoverContext, providePopoverContext: (context: PopoverContext, app?: vue233.App) => PopoverContext;
+//#endregion
+//#region src/components/Popover/PopoverAnchor.vue.d.ts
+interface PopoverAnchorProps extends AtomProps {
+  target?: string;
+}
+//#endregion
+//#region src/components/Popover/PopoverContent.vue.d.ts
+interface PopoverContentProps extends AtomProps {
+  id?: string;
+  positionArea?: string;
+  positionTry?: string;
+}
+interface PopoverContentEmits {
+  beforetoggle: [e: ToggleEvent];
+}
+//#endregion
+//#region src/components/Popover/index.d.ts
+declare const Popover: {
+  Root: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<PopoverRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {
+      "update:modelValue": (value: boolean) => any;
+    }, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverRootProps & {
+      modelValue?: boolean;
+    }> & Readonly<{
+      "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<PopoverRootProps & {
+    modelValue?: boolean;
+  }> & Readonly<{
+    "onUpdate:modelValue"?: ((value: boolean) => any) | undefined;
+  }>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {
+    "update:modelValue": (value: boolean) => any;
+  }, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: {
+        id: Readonly<vue233.Ref<string, string>>;
+        isSelected: vue233.ModelRef<boolean, string, boolean, boolean>;
+        toggle: () => void;
+      }) => any;
+    };
+  });
+  Anchor: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<PopoverAnchorProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverAnchorProps> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<PopoverAnchorProps> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  });
+  Content: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<PopoverContentProps> & Readonly<{
+      onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {
+      beforetoggle: (e: ToggleEvent) => any;
+    }, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<PopoverContentProps> & Readonly<{
+      onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+    }>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<PopoverContentProps> & Readonly<{
+    onBeforetoggle?: ((e: ToggleEvent) => any) | undefined;
+  }>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {
+    beforetoggle: (e: ToggleEvent) => any;
+  }, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default?: (props: {}) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Selection/index.d.ts
+declare const Selection: {
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+    slots: {
+      default: (props: {
+        disabled: boolean;
+        multiple: boolean;
+        select: (id: ID) => void;
+        unselect: (id: ID) => void;
+        toggle: (id: ID) => void;
+        ariaMultiselectable: boolean;
+      }) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      multiple?: boolean | undefined;
+      modelValue?: (T | T[]) | undefined;
+      "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    } & vue233.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: {
+        disabled: boolean;
+        multiple: boolean;
+        select: (id: ID) => void;
+        unselect: (id: ID) => void;
+        toggle: (id: ID) => void;
+        ariaMultiselectable: boolean;
+      }) => any;
+    };
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }>) => vue233.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  Item: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<{
+      label?: string;
+      id?: string;
+      disabled?: vue233.MaybeRef<boolean>;
+      value?: any;
+      namespace?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<{
+      label?: string;
+      id?: string;
+      disabled?: vue233.MaybeRef<boolean>;
+      value?: any;
+      namespace?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<{
+    label?: string;
+    id?: string;
+    disabled?: vue233.MaybeRef<boolean>;
+    value?: any;
+    namespace?: string;
+  }> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: {
+        id: string;
+        label?: string;
+        value: any;
+        isSelected: boolean;
+        disabled: boolean;
+        ariaSelected: boolean;
+        ariaDisabled: boolean;
+        select: () => void;
+        unselect: () => void;
+        toggle: () => void;
+      }) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Single/index.d.ts
+declare const Single: {
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+    slots: {
+      default: (props: {
+        disabled: boolean;
+        select: (id: ID) => void;
+        unselect: (id: ID) => void;
+        toggle: (id: ID) => void;
+        ariaMultiselectable: boolean;
+      }) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      modelValue?: (T | T[]) | undefined;
+      "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    } & vue233.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: {
+        disabled: boolean;
+        select: (id: ID) => void;
+        unselect: (id: ID) => void;
+        toggle: (id: ID) => void;
+        ariaMultiselectable: boolean;
+      }) => any;
+    };
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }>) => vue233.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  Item: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<{
+      label?: string;
+      id?: string;
+      disabled?: vue233.MaybeRef<boolean>;
+      value?: any;
+      namespace?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<{
+      label?: string;
+      id?: string;
+      disabled?: vue233.MaybeRef<boolean>;
+      value?: any;
+      namespace?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<{
+    label?: string;
+    id?: string;
+    disabled?: vue233.MaybeRef<boolean>;
+    value?: any;
+    namespace?: string;
+  }> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: {
+        id: string;
+        label?: string;
+        value: any;
+        isSelected: boolean;
+        disabled: boolean;
+        ariaSelected: boolean;
+        ariaDisabled: boolean;
+        select: () => void;
+        unselect: () => void;
+        toggle: () => void;
+      }) => any;
+    };
+  });
+};
+//#endregion
+//#region src/components/Step/index.d.ts
+declare const Step: {
+  Root: <T = unknown>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: {
+    attrs: any;
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+    slots: {
+      default: (props: {
+        disabled: boolean;
+        ariaMultiselectable: boolean;
+        first: () => void;
+        last: () => void;
+        next: () => void;
+        prev: () => void;
+        step: (count: number) => void;
+        select: (id: ID) => void;
+        unselect: (id: ID) => void;
+        toggle: (id: ID) => void;
+      }) => any;
+    };
+  }, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: {
+      namespace?: string | undefined;
+      disabled?: boolean | undefined;
+      enroll?: boolean | undefined;
+      mandatory?: boolean | "force" | undefined;
+      modelValue?: (T | T[]) | undefined;
+      "onUpdate:modelValue"?: ((value: T | T[] | undefined) => any) | undefined;
+    } & vue233.PublicProps;
+    expose: (exposed: {}) => void;
+    attrs: any;
+    slots: {
+      default: (props: {
+        disabled: boolean;
+        ariaMultiselectable: boolean;
+        first: () => void;
+        last: () => void;
+        next: () => void;
+        prev: () => void;
+        step: (count: number) => void;
+        select: (id: ID) => void;
+        unselect: (id: ID) => void;
+        toggle: (id: ID) => void;
+      }) => any;
+    };
+    emit: (evt: "update:modelValue", value: T | T[] | undefined) => void;
+  }>) => vue233.VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+  };
+  Item: {
+    new (...args: any[]): vue233.CreateComponentPublicInstanceWithMixins<Readonly<{
+      label?: string;
+      id?: string;
+      disabled?: vue233.MaybeRef<boolean>;
+      value?: any;
+      namespace?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, vue233.PublicProps, {}, false, {}, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, {}, any, vue233.ComponentProvideOptions, {
+      P: {};
+      B: {};
+      D: {};
+      C: {};
+      M: {};
+      Defaults: {};
+    }, Readonly<{
+      label?: string;
+      id?: string;
+      disabled?: vue233.MaybeRef<boolean>;
+      value?: any;
+      namespace?: string;
+    }> & Readonly<{}>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+  } & vue233.ComponentOptionsBase<Readonly<{
+    label?: string;
+    id?: string;
+    disabled?: vue233.MaybeRef<boolean>;
+    value?: any;
+    namespace?: string;
+  }> & Readonly<{}>, {}, {}, {}, {}, vue233.ComponentOptionsMixin, vue233.ComponentOptionsMixin, {}, string, {}, {}, string, {}, vue233.GlobalComponents, vue233.GlobalDirectives, string, vue233.ComponentProvideOptions> & vue233.VNodeProps & vue233.AllowedComponentProps & vue233.ComponentCustomProps & (new () => {
+    $slots: {
+      default: (props: {
+        id: string;
+        label?: string;
+        value: any;
+        isSelected: boolean;
+        disabled: boolean;
+        ariaSelected: boolean;
+        ariaDisabled: boolean;
+        select: () => void;
+        unselect: () => void;
+        toggle: () => void;
+      }) => any;
+    };
+  });
+};
+//#endregion
+export { AtomSlots as A, AvatarContext as C, AvatarFallbackProps as D, AvatarImageProps as E, AtomExpose as O, Avatar as S, AvatarImageEmits as T, ExpansionPanelActivatorSlotProps as _, PopoverContentEmits as a, ExpansionPanelRootProps as b, PopoverContext as c, usePopoverContext as d, Group as f, ExpansionPanelActivatorProps as g, ExpansionPanelContentSlotProps as h, Popover as i, _default as j, AtomProps as k, PopoverRootProps as l, ExpansionPanelContentProps as m, Single as n, PopoverContentProps as o, ExpansionPanel as p, Selection as r, PopoverAnchorProps as s, Step as t, providePopoverContext as u, ExpansionPanelItemContext as v, AvatarRootProps as w, ExpansionPanelRootSlotProps as x, ExpansionPanelItemProps as y };