@elvora/vue 1.0.0-rc.1

package/dist/index.d.cts

@@ -0,0 +1,4508 @@
+import * as vue from 'vue';
+import { PropType, InjectionKey, Ref, VNode } from 'vue';
+import { ElvoraTheme, Direction as Direction$1, ElvoraVariant, ElvoraSize, ElvoraStatus, Orientation, ElvoraTone, Placement as Placement$4, ErrorCorrection } from '@elvora/core';
+export { Direction, ElvoraSize, ElvoraStatus, ElvoraTheme, ElvoraTone, ElvoraVariant, IntentScale, Orientation, Placement, ThemeColors } from '@elvora/core';
+import { IconName } from '@elvora/icons';
+
+/**
+ * `<ElvoraProvider>` component — convenience wrapper around `provideElvora`.
+ * Use either this component or the composable, not both.
+ */
+declare const ElvoraProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    theme: {
+        type: PropType<ElvoraTheme>;
+        default: () => ElvoraTheme;
+    };
+    direction: {
+        type: PropType<Direction$1>;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    theme: {
+        type: PropType<ElvoraTheme>;
+        default: () => ElvoraTheme;
+    };
+    direction: {
+        type: PropType<Direction$1>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    theme: ElvoraTheme;
+    direction: Direction$1;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraContext {
+    theme: Ref<ElvoraTheme>;
+    direction: Ref<Direction$1>;
+}
+declare const ELVORA_CONTEXT: InjectionKey<ElvoraContext>;
+/**
+ * Provide a theme + direction to all descendant Elvora components. Call inside
+ * a parent component's `setup()` or `<script setup>` block.
+ */
+declare function provideElvora(options?: {
+    theme?: ElvoraTheme;
+    direction?: Direction$1;
+}): ElvoraContext;
+declare function useElvoraContext(): ElvoraContext;
+declare function useTheme(): Ref<ElvoraTheme>;
+
+/**
+ * Vue 3 Button. Same headless contract as the React, RN, and Angular adapters.
+ *
+ * ```vue
+ * <ElvoraButton variant="primary" size="md" @press="handlePress">
+ *   Click me
+ * </ElvoraButton>
+ * ```
+ */
+declare const ElvoraButton: vue.DefineComponent<vue.ExtractPropTypes<{
+    variant: {
+        type: PropType<ElvoraVariant>;
+        default: ElvoraVariant;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    intent: {
+        type: PropType<keyof ElvoraTheme["colors"]["intent"]>;
+        default: undefined;
+    };
+    fullWidth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingText: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: PropType<"button" | "submit" | "reset">;
+        default: "button";
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    press: (_event: MouseEvent | KeyboardEvent) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    variant: {
+        type: PropType<ElvoraVariant>;
+        default: ElvoraVariant;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    intent: {
+        type: PropType<keyof ElvoraTheme["colors"]["intent"]>;
+        default: undefined;
+    };
+    fullWidth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingText: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: PropType<"button" | "submit" | "reset">;
+        default: "button";
+    };
+}>> & Readonly<{
+    onPress?: ((_event: MouseEvent | KeyboardEvent) => any) | undefined;
+}>, {
+    size: ElvoraSize;
+    intent: "primary" | "neutral" | "success" | "warning" | "danger" | "info";
+    type: "button" | "reset" | "submit";
+    variant: ElvoraVariant;
+    fullWidth: boolean;
+    isLoading: boolean;
+    isDisabled: boolean;
+    loadingText: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Square icon-only button. `ariaLabel` is REQUIRED. */
+declare const ElvoraIconButton: vue.DefineComponent<vue.ExtractPropTypes<{
+    ariaLabel: {
+        type: StringConstructor;
+        required: true;
+    };
+    variant: {
+        type: PropType<ElvoraVariant>;
+        default: ElvoraVariant;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    intent: {
+        type: PropType<keyof ElvoraTheme["colors"]["intent"]>;
+        default: undefined;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    press: (_event: MouseEvent) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    ariaLabel: {
+        type: StringConstructor;
+        required: true;
+    };
+    variant: {
+        type: PropType<ElvoraVariant>;
+        default: ElvoraVariant;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    intent: {
+        type: PropType<keyof ElvoraTheme["colors"]["intent"]>;
+        default: undefined;
+    };
+    isLoading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onPress?: ((_event: MouseEvent) => any) | undefined;
+}>, {
+    size: ElvoraSize;
+    intent: "primary" | "neutral" | "success" | "warning" | "danger" | "info";
+    variant: ElvoraVariant;
+    isLoading: boolean;
+    isDisabled: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Text input. Use `v-model` for two-way binding. */
+declare const ElvoraInput: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: PropType<"text" | "email" | "password" | "search" | "tel" | "url" | "number">;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: ElvoraStatus;
+    };
+    isReadOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    type: {
+        type: PropType<"text" | "email" | "password" | "search" | "tel" | "url" | "number">;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: ElvoraStatus;
+    };
+    isReadOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string) => any) | undefined;
+}>, {
+    size: ElvoraSize;
+    type: "number" | "search" | "text" | "email" | "password" | "tel" | "url";
+    isDisabled: boolean;
+    modelValue: string;
+    placeholder: string;
+    status: ElvoraStatus;
+    isReadOnly: boolean;
+    isRequired: boolean;
+    isInvalid: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Multi-line text input. Use `v-model` for two-way binding. */
+declare const ElvoraTextarea: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isResizable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: ElvoraStatus;
+    };
+    isReadOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    rows: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isResizable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: ElvoraStatus;
+    };
+    isReadOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string) => any) | undefined;
+}>, {
+    size: ElvoraSize;
+    isDisabled: boolean;
+    modelValue: string;
+    placeholder: string;
+    status: ElvoraStatus;
+    isReadOnly: boolean;
+    isRequired: boolean;
+    isInvalid: boolean;
+    rows: number;
+    isResizable: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type CheckboxSize = 'sm' | 'md' | 'lg';
+declare const ElvoraCheckbox: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isIndeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<CheckboxSize>;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: boolean) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isIndeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<CheckboxSize>;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: boolean) => any) | undefined;
+}>, {
+    size: CheckboxSize;
+    isDisabled: boolean;
+    modelValue: boolean;
+    isInvalid: boolean;
+    isIndeterminate: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type RadioSize = 'sm' | 'md' | 'lg';
+declare const ElvoraRadioGroup: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<RadioSize>;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<RadioSize>;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string) => any) | undefined;
+}>, {
+    size: RadioSize;
+    label: string;
+    isDisabled: boolean;
+    modelValue: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const ElvoraRadio: vue.DefineComponent<vue.ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    isDisabled: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type SwitchSize = 'sm' | 'md' | 'lg';
+declare const ElvoraSwitch: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<SwitchSize>;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: boolean) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<SwitchSize>;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: boolean) => any) | undefined;
+}>, {
+    size: SwitchSize;
+    isDisabled: boolean;
+    modelValue: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraSelectOption {
+    label: string;
+    value: string;
+    disabled?: boolean;
+}
+/** Native `<select>` styled with Elvora tokens. Use `v-model`. */
+declare const ElvoraSelect: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<ElvoraSelectOption[]>;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: ElvoraStatus;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<ElvoraSelectOption[]>;
+        required: true;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: ElvoraSize;
+    };
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: ElvoraStatus;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string) => any) | undefined;
+}>, {
+    size: ElvoraSize;
+    isDisabled: boolean;
+    modelValue: string;
+    placeholder: string;
+    status: ElvoraStatus;
+    isRequired: boolean;
+    isInvalid: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type LabelSize = 'xs' | 'sm' | 'md' | 'lg';
+/** Accessible form label. Pair via `for` with an input, or wrap an input. */
+declare const ElvoraLabel: vue.DefineComponent<vue.ExtractPropTypes<{
+    for: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<LabelSize>;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    for: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<LabelSize>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    size: LabelSize;
+    isRequired: boolean;
+    for: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Renders an SVG icon from `@elvora/icons` by name. */
+declare const ElvoraIcon: vue.DefineComponent<vue.ExtractPropTypes<{
+    name: {
+        type: PropType<IconName>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    name: {
+        type: PropType<IconName>;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    size: number;
+    label: string;
+    color: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Visual separator. Provide a default slot to render an "OR"-style divider. */
+declare const ElvoraDivider: vue.DefineComponent<vue.ExtractPropTypes<{
+    orientation: {
+        type: PropType<Orientation>;
+        default: string;
+    };
+    thickness: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isDecorative: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    orientation: {
+        type: PropType<Orientation>;
+        default: string;
+    };
+    thickness: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isDecorative: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    orientation: Orientation;
+    thickness: number;
+    isDecorative: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** User avatar. Falls back gracefully: image → initials → custom fallback slot. */
+declare const ElvoraAvatar: vue.DefineComponent<vue.ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    alt: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: string;
+    };
+    shape: {
+        type: PropType<"circle" | "square">;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    alt: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    name: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<ElvoraSize>;
+        default: string;
+    };
+    shape: {
+        type: PropType<"circle" | "square">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    size: ElvoraSize;
+    name: string;
+    src: string;
+    alt: string;
+    shape: "circle" | "square";
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type BadgeSize = Exclude<ElvoraSize, 'xl'>;
+declare const ElvoraBadge: vue.DefineComponent<vue.ExtractPropTypes<{
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: string;
+    };
+    size: {
+        type: PropType<BadgeSize>;
+        default: string;
+    };
+    tone: {
+        type: PropType<ElvoraTone>;
+        default: string;
+    };
+    isDot: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: string;
+    };
+    size: {
+        type: PropType<BadgeSize>;
+        default: string;
+    };
+    tone: {
+        type: PropType<ElvoraTone>;
+        default: string;
+    };
+    isDot: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    size: BadgeSize;
+    status: ElvoraStatus;
+    tone: ElvoraTone;
+    isDot: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type TagSize = Exclude<ElvoraSize, 'xl'>;
+declare const ElvoraTag: vue.DefineComponent<vue.ExtractPropTypes<{
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: string;
+    };
+    size: {
+        type: PropType<TagSize>;
+        default: string;
+    };
+    tone: {
+        type: PropType<ElvoraTone>;
+        default: string;
+    };
+    dismissible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    close: (_event: MouseEvent) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: string;
+    };
+    size: {
+        type: PropType<TagSize>;
+        default: string;
+    };
+    tone: {
+        type: PropType<ElvoraTone>;
+        default: string;
+    };
+    dismissible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onClose?: ((_event: MouseEvent) => any) | undefined;
+}>, {
+    size: TagSize;
+    status: ElvoraStatus;
+    tone: ElvoraTone;
+    dismissible: boolean;
+    closeLabel: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Spinner — accessible loading indicator. */
+declare const ElvoraSpinner: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<ElvoraSize | number>;
+        default: string;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    thickness: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<ElvoraSize | number>;
+        default: string;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+    thickness: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    size: number | ElvoraSize;
+    label: string;
+    color: string;
+    thickness: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ProgressSize = Exclude<ElvoraSize, 'xl'>;
+declare const ElvoraProgress: vue.DefineComponent<vue.ExtractPropTypes<{
+    value: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    size: {
+        type: PropType<ProgressSize>;
+        default: string;
+    };
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    value: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    size: {
+        type: PropType<ProgressSize>;
+        default: string;
+    };
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: string;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{}>, {
+    size: ProgressSize;
+    max: number;
+    label: string;
+    status: ElvoraStatus;
+    value: number;
+    min: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/**
+ * Tooltip. Wrap a single focusable element in the default slot. Shows `label`
+ * on hover/focus.
+ */
+declare const ElvoraTooltip: vue.DefineComponent<vue.ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement$4>;
+        default: string;
+    };
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement$4>;
+        default: string;
+    };
+    openDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    closeDelay: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    placement: Placement$4;
+    openDelay: number;
+    closeDelay: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Box — universal layout primitive. Accepts shorthand style props. */
+declare const ElvoraBox: vue.DefineComponent<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+    p: (StringConstructor | NumberConstructor)[];
+    px: (StringConstructor | NumberConstructor)[];
+    py: (StringConstructor | NumberConstructor)[];
+    pt: (StringConstructor | NumberConstructor)[];
+    pr: (StringConstructor | NumberConstructor)[];
+    pb: (StringConstructor | NumberConstructor)[];
+    pl: (StringConstructor | NumberConstructor)[];
+    m: (StringConstructor | NumberConstructor)[];
+    mx: (StringConstructor | NumberConstructor)[];
+    my: (StringConstructor | NumberConstructor)[];
+    mt: (StringConstructor | NumberConstructor)[];
+    mr: (StringConstructor | NumberConstructor)[];
+    mb: (StringConstructor | NumberConstructor)[];
+    ml: (StringConstructor | NumberConstructor)[];
+    w: (StringConstructor | NumberConstructor)[];
+    h: (StringConstructor | NumberConstructor)[];
+    minW: (StringConstructor | NumberConstructor)[];
+    minH: (StringConstructor | NumberConstructor)[];
+    maxW: (StringConstructor | NumberConstructor)[];
+    maxH: (StringConstructor | NumberConstructor)[];
+    bg: StringConstructor;
+    color: StringConstructor;
+    rounded: (StringConstructor | NumberConstructor)[];
+    shadow: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    as: {
+        type: StringConstructor;
+        default: string;
+    };
+    p: (StringConstructor | NumberConstructor)[];
+    px: (StringConstructor | NumberConstructor)[];
+    py: (StringConstructor | NumberConstructor)[];
+    pt: (StringConstructor | NumberConstructor)[];
+    pr: (StringConstructor | NumberConstructor)[];
+    pb: (StringConstructor | NumberConstructor)[];
+    pl: (StringConstructor | NumberConstructor)[];
+    m: (StringConstructor | NumberConstructor)[];
+    mx: (StringConstructor | NumberConstructor)[];
+    my: (StringConstructor | NumberConstructor)[];
+    mt: (StringConstructor | NumberConstructor)[];
+    mr: (StringConstructor | NumberConstructor)[];
+    mb: (StringConstructor | NumberConstructor)[];
+    ml: (StringConstructor | NumberConstructor)[];
+    w: (StringConstructor | NumberConstructor)[];
+    h: (StringConstructor | NumberConstructor)[];
+    minW: (StringConstructor | NumberConstructor)[];
+    minH: (StringConstructor | NumberConstructor)[];
+    maxW: (StringConstructor | NumberConstructor)[];
+    maxH: (StringConstructor | NumberConstructor)[];
+    bg: StringConstructor;
+    color: StringConstructor;
+    rounded: (StringConstructor | NumberConstructor)[];
+    shadow: StringConstructor;
+}>> & Readonly<{}>, {
+    as: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type Direction = 'row' | 'column' | 'row-reverse' | 'column-reverse';
+/** Stack — flex container. */
+declare const ElvoraStack: vue.DefineComponent<vue.ExtractPropTypes<{
+    direction: {
+        type: PropType<Direction>;
+        default: string;
+    };
+    gap: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    align: StringConstructor;
+    justify: StringConstructor;
+    wrap: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    direction: {
+        type: PropType<Direction>;
+        default: string;
+    };
+    gap: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    align: StringConstructor;
+    justify: StringConstructor;
+    wrap: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    inline: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    direction: Direction;
+    gap: string | number;
+    inline: boolean;
+    wrap: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const ElvoraHStack: vue.DefineComponent<vue.ExtractPropTypes<{
+    gap: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    align: {
+        type: StringConstructor;
+        default: string;
+    };
+    justify: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    gap: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    align: {
+        type: StringConstructor;
+        default: string;
+    };
+    justify: StringConstructor;
+}>> & Readonly<{}>, {
+    gap: string | number;
+    align: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const ElvoraVStack: vue.DefineComponent<vue.ExtractPropTypes<{
+    gap: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    align: StringConstructor;
+    justify: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    gap: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    align: StringConstructor;
+    justify: StringConstructor;
+}>> & Readonly<{}>, {
+    gap: string | number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Grid — CSS Grid container. */
+declare const ElvoraGrid: vue.DefineComponent<vue.ExtractPropTypes<{
+    columns: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    rows: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    gap: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    autoFlow: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    columns: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    rows: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    gap: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    autoFlow: StringConstructor;
+}>> & Readonly<{}>, {
+    columns: string | number;
+    gap: string | number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/** GridItem — child of `<ElvoraGrid>` with span controls. */
+declare const ElvoraGridItem: vue.DefineComponent<vue.ExtractPropTypes<{
+    colSpan: NumberConstructor;
+    rowSpan: NumberConstructor;
+    colStart: NumberConstructor;
+    colEnd: NumberConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    colSpan: NumberConstructor;
+    rowSpan: NumberConstructor;
+    colStart: NumberConstructor;
+    colEnd: NumberConstructor;
+}>> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type Size$1 = 'sm' | 'md' | 'lg' | 'xl' | '2xl' | 'full';
+/** Container — centered, max-width container. */
+declare const ElvoraContainer: vue.DefineComponent<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<Size$1>;
+        default: string;
+    };
+    padding: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    centerContent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    size: {
+        type: PropType<Size$1>;
+        default: string;
+    };
+    padding: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    centerContent: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    size: Size$1;
+    padding: string | number;
+    centerContent: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type Variant$1 = 'outline' | 'elevated' | 'filled';
+/** Card — content container with elevation, padding, rounded corners. */
+declare const ElvoraCard: vue.DefineComponent<vue.ExtractPropTypes<{
+    variant: {
+        type: PropType<Variant$1>;
+        default: string;
+    };
+    padding: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    variant: {
+        type: PropType<Variant$1>;
+        default: string;
+    };
+    padding: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    variant: Variant$1;
+    padding: string | number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const ElvoraCardHeader: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const ElvoraCardBody: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const ElvoraCardFooter: vue.DefineComponent<{}, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Alert — banner-style feedback message. */
+declare const ElvoraAlert: vue.DefineComponent<vue.ExtractPropTypes<{
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: string;
+    };
+    tone: {
+        type: PropType<ElvoraTone>;
+        default: string;
+    };
+    title: StringConstructor;
+    description: StringConstructor;
+    closeable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "close"[], "close", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    status: {
+        type: PropType<ElvoraStatus>;
+        default: string;
+    };
+    tone: {
+        type: PropType<ElvoraTone>;
+        default: string;
+    };
+    title: StringConstructor;
+    description: StringConstructor;
+    closeable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    status: ElvoraStatus;
+    tone: ElvoraTone;
+    closeLabel: string;
+    closeable: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Skeleton — placeholder loading block with optional pulse animation. */
+declare const ElvoraSkeleton: vue.DefineComponent<vue.ExtractPropTypes<{
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    height: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    rounded: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    animated: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    width: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: string;
+    };
+    height: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    rounded: {
+        type: (StringConstructor | NumberConstructor)[];
+    };
+    animated: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    width: string | number;
+    height: string | number;
+    animated: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Empty — placeholder for no-data states. */
+declare const ElvoraEmpty: vue.DefineComponent<vue.ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    description: StringConstructor;
+}>> & Readonly<{}>, {
+    title: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ElvoraResultStatus = ElvoraStatus | '404' | '500' | '403';
+/** Result — page-level status component. */
+declare const ElvoraResult: vue.DefineComponent<vue.ExtractPropTypes<{
+    status: {
+        type: PropType<ElvoraResultStatus>;
+        default: string;
+    };
+    title: StringConstructor;
+    subtitle: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    status: {
+        type: PropType<ElvoraResultStatus>;
+        default: string;
+    };
+    title: StringConstructor;
+    subtitle: StringConstructor;
+}>> & Readonly<{}>, {
+    status: ElvoraResultStatus;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type Size = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+/** Modal — centered overlay dialog. Teleports to <body>. */
+declare const ElvoraModal: vue.DefineComponent<vue.ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+    };
+    title: StringConstructor;
+    showCloseButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnEscape: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnOverlayClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "close"[], "close", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    size: {
+        type: PropType<Size>;
+        default: string;
+    };
+    title: StringConstructor;
+    showCloseButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnEscape: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnOverlayClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: Size;
+    closeLabel: string;
+    showCloseButton: boolean;
+    closeOnEscape: boolean;
+    closeOnOverlayClick: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type Placement$3 = 'left' | 'right' | 'top' | 'bottom';
+/** Drawer — edge-anchored overlay panel. */
+declare const ElvoraDrawer: vue.DefineComponent<vue.ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement$3>;
+        default: string;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    title: StringConstructor;
+    showCloseButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnEscape: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnOverlayClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "close"[], "close", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement$3>;
+        default: string;
+    };
+    size: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: number;
+    };
+    title: StringConstructor;
+    showCloseButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnEscape: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeOnOverlayClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    closeLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: string | number;
+    closeLabel: string;
+    placement: Placement$3;
+    showCloseButton: boolean;
+    closeOnEscape: boolean;
+    closeOnOverlayClick: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type Placement$2 = 'top' | 'bottom' | 'left' | 'right';
+/** Popover — content overlay anchored to a trigger element. */
+declare const ElvoraPopover: vue.DefineComponent<vue.ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    placement: {
+        type: PropType<Placement$2>;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:isOpen"[], "update:isOpen", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    placement: {
+        type: PropType<Placement$2>;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:isOpen"?: ((...args: any[]) => any) | undefined;
+}>, {
+    placement: Placement$2;
+    isOpen: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraToastOptions {
+    id?: string;
+    status?: ElvoraStatus;
+    title?: string;
+    description?: string;
+    duration?: number | null;
+}
+interface ElvoraToastApi {
+    show: (opts: ElvoraToastOptions) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+}
+type Placement$1 = 'top-right' | 'top-left' | 'top-center' | 'bottom-right' | 'bottom-left' | 'bottom-center';
+/**
+ * ToastProvider — wrap your application root with this to enable toasts.
+ * Children call `useToast()` to imperatively trigger them.
+ */
+declare const ElvoraToastProvider: vue.DefineComponent<vue.ExtractPropTypes<{
+    defaultDuration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    placement: {
+        type: PropType<Placement$1>;
+        default: string;
+    };
+}>, () => (vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>[] | null | undefined)[], {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    defaultDuration: {
+        type: NumberConstructor;
+        default: number;
+    };
+    placement: {
+        type: PropType<Placement$1>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    placement: Placement$1;
+    defaultDuration: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+/** useToast — must be called from within a ElvoraToastProvider. */
+declare function useToast(): ElvoraToastApi;
+
+interface ElvoraTabItem {
+    value: string;
+    label: string;
+    isDisabled?: boolean;
+    /** Render function for the tab's panel content. */
+    panel: () => VNode | VNode[] | string | null;
+}
+type Variant = 'underline' | 'pill' | 'solid';
+/** Tabs — WAI-ARIA Tabs pattern with keyboard navigation. */
+declare const ElvoraTabs: vue.DefineComponent<vue.ExtractPropTypes<{
+    tabs: {
+        type: PropType<ElvoraTabItem[]>;
+        required: true;
+    };
+    modelValue: StringConstructor;
+    variant: {
+        type: PropType<Variant>;
+        default: string;
+    };
+    orientation: {
+        type: PropType<Orientation>;
+        default: string;
+    };
+    activation: {
+        type: PropType<"automatic" | "manual">;
+        default: string;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    tabs: {
+        type: PropType<ElvoraTabItem[]>;
+        required: true;
+    };
+    modelValue: StringConstructor;
+    variant: {
+        type: PropType<Variant>;
+        default: string;
+    };
+    orientation: {
+        type: PropType<Orientation>;
+        default: string;
+    };
+    activation: {
+        type: PropType<"automatic" | "manual">;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    variant: Variant;
+    orientation: Orientation;
+    activation: "manual" | "automatic";
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraMenuItem {
+    value: string;
+    label: string;
+    isDisabled?: boolean;
+    hasSeparatorBefore?: boolean;
+}
+type Placement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+/** Menu — dropdown menu. Default slot is the trigger. */
+declare const ElvoraMenu: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraMenuItem[]>;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "select"[], "select", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraMenuItem[]>;
+        required: true;
+    };
+    placement: {
+        type: PropType<Placement>;
+        default: string;
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    placement: Placement;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ElvoraDropdownItem = ElvoraMenuItem;
+/** Dropdown — convenience alias for `<ElvoraMenu>`. */
+declare const ElvoraDropdown: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraDropdownItem[]>;
+        required: true;
+    };
+    placement: {
+        type: PropType<"bottom-start" | "bottom-end" | "top-start" | "top-end">;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "select"[], "select", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraDropdownItem[]>;
+        required: true;
+    };
+    placement: {
+        type: PropType<"bottom-start" | "bottom-end" | "top-start" | "top-end">;
+        default: string;
+    };
+}>> & Readonly<{
+    onSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    placement: "top-start" | "top-end" | "bottom-start" | "bottom-end";
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraBreadcrumbItem {
+    label: string;
+    href?: string;
+    isCurrent?: boolean;
+}
+/** Breadcrumb — navigation trail. */
+declare const ElvoraBreadcrumb: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraBreadcrumbItem[]>;
+        required: true;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "activate"[], "activate", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraBreadcrumbItem[]>;
+        required: true;
+    };
+}>> & Readonly<{
+    onActivate?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** Pagination — accessible page navigator. */
+declare const ElvoraPagination: vue.DefineComponent<vue.ExtractPropTypes<{
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    pageSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    current: {
+        type: NumberConstructor;
+        default: number;
+    };
+    siblingCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showFirstLast: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideOnSinglePage: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("change" | "update:current")[], "change" | "update:current", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    pageSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    current: {
+        type: NumberConstructor;
+        default: number;
+    };
+    siblingCount: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showFirstLast: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideOnSinglePage: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+    "onUpdate:current"?: ((...args: any[]) => any) | undefined;
+}>, {
+    pageSize: number;
+    current: number;
+    siblingCount: number;
+    showFirstLast: boolean;
+    hideOnSinglePage: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraStep {
+    title: string;
+    description?: string;
+    status?: 'wait' | 'process' | 'finish' | 'error';
+}
+/** Steps — multi-step progress indicator. */
+declare const ElvoraSteps: vue.DefineComponent<vue.ExtractPropTypes<{
+    steps: {
+        type: PropType<ElvoraStep[]>;
+        required: true;
+    };
+    current: {
+        type: NumberConstructor;
+        default: number;
+    };
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "change"[], "change", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    steps: {
+        type: PropType<ElvoraStep[]>;
+        required: true;
+    };
+    current: {
+        type: NumberConstructor;
+        default: number;
+    };
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {
+    orientation: "horizontal" | "vertical";
+    current: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraAnchorLink {
+    href: string;
+    label: string;
+    children?: ElvoraAnchorLink[];
+}
+/** Anchor — in-page navigation. */
+declare const ElvoraAnchor: vue.DefineComponent<vue.ExtractPropTypes<{
+    links: {
+        type: PropType<ElvoraAnchorLink[]>;
+        required: true;
+    };
+    offsetTop: {
+        type: NumberConstructor;
+        default: number;
+    };
+    smooth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    links: {
+        type: PropType<ElvoraAnchorLink[]>;
+        required: true;
+    };
+    offsetTop: {
+        type: NumberConstructor;
+        default: number;
+    };
+    smooth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    smooth: boolean;
+    offsetTop: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+/** BackTop — floating "scroll to top" button. */
+declare const ElvoraBackTop: vue.DefineComponent<vue.ExtractPropTypes<{
+    visibilityHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    bottom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    right: {
+        type: NumberConstructor;
+        default: number;
+    };
+    smooth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    visibilityHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    bottom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    right: {
+        type: NumberConstructor;
+        default: number;
+    };
+    smooth: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    label: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    label: string;
+    bottom: number;
+    right: number;
+    smooth: boolean;
+    visibilityHeight: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraForm: vue.DefineComponent<vue.ExtractPropTypes<{
+    layout: {
+        type: PropType<"vertical" | "horizontal">;
+        default: string;
+    };
+    labelWidth: {
+        type: PropType<number | string | null>;
+        default: null;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    submit: (_e: Event) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    layout: {
+        type: PropType<"vertical" | "horizontal">;
+        default: string;
+    };
+    labelWidth: {
+        type: PropType<number | string | null>;
+        default: null;
+    };
+}>> & Readonly<{
+    onSubmit?: ((_e: Event) => any) | undefined;
+}>, {
+    layout: "horizontal" | "vertical";
+    labelWidth: string | number | null;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const ElvoraFormField: vue.DefineComponent<vue.ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    hint: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    error: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    name: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    hint: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    error: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isRequired: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{}>, {
+    label: string;
+    error: string;
+    isRequired: boolean;
+    hint: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare function useFormField(name: string): {
+    error: vue.ComputedRef<string | undefined>;
+    setError(e: string | undefined): void;
+};
+
+declare const ElvoraNumberInput: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<number | null>;
+        default: null;
+    };
+    min: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    precision: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isReadOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideSteppers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: number | null) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<number | null>;
+        default: null;
+    };
+    min: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    max: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    precision: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isReadOnly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hideSteppers: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: number | null) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    max: number;
+    isDisabled: boolean;
+    modelValue: number | null;
+    placeholder: string;
+    isReadOnly: boolean;
+    isInvalid: boolean;
+    min: number;
+    step: number;
+    precision: number;
+    hideSteppers: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraSegmentedOption {
+    value: string;
+    label: string;
+    isDisabled?: boolean;
+}
+declare const ElvoraSegmented: vue.DefineComponent<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<ElvoraSegmentedOption[]>;
+        required: true;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<ElvoraSegmentedOption[]>;
+        required: true;
+    };
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    isDisabled: boolean;
+    modelValue: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraSlider: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: number) => true;
+    'change-end': (_v: number) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    min: {
+        type: NumberConstructor;
+        default: number;
+    };
+    max: {
+        type: NumberConstructor;
+        default: number;
+    };
+    step: {
+        type: NumberConstructor;
+        default: number;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: number) => any) | undefined;
+    "onChange-end"?: ((_v: number) => any) | undefined;
+}>, {
+    max: number;
+    isDisabled: boolean;
+    ariaLabel: string;
+    modelValue: number;
+    min: number;
+    step: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraRate: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    count: {
+        type: NumberConstructor;
+        default: number;
+    };
+    allowHalf: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: number) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    count: {
+        type: NumberConstructor;
+        default: number;
+    };
+    allowHalf: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: number) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    ariaLabel: string;
+    modelValue: number;
+    count: number;
+    allowHalf: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraUploadFile {
+    id: string;
+    file: File;
+    status: 'pending' | 'uploading' | 'done' | 'error';
+    progress?: number;
+    error?: string;
+}
+declare const ElvoraUpload: vue.DefineComponent<vue.ExtractPropTypes<{
+    files: {
+        type: PropType<ElvoraUploadFile[]>;
+        default: () => never[];
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    accept: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    description: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:files': (_v: ElvoraUploadFile[]) => true;
+    upload: (_files: File[]) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    files: {
+        type: PropType<ElvoraUploadFile[]>;
+        default: () => never[];
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    accept: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    description: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onUpload?: ((_files: File[]) => any) | undefined;
+    "onUpdate:files"?: ((_v: ElvoraUploadFile[]) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    multiple: boolean;
+    description: string;
+    files: ElvoraUploadFile[];
+    accept: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraAutoCompleteOption {
+    value: string;
+    label?: string;
+}
+declare const ElvoraAutoComplete: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<ElvoraAutoCompleteOption[]>;
+        default: () => never[];
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string) => true;
+    select: (_opt: ElvoraAutoCompleteOption) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<ElvoraAutoCompleteOption[]>;
+        default: () => never[];
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSelect?: ((_opt: ElvoraAutoCompleteOption) => any) | undefined;
+    "onUpdate:modelValue"?: ((_v: string) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    modelValue: string;
+    placeholder: string;
+    isInvalid: boolean;
+    options: ElvoraAutoCompleteOption[];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraColorPicker: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    presets: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    presets: {
+        type: PropType<string[]>;
+        default: () => string[];
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    modelValue: string;
+    presets: string[];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraDatePicker: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<Date | null>;
+        default: null;
+    };
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: number;
+    };
+    format: {
+        type: PropType<(d: Date) => string>;
+        default: (d: Date) => string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: Date | null) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<Date | null>;
+        default: null;
+    };
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: number;
+    };
+    format: {
+        type: PropType<(d: Date) => string>;
+        default: (d: Date) => string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: Date | null) => any) | undefined;
+}>, {
+    max: Date;
+    isDisabled: boolean;
+    modelValue: Date | null;
+    placeholder: string;
+    isInvalid: boolean;
+    min: Date;
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    format: (d: Date) => string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraTimeValue {
+    hours: number;
+    minutes: number;
+    seconds?: number;
+}
+declare const ElvoraTimePicker: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<ElvoraTimeValue | null>;
+        default: null;
+    };
+    showSeconds: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    use12Hours: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minuteStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: ElvoraTimeValue | null) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<ElvoraTimeValue | null>;
+        default: null;
+    };
+    showSeconds: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    use12Hours: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    minuteStep: {
+        type: NumberConstructor;
+        default: number;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: ElvoraTimeValue | null) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    modelValue: ElvoraTimeValue | null;
+    placeholder: string;
+    showSeconds: boolean;
+    use12Hours: boolean;
+    minuteStep: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraDateRange {
+    start: Date | null;
+    end: Date | null;
+}
+declare const ElvoraDateRangePicker: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<ElvoraDateRange | null>;
+        default: null;
+    };
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: number;
+    };
+    format: {
+        type: PropType<(d: Date) => string>;
+        default: (d: Date) => string;
+    };
+    placeholder: {
+        type: PropType<{
+            start?: string;
+            end?: string;
+        }>;
+        default: undefined;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: ElvoraDateRange) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<ElvoraDateRange | null>;
+        default: null;
+    };
+    min: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    max: {
+        type: DateConstructor;
+        default: undefined;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isInvalid: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: number;
+    };
+    format: {
+        type: PropType<(d: Date) => string>;
+        default: (d: Date) => string;
+    };
+    placeholder: {
+        type: PropType<{
+            start?: string;
+            end?: string;
+        }>;
+        default: undefined;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: ElvoraDateRange) => any) | undefined;
+}>, {
+    max: Date;
+    isDisabled: boolean;
+    modelValue: ElvoraDateRange | null;
+    placeholder: {
+        start?: string;
+        end?: string;
+    };
+    isInvalid: boolean;
+    min: Date;
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+    format: (d: Date) => string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraCascaderOption {
+    value: string;
+    label: string;
+    children?: ElvoraCascaderOption[];
+    isDisabled?: boolean;
+}
+declare const ElvoraCascader: vue.DefineComponent<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<ElvoraCascaderOption[]>;
+        required: true;
+    };
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    displaySeparator: {
+        type: StringConstructor;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string[]) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<ElvoraCascaderOption[]>;
+        required: true;
+    };
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    displaySeparator: {
+        type: StringConstructor;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string[]) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    modelValue: string[];
+    placeholder: string;
+    displaySeparator: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraTreeNode$1 {
+    value: string;
+    label: string;
+    children?: ElvoraTreeNode$1[];
+    isDisabled?: boolean;
+}
+declare const ElvoraTreeSelect: vue.DefineComponent<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<ElvoraTreeNode$1[]>;
+        required: true;
+    };
+    modelValue: {
+        type: PropType<string | string[]>;
+        default: string;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultExpanded: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string | string[]) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    options: {
+        type: PropType<ElvoraTreeNode$1[]>;
+        required: true;
+    };
+    modelValue: {
+        type: PropType<string | string[]>;
+        default: string;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    placeholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    defaultExpanded: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string | string[]) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    modelValue: string | string[];
+    placeholder: string;
+    multiple: boolean;
+    defaultExpanded: string[];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraMentionItem {
+    value: string;
+    label?: string;
+}
+declare const ElvoraMentions: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<ElvoraMentionItem[]>;
+        default: () => never[];
+    };
+    trigger: {
+        type: StringConstructor;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: StringConstructor;
+        default: string;
+    };
+    options: {
+        type: PropType<ElvoraMentionItem[]>;
+        default: () => never[];
+    };
+    trigger: {
+        type: StringConstructor;
+        default: string;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    modelValue: string;
+    options: ElvoraMentionItem[];
+    trigger: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraTransferItem {
+    key: string;
+    label: string;
+    isDisabled?: boolean;
+}
+declare const ElvoraTransfer: vue.DefineComponent<vue.ExtractPropTypes<{
+    dataSource: {
+        type: PropType<ElvoraTransferItem[]>;
+        required: true;
+    };
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    titles: {
+        type: PropType<[string, string]>;
+        default: undefined;
+    };
+    showSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    'update:modelValue': (_v: string[]) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    dataSource: {
+        type: PropType<ElvoraTransferItem[]>;
+        required: true;
+    };
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    titles: {
+        type: PropType<[string, string]>;
+        default: undefined;
+    };
+    showSearch: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isDisabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((_v: string[]) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    modelValue: string[];
+    titles: [string, string];
+    showSearch: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ElvoraSortOrder = 'asc' | 'desc' | null;
+interface ElvoraTableColumn<Row = Record<string, unknown>> {
+    key: string;
+    title: string;
+    dataIndex?: keyof Row | string;
+    sortable?: boolean;
+    sorter?: (a: Row, b: Row) => number;
+    width?: number | string;
+    align?: 'left' | 'center' | 'right';
+}
+declare const ElvoraTable: vue.DefineComponent<vue.ExtractPropTypes<{
+    columns: {
+        type: PropType<ElvoraTableColumn[]>;
+        required: true;
+    };
+    dataSource: {
+        type: PropType<Record<string, unknown>[]>;
+        required: true;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    bordered: BooleanConstructor;
+    striped: BooleanConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "rowClick"[], "rowClick", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    columns: {
+        type: PropType<ElvoraTableColumn[]>;
+        required: true;
+    };
+    dataSource: {
+        type: PropType<Record<string, unknown>[]>;
+        required: true;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    bordered: BooleanConstructor;
+    striped: BooleanConstructor;
+}>> & Readonly<{
+    onRowClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    bordered: boolean;
+    striped: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraTreeNode {
+    key: string;
+    label: string;
+    children?: ElvoraTreeNode[];
+    isDisabled?: boolean;
+}
+declare const ElvoraTree: vue.DefineComponent<vue.ExtractPropTypes<{
+    treeData: {
+        type: PropType<ElvoraTreeNode[]>;
+        required: true;
+    };
+    expandedKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    selectedKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    multiple: BooleanConstructor;
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:expandedKeys" | "update:selectedKeys" | "nodeSelect")[], "update:expandedKeys" | "update:selectedKeys" | "nodeSelect", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    treeData: {
+        type: PropType<ElvoraTreeNode[]>;
+        required: true;
+    };
+    expandedKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    selectedKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    multiple: BooleanConstructor;
+}>> & Readonly<{
+    "onUpdate:expandedKeys"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:selectedKeys"?: ((...args: any[]) => any) | undefined;
+    onNodeSelect?: ((...args: any[]) => any) | undefined;
+}>, {
+    multiple: boolean;
+    expandedKeys: string[];
+    selectedKeys: string[];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraList: vue.DefineComponent<vue.ExtractPropTypes<{
+    dataSource: {
+        type: PropType<unknown[]>;
+        required: true;
+    };
+    header: StringConstructor;
+    footer: StringConstructor;
+    bordered: BooleanConstructor;
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    divided: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyMessage: StringConstructor;
+}>, () => VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    dataSource: {
+        type: PropType<unknown[]>;
+        required: true;
+    };
+    header: StringConstructor;
+    footer: StringConstructor;
+    bordered: BooleanConstructor;
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+    divided: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    emptyMessage: StringConstructor;
+}>> & Readonly<{}>, {
+    size: "sm" | "md" | "lg";
+    bordered: boolean;
+    divided: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraDescriptionItem {
+    key: string;
+    label: string;
+    value: string;
+    span?: number;
+}
+declare const ElvoraDescriptions: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraDescriptionItem[]>;
+        required: true;
+    };
+    title: StringConstructor;
+    columns: {
+        type: NumberConstructor;
+        default: number;
+    };
+    layout: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    bordered: BooleanConstructor;
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraDescriptionItem[]>;
+        required: true;
+    };
+    title: StringConstructor;
+    columns: {
+        type: NumberConstructor;
+        default: number;
+    };
+    layout: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    bordered: BooleanConstructor;
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    size: "sm" | "md" | "lg";
+    columns: number;
+    layout: "horizontal" | "vertical";
+    bordered: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraCalendar: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<Date | null>;
+        default: null;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: number;
+    };
+    locale: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<Date | null>;
+        default: null;
+    };
+    weekStartsOn: {
+        type: PropType<0 | 1 | 2 | 3 | 4 | 5 | 6>;
+        default: number;
+    };
+    locale: StringConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    modelValue: Date | null;
+    weekStartsOn: 0 | 1 | 2 | 3 | 4 | 5 | 6;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraStatistic: vue.DefineComponent<vue.ExtractPropTypes<{
+    title: StringConstructor;
+    value: {
+        type: PropType<number | string>;
+        required: true;
+    };
+    precision: NumberConstructor;
+    prefix: StringConstructor;
+    suffix: StringConstructor;
+    groupSeparator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tone: {
+        type: PropType<"default" | "success" | "danger" | "warning" | "primary">;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    title: StringConstructor;
+    value: {
+        type: PropType<number | string>;
+        required: true;
+    };
+    precision: NumberConstructor;
+    prefix: StringConstructor;
+    suffix: StringConstructor;
+    groupSeparator: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tone: {
+        type: PropType<"default" | "success" | "danger" | "warning" | "primary">;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    tone: "primary" | "success" | "warning" | "danger" | "default";
+    groupSeparator: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraCarousel: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    modelValue: NumberConstructor;
+    autoplay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    arrows: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dots: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<string[]>;
+        required: true;
+    };
+    modelValue: NumberConstructor;
+    autoplay: {
+        type: NumberConstructor;
+        default: number;
+    };
+    arrows: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    dots: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loop: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    height: number;
+    autoplay: number;
+    arrows: boolean;
+    dots: boolean;
+    loop: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraImage: vue.DefineComponent<vue.ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+    alt: {
+        type: StringConstructor;
+        default: string;
+    };
+    fallback: StringConstructor;
+    placeholder: StringConstructor;
+    preview: BooleanConstructor;
+    width: PropType<number | string>;
+    height: PropType<number | string>;
+    fit: {
+        type: PropType<"cover" | "contain" | "fill" | "none" | "scale-down">;
+        default: string;
+    };
+    rounded: BooleanConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    src: {
+        type: StringConstructor;
+        required: true;
+    };
+    alt: {
+        type: StringConstructor;
+        default: string;
+    };
+    fallback: StringConstructor;
+    placeholder: StringConstructor;
+    preview: BooleanConstructor;
+    width: PropType<number | string>;
+    height: PropType<number | string>;
+    fit: {
+        type: PropType<"cover" | "contain" | "fill" | "none" | "scale-down">;
+        default: string;
+    };
+    rounded: BooleanConstructor;
+}>> & Readonly<{}>, {
+    alt: string;
+    rounded: boolean;
+    preview: boolean;
+    fit: "none" | "fill" | "contain" | "cover" | "scale-down";
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ElvoraTimelineStatus = 'default' | 'success' | 'danger' | 'warning' | 'info' | 'primary';
+interface ElvoraTimelineItem {
+    key: string;
+    content: string;
+    label?: string;
+    status?: ElvoraTimelineStatus;
+}
+declare const ElvoraTimeline: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraTimelineItem[]>;
+        required: true;
+    };
+    reverse: BooleanConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraTimelineItem[]>;
+        required: true;
+    };
+    reverse: BooleanConstructor;
+}>> & Readonly<{}>, {
+    reverse: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraCollapseItem {
+    key: string;
+    header: string;
+    content: string;
+    extra?: string;
+    isDisabled?: boolean;
+}
+declare const ElvoraCollapse: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraCollapseItem[]>;
+        required: true;
+    };
+    activeKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    accordion: BooleanConstructor;
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:activeKeys"[], "update:activeKeys", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraCollapseItem[]>;
+        required: true;
+    };
+    activeKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    accordion: BooleanConstructor;
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:activeKeys"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    bordered: boolean;
+    accordion: boolean;
+    activeKeys: string[];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ElvoraAccordionItem = ElvoraCollapseItem;
+declare const ElvoraAccordion: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraAccordionItem[]>;
+        required: true;
+    };
+    activeKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:activeKeys"[], "update:activeKeys", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraAccordionItem[]>;
+        required: true;
+    };
+    activeKeys: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    bordered: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    size: {
+        type: PropType<"sm" | "md" | "lg">;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:activeKeys"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: "sm" | "md" | "lg";
+    bordered: boolean;
+    activeKeys: string[];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraTourStep {
+    target?: string;
+    title: string;
+    description?: string;
+}
+declare const ElvoraTour: vue.DefineComponent<vue.ExtractPropTypes<{
+    open: BooleanConstructor;
+    steps: {
+        type: PropType<ElvoraTourStep[]>;
+        required: true;
+    };
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    finishLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:modelValue" | "update:open")[], "update:modelValue" | "update:open", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    open: BooleanConstructor;
+    steps: {
+        type: PropType<ElvoraTourStep[]>;
+        required: true;
+    };
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    mask: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    finishLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:open"?: ((...args: any[]) => any) | undefined;
+}>, {
+    mask: boolean;
+    modelValue: number;
+    open: boolean;
+    finishLabel: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ElvoraFloatButtonTone = 'primary' | 'neutral' | 'danger' | 'success';
+declare const ElvoraFloatButton: vue.DefineComponent<vue.ExtractPropTypes<{
+    label: StringConstructor;
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    right: {
+        type: NumberConstructor;
+        default: number;
+    };
+    bottom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tone: {
+        type: PropType<ElvoraFloatButtonTone>;
+        default: string;
+    };
+    extended: BooleanConstructor;
+    isDisabled: BooleanConstructor;
+    ariaLabel: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "press"[], "press", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    label: StringConstructor;
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    right: {
+        type: NumberConstructor;
+        default: number;
+    };
+    bottom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    tone: {
+        type: PropType<ElvoraFloatButtonTone>;
+        default: string;
+    };
+    extended: BooleanConstructor;
+    isDisabled: BooleanConstructor;
+    ariaLabel: StringConstructor;
+}>> & Readonly<{
+    onPress?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: number;
+    isDisabled: boolean;
+    bottom: number;
+    right: number;
+    tone: ElvoraFloatButtonTone;
+    extended: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraWatermark: vue.DefineComponent<vue.ExtractPropTypes<{
+    content: {
+        type: PropType<string | string[]>;
+        required: true;
+    };
+    font: {
+        type: StringConstructor;
+        default: string;
+    };
+    fontSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    rotate: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gapX: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gapY: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    content: {
+        type: PropType<string | string[]>;
+        required: true;
+    };
+    font: {
+        type: StringConstructor;
+        default: string;
+    };
+    fontSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    color: {
+        type: StringConstructor;
+        default: string;
+    };
+    rotate: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gapX: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gapY: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    fontSize: number;
+    color: string;
+    rotate: number;
+    font: string;
+    gapX: number;
+    gapY: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraQrCode: vue.DefineComponent<vue.ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    level: {
+        type: PropType<ErrorCorrection>;
+        default: string;
+    };
+    foreground: {
+        type: StringConstructor;
+        default: string;
+    };
+    background: {
+        type: StringConstructor;
+        default: string;
+    };
+    ariaLabel: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    value: {
+        type: StringConstructor;
+        required: true;
+    };
+    size: {
+        type: NumberConstructor;
+        default: number;
+    };
+    level: {
+        type: PropType<ErrorCorrection>;
+        default: string;
+    };
+    foreground: {
+        type: StringConstructor;
+        default: string;
+    };
+    background: {
+        type: StringConstructor;
+        default: string;
+    };
+    ariaLabel: StringConstructor;
+}>> & Readonly<{}>, {
+    size: number;
+    background: string;
+    level: ErrorCorrection;
+    foreground: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraSplitter: vue.DefineComponent<vue.ExtractPropTypes<{
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minRatio: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxRatio: {
+        type: NumberConstructor;
+        default: number;
+    };
+    handleSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    direction: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    modelValue: {
+        type: NumberConstructor;
+        default: number;
+    };
+    minRatio: {
+        type: NumberConstructor;
+        default: number;
+    };
+    maxRatio: {
+        type: NumberConstructor;
+        default: number;
+    };
+    handleSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    direction: "horizontal" | "vertical";
+    modelValue: number;
+    minRatio: number;
+    maxRatio: number;
+    handleSize: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraAffix: vue.DefineComponent<vue.ExtractPropTypes<{
+    offsetTop: NumberConstructor;
+    offsetBottom: NumberConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "change"[], "change", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    offsetTop: NumberConstructor;
+    offsetBottom: NumberConstructor;
+}>> & Readonly<{
+    onChange?: ((...args: any[]) => any) | undefined;
+}>, {}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraSpeedDialAction {
+    key: string;
+    label: string;
+    isDisabled?: boolean;
+}
+declare const ElvoraSpeedDial: vue.DefineComponent<vue.ExtractPropTypes<{
+    actions: {
+        type: PropType<ElvoraSpeedDialAction[]>;
+        default: () => never[];
+    };
+    right: {
+        type: NumberConstructor;
+        default: number;
+    };
+    bottom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    direction: {
+        type: PropType<"up" | "down" | "left" | "right">;
+        default: string;
+    };
+    ariaLabel: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("action" | "open-change")[], "action" | "open-change", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    actions: {
+        type: PropType<ElvoraSpeedDialAction[]>;
+        default: () => never[];
+    };
+    right: {
+        type: NumberConstructor;
+        default: number;
+    };
+    bottom: {
+        type: NumberConstructor;
+        default: number;
+    };
+    direction: {
+        type: PropType<"up" | "down" | "left" | "right">;
+        default: string;
+    };
+    ariaLabel: StringConstructor;
+}>> & Readonly<{
+    onAction?: ((...args: any[]) => any) | undefined;
+    "onOpen-change"?: ((...args: any[]) => any) | undefined;
+}>, {
+    direction: "left" | "right" | "up" | "down";
+    bottom: number;
+    right: number;
+    actions: ElvoraSpeedDialAction[];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraBackdrop: vue.DefineComponent<vue.ExtractPropTypes<{
+    open: BooleanConstructor;
+    tint: StringConstructor;
+    invisible: BooleanConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "close"[], "close", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    open: BooleanConstructor;
+    tint: StringConstructor;
+    invisible: BooleanConstructor;
+}>> & Readonly<{
+    onClose?: ((...args: any[]) => any) | undefined;
+}>, {
+    open: boolean;
+    invisible: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraImageListItem {
+    key: string;
+    src?: string;
+    alt?: string;
+    caption?: string;
+    cols?: number;
+    rows?: number;
+}
+declare const ElvoraImageList: vue.DefineComponent<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraImageListItem[]>;
+        default: () => never[];
+    };
+    cols: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    items: {
+        type: PropType<ElvoraImageListItem[]>;
+        default: () => never[];
+    };
+    cols: {
+        type: NumberConstructor;
+        default: number;
+    };
+    gap: {
+        type: NumberConstructor;
+        default: number;
+    };
+    rowHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{}>, {
+    gap: number;
+    items: ElvoraImageListItem[];
+    cols: number;
+    rowHeight: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraSimplePagination: vue.DefineComponent<vue.ExtractPropTypes<{
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    pageSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    current: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showJumper: BooleanConstructor;
+    showSizeChanger: BooleanConstructor;
+    pageSizeOptions: {
+        type: PropType<number[]>;
+        default: () => number[];
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("update:current" | "update:pageSize")[], "update:current" | "update:pageSize", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    pageSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    current: {
+        type: NumberConstructor;
+        default: number;
+    };
+    showJumper: BooleanConstructor;
+    showSizeChanger: BooleanConstructor;
+    pageSizeOptions: {
+        type: PropType<number[]>;
+        default: () => number[];
+    };
+}>> & Readonly<{
+    "onUpdate:current"?: ((...args: any[]) => any) | undefined;
+    "onUpdate:pageSize"?: ((...args: any[]) => any) | undefined;
+}>, {
+    pageSize: number;
+    current: number;
+    showJumper: boolean;
+    showSizeChanger: boolean;
+    pageSizeOptions: number[];
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+declare const ElvoraMiniPagination: vue.DefineComponent<vue.ExtractPropTypes<{
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    pageSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    current: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:current"[], "update:current", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    total: {
+        type: NumberConstructor;
+        required: true;
+    };
+    pageSize: {
+        type: NumberConstructor;
+        default: number;
+    };
+    current: {
+        type: NumberConstructor;
+        default: number;
+    };
+}>> & Readonly<{
+    "onUpdate:current"?: ((...args: any[]) => any) | undefined;
+}>, {
+    pageSize: number;
+    current: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraStepperStep {
+    key: string;
+    label: string;
+    description?: string;
+    optional?: boolean;
+}
+declare const ElvoraStepper: vue.DefineComponent<vue.ExtractPropTypes<{
+    steps: {
+        type: PropType<ElvoraStepperStep[]>;
+        default: () => never[];
+    };
+    active: {
+        type: NumberConstructor;
+        default: number;
+    };
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    showNavigation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nextLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    prevLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    finishLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, ("finish" | "update:active")[], "finish" | "update:active", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    steps: {
+        type: PropType<ElvoraStepperStep[]>;
+        default: () => never[];
+    };
+    active: {
+        type: NumberConstructor;
+        default: number;
+    };
+    orientation: {
+        type: PropType<"horizontal" | "vertical">;
+        default: string;
+    };
+    showNavigation: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    nextLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    prevLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    finishLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onFinish?: ((...args: any[]) => any) | undefined;
+    "onUpdate:active"?: ((...args: any[]) => any) | undefined;
+}>, {
+    active: number;
+    orientation: "horizontal" | "vertical";
+    steps: ElvoraStepperStep[];
+    finishLabel: string;
+    showNavigation: boolean;
+    nextLabel: string;
+    prevLabel: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraToggleButton: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    value: StringConstructor;
+    size: {
+        type: PropType<ElvoraSize>;
+        default: string;
+    };
+    isDisabled: BooleanConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: BooleanConstructor;
+        default: undefined;
+    };
+    value: StringConstructor;
+    size: {
+        type: PropType<ElvoraSize>;
+        default: string;
+    };
+    isDisabled: BooleanConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    size: ElvoraSize;
+    isDisabled: boolean;
+    modelValue: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ElvoraButtonGroupOrientation = 'horizontal' | 'vertical';
+declare const ElvoraButtonGroup: vue.DefineComponent<vue.ExtractPropTypes<{
+    orientation: {
+        type: PropType<ElvoraButtonGroupOrientation>;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    orientation: {
+        type: PropType<ElvoraButtonGroupOrientation>;
+        default: string;
+    };
+}>> & Readonly<{}>, {
+    orientation: ElvoraButtonGroupOrientation;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+declare const ElvoraChipInput: vue.DefineComponent<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    placeholder: StringConstructor;
+    isDisabled: BooleanConstructor;
+    unique: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxChips: NumberConstructor;
+    ariaLabel: StringConstructor;
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "update:modelValue"[], "update:modelValue", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    modelValue: {
+        type: PropType<string[]>;
+        default: () => never[];
+    };
+    placeholder: StringConstructor;
+    isDisabled: BooleanConstructor;
+    unique: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    maxChips: NumberConstructor;
+    ariaLabel: StringConstructor;
+}>> & Readonly<{
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+}>, {
+    isDisabled: boolean;
+    modelValue: string[];
+    unique: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraProTableColumn<Row = Record<string, unknown>> extends ElvoraTableColumn<Row> {
+    searchable?: boolean;
+}
+declare const ElvoraProTable: vue.DefineComponent<vue.ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    columns: {
+        type: PropType<ElvoraProTableColumn[]>;
+        required: true;
+    };
+    dataSource: {
+        type: PropType<Record<string, unknown>[]>;
+        required: true;
+    };
+    search: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    empty: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "rowClick"[], "rowClick", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    title: {
+        type: StringConstructor;
+        default: string;
+    };
+    columns: {
+        type: PropType<ElvoraProTableColumn[]>;
+        required: true;
+    };
+    dataSource: {
+        type: PropType<Record<string, unknown>[]>;
+        required: true;
+    };
+    search: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searchPlaceholder: {
+        type: StringConstructor;
+        default: string;
+    };
+    empty: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onRowClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    search: boolean;
+    title: string;
+    searchPlaceholder: string;
+    empty: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ElvoraProFormFieldType = 'text' | 'password' | 'email' | 'number' | 'textarea' | 'switch' | 'checkbox' | 'select';
+interface ElvoraProFormField {
+    name: string;
+    label?: string;
+    type: ElvoraProFormFieldType;
+    placeholder?: string;
+    hint?: string;
+    required?: boolean;
+    disabled?: boolean;
+    defaultValue?: unknown;
+    options?: ElvoraSelectOption[];
+    validate?: (value: unknown, values: Record<string, unknown>) => string | undefined;
+}
+declare const ElvoraProForm: vue.DefineComponent<vue.ExtractPropTypes<{
+    fields: {
+        type: PropType<ElvoraProFormField[]>;
+        required: true;
+    };
+    initialValues: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+    submitLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    isSubmitting: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    submit: (_v: Record<string, unknown>) => true;
+    'values-change': (_v: Record<string, unknown>) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    fields: {
+        type: PropType<ElvoraProFormField[]>;
+        required: true;
+    };
+    initialValues: {
+        type: PropType<Record<string, unknown>>;
+        default: () => {};
+    };
+    submitLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    resetLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    isSubmitting: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & Readonly<{
+    onSubmit?: ((_v: Record<string, unknown>) => any) | undefined;
+    "onValues-change"?: ((_v: Record<string, unknown>) => any) | undefined;
+}>, {
+    initialValues: Record<string, unknown>;
+    submitLabel: string;
+    resetLabel: string;
+    isSubmitting: boolean;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+interface ElvoraProLayoutMenuItem {
+    key: string;
+    label: string;
+    icon?: IconName;
+    children?: ElvoraProLayoutMenuItem[];
+}
+interface ElvoraProLayoutUser {
+    name: string;
+    avatar?: string;
+    caption?: string;
+}
+declare const ElvoraProLayout: vue.DefineComponent<vue.ExtractPropTypes<{
+    brand: {
+        type: StringConstructor;
+        default: string;
+    };
+    menu: {
+        type: PropType<ElvoraProLayoutMenuItem[]>;
+        default: () => never[];
+    };
+    user: {
+        type: PropType<ElvoraProLayoutUser | null>;
+        default: null;
+    };
+    sidebarWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    selectedKey: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, {
+    select: (_key: string) => true;
+}, string, vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    brand: {
+        type: StringConstructor;
+        default: string;
+    };
+    menu: {
+        type: PropType<ElvoraProLayoutMenuItem[]>;
+        default: () => never[];
+    };
+    user: {
+        type: PropType<ElvoraProLayoutUser | null>;
+        default: null;
+    };
+    sidebarWidth: {
+        type: NumberConstructor;
+        default: number;
+    };
+    selectedKey: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onSelect?: ((_key: string) => any) | undefined;
+}>, {
+    menu: ElvoraProLayoutMenuItem[];
+    brand: string;
+    user: ElvoraProLayoutUser | null;
+    sidebarWidth: number;
+    selectedKey: string;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+type ElvoraDataGridSortOrder = 'asc' | 'desc' | null;
+interface ElvoraDataGridColumn<Row = Record<string, unknown>> {
+    key: string;
+    title: string;
+    dataIndex?: keyof Row | string;
+    width?: number;
+    sortable?: boolean;
+    sorter?: (a: Row, b: Row) => number;
+    align?: 'left' | 'center' | 'right';
+}
+declare const ElvoraDataGrid: vue.DefineComponent<vue.ExtractPropTypes<{
+    columns: {
+        type: PropType<ElvoraDataGridColumn[]>;
+        required: true;
+    };
+    dataSource: {
+        type: PropType<Record<string, unknown>[]>;
+        required: true;
+    };
+    rowHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    overscan: {
+        type: NumberConstructor;
+        default: number;
+    };
+    empty: {
+        type: StringConstructor;
+        default: string;
+    };
+}>, () => vue.VNode<vue.RendererNode, vue.RendererElement, {
+    [key: string]: any;
+}>, {}, {}, {}, vue.ComponentOptionsMixin, vue.ComponentOptionsMixin, "rowClick"[], "rowClick", vue.PublicProps, Readonly<vue.ExtractPropTypes<{
+    columns: {
+        type: PropType<ElvoraDataGridColumn[]>;
+        required: true;
+    };
+    dataSource: {
+        type: PropType<Record<string, unknown>[]>;
+        required: true;
+    };
+    rowHeight: {
+        type: NumberConstructor;
+        default: number;
+    };
+    height: {
+        type: NumberConstructor;
+        default: number;
+    };
+    overscan: {
+        type: NumberConstructor;
+        default: number;
+    };
+    empty: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & Readonly<{
+    onRowClick?: ((...args: any[]) => any) | undefined;
+}>, {
+    height: number;
+    rowHeight: number;
+    empty: string;
+    overscan: number;
+}, {}, {}, {}, string, vue.ComponentProvideOptions, true, {}, any>;
+
+export { ELVORA_CONTEXT, ElvoraAccordion, type ElvoraAccordionItem, ElvoraAffix, ElvoraAlert, ElvoraAnchor, type ElvoraAnchorLink, ElvoraAutoComplete, type ElvoraAutoCompleteOption, ElvoraAvatar, ElvoraBackTop, ElvoraBackdrop, ElvoraBadge, ElvoraBox, ElvoraBreadcrumb, type ElvoraBreadcrumbItem, ElvoraButton, ElvoraButtonGroup, type ElvoraButtonGroupOrientation, ElvoraCalendar, ElvoraCard, ElvoraCardBody, ElvoraCardFooter, ElvoraCardHeader, ElvoraCarousel, ElvoraCascader, type ElvoraCascaderOption, ElvoraCheckbox, ElvoraChipInput, ElvoraCollapse, type ElvoraCollapseItem, ElvoraColorPicker, ElvoraContainer, ElvoraDataGrid, type ElvoraDataGridColumn, type ElvoraDataGridSortOrder, ElvoraDatePicker, type ElvoraDateRange, ElvoraDateRangePicker, type ElvoraDescriptionItem, ElvoraDescriptions, ElvoraDivider, ElvoraDrawer, ElvoraDropdown, type ElvoraDropdownItem, ElvoraEmpty, ElvoraFloatButton, type ElvoraFloatButtonTone, ElvoraForm, ElvoraFormField, ElvoraGrid, ElvoraGridItem, ElvoraHStack, ElvoraIcon, ElvoraIconButton, ElvoraImage, ElvoraImageList, type ElvoraImageListItem, ElvoraInput, ElvoraLabel, ElvoraList, type ElvoraMentionItem, ElvoraMentions, ElvoraMenu, type ElvoraMenuItem, ElvoraMiniPagination, ElvoraModal, ElvoraNumberInput, ElvoraPagination, ElvoraPopover, ElvoraProForm, type ElvoraProFormField, type ElvoraProFormFieldType, ElvoraProLayout, type ElvoraProLayoutMenuItem, type ElvoraProLayoutUser, ElvoraProTable, type ElvoraProTableColumn, ElvoraProgress, ElvoraProvider, ElvoraQrCode, ElvoraRadio, ElvoraRadioGroup, ElvoraRate, ElvoraResult, type ElvoraResultStatus, ElvoraSegmented, type ElvoraSegmentedOption, ElvoraSelect, type ElvoraSelectOption, ElvoraSimplePagination, ElvoraSkeleton, ElvoraSlider, type ElvoraSortOrder, ElvoraSpeedDial, type ElvoraSpeedDialAction, ElvoraSpinner, ElvoraSplitter, ElvoraStack, ElvoraStatistic, type ElvoraStep, ElvoraStepper, type ElvoraStepperStep, ElvoraSteps, ElvoraSwitch, type ElvoraTabItem, ElvoraTable, type ElvoraTableColumn, ElvoraTabs, ElvoraTag, ElvoraTextarea, ElvoraTimePicker, type ElvoraTimeValue, ElvoraTimeline, type ElvoraTimelineItem, type ElvoraTimelineStatus, type ElvoraToastApi, type ElvoraToastOptions, ElvoraToastProvider, ElvoraToggleButton, ElvoraTooltip, ElvoraTour, type ElvoraTourStep, ElvoraTransfer, type ElvoraTransferItem, ElvoraTree, type ElvoraTreeNode as ElvoraTreeDataNode, type ElvoraTreeNode$1 as ElvoraTreeNode, ElvoraTreeSelect, ElvoraUpload, type ElvoraUploadFile, ElvoraVStack, ElvoraWatermark, provideElvora, useElvoraContext, useFormField, useTheme, useToast };