@adyen/bento-vue3 1.10.0 → 1.11.0

package/dist/@types/packages/vue2/src/components/dropdown/dropdown.vue.d.ts

@@ -1,4 +1,4 @@
-import { PropType } from "../../../../vue3/node_modules/vue";
+import { PropType, Ref } from "../../../../vue3/node_modules/vue";
 import { BentoDropdownEmptyStateProps, BentoDropdownEvent, BentoDropdownLazyLoadType, BentoDropdownSearchOptions, BentoDropdownSize, BentoDropdownVirtulisationOptions } from './dropdown.types';
 import { BentoListboxOptions, BentoListboxSelectedValue } from "../../types";
 declare const _default: import("../../../../vue3/node_modules/vue").DefineComponent<{
@@ -115,13 +115,13 @@ declare const _default: import("../../../../vue3/node_modules/vue").DefineCompon
     computedAriaLabel: import("../../../../vue3/node_modules/vue").ComputedRef<string>;
     additionalItemsSelected: import("../../../../vue3/node_modules/vue").ComputedRef<string | number>;
     idDefaultSize: import("../../../../vue3/node_modules/vue").ComputedRef<boolean>;
-    isDropdownOpen: import("../../../../vue3/node_modules/vue").Ref<boolean>;
+    isDropdownOpen: Ref<boolean>;
     displayValue: import("../../../../vue3/node_modules/vue").ComputedRef<string>;
     dropdownOptionsContainerId: string;
     filteredItems: import("../../../../vue3/node_modules/vue").ComputedRef<any>;
     isSearching: import("../../../../vue3/node_modules/vue").ComputedRef<boolean>;
     isReadOnly: import("../../../../vue3/node_modules/vue").ComputedRef<boolean>;
-    searchTerm: import("../../../../vue3/node_modules/vue").Ref<string>;
+    searchTerm: Ref<string>;
     labelId: string;
     descriptionId: string;
     errorId: string;
@@ -136,8 +136,2347 @@ declare const _default: import("../../../../vue3/node_modules/vue").DefineCompon
     hasSlot: (name: string) => boolean;
     inputContainerRef: any;
     inputContainerRefWrapper: any;
-    optionsContainerRef: any;
-    closeOpenedDropdown: () => void;
+    optionsContainerRef: Ref<{
+        $: import("../../../../vue3/node_modules/vue").ComponentInternalInstance;
+        $data: {};
+        $props: Partial<{
+            disabled: boolean;
+            multiple: boolean;
+            isOptionDisabled: (optionValue: import("../../types").BentoListboxOptionItem) => boolean;
+            selectedValue: BentoListboxSelectedValue;
+            staticCategories: boolean;
+            ariaLabel: string;
+            searching: any;
+            loading: boolean;
+            emptyState: BentoDropdownEmptyStateProps;
+            hasMoreItems: boolean;
+            lazyLoadType: "button" | "none" | "automatic" | BentoDropdownLazyLoadType;
+            virtualScroll: BentoDropdownVirtulisationOptions;
+            inputSize: "DropdownInputDefault" | "DropdownInputSmall" | BentoDropdownSize;
+        }> & Omit<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            emptyState: {
+                type: PropType<BentoDropdownEmptyStateProps>;
+                default: any;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hasMoreItems: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+                required: true;
+            };
+            isOptionDisabled: {
+                type: PropType<(optionValue: import("../../types").BentoListboxOptionItem) => boolean>;
+                default: any;
+            };
+            inputSize: {
+                type: PropType<"DropdownInputDefault" | "DropdownInputSmall" | BentoDropdownSize>;
+                default: BentoDropdownSize;
+                validator: (value: BentoDropdownSize) => boolean;
+            };
+            items: {
+                type: PropType<BentoListboxOptions>;
+                required: true;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            lazyLoadType: {
+                type: PropType<"button" | "none" | "automatic" | BentoDropdownLazyLoadType>;
+                default: BentoDropdownLazyLoadType;
+                validator: (value: BentoDropdownLazyLoadType) => boolean;
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            staticCategories: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            open: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            selectedValue: {
+                type: PropType<BentoListboxSelectedValue>;
+                default: any;
+            };
+            searching: any;
+            targetElement: {
+                type: any;
+                required: true;
+            };
+            virtualScroll: {
+                type: PropType<BentoDropdownVirtulisationOptions>;
+                default: boolean;
+            };
+        }>> & {
+            onSelect?: (...args: any[]) => any;
+            "onEnter-pressed"?: (...args: any[]) => any;
+            "onSpace-pressed"?: (...args: any[]) => any;
+            "onTab-pressed"?: (...args: any[]) => any;
+            "onShow-more"?: (...args: any[]) => any;
+            "onEscape-pressed"?: (...args: any[]) => any;
+            "onClose-dropdown"?: (...args: any[]) => any;
+        } & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "disabled" | "multiple" | "isOptionDisabled" | "selectedValue" | "staticCategories" | "ariaLabel" | "searching" | "loading" | "emptyState" | "hasMoreItems" | "lazyLoadType" | "virtualScroll" | "inputSize">;
+        $attrs: {
+            [x: string]: unknown;
+        };
+        $refs: {
+            [x: string]: unknown;
+        };
+        $slots: Readonly<{
+            [name: string]: import("../../../../vue3/node_modules/vue").Slot;
+        }>;
+        $root: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $parent: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+        $emit: (event: BentoDropdownEvent.SELECT | BentoDropdownEvent.SHOW_MORE | BentoDropdownEvent.ESCAPE | BentoDropdownEvent.ENTER | BentoDropdownEvent.SPACE | BentoDropdownEvent.TAB | BentoDropdownEvent.CLOSE_DROPDOWN, ...args: any[]) => void;
+        $el: any;
+        $options: import("../../../../vue3/node_modules/vue").ComponentOptionsBase<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            emptyState: {
+                type: PropType<BentoDropdownEmptyStateProps>;
+                default: any;
+            };
+            disabled: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            hasMoreItems: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+                required: true;
+            };
+            isOptionDisabled: {
+                type: PropType<(optionValue: import("../../types").BentoListboxOptionItem) => boolean>;
+                default: any;
+            };
+            inputSize: {
+                type: PropType<"DropdownInputDefault" | "DropdownInputSmall" | BentoDropdownSize>;
+                default: BentoDropdownSize;
+                validator: (value: BentoDropdownSize) => boolean;
+            };
+            items: {
+                type: PropType<BentoListboxOptions>;
+                required: true;
+            };
+            loading: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            lazyLoadType: {
+                type: PropType<"button" | "none" | "automatic" | BentoDropdownLazyLoadType>;
+                default: BentoDropdownLazyLoadType;
+                validator: (value: BentoDropdownLazyLoadType) => boolean;
+            };
+            multiple: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            staticCategories: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            open: {
+                type: BooleanConstructor;
+                required: true;
+            };
+            selectedValue: {
+                type: PropType<BentoListboxSelectedValue>;
+                default: any;
+            };
+            searching: any;
+            targetElement: {
+                type: any;
+                required: true;
+            };
+            virtualScroll: {
+                type: PropType<BentoDropdownVirtulisationOptions>;
+                default: boolean;
+            };
+        }>> & {
+            onSelect?: (...args: any[]) => any;
+            "onEnter-pressed"?: (...args: any[]) => any;
+            "onSpace-pressed"?: (...args: any[]) => any;
+            "onTab-pressed"?: (...args: any[]) => any;
+            "onShow-more"?: (...args: any[]) => any;
+            "onEscape-pressed"?: (...args: any[]) => any;
+            "onClose-dropdown"?: (...args: any[]) => any;
+        }, {
+            isDropdownOpen: import("../../../../vue3/node_modules/vue").ComputedRef<boolean>;
+            conditionalClasses: import("../../../../vue3/node_modules/vue").ComputedRef<{
+                'b-dropdown-options-container--single': boolean;
+            }>;
+            conditionalListboxClasses: import("../../../../vue3/node_modules/vue").ComputedRef<{
+                'b-dropdown-options-container__listbox--small': boolean;
+                'b-dropdown-options-container__listbox--single': boolean;
+            }>;
+            noResultsMessage: import("../../../../vue3/node_modules/vue").ComputedRef<string>;
+            slots: Readonly<{
+                [name: string]: import("../../../../vue3/node_modules/vue").Slot;
+            }>;
+            actions: import("../../../../vue3/node_modules/vue").ComputedRef<({
+                title: string;
+                event: () => void;
+                disabled: boolean;
+            } | {
+                title: string;
+                event: () => void;
+                disabled?: undefined;
+            })[]>;
+            internalSelectedValue: Ref<import("../../types").BentoListboxValue | import("../../types").BentoListboxValue[]>;
+            popperContainerOrPopoverComponent: import("../../../../vue3/node_modules/vue").ComputedRef<({
+                new (...args: any[]): {
+                    $: import("../../../../vue3/node_modules/vue").ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        id: string;
+                        position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                        offset: number[];
+                        ariaRole: import("../popper-container").PopperContainerAriaRole;
+                        arrow: any;
+                        disabledFocusTrap: boolean;
+                        fallbackPosition: import("../popper-container").FallbackPositionProp;
+                        fixedPositioning: boolean;
+                        isHidden: boolean;
+                        matchWidth: boolean;
+                        middleware: {
+                            name: string;
+                            options?: any;
+                            fn: (state: {
+                                x: number;
+                                y: number;
+                                initialPlacement: import("@floating-ui/utils").Placement;
+                                placement: import("@floating-ui/utils").Placement;
+                                strategy: import("@floating-ui/utils").Strategy;
+                                middlewareData: import("@floating-ui/core").MiddlewareData;
+                                rects: import("@floating-ui/utils").ElementRects;
+                                platform: import("@floating-ui/core").Platform;
+                                elements: import("@floating-ui/dom").Elements;
+                            }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                        }[];
+                    }> & Omit<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                        ariaRole: {
+                            type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                            default: any;
+                            validator: (value: unknown) => boolean;
+                        };
+                        arrow: {
+                            type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                            default: any;
+                        };
+                        disabledFocusTrap: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        fallbackPosition: {
+                            type: PropType<import("../popper-container").FallbackPositionProp>;
+                            default: any;
+                        };
+                        fixedPositioning: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: any;
+                        };
+                        isHidden: {
+                            type: BooleanConstructor;
+                            default: any;
+                        };
+                        matchWidth: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        middleware: {
+                            type: PropType<{
+                                name: string;
+                                options?: any;
+                                fn: (state: {
+                                    x: number;
+                                    y: number;
+                                    initialPlacement: import("@floating-ui/utils").Placement;
+                                    placement: import("@floating-ui/utils").Placement;
+                                    strategy: import("@floating-ui/utils").Strategy;
+                                    middlewareData: import("@floating-ui/core").MiddlewareData;
+                                    rects: import("@floating-ui/utils").ElementRects;
+                                    platform: import("@floating-ui/core").Platform;
+                                    elements: import("@floating-ui/dom").Elements;
+                                }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                            }[]>;
+                            default: any;
+                        };
+                        offset: {
+                            type: PropType<number[]>;
+                            default: () => number[];
+                            validator: (value: number[]) => boolean;
+                        };
+                        position: {
+                            type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                            default: import("../popper-container").PopperContainerPositionExtended;
+                            validator: (value: unknown) => boolean;
+                        };
+                        targetElement: {
+                            type: PropType<import("../../types").VueNodeElement>;
+                            required: true;
+                        };
+                    }>> & {
+                        onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+                    } & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "id" | "position" | "offset" | "ariaRole" | "arrow" | "disabledFocusTrap" | "fallbackPosition" | "fixedPositioning" | "isHidden" | "matchWidth" | "middleware">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import("../../../../vue3/node_modules/vue").Slot;
+                    }>;
+                    $root: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+                    $parent: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+                    $emit: (event: "placement", value: import("@floating-ui/utils").Placement) => void;
+                    $el: any;
+                    $options: import("../../../../vue3/node_modules/vue").ComponentOptionsBase<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                        ariaRole: {
+                            type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                            default: any;
+                            validator: (value: unknown) => boolean;
+                        };
+                        arrow: {
+                            type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                            default: any;
+                        };
+                        disabledFocusTrap: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        fallbackPosition: {
+                            type: PropType<import("../popper-container").FallbackPositionProp>;
+                            default: any;
+                        };
+                        fixedPositioning: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        id: {
+                            type: StringConstructor;
+                            default: any;
+                        };
+                        isHidden: {
+                            type: BooleanConstructor;
+                            default: any;
+                        };
+                        matchWidth: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        middleware: {
+                            type: PropType<{
+                                name: string;
+                                options?: any;
+                                fn: (state: {
+                                    x: number;
+                                    y: number;
+                                    initialPlacement: import("@floating-ui/utils").Placement;
+                                    placement: import("@floating-ui/utils").Placement;
+                                    strategy: import("@floating-ui/utils").Strategy;
+                                    middlewareData: import("@floating-ui/core").MiddlewareData;
+                                    rects: import("@floating-ui/utils").ElementRects;
+                                    platform: import("@floating-ui/core").Platform;
+                                    elements: import("@floating-ui/dom").Elements;
+                                }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                            }[]>;
+                            default: any;
+                        };
+                        offset: {
+                            type: PropType<number[]>;
+                            default: () => number[];
+                            validator: (value: number[]) => boolean;
+                        };
+                        position: {
+                            type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                            default: import("../popper-container").PopperContainerPositionExtended;
+                            validator: (value: unknown) => boolean;
+                        };
+                        targetElement: {
+                            type: PropType<import("../../types").VueNodeElement>;
+                            required: true;
+                        };
+                    }>> & {
+                        onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+                    }, {}, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, {
+                        placement: (value: import("@floating-ui/utils").Placement) => void;
+                    }, string, {
+                        id: string;
+                        position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                        offset: number[];
+                        ariaRole: import("../popper-container").PopperContainerAriaRole;
+                        arrow: any;
+                        disabledFocusTrap: boolean;
+                        fallbackPosition: import("../popper-container").FallbackPositionProp;
+                        fixedPositioning: boolean;
+                        isHidden: boolean;
+                        matchWidth: boolean;
+                        middleware: {
+                            name: string;
+                            options?: any;
+                            fn: (state: {
+                                x: number;
+                                y: number;
+                                initialPlacement: import("@floating-ui/utils").Placement;
+                                placement: import("@floating-ui/utils").Placement;
+                                strategy: import("@floating-ui/utils").Strategy;
+                                middlewareData: import("@floating-ui/core").MiddlewareData;
+                                rects: import("@floating-ui/utils").ElementRects;
+                                platform: import("@floating-ui/core").Platform;
+                                elements: import("@floating-ui/dom").Elements;
+                            }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                        }[];
+                    }, {}, 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("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof import("../../../../vue3/node_modules/vue").nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("../../../../vue3/node_modules/vue").WatchOptions<boolean>): import("../../../../vue3/node_modules/vue").WatchStopHandle;
+                } & Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                    ariaRole: {
+                        type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                        default: any;
+                        validator: (value: unknown) => boolean;
+                    };
+                    arrow: {
+                        type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                        default: any;
+                    };
+                    disabledFocusTrap: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    fallbackPosition: {
+                        type: PropType<import("../popper-container").FallbackPositionProp>;
+                        default: any;
+                    };
+                    fixedPositioning: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: any;
+                    };
+                    isHidden: {
+                        type: BooleanConstructor;
+                        default: any;
+                    };
+                    matchWidth: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    middleware: {
+                        type: PropType<{
+                            name: string;
+                            options?: any;
+                            fn: (state: {
+                                x: number;
+                                y: number;
+                                initialPlacement: import("@floating-ui/utils").Placement;
+                                placement: import("@floating-ui/utils").Placement;
+                                strategy: import("@floating-ui/utils").Strategy;
+                                middlewareData: import("@floating-ui/core").MiddlewareData;
+                                rects: import("@floating-ui/utils").ElementRects;
+                                platform: import("@floating-ui/core").Platform;
+                                elements: import("@floating-ui/dom").Elements;
+                            }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                        }[]>;
+                        default: any;
+                    };
+                    offset: {
+                        type: PropType<number[]>;
+                        default: () => number[];
+                        validator: (value: number[]) => boolean;
+                    };
+                    position: {
+                        type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                        default: import("../popper-container").PopperContainerPositionExtended;
+                        validator: (value: unknown) => boolean;
+                    };
+                    targetElement: {
+                        type: PropType<import("../../types").VueNodeElement>;
+                        required: true;
+                    };
+                }>> & {
+                    onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+                } & import("../../../../vue3/node_modules/vue").ShallowUnwrapRef<{}> & {} & import("../../../../vue3/node_modules/vue").ComponentCustomProperties & {};
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("../../../../vue3/node_modules/vue").ComponentOptionsBase<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                ariaRole: {
+                    type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                    default: any;
+                    validator: (value: unknown) => boolean;
+                };
+                arrow: {
+                    type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                    default: any;
+                };
+                disabledFocusTrap: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fallbackPosition: {
+                    type: PropType<import("../popper-container").FallbackPositionProp>;
+                    default: any;
+                };
+                fixedPositioning: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                isHidden: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                matchWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                middleware: {
+                    type: PropType<{
+                        name: string;
+                        options?: any;
+                        fn: (state: {
+                            x: number;
+                            y: number;
+                            initialPlacement: import("@floating-ui/utils").Placement;
+                            placement: import("@floating-ui/utils").Placement;
+                            strategy: import("@floating-ui/utils").Strategy;
+                            middlewareData: import("@floating-ui/core").MiddlewareData;
+                            rects: import("@floating-ui/utils").ElementRects;
+                            platform: import("@floating-ui/core").Platform;
+                            elements: import("@floating-ui/dom").Elements;
+                        }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                    }[]>;
+                    default: any;
+                };
+                offset: {
+                    type: PropType<number[]>;
+                    default: () => number[];
+                    validator: (value: number[]) => boolean;
+                };
+                position: {
+                    type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                    default: import("../popper-container").PopperContainerPositionExtended;
+                    validator: (value: unknown) => boolean;
+                };
+                targetElement: {
+                    type: PropType<import("../../types").VueNodeElement>;
+                    required: true;
+                };
+            }>> & {
+                onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+            }, {}, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, {
+                placement: (value: import("@floating-ui/utils").Placement) => void;
+            }, string, {
+                id: string;
+                position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                offset: number[];
+                ariaRole: import("../popper-container").PopperContainerAriaRole;
+                arrow: any;
+                disabledFocusTrap: boolean;
+                fallbackPosition: import("../popper-container").FallbackPositionProp;
+                fixedPositioning: boolean;
+                isHidden: boolean;
+                matchWidth: boolean;
+                middleware: {
+                    name: string;
+                    options?: any;
+                    fn: (state: {
+                        x: number;
+                        y: number;
+                        initialPlacement: import("@floating-ui/utils").Placement;
+                        placement: import("@floating-ui/utils").Placement;
+                        strategy: import("@floating-ui/utils").Strategy;
+                        middlewareData: import("@floating-ui/core").MiddlewareData;
+                        rects: import("@floating-ui/utils").ElementRects;
+                        platform: import("@floating-ui/core").Platform;
+                        elements: import("@floating-ui/dom").Elements;
+                    }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                }[];
+            }, {}, string> & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    default: (_: {}) => any;
+                };
+            })) | ({
+                new (...args: any[]): {
+                    $: import("../../../../vue3/node_modules/vue").ComponentInternalInstance;
+                    $data: {};
+                    $props: Partial<{
+                        small: boolean;
+                        title: string;
+                        large: boolean;
+                        position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                        open: boolean;
+                        modifiers: unknown[];
+                        fallbackPosition: import("@floating-ui/utils").Placement[];
+                        fixedPositioning: boolean;
+                        ariaLabel: string;
+                        actions: import("../button").BentoButtonActionsList;
+                        actionsLayout: "space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start";
+                        divider: boolean;
+                        disableFocusTrap: boolean;
+                        dismissible: boolean;
+                        fitContent: boolean;
+                        withoutSpace: boolean;
+                    }> & Omit<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                        actions: {
+                            type: PropType<import("../button").BentoButtonActionsList>;
+                            default: any;
+                        };
+                        actionsLayout: {
+                            type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                            default: import("../button").BentoButtonActionsLayoutBasic;
+                            validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+                        };
+                        ariaLabel: {
+                            type: StringConstructor;
+                            default: any;
+                        };
+                        divider: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disableFocusTrap: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        dismissible: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        fallbackPosition: {
+                            type: PropType<import("@floating-ui/utils").Placement[]>;
+                            default: () => string[];
+                        };
+                        fitContent: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        fixedPositioning: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        open: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        large: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        modifiers: {
+                            type: ArrayConstructor;
+                            default: any;
+                        };
+                        position: {
+                            type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                            default: import("../popper-container").PopperContainerPositionExtended;
+                            validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+                        };
+                        small: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        title: {
+                            type: StringConstructor;
+                            default: any;
+                        };
+                        targetElement: {
+                            type: any;
+                            required: true;
+                        };
+                        withoutSpace: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & {
+                        onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+                        onDismiss?: () => any;
+                    } & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "small" | "title" | "large" | "position" | "open" | "modifiers" | "fallbackPosition" | "fixedPositioning" | "ariaLabel" | "actions" | "actionsLayout" | "divider" | "disableFocusTrap" | "dismissible" | "fitContent" | "withoutSpace">;
+                    $attrs: {
+                        [x: string]: unknown;
+                    };
+                    $refs: {
+                        [x: string]: unknown;
+                    };
+                    $slots: Readonly<{
+                        [name: string]: import("../../../../vue3/node_modules/vue").Slot;
+                    }>;
+                    $root: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+                    $parent: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+                    $emit: ((event: "placement", placement: import("@floating-ui/utils").Placement) => void) & ((event: "dismiss") => void);
+                    $el: any;
+                    $options: import("../../../../vue3/node_modules/vue").ComponentOptionsBase<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                        actions: {
+                            type: PropType<import("../button").BentoButtonActionsList>;
+                            default: any;
+                        };
+                        actionsLayout: {
+                            type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                            default: import("../button").BentoButtonActionsLayoutBasic;
+                            validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+                        };
+                        ariaLabel: {
+                            type: StringConstructor;
+                            default: any;
+                        };
+                        divider: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        disableFocusTrap: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        dismissible: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        fallbackPosition: {
+                            type: PropType<import("@floating-ui/utils").Placement[]>;
+                            default: () => string[];
+                        };
+                        fitContent: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        fixedPositioning: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        open: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        large: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        modifiers: {
+                            type: ArrayConstructor;
+                            default: any;
+                        };
+                        position: {
+                            type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                            default: import("../popper-container").PopperContainerPositionExtended;
+                            validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+                        };
+                        small: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                        title: {
+                            type: StringConstructor;
+                            default: any;
+                        };
+                        targetElement: {
+                            type: any;
+                            required: true;
+                        };
+                        withoutSpace: {
+                            type: BooleanConstructor;
+                            default: boolean;
+                        };
+                    }>> & {
+                        onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+                        onDismiss?: () => any;
+                    }, {}, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, {
+                        dismiss: () => void;
+                    } & {
+                        placement: (placement: import("@floating-ui/utils").Placement) => void;
+                    }, string, {
+                        small: boolean;
+                        title: string;
+                        large: boolean;
+                        position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                        open: boolean;
+                        modifiers: unknown[];
+                        fallbackPosition: import("@floating-ui/utils").Placement[];
+                        fixedPositioning: boolean;
+                        ariaLabel: string;
+                        actions: import("../button").BentoButtonActionsList;
+                        actionsLayout: "space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start";
+                        divider: boolean;
+                        disableFocusTrap: boolean;
+                        dismissible: boolean;
+                        fitContent: boolean;
+                        withoutSpace: 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("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+                        renderTriggered?: ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+                        errorCaptured?: ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+                    };
+                    $forceUpdate: () => void;
+                    $nextTick: typeof import("../../../../vue3/node_modules/vue").nextTick;
+                    $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("../../../../vue3/node_modules/vue").WatchOptions<boolean>): import("../../../../vue3/node_modules/vue").WatchStopHandle;
+                } & Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                    actions: {
+                        type: PropType<import("../button").BentoButtonActionsList>;
+                        default: any;
+                    };
+                    actionsLayout: {
+                        type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                        default: import("../button").BentoButtonActionsLayoutBasic;
+                        validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+                    };
+                    ariaLabel: {
+                        type: StringConstructor;
+                        default: any;
+                    };
+                    divider: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disableFocusTrap: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    dismissible: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    fallbackPosition: {
+                        type: PropType<import("@floating-ui/utils").Placement[]>;
+                        default: () => string[];
+                    };
+                    fitContent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    fixedPositioning: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    open: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    large: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    modifiers: {
+                        type: ArrayConstructor;
+                        default: any;
+                    };
+                    position: {
+                        type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                        default: import("../popper-container").PopperContainerPositionExtended;
+                        validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+                    };
+                    small: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    title: {
+                        type: StringConstructor;
+                        default: any;
+                    };
+                    targetElement: {
+                        type: any;
+                        required: true;
+                    };
+                    withoutSpace: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+                    onDismiss?: () => any;
+                } & import("../../../../vue3/node_modules/vue").ShallowUnwrapRef<{}> & {} & import("../../../../vue3/node_modules/vue").ComponentCustomProperties & {};
+                __isFragment?: never;
+                __isTeleport?: never;
+                __isSuspense?: never;
+            } & import("../../../../vue3/node_modules/vue").ComponentOptionsBase<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                actions: {
+                    type: PropType<import("../button").BentoButtonActionsList>;
+                    default: any;
+                };
+                actionsLayout: {
+                    type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                    default: import("../button").BentoButtonActionsLayoutBasic;
+                    validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+                };
+                ariaLabel: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                divider: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disableFocusTrap: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                dismissible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fallbackPosition: {
+                    type: PropType<import("@floating-ui/utils").Placement[]>;
+                    default: () => string[];
+                };
+                fitContent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fixedPositioning: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                open: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                large: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                modifiers: {
+                    type: ArrayConstructor;
+                    default: any;
+                };
+                position: {
+                    type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                    default: import("../popper-container").PopperContainerPositionExtended;
+                    validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+                };
+                small: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                title: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                targetElement: {
+                    type: any;
+                    required: true;
+                };
+                withoutSpace: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+                onDismiss?: () => any;
+            }, {}, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, {
+                dismiss: () => void;
+            } & {
+                placement: (placement: import("@floating-ui/utils").Placement) => void;
+            }, string, {
+                small: boolean;
+                title: string;
+                large: boolean;
+                position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                open: boolean;
+                modifiers: unknown[];
+                fallbackPosition: import("@floating-ui/utils").Placement[];
+                fixedPositioning: boolean;
+                ariaLabel: string;
+                actions: import("../button").BentoButtonActionsList;
+                actionsLayout: "space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start";
+                divider: boolean;
+                disableFocusTrap: boolean;
+                dismissible: boolean;
+                fitContent: boolean;
+                withoutSpace: boolean;
+            }, {}, string> & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps & (new () => {
+                $slots: {
+                    image: (_: {}) => any;
+                    headerIcon: (_: {}) => any;
+                    default: (_: {}) => any;
+                };
+            }))>;
+            popperContainerOrPopoverProps: import("../../../../vue3/node_modules/vue").ComputedRef<(Partial<{
+                id: string;
+                position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                offset: number[];
+                ariaRole: import("../popper-container").PopperContainerAriaRole;
+                arrow: any;
+                disabledFocusTrap: boolean;
+                fallbackPosition: import("../popper-container").FallbackPositionProp;
+                fixedPositioning: boolean;
+                isHidden: boolean;
+                matchWidth: boolean;
+                middleware: {
+                    name: string;
+                    options?: any;
+                    fn: (state: {
+                        x: number;
+                        y: number;
+                        initialPlacement: import("@floating-ui/utils").Placement;
+                        placement: import("@floating-ui/utils").Placement;
+                        strategy: import("@floating-ui/utils").Strategy;
+                        middlewareData: import("@floating-ui/core").MiddlewareData;
+                        rects: import("@floating-ui/utils").ElementRects;
+                        platform: import("@floating-ui/core").Platform;
+                        elements: import("@floating-ui/dom").Elements;
+                    }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                }[];
+            }> & Omit<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                ariaRole: {
+                    type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                    default: any;
+                    validator: (value: unknown) => boolean;
+                };
+                arrow: {
+                    type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                    default: any;
+                };
+                disabledFocusTrap: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fallbackPosition: {
+                    type: PropType<import("../popper-container").FallbackPositionProp>;
+                    default: any;
+                };
+                fixedPositioning: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                isHidden: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                matchWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                middleware: {
+                    type: PropType<{
+                        name: string;
+                        options?: any;
+                        fn: (state: {
+                            x: number;
+                            y: number;
+                            initialPlacement: import("@floating-ui/utils").Placement;
+                            placement: import("@floating-ui/utils").Placement;
+                            strategy: import("@floating-ui/utils").Strategy;
+                            middlewareData: import("@floating-ui/core").MiddlewareData;
+                            rects: import("@floating-ui/utils").ElementRects;
+                            platform: import("@floating-ui/core").Platform;
+                            elements: import("@floating-ui/dom").Elements;
+                        }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                    }[]>;
+                    default: any;
+                };
+                offset: {
+                    type: PropType<number[]>;
+                    default: () => number[];
+                    validator: (value: number[]) => boolean;
+                };
+                position: {
+                    type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                    default: import("../popper-container").PopperContainerPositionExtended;
+                    validator: (value: unknown) => boolean;
+                };
+                targetElement: {
+                    type: PropType<import("../../types").VueNodeElement>;
+                    required: true;
+                };
+            }>> & {
+                onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+            } & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "id" | "position" | "offset" | "ariaRole" | "arrow" | "disabledFocusTrap" | "fallbackPosition" | "fixedPositioning" | "isHidden" | "matchWidth" | "middleware">) | (Partial<{
+                small: boolean;
+                title: string;
+                large: boolean;
+                position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                open: boolean;
+                modifiers: unknown[];
+                fallbackPosition: import("@floating-ui/utils").Placement[];
+                fixedPositioning: boolean;
+                ariaLabel: string;
+                actions: import("../button").BentoButtonActionsList;
+                actionsLayout: "space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start";
+                divider: boolean;
+                disableFocusTrap: boolean;
+                dismissible: boolean;
+                fitContent: boolean;
+                withoutSpace: boolean;
+            }> & Omit<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                actions: {
+                    type: PropType<import("../button").BentoButtonActionsList>;
+                    default: any;
+                };
+                actionsLayout: {
+                    type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                    default: import("../button").BentoButtonActionsLayoutBasic;
+                    validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+                };
+                ariaLabel: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                divider: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disableFocusTrap: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                dismissible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fallbackPosition: {
+                    type: PropType<import("@floating-ui/utils").Placement[]>;
+                    default: () => string[];
+                };
+                fitContent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fixedPositioning: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                open: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                large: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                modifiers: {
+                    type: ArrayConstructor;
+                    default: any;
+                };
+                position: {
+                    type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                    default: import("../popper-container").PopperContainerPositionExtended;
+                    validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+                };
+                small: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                title: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                targetElement: {
+                    type: any;
+                    required: true;
+                };
+                withoutSpace: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+                onDismiss?: () => any;
+            } & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "small" | "title" | "large" | "position" | "open" | "modifiers" | "fallbackPosition" | "fixedPositioning" | "ariaLabel" | "actions" | "actionsLayout" | "divider" | "disableFocusTrap" | "dismissible" | "fitContent" | "withoutSpace">)>;
+            dropdownOptionsListboxRef: any;
+            onEscapeKey: () => void;
+            onOutsideDropdownClick: () => void;
+            listeners: {
+                select: (newSelectedValue: BentoListboxSelectedValue) => void;
+                "show-more": () => void;
+                "tab-pressed": (newSelectedValue: BentoListboxSelectedValue) => void;
+                "space-pressed": (newSelectedValue: BentoListboxSelectedValue) => void;
+                "enter-pressed": (newSelectedValue: BentoListboxSelectedValue) => void;
+            };
+        }, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, (BentoDropdownEvent.SELECT | BentoDropdownEvent.SHOW_MORE | BentoDropdownEvent.ESCAPE | BentoDropdownEvent.ENTER | BentoDropdownEvent.SPACE | BentoDropdownEvent.TAB | BentoDropdownEvent.CLOSE_DROPDOWN)[], string, {
+            disabled: boolean;
+            multiple: boolean;
+            isOptionDisabled: (optionValue: import("../../types").BentoListboxOptionItem) => boolean;
+            selectedValue: BentoListboxSelectedValue;
+            staticCategories: boolean;
+            ariaLabel: string;
+            searching: any;
+            loading: boolean;
+            emptyState: BentoDropdownEmptyStateProps;
+            hasMoreItems: boolean;
+            lazyLoadType: "button" | "none" | "automatic" | BentoDropdownLazyLoadType;
+            virtualScroll: BentoDropdownVirtulisationOptions;
+            inputSize: "DropdownInputDefault" | "DropdownInputSmall" | BentoDropdownSize;
+        }, {}, 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("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+            renderTriggered?: ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+            errorCaptured?: ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+        };
+        $forceUpdate: () => void;
+        $nextTick: typeof import("../../../../vue3/node_modules/vue").nextTick;
+        $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("../../../../vue3/node_modules/vue").WatchOptions<boolean>): import("../../../../vue3/node_modules/vue").WatchStopHandle;
+    } & Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+        ariaLabel: {
+            type: StringConstructor;
+            default: any;
+        };
+        emptyState: {
+            type: PropType<BentoDropdownEmptyStateProps>;
+            default: any;
+        };
+        disabled: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        hasMoreItems: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        id: {
+            type: StringConstructor;
+            required: true;
+        };
+        isOptionDisabled: {
+            type: PropType<(optionValue: import("../../types").BentoListboxOptionItem) => boolean>;
+            default: any;
+        };
+        inputSize: {
+            type: PropType<"DropdownInputDefault" | "DropdownInputSmall" | BentoDropdownSize>;
+            default: BentoDropdownSize;
+            validator: (value: BentoDropdownSize) => boolean;
+        };
+        items: {
+            type: PropType<BentoListboxOptions>;
+            required: true;
+        };
+        loading: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        lazyLoadType: {
+            type: PropType<"button" | "none" | "automatic" | BentoDropdownLazyLoadType>;
+            default: BentoDropdownLazyLoadType;
+            validator: (value: BentoDropdownLazyLoadType) => boolean;
+        };
+        multiple: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        staticCategories: {
+            type: BooleanConstructor;
+            default: boolean;
+        };
+        open: {
+            type: BooleanConstructor;
+            required: true;
+        };
+        selectedValue: {
+            type: PropType<BentoListboxSelectedValue>;
+            default: any;
+        };
+        searching: any;
+        targetElement: {
+            type: any;
+            required: true;
+        };
+        virtualScroll: {
+            type: PropType<BentoDropdownVirtulisationOptions>;
+            default: boolean;
+        };
+    }>> & {
+        onSelect?: (...args: any[]) => any;
+        "onEnter-pressed"?: (...args: any[]) => any;
+        "onSpace-pressed"?: (...args: any[]) => any;
+        "onTab-pressed"?: (...args: any[]) => any;
+        "onShow-more"?: (...args: any[]) => any;
+        "onEscape-pressed"?: (...args: any[]) => any;
+        "onClose-dropdown"?: (...args: any[]) => any;
+    } & import("../../../../vue3/node_modules/vue").ShallowUnwrapRef<{
+        isDropdownOpen: import("../../../../vue3/node_modules/vue").ComputedRef<boolean>;
+        conditionalClasses: import("../../../../vue3/node_modules/vue").ComputedRef<{
+            'b-dropdown-options-container--single': boolean;
+        }>;
+        conditionalListboxClasses: import("../../../../vue3/node_modules/vue").ComputedRef<{
+            'b-dropdown-options-container__listbox--small': boolean;
+            'b-dropdown-options-container__listbox--single': boolean;
+        }>;
+        noResultsMessage: import("../../../../vue3/node_modules/vue").ComputedRef<string>;
+        slots: Readonly<{
+            [name: string]: import("../../../../vue3/node_modules/vue").Slot;
+        }>;
+        actions: import("../../../../vue3/node_modules/vue").ComputedRef<({
+            title: string;
+            event: () => void;
+            disabled: boolean;
+        } | {
+            title: string;
+            event: () => void;
+            disabled?: undefined;
+        })[]>;
+        internalSelectedValue: Ref<import("../../types").BentoListboxValue | import("../../types").BentoListboxValue[]>;
+        popperContainerOrPopoverComponent: import("../../../../vue3/node_modules/vue").ComputedRef<({
+            new (...args: any[]): {
+                $: import("../../../../vue3/node_modules/vue").ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    id: string;
+                    position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                    offset: number[];
+                    ariaRole: import("../popper-container").PopperContainerAriaRole;
+                    arrow: any;
+                    disabledFocusTrap: boolean;
+                    fallbackPosition: import("../popper-container").FallbackPositionProp;
+                    fixedPositioning: boolean;
+                    isHidden: boolean;
+                    matchWidth: boolean;
+                    middleware: {
+                        name: string;
+                        options?: any;
+                        fn: (state: {
+                            x: number;
+                            y: number;
+                            initialPlacement: import("@floating-ui/utils").Placement;
+                            placement: import("@floating-ui/utils").Placement;
+                            strategy: import("@floating-ui/utils").Strategy;
+                            middlewareData: import("@floating-ui/core").MiddlewareData;
+                            rects: import("@floating-ui/utils").ElementRects;
+                            platform: import("@floating-ui/core").Platform;
+                            elements: import("@floating-ui/dom").Elements;
+                        }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                    }[];
+                }> & Omit<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                    ariaRole: {
+                        type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                        default: any;
+                        validator: (value: unknown) => boolean;
+                    };
+                    arrow: {
+                        type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                        default: any;
+                    };
+                    disabledFocusTrap: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    fallbackPosition: {
+                        type: PropType<import("../popper-container").FallbackPositionProp>;
+                        default: any;
+                    };
+                    fixedPositioning: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: any;
+                    };
+                    isHidden: {
+                        type: BooleanConstructor;
+                        default: any;
+                    };
+                    matchWidth: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    middleware: {
+                        type: PropType<{
+                            name: string;
+                            options?: any;
+                            fn: (state: {
+                                x: number;
+                                y: number;
+                                initialPlacement: import("@floating-ui/utils").Placement;
+                                placement: import("@floating-ui/utils").Placement;
+                                strategy: import("@floating-ui/utils").Strategy;
+                                middlewareData: import("@floating-ui/core").MiddlewareData;
+                                rects: import("@floating-ui/utils").ElementRects;
+                                platform: import("@floating-ui/core").Platform;
+                                elements: import("@floating-ui/dom").Elements;
+                            }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                        }[]>;
+                        default: any;
+                    };
+                    offset: {
+                        type: PropType<number[]>;
+                        default: () => number[];
+                        validator: (value: number[]) => boolean;
+                    };
+                    position: {
+                        type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                        default: import("../popper-container").PopperContainerPositionExtended;
+                        validator: (value: unknown) => boolean;
+                    };
+                    targetElement: {
+                        type: PropType<import("../../types").VueNodeElement>;
+                        required: true;
+                    };
+                }>> & {
+                    onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+                } & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "id" | "position" | "offset" | "ariaRole" | "arrow" | "disabledFocusTrap" | "fallbackPosition" | "fixedPositioning" | "isHidden" | "matchWidth" | "middleware">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import("../../../../vue3/node_modules/vue").Slot;
+                }>;
+                $root: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+                $parent: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+                $emit: (event: "placement", value: import("@floating-ui/utils").Placement) => void;
+                $el: any;
+                $options: import("../../../../vue3/node_modules/vue").ComponentOptionsBase<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                    ariaRole: {
+                        type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                        default: any;
+                        validator: (value: unknown) => boolean;
+                    };
+                    arrow: {
+                        type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                        default: any;
+                    };
+                    disabledFocusTrap: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    fallbackPosition: {
+                        type: PropType<import("../popper-container").FallbackPositionProp>;
+                        default: any;
+                    };
+                    fixedPositioning: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    id: {
+                        type: StringConstructor;
+                        default: any;
+                    };
+                    isHidden: {
+                        type: BooleanConstructor;
+                        default: any;
+                    };
+                    matchWidth: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    middleware: {
+                        type: PropType<{
+                            name: string;
+                            options?: any;
+                            fn: (state: {
+                                x: number;
+                                y: number;
+                                initialPlacement: import("@floating-ui/utils").Placement;
+                                placement: import("@floating-ui/utils").Placement;
+                                strategy: import("@floating-ui/utils").Strategy;
+                                middlewareData: import("@floating-ui/core").MiddlewareData;
+                                rects: import("@floating-ui/utils").ElementRects;
+                                platform: import("@floating-ui/core").Platform;
+                                elements: import("@floating-ui/dom").Elements;
+                            }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                        }[]>;
+                        default: any;
+                    };
+                    offset: {
+                        type: PropType<number[]>;
+                        default: () => number[];
+                        validator: (value: number[]) => boolean;
+                    };
+                    position: {
+                        type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                        default: import("../popper-container").PopperContainerPositionExtended;
+                        validator: (value: unknown) => boolean;
+                    };
+                    targetElement: {
+                        type: PropType<import("../../types").VueNodeElement>;
+                        required: true;
+                    };
+                }>> & {
+                    onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+                }, {}, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, {
+                    placement: (value: import("@floating-ui/utils").Placement) => void;
+                }, string, {
+                    id: string;
+                    position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                    offset: number[];
+                    ariaRole: import("../popper-container").PopperContainerAriaRole;
+                    arrow: any;
+                    disabledFocusTrap: boolean;
+                    fallbackPosition: import("../popper-container").FallbackPositionProp;
+                    fixedPositioning: boolean;
+                    isHidden: boolean;
+                    matchWidth: boolean;
+                    middleware: {
+                        name: string;
+                        options?: any;
+                        fn: (state: {
+                            x: number;
+                            y: number;
+                            initialPlacement: import("@floating-ui/utils").Placement;
+                            placement: import("@floating-ui/utils").Placement;
+                            strategy: import("@floating-ui/utils").Strategy;
+                            middlewareData: import("@floating-ui/core").MiddlewareData;
+                            rects: import("@floating-ui/utils").ElementRects;
+                            platform: import("@floating-ui/core").Platform;
+                            elements: import("@floating-ui/dom").Elements;
+                        }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                    }[];
+                }, {}, 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("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import("../../../../vue3/node_modules/vue").nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("../../../../vue3/node_modules/vue").WatchOptions<boolean>): import("../../../../vue3/node_modules/vue").WatchStopHandle;
+            } & Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                ariaRole: {
+                    type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                    default: any;
+                    validator: (value: unknown) => boolean;
+                };
+                arrow: {
+                    type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                    default: any;
+                };
+                disabledFocusTrap: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fallbackPosition: {
+                    type: PropType<import("../popper-container").FallbackPositionProp>;
+                    default: any;
+                };
+                fixedPositioning: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                id: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                isHidden: {
+                    type: BooleanConstructor;
+                    default: any;
+                };
+                matchWidth: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                middleware: {
+                    type: PropType<{
+                        name: string;
+                        options?: any;
+                        fn: (state: {
+                            x: number;
+                            y: number;
+                            initialPlacement: import("@floating-ui/utils").Placement;
+                            placement: import("@floating-ui/utils").Placement;
+                            strategy: import("@floating-ui/utils").Strategy;
+                            middlewareData: import("@floating-ui/core").MiddlewareData;
+                            rects: import("@floating-ui/utils").ElementRects;
+                            platform: import("@floating-ui/core").Platform;
+                            elements: import("@floating-ui/dom").Elements;
+                        }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                    }[]>;
+                    default: any;
+                };
+                offset: {
+                    type: PropType<number[]>;
+                    default: () => number[];
+                    validator: (value: number[]) => boolean;
+                };
+                position: {
+                    type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                    default: import("../popper-container").PopperContainerPositionExtended;
+                    validator: (value: unknown) => boolean;
+                };
+                targetElement: {
+                    type: PropType<import("../../types").VueNodeElement>;
+                    required: true;
+                };
+            }>> & {
+                onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+            } & import("../../../../vue3/node_modules/vue").ShallowUnwrapRef<{}> & {} & import("../../../../vue3/node_modules/vue").ComponentCustomProperties & {};
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("../../../../vue3/node_modules/vue").ComponentOptionsBase<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+            ariaRole: {
+                type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                default: any;
+                validator: (value: unknown) => boolean;
+            };
+            arrow: {
+                type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                default: any;
+            };
+            disabledFocusTrap: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fallbackPosition: {
+                type: PropType<import("../popper-container").FallbackPositionProp>;
+                default: any;
+            };
+            fixedPositioning: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+                default: any;
+            };
+            isHidden: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            matchWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            middleware: {
+                type: PropType<{
+                    name: string;
+                    options?: any;
+                    fn: (state: {
+                        x: number;
+                        y: number;
+                        initialPlacement: import("@floating-ui/utils").Placement;
+                        placement: import("@floating-ui/utils").Placement;
+                        strategy: import("@floating-ui/utils").Strategy;
+                        middlewareData: import("@floating-ui/core").MiddlewareData;
+                        rects: import("@floating-ui/utils").ElementRects;
+                        platform: import("@floating-ui/core").Platform;
+                        elements: import("@floating-ui/dom").Elements;
+                    }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                }[]>;
+                default: any;
+            };
+            offset: {
+                type: PropType<number[]>;
+                default: () => number[];
+                validator: (value: number[]) => boolean;
+            };
+            position: {
+                type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                default: import("../popper-container").PopperContainerPositionExtended;
+                validator: (value: unknown) => boolean;
+            };
+            targetElement: {
+                type: PropType<import("../../types").VueNodeElement>;
+                required: true;
+            };
+        }>> & {
+            onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+        }, {}, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, {
+            placement: (value: import("@floating-ui/utils").Placement) => void;
+        }, string, {
+            id: string;
+            position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+            offset: number[];
+            ariaRole: import("../popper-container").PopperContainerAriaRole;
+            arrow: any;
+            disabledFocusTrap: boolean;
+            fallbackPosition: import("../popper-container").FallbackPositionProp;
+            fixedPositioning: boolean;
+            isHidden: boolean;
+            matchWidth: boolean;
+            middleware: {
+                name: string;
+                options?: any;
+                fn: (state: {
+                    x: number;
+                    y: number;
+                    initialPlacement: import("@floating-ui/utils").Placement;
+                    placement: import("@floating-ui/utils").Placement;
+                    strategy: import("@floating-ui/utils").Strategy;
+                    middlewareData: import("@floating-ui/core").MiddlewareData;
+                    rects: import("@floating-ui/utils").ElementRects;
+                    platform: import("@floating-ui/core").Platform;
+                    elements: import("@floating-ui/dom").Elements;
+                }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+            }[];
+        }, {}, string> & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps & (new () => {
+            $slots: {
+                default: (_: {}) => any;
+            };
+        })) | ({
+            new (...args: any[]): {
+                $: import("../../../../vue3/node_modules/vue").ComponentInternalInstance;
+                $data: {};
+                $props: Partial<{
+                    small: boolean;
+                    title: string;
+                    large: boolean;
+                    position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                    open: boolean;
+                    modifiers: unknown[];
+                    fallbackPosition: import("@floating-ui/utils").Placement[];
+                    fixedPositioning: boolean;
+                    ariaLabel: string;
+                    actions: import("../button").BentoButtonActionsList;
+                    actionsLayout: "space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start";
+                    divider: boolean;
+                    disableFocusTrap: boolean;
+                    dismissible: boolean;
+                    fitContent: boolean;
+                    withoutSpace: boolean;
+                }> & Omit<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                    actions: {
+                        type: PropType<import("../button").BentoButtonActionsList>;
+                        default: any;
+                    };
+                    actionsLayout: {
+                        type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                        default: import("../button").BentoButtonActionsLayoutBasic;
+                        validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+                    };
+                    ariaLabel: {
+                        type: StringConstructor;
+                        default: any;
+                    };
+                    divider: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disableFocusTrap: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    dismissible: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    fallbackPosition: {
+                        type: PropType<import("@floating-ui/utils").Placement[]>;
+                        default: () => string[];
+                    };
+                    fitContent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    fixedPositioning: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    open: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    large: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    modifiers: {
+                        type: ArrayConstructor;
+                        default: any;
+                    };
+                    position: {
+                        type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                        default: import("../popper-container").PopperContainerPositionExtended;
+                        validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+                    };
+                    small: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    title: {
+                        type: StringConstructor;
+                        default: any;
+                    };
+                    targetElement: {
+                        type: any;
+                        required: true;
+                    };
+                    withoutSpace: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+                    onDismiss?: () => any;
+                } & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "small" | "title" | "large" | "position" | "open" | "modifiers" | "fallbackPosition" | "fixedPositioning" | "ariaLabel" | "actions" | "actionsLayout" | "divider" | "disableFocusTrap" | "dismissible" | "fitContent" | "withoutSpace">;
+                $attrs: {
+                    [x: string]: unknown;
+                };
+                $refs: {
+                    [x: string]: unknown;
+                };
+                $slots: Readonly<{
+                    [name: string]: import("../../../../vue3/node_modules/vue").Slot;
+                }>;
+                $root: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+                $parent: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>;
+                $emit: ((event: "placement", placement: import("@floating-ui/utils").Placement) => void) & ((event: "dismiss") => void);
+                $el: any;
+                $options: import("../../../../vue3/node_modules/vue").ComponentOptionsBase<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                    actions: {
+                        type: PropType<import("../button").BentoButtonActionsList>;
+                        default: any;
+                    };
+                    actionsLayout: {
+                        type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                        default: import("../button").BentoButtonActionsLayoutBasic;
+                        validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+                    };
+                    ariaLabel: {
+                        type: StringConstructor;
+                        default: any;
+                    };
+                    divider: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    disableFocusTrap: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    dismissible: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    fallbackPosition: {
+                        type: PropType<import("@floating-ui/utils").Placement[]>;
+                        default: () => string[];
+                    };
+                    fitContent: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    fixedPositioning: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    open: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    large: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    modifiers: {
+                        type: ArrayConstructor;
+                        default: any;
+                    };
+                    position: {
+                        type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                        default: import("../popper-container").PopperContainerPositionExtended;
+                        validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+                    };
+                    small: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                    title: {
+                        type: StringConstructor;
+                        default: any;
+                    };
+                    targetElement: {
+                        type: any;
+                        required: true;
+                    };
+                    withoutSpace: {
+                        type: BooleanConstructor;
+                        default: boolean;
+                    };
+                }>> & {
+                    onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+                    onDismiss?: () => any;
+                }, {}, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, {
+                    dismiss: () => void;
+                } & {
+                    placement: (placement: import("@floating-ui/utils").Placement) => void;
+                }, string, {
+                    small: boolean;
+                    title: string;
+                    large: boolean;
+                    position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+                    open: boolean;
+                    modifiers: unknown[];
+                    fallbackPosition: import("@floating-ui/utils").Placement[];
+                    fixedPositioning: boolean;
+                    ariaLabel: string;
+                    actions: import("../button").BentoButtonActionsList;
+                    actionsLayout: "space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start";
+                    divider: boolean;
+                    disableFocusTrap: boolean;
+                    dismissible: boolean;
+                    fitContent: boolean;
+                    withoutSpace: 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("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+                    renderTriggered?: ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void) | ((e: import("../../../../vue3/node_modules/vue").DebuggerEvent) => void)[];
+                    errorCaptured?: ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void) | ((err: unknown, instance: import("../../../../vue3/node_modules/vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("../../../../vue3/node_modules/vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string>, {}>, info: string) => boolean | void)[];
+                };
+                $forceUpdate: () => void;
+                $nextTick: typeof import("../../../../vue3/node_modules/vue").nextTick;
+                $watch<T extends string | ((...args: any) => any)>(source: T, cb: T extends (...args: any) => infer R ? (args_0: R, args_1: R) => any : (...args: any) => any, options?: import("../../../../vue3/node_modules/vue").WatchOptions<boolean>): import("../../../../vue3/node_modules/vue").WatchStopHandle;
+            } & Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+                actions: {
+                    type: PropType<import("../button").BentoButtonActionsList>;
+                    default: any;
+                };
+                actionsLayout: {
+                    type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                    default: import("../button").BentoButtonActionsLayoutBasic;
+                    validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+                };
+                ariaLabel: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                divider: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                disableFocusTrap: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                dismissible: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fallbackPosition: {
+                    type: PropType<import("@floating-ui/utils").Placement[]>;
+                    default: () => string[];
+                };
+                fitContent: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                fixedPositioning: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                open: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                large: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                modifiers: {
+                    type: ArrayConstructor;
+                    default: any;
+                };
+                position: {
+                    type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                    default: import("../popper-container").PopperContainerPositionExtended;
+                    validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+                };
+                small: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+                title: {
+                    type: StringConstructor;
+                    default: any;
+                };
+                targetElement: {
+                    type: any;
+                    required: true;
+                };
+                withoutSpace: {
+                    type: BooleanConstructor;
+                    default: boolean;
+                };
+            }>> & {
+                onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+                onDismiss?: () => any;
+            } & import("../../../../vue3/node_modules/vue").ShallowUnwrapRef<{}> & {} & import("../../../../vue3/node_modules/vue").ComponentCustomProperties & {};
+            __isFragment?: never;
+            __isTeleport?: never;
+            __isSuspense?: never;
+        } & import("../../../../vue3/node_modules/vue").ComponentOptionsBase<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+            actions: {
+                type: PropType<import("../button").BentoButtonActionsList>;
+                default: any;
+            };
+            actionsLayout: {
+                type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                default: import("../button").BentoButtonActionsLayoutBasic;
+                validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+            };
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            divider: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disableFocusTrap: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dismissible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fallbackPosition: {
+                type: PropType<import("@floating-ui/utils").Placement[]>;
+                default: () => string[];
+            };
+            fitContent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fixedPositioning: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            open: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            large: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            modifiers: {
+                type: ArrayConstructor;
+                default: any;
+            };
+            position: {
+                type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                default: import("../popper-container").PopperContainerPositionExtended;
+                validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+            };
+            small: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            title: {
+                type: StringConstructor;
+                default: any;
+            };
+            targetElement: {
+                type: any;
+                required: true;
+            };
+            withoutSpace: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & {
+            onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+            onDismiss?: () => any;
+        }, {}, unknown, {}, {}, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, import("../../../../vue3/node_modules/vue").ComponentOptionsMixin, {
+            dismiss: () => void;
+        } & {
+            placement: (placement: import("@floating-ui/utils").Placement) => void;
+        }, string, {
+            small: boolean;
+            title: string;
+            large: boolean;
+            position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+            open: boolean;
+            modifiers: unknown[];
+            fallbackPosition: import("@floating-ui/utils").Placement[];
+            fixedPositioning: boolean;
+            ariaLabel: string;
+            actions: import("../button").BentoButtonActionsList;
+            actionsLayout: "space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start";
+            divider: boolean;
+            disableFocusTrap: boolean;
+            dismissible: boolean;
+            fitContent: boolean;
+            withoutSpace: boolean;
+        }, {}, string> & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps & (new () => {
+            $slots: {
+                image: (_: {}) => any;
+                headerIcon: (_: {}) => any;
+                default: (_: {}) => any;
+            };
+        }))>;
+        popperContainerOrPopoverProps: import("../../../../vue3/node_modules/vue").ComputedRef<(Partial<{
+            id: string;
+            position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+            offset: number[];
+            ariaRole: import("../popper-container").PopperContainerAriaRole;
+            arrow: any;
+            disabledFocusTrap: boolean;
+            fallbackPosition: import("../popper-container").FallbackPositionProp;
+            fixedPositioning: boolean;
+            isHidden: boolean;
+            matchWidth: boolean;
+            middleware: {
+                name: string;
+                options?: any;
+                fn: (state: {
+                    x: number;
+                    y: number;
+                    initialPlacement: import("@floating-ui/utils").Placement;
+                    placement: import("@floating-ui/utils").Placement;
+                    strategy: import("@floating-ui/utils").Strategy;
+                    middlewareData: import("@floating-ui/core").MiddlewareData;
+                    rects: import("@floating-ui/utils").ElementRects;
+                    platform: import("@floating-ui/core").Platform;
+                    elements: import("@floating-ui/dom").Elements;
+                }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+            }[];
+        }> & Omit<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+            ariaRole: {
+                type: PropType<import("../popper-container").PopperContainerAriaRole>;
+                default: any;
+                validator: (value: unknown) => boolean;
+            };
+            arrow: {
+                type: PropType<boolean | import("../popper-container").PopperContainerArrowProp>;
+                default: any;
+            };
+            disabledFocusTrap: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fallbackPosition: {
+                type: PropType<import("../popper-container").FallbackPositionProp>;
+                default: any;
+            };
+            fixedPositioning: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            id: {
+                type: StringConstructor;
+                default: any;
+            };
+            isHidden: {
+                type: BooleanConstructor;
+                default: any;
+            };
+            matchWidth: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            middleware: {
+                type: PropType<{
+                    name: string;
+                    options?: any;
+                    fn: (state: {
+                        x: number;
+                        y: number;
+                        initialPlacement: import("@floating-ui/utils").Placement;
+                        placement: import("@floating-ui/utils").Placement;
+                        strategy: import("@floating-ui/utils").Strategy;
+                        middlewareData: import("@floating-ui/core").MiddlewareData;
+                        rects: import("@floating-ui/utils").ElementRects;
+                        platform: import("@floating-ui/core").Platform;
+                        elements: import("@floating-ui/dom").Elements;
+                    }) => import("@floating-ui/core").MiddlewareReturn | Promise<import("@floating-ui/core").MiddlewareReturn>;
+                }[]>;
+                default: any;
+            };
+            offset: {
+                type: PropType<number[]>;
+                default: () => number[];
+                validator: (value: number[]) => boolean;
+            };
+            position: {
+                type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                default: import("../popper-container").PopperContainerPositionExtended;
+                validator: (value: unknown) => boolean;
+            };
+            targetElement: {
+                type: PropType<import("../../types").VueNodeElement>;
+                required: true;
+            };
+        }>> & {
+            onPlacement?: (value: import("@floating-ui/utils").Placement) => any;
+        } & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "id" | "position" | "offset" | "ariaRole" | "arrow" | "disabledFocusTrap" | "fallbackPosition" | "fixedPositioning" | "isHidden" | "matchWidth" | "middleware">) | (Partial<{
+            small: boolean;
+            title: string;
+            large: boolean;
+            position: "auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition;
+            open: boolean;
+            modifiers: unknown[];
+            fallbackPosition: import("@floating-ui/utils").Placement[];
+            fixedPositioning: boolean;
+            ariaLabel: string;
+            actions: import("../button").BentoButtonActionsList;
+            actionsLayout: "space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start";
+            divider: boolean;
+            disableFocusTrap: boolean;
+            dismissible: boolean;
+            fitContent: boolean;
+            withoutSpace: boolean;
+        }> & Omit<Readonly<import("../../../../vue3/node_modules/vue").ExtractPropTypes<{
+            actions: {
+                type: PropType<import("../button").BentoButtonActionsList>;
+                default: any;
+            };
+            actionsLayout: {
+                type: PropType<"space-between" | import("../button").BentoButtonActionsLayout | "buttons-end" | "fill-container" | "vertical-stack" | "buttons-start">;
+                default: import("../button").BentoButtonActionsLayoutBasic;
+                validator: (value: import("../button").BentoButtonActionsLayout) => boolean;
+            };
+            ariaLabel: {
+                type: StringConstructor;
+                default: any;
+            };
+            divider: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            disableFocusTrap: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            dismissible: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fallbackPosition: {
+                type: PropType<import("@floating-ui/utils").Placement[]>;
+                default: () => string[];
+            };
+            fitContent: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            fixedPositioning: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            open: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            large: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            modifiers: {
+                type: ArrayConstructor;
+                default: any;
+            };
+            position: {
+                type: PropType<"auto" | "left" | "right" | "bottom" | "top" | "auto-start" | "auto-end" | "top-start" | "top-end" | "right-start" | "right-end" | "bottom-start" | "bottom-end" | "left-start" | "left-end" | import("../popper-container").PopperContainerPosition>;
+                default: import("../popper-container").PopperContainerPositionExtended;
+                validator: (value: import("../popper-container").PopperContainerPosition) => boolean;
+            };
+            small: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+            title: {
+                type: StringConstructor;
+                default: any;
+            };
+            targetElement: {
+                type: any;
+                required: true;
+            };
+            withoutSpace: {
+                type: BooleanConstructor;
+                default: boolean;
+            };
+        }>> & {
+            onPlacement?: (placement: import("@floating-ui/utils").Placement) => any;
+            onDismiss?: () => any;
+        } & import("../../../../vue3/node_modules/vue").VNodeProps & import("../../../../vue3/node_modules/vue").AllowedComponentProps & import("../../../../vue3/node_modules/vue").ComponentCustomProps, "small" | "title" | "large" | "position" | "open" | "modifiers" | "fallbackPosition" | "fixedPositioning" | "ariaLabel" | "actions" | "actionsLayout" | "divider" | "disableFocusTrap" | "dismissible" | "fitContent" | "withoutSpace">)>;
+        dropdownOptionsListboxRef: any;
+        onEscapeKey: () => void;
+        onOutsideDropdownClick: () => void;
+        listeners: {
+            select: (newSelectedValue: BentoListboxSelectedValue) => void;
+            "show-more": () => void;
+            "tab-pressed": (newSelectedValue: BentoListboxSelectedValue) => void;
+            "space-pressed": (newSelectedValue: BentoListboxSelectedValue) => void;
+            "enter-pressed": (newSelectedValue: BentoListboxSelectedValue) => void;
+        };
+    }> & {} & import("../../../../vue3/node_modules/vue").ComponentCustomProperties & {}>;
+    clickOutsideDropdown: () => void;
     toggleDropdown: () => void;
     onOptionSelected: (selectedValue: BentoListboxSelectedValue) => void;
     emitShowMoreEvent: () => void;