@onereach/ui-components 25.3.5-beta.5816.0 → 25.3.6-beta.5818.0

package/dist/types/components/or-label-v3/types.d.ts

@@ -0,0 +1,6 @@
+export declare enum LabelVariant {
+    Input = "input",
+    Toggle = "toggle",
+    Group = "group",
+    MenuItem = "menu-item"
+}

package/dist/types/components/or-link-v3/OrLink.vue.d.ts

@@ -0,0 +1,63 @@
+import { PropType } from 'vue';
+import { LinkColor } from './props';
+declare const _default: import("vue").DefineComponent<{
+    href: {
+        type: StringConstructor;
+        required: true;
+    };
+    color: {
+        type: PropType<`${LinkColor}`>;
+        default: () => LinkColor;
+    };
+    underlined: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingText: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    root: import("vue").Ref<HTMLButtonElement | undefined>;
+    rootStyles: import("vue").ComputedRef<(string | false)[]>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    href: {
+        type: StringConstructor;
+        required: true;
+    };
+    color: {
+        type: PropType<`${LinkColor}`>;
+        default: () => LinkColor;
+    };
+    underlined: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loading: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadingText: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    disabled: boolean;
+    color: "inherit" | "primary" | "danger" | "success" | "warning";
+    loading: boolean;
+    loadingText: string;
+    underlined: boolean;
+}, {}>;
+export default _default;

package/dist/types/components/or-link-v3/index.d.ts

@@ -0,0 +1,2 @@
+export { default as OrLinkV3 } from './OrLink.vue';
+export * from './props';

package/dist/types/components/or-link-v3/props.d.ts

@@ -0,0 +1,7 @@
+export declare enum LinkColor {
+    Primary = "primary",
+    Success = "success",
+    Warning = "warning",
+    Danger = "danger",
+    Inherit = "inherit"
+}

package/dist/types/components/or-link-v3/styles.d.ts

@@ -0,0 +1,3 @@
+import { LinkColor } from './props';
+export declare const LinkRoot: string[];
+export declare const LinkRootColors: Record<LinkColor, string[]>;

package/dist/types/components/or-list-v3/OrList.vue.d.ts

@@ -0,0 +1,107 @@
+import { PropType } from 'vue';
+import { ListItem } from './types';
+declare const _default: import("vue").DefineComponent<{
+    modelValue: {
+        type: PropType<ListItem[]>;
+        default: () => never[];
+    };
+    selection: {
+        type: PropType<ListItem[]>;
+        default: () => never[];
+    };
+    itemFactory: {
+        type: PropType<() => ListItem>;
+        default: () => {};
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    addButtonLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    canAdd: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canDelete: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canReorder: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    root: import("vue").Ref<HTMLElement | undefined>;
+    rootStyles: import("vue").ComputedRef<string[]>;
+    headerStyles: import("vue").ComputedRef<string[]>;
+    content: import("vue").Ref<HTMLElement | undefined>;
+    contentStyles: import("vue").ComputedRef<string[]>;
+    footerStyles: import("vue").ComputedRef<string[]>;
+    model: import("@onereach/ui-components-common/hooks").UseProxyModelValueReturn<ListItem[]>;
+    addItem: () => void;
+    deleteItem: (index: number) => void;
+    uuid: (<T extends ArrayLike<number>>(options: import("uuid").V4Options | null | undefined, buffer: T, offset?: number) => T) & ((options?: import("uuid").V4Options) => string);
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:modelValue" | "add" | "before:add" | "before:delete" | "before:reorder" | "delete" | "reorder")[], "update:modelValue" | "add" | "before:add" | "before:delete" | "before:reorder" | "delete" | "reorder", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    modelValue: {
+        type: PropType<ListItem[]>;
+        default: () => never[];
+    };
+    selection: {
+        type: PropType<ListItem[]>;
+        default: () => never[];
+    };
+    itemFactory: {
+        type: PropType<() => ListItem>;
+        default: () => {};
+    };
+    label: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    addButtonLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    canAdd: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canDelete: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    canReorder: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((...args: any[]) => any) | undefined;
+    onAdd?: ((...args: any[]) => any) | undefined;
+    "onBefore:add"?: ((...args: any[]) => any) | undefined;
+    "onBefore:delete"?: ((...args: any[]) => any) | undefined;
+    "onBefore:reorder"?: ((...args: any[]) => any) | undefined;
+    onDelete?: ((...args: any[]) => any) | undefined;
+    onReorder?: ((...args: any[]) => any) | undefined;
+}, {
+    disabled: boolean;
+    modelValue: ListItem[];
+    label: string;
+    selection: ListItem[];
+    itemFactory: () => ListItem;
+    addButtonLabel: string;
+    canAdd: boolean;
+    canDelete: boolean;
+    canReorder: boolean;
+}, {}>;
+export default _default;

package/dist/types/components/or-list-v3/index.d.ts

@@ -0,0 +1,3 @@
+export { default as OrListV3 } from './OrList.vue';
+export * from './partials';
+export * from './types';

package/dist/types/components/or-list-v3/partials/index.d.ts

@@ -0,0 +1 @@
+export { default as OrListItem } from './or-list-item/OrListItem.vue';

package/dist/types/components/or-list-v3/partials/or-list-item/OrListItem.vue.d.ts

@@ -0,0 +1,36 @@
+declare const _default: import("vue").DefineComponent<{
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selected: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    root: import("vue").Ref<HTMLElement | undefined>;
+    rootStyles: import("vue").ComputedRef<string[]>;
+    contentStyles: import("vue").ComputedRef<string[]>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selected: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    disabled: boolean;
+    selected: boolean;
+    draggable: boolean;
+}, {}>;
+export default _default;

package/dist/types/components/or-list-v3/partials/or-list-item/styles.d.ts

@@ -0,0 +1,2 @@
+export declare const ListItem: string[];
+export declare const ListItemContent: string[];

package/dist/types/components/or-list-v3/styles.d.ts

@@ -0,0 +1,4 @@
+export declare const List: string[];
+export declare const ListHeader: string[];
+export declare const ListContent: string[];
+export declare const ListFooter: string[];

package/dist/types/components/or-list-v3/types.d.ts

@@ -0,0 +1,4 @@
+export type ListItem = {
+    key?: string;
+    [property: string]: unknown;
+};

package/dist/types/components/or-loader-v3/OrLoader.vue.d.ts

@@ -0,0 +1,84 @@
+import { PropType } from 'vue';
+import { LoaderColor, LoaderSize, LoaderVariant } from './props';
+declare const _default: import("vue").DefineComponent<{
+    variant: {
+        type: PropType<`${LoaderVariant}`>;
+        default: () => LoaderVariant;
+    };
+    /**
+     * Defines a semantic color of the loading indicator.
+     * Use `'inherit'` option to set your own color from the parent (not recommended).
+     */
+    color: {
+        type: PropType<`${LoaderColor}`>;
+        default: () => LoaderColor;
+    };
+    /**
+     * Defines a diameter of the circular loader. Ignored for linear one.
+     */
+    size: {
+        type: PropType<`${LoaderSize}`>;
+        default: () => LoaderSize;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    description: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    root: import("vue").Ref<HTMLElement | undefined>;
+    rootStyles: import("vue").ComputedRef<string[]>;
+    containerStyles: import("vue").ComputedRef<string[]>;
+    titleStyles: import("vue").ComputedRef<string[]>;
+    descriptionStyles: import("vue").ComputedRef<string[]>;
+    computedSize: import("vue").ComputedRef<16 | 20 | undefined>;
+    strokeWidth: import("vue").ComputedRef<number | "100%">;
+    wrapperStyle: import("vue").ComputedRef<string>;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    variant: {
+        type: PropType<`${LoaderVariant}`>;
+        default: () => LoaderVariant;
+    };
+    /**
+     * Defines a semantic color of the loading indicator.
+     * Use `'inherit'` option to set your own color from the parent (not recommended).
+     */
+    color: {
+        type: PropType<`${LoaderColor}`>;
+        default: () => LoaderColor;
+    };
+    /**
+     * Defines a diameter of the circular loader. Ignored for linear one.
+     */
+    size: {
+        type: PropType<`${LoaderSize}`>;
+        default: () => LoaderSize;
+    };
+    title: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    description: {
+        type: StringConstructor;
+        default: undefined;
+    };
+    text: {
+        type: StringConstructor;
+        default: string;
+    };
+}>>, {
+    variant: "circular" | "linear" | "text";
+    size: "m" | "s";
+    color: "inherit" | "primary" | "danger";
+    text: string;
+    title: string;
+    description: string;
+}, {}>;
+export default _default;

package/dist/types/components/or-loader-v3/index.d.ts

@@ -0,0 +1,2 @@
+export { default as OrLoaderV3 } from './OrLoader.vue';
+export * from './props';

package/dist/types/components/or-loader-v3/props.d.ts

@@ -0,0 +1,14 @@
+export declare enum LoaderVariant {
+    Circular = "circular",
+    Linear = "linear",
+    Text = "text"
+}
+export declare enum LoaderColor {
+    Primary = "primary",
+    Danger = "danger",
+    Inherit = "inherit"
+}
+export declare enum LoaderSize {
+    M = "m",
+    S = "s"
+}

package/dist/types/components/or-loader-v3/styles.d.ts

@@ -0,0 +1,6 @@
+import { LoaderColor } from './props';
+export declare const LoaderRoot: string[];
+export declare const LoaderRootColors: Record<LoaderColor, string[]>;
+export declare const LoaderContainer: string[];
+export declare const LoaderTitle: string[];
+export declare const LoaderDescription: string[];

package/dist/types/components/or-menu-item-v3/OrMenuItem.vue.d.ts

@@ -0,0 +1,260 @@
+import { IconVariant, OrIconV3 as OrIcon } from '@onereach/ui-components.or-icon-v3';
+import { PropType } from 'vue';
+declare const _default: import("vue").DefineComponent<{
+    icon: {
+        type: PropType<string | InstanceType<typeof OrIcon>["$props"]>;
+        default: undefined;
+    };
+    closeButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selected: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tooltipText: {
+        type: StringConstructor;
+        default: string;
+    };
+}, {
+    content: import("vue").Ref<HTMLDivElement | undefined>;
+    root: import("vue").Ref<HTMLElement | undefined>;
+    tooltip: import("vue").Ref<({
+        $: import("vue").ComponentInternalInstance;
+        $data: {};
+        $props: {
+            content?: string | undefined;
+            offset?: import("..").PopoverOffset | undefined;
+            isOpen?: boolean | undefined;
+            placement?: "bottom" | "left" | "right" | "top" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end" | "top-start" | "top-end" | undefined;
+            trigger?: import("@floating-ui/dom").ReferenceElement | undefined;
+            fallbackPlacement?: "none" | "start" | "end" | undefined;
+            debounce?: number | undefined;
+            externalControl?: boolean | undefined;
+            "onUpdate:state"?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+            key?: string | number | symbol | undefined;
+            ref?: import("vue").VNodeRef | undefined;
+            ref_for?: boolean | undefined;
+            ref_key?: string | undefined;
+            onVnodeBeforeMount?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
+            onVnodeMounted?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
+            onVnodeBeforeUpdate?: (((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]) | undefined;
+            onVnodeUpdated?: (((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]) | undefined;
+            onVnodeBeforeUnmount?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
+            onVnodeUnmounted?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
+            class?: unknown;
+            style?: unknown;
+        };
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("vue").Slot<any> | undefined;
+        }>;
+        $root: import("vue").ComponentPublicInstance | null;
+        $parent: import("vue").ComponentPublicInstance | null;
+        $emit: (event: "update:state" | "open" | "close", ...args: any[]) => void;
+        $el: any;
+        $options: import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+            isOpen: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            content: {
+                type: StringConstructor;
+                default: undefined;
+            };
+            placement: {
+                type: PropType<`${import("..").PopoverPlacement}`>;
+                default: () => import("..").PopoverPlacement;
+            };
+            fallbackPlacement: {
+                type: PropType<import("@floating-ui/dom").FlipOptions["fallbackAxisSideDirection"]>;
+                default: undefined;
+            };
+            offset: {
+                type: PropType<import("..").PopoverOffset>;
+                default: number;
+            };
+            debounce: {
+                type: NumberConstructor;
+                default: number;
+            };
+            externalControl: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            trigger: {
+                type: PropType<import("@floating-ui/dom").ReferenceElement>;
+                default: undefined;
+            };
+        }>> & {
+            "onUpdate:state"?: ((...args: any[]) => any) | undefined;
+            onOpen?: ((...args: any[]) => any) | undefined;
+            onClose?: ((...args: any[]) => any) | undefined;
+        }, {
+            root: import("vue").Ref<HTMLElement | undefined>;
+            localTrigger: import("vue").ComputedRef<import("@floating-ui/dom").ReferenceElement | undefined>;
+            hasExternalControl: import("vue").ComputedRef<boolean>;
+            rootStyles: import("vue").ComputedRef<string[]>;
+            popoverStyles: import("vue").ComputedRef<string[]>;
+            bodyStyles: import("vue").ComputedRef<string[]>;
+            state: Readonly<import("vue").Ref<"open" | "closed">>;
+            open: () => void;
+            close: () => void;
+            toggle: () => void;
+        }, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:state" | "open" | "close")[], string, {
+            content: string;
+            offset: import("..").PopoverOffset;
+            isOpen: boolean;
+            placement: "bottom" | "left" | "right" | "top" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | "right-start" | "right-end" | "top-start" | "top-end";
+            trigger: import("@floating-ui/dom").ReferenceElement;
+            fallbackPlacement: "none" | "start" | "end" | undefined;
+            debounce: number;
+            externalControl: boolean;
+        }, {}, string, {}> & {
+            beforeCreate?: (() => void) | (() => void)[];
+            created?: (() => void) | (() => void)[];
+            beforeMount?: (() => void) | (() => void)[];
+            mounted?: (() => void) | (() => void)[];
+            beforeUpdate?: (() => void) | (() => void)[];
+            updated?: (() => void) | (() => void)[];
+            activated?: (() => void) | (() => void)[];
+            deactivated?: (() => void) | (() => void)[];
+            beforeDestroy?: (() => void) | (() => void)[];
+            beforeUnmount?: (() => void) | (() => void)[];
+            destroyed?: (() => void) | (() => void)[];
+            unmounted?: (() => void) | (() => void)[];
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | ((e: import("vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void) | ((err: unknown, instance: import("vue").ComponentPublicInstance | null, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (...args: [R, R]) => any : (...args: any) => any, options?: import("vue").WatchOptions): import("vue").WatchStopHandle;
+    } & Readonly<import("vue").ExtractPropTypes<{
+        isOpen: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        content: {
+            type: StringConstructor;
+            default: undefined;
+        };
+        placement: {
+            type: PropType<`${import("..").PopoverPlacement}`>;
+            default: () => import("..").PopoverPlacement;
+        };
+        fallbackPlacement: {
+            type: PropType<import("@floating-ui/dom").FlipOptions["fallbackAxisSideDirection"]>;
+            default: undefined;
+        };
+        offset: {
+            type: PropType<import("..").PopoverOffset>;
+            default: number;
+        };
+        debounce: {
+            type: NumberConstructor;
+            default: number;
+        };
+        externalControl: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        trigger: {
+            type: PropType<import("@floating-ui/dom").ReferenceElement>;
+            default: undefined;
+        };
+    }>> & {
+        "onUpdate:state"?: ((...args: any[]) => any) | undefined;
+        onOpen?: ((...args: any[]) => any) | undefined;
+        onClose?: ((...args: any[]) => any) | undefined;
+    } & import("vue").ShallowUnwrapRef<{
+        root: import("vue").Ref<HTMLElement | undefined>;
+        localTrigger: import("vue").ComputedRef<import("@floating-ui/dom").ReferenceElement | undefined>;
+        hasExternalControl: import("vue").ComputedRef<boolean>;
+        rootStyles: import("vue").ComputedRef<string[]>;
+        popoverStyles: import("vue").ComputedRef<string[]>;
+        bodyStyles: import("vue").ComputedRef<string[]>;
+        state: Readonly<import("vue").Ref<"open" | "closed">>;
+        open: () => void;
+        close: () => void;
+        toggle: () => void;
+    }> & {} & import("vue").ComponentCustomProperties & {}) | undefined>;
+    rootStyles: import("vue").ComputedRef<string[]>;
+    iconStyles: import("vue").ComputedRef<string[]>;
+    isTooltipShown: import("vue").ComputedRef<boolean>;
+    iconProps: import("vue").ComputedRef<{
+        icon: string;
+        variant: IconVariant;
+    } | {
+        variant: IconVariant;
+        icon?: undefined;
+    }>;
+    isRootVisible: import("vue").Ref<boolean>;
+    stop: () => void;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("click" | "close" | "focus" | "blur" | "mouseover" | "mouseout" | "mouseenter" | "mouseleave")[], "click" | "close" | "focus" | "blur" | "mouseover" | "mouseout" | "mouseenter" | "mouseleave", import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<import("vue").ExtractPropTypes<{
+    icon: {
+        type: PropType<string | InstanceType<typeof OrIcon>["$props"]>;
+        default: undefined;
+    };
+    closeButton: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selected: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    tooltipText: {
+        type: StringConstructor;
+        default: string;
+    };
+}>> & {
+    onClick?: ((...args: any[]) => any) | undefined;
+    onClose?: ((...args: any[]) => any) | undefined;
+    onFocus?: ((...args: any[]) => any) | undefined;
+    onBlur?: ((...args: any[]) => any) | undefined;
+    onMouseover?: ((...args: any[]) => any) | undefined;
+    onMouseout?: ((...args: any[]) => any) | undefined;
+    onMouseenter?: ((...args: any[]) => any) | undefined;
+    onMouseleave?: ((...args: any[]) => any) | undefined;
+}, {
+    disabled: boolean;
+    icon: string | {
+        variant?: "outlined" | "outlined-bold" | "filled" | "filled-bold" | "inherit" | undefined;
+        size?: "xl" | "inherit" | "l" | "m" | undefined;
+        onClick?: ((...args: any[]) => any) | undefined;
+        readonly icon: string;
+        key?: string | number | symbol | undefined;
+        ref?: import("vue").VNodeRef | undefined;
+        ref_for?: boolean | undefined;
+        ref_key?: string | undefined;
+        onVnodeBeforeMount?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
+        onVnodeMounted?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
+        onVnodeBeforeUpdate?: (((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]) | undefined;
+        onVnodeUpdated?: (((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void) | ((vnode: import("vue").VNode, oldVNode: import("vue").VNode) => void)[]) | undefined;
+        onVnodeBeforeUnmount?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
+        onVnodeUnmounted?: (((vnode: import("vue").VNode) => void) | ((vnode: import("vue").VNode) => void)[]) | undefined;
+        class?: unknown;
+        style?: unknown;
+    };
+    selected: boolean;
+    closeButton: boolean;
+    tooltipText: string;
+}, {}>;
+export default _default;

package/dist/types/components/or-menu-item-v3/index.d.ts

@@ -0,0 +1 @@
+export { default as OrMenuItemV3 } from './OrMenuItem.vue';

package/dist/types/components/or-menu-item-v3/styles.d.ts

@@ -0,0 +1,3 @@
+export declare const MenuItem: string[];
+export declare const MenuItemIcon: string[];
+export declare const MenuItemIconSelected: string[];