bitboss-ui 2.1.102 → 2.1.104

package/dist/components/BaseColorInput/BaseColorInput.vue.d.ts

@@ -2,9 +2,15 @@ import { HTMLAttributes, InputHTMLAttributes } from 'vue';
 import { IconType } from '../../types/Icon';
 /**
  * Color input with hex value masking and an optional palette popover.
- * Accepts and emits `#RRGGBB` values via v-model and supports full input chrome slots.
+ * Accepts and emits `#RRGGBB` (or `#RRGGBBAA` when `alpha` is enabled) values via v-model
+ * and supports full input chrome slots.
  */
 export type BaseColorInputProps = {
+    /**
+     * Enable the alpha channel. When true the picker shows an opacity slider and
+     * emits / accepts `#RRGGBBAA` hex8 values.
+     */
+    alpha?: boolean;
     /**
      * Name of the icon to render at the right hand side of the input.
      */
@@ -72,6 +78,19 @@ export type BaseColorInputProps = {
      * Mark the input as required.
      */
     required?: boolean;
+    /**
+     * Show an eyedropper button to sample any color on screen.
+     * Uses the native EyeDropper API — hidden automatically on unsupported browsers.
+     * @default false
+     */
+    picker?: boolean;
+    /**
+     * Controls swatches display in the picker:
+     * - `true`       — show the built-in Material-palette swatches
+     * - `string[][]` — show custom swatches (each inner array = a column of shades)
+     * - `false` / omitted — no swatches section
+     */
+    swatches?: boolean | string[][];
     /**
      * Transition duration (ms) of the palette popover.
      * @default 250
@@ -216,29 +235,6 @@ declare function __VLS_template(): {
                 suffix?(_: {}): any;
             };
         }) | null;
-        indicator: HTMLButtonElement;
-        pallette: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
-            modelValue: string | null;
-        }> & Readonly<{
-            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-        }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-            "update:modelValue": (value: string) => any;
-        }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
-            paletteRef: HTMLSpanElement;
-            mainCanvasRef: HTMLCanvasElement;
-            hueCanvasRef: HTMLCanvasElement;
-        }, HTMLSpanElement, import('vue').ComponentProvideOptions, {
-            P: {};
-            B: {};
-            D: {};
-            C: {};
-            M: {};
-            Defaults: {};
-        }, Readonly<{
-            modelValue: string | null;
-        }> & Readonly<{
-            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-        }>, {}, {}, {}, {}, {}> | null;
     };
     rootEl: HTMLSpanElement;
 };
@@ -266,6 +262,7 @@ declare const __VLS_component: import('vue').DefineComponent<BaseColorInputProps
 }>, {
     autocomplete: string;
     transitionDuration: number;
+    alpha: boolean;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     wrapper: ({
         $: import('vue').ComponentInternalInstance;
@@ -373,29 +370,6 @@ declare const __VLS_component: import('vue').DefineComponent<BaseColorInputProps
             suffix?(_: {}): any;
         };
     }) | null;
-    indicator: HTMLButtonElement;
-    pallette: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
-        modelValue: string | null;
-    }> & Readonly<{
-        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    }>, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
-        "update:modelValue": (value: string) => any;
-    }, import('vue').PublicProps, {}, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
-        paletteRef: HTMLSpanElement;
-        mainCanvasRef: HTMLCanvasElement;
-        hueCanvasRef: HTMLCanvasElement;
-    }, HTMLSpanElement, import('vue').ComponentProvideOptions, {
-        P: {};
-        B: {};
-        D: {};
-        C: {};
-        M: {};
-        Defaults: {};
-    }, Readonly<{
-        modelValue: string | null;
-    }> & Readonly<{
-        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
-    }>, {}, {}, {}, {}, {}> | null;
 }, HTMLSpanElement>;
 declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
 export default _default;

package/dist/components/BaseColorInput/ColorPalette.vue.d.ts

@@ -0,0 +1,36 @@
+export type ColorPaletteProps = {
+    modelValue: string | null;
+    alpha?: boolean;
+    /**
+     * Show an eyedropper button that lets the user sample any color on screen.
+     * Uses the native EyeDropper API — hidden automatically on unsupported browsers.
+     * @default false
+     */
+    picker?: boolean;
+    /**
+     * Controls swatches display:
+     * - `true`      — show the built-in Material-palette swatches
+     * - `string[][]` — show custom swatches (each inner array = a column of shades)
+     * - `false` / omitted — no swatches section
+     */
+    swatches?: boolean | string[][];
+};
+declare const _default: import('vue').DefineComponent<ColorPaletteProps, {
+    el: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string) => any;
+}, string, import('vue').PublicProps, Readonly<ColorPaletteProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+}>, {
+    alpha: boolean;
+    picker: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    pickerRef: HTMLDivElement;
+    canvasWrapRef: HTMLDivElement;
+    mainCanvasRef: HTMLCanvasElement;
+    hueWrapRef: HTMLDivElement;
+    hueCanvasRef: HTMLCanvasElement;
+    alphaWrapRef: HTMLDivElement;
+    alphaCanvasRef: HTMLCanvasElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/components/BbBreadcrumbs/BbBreadcrumbs.vue.d.ts

@@ -126,10 +126,10 @@ declare function __VLS_template(): {
 };
 type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
 declare const __VLS_component: import('vue').DefineComponent<BbBreadcrumbsProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<BbBreadcrumbsProps> & Readonly<{}>, {
+    offsetWidth: number;
     divider: string;
     dividerWidth: number;
     gapWidth: number;
-    offsetWidth: number;
     estimationBias: number;
 }, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
     navRef: HTMLElement;

package/dist/components/BbColorInput/BbColorInput.vue.d.ts

@@ -2,6 +2,10 @@ import { BaseColorInputEvents, BaseColorInputSlots } from '../BaseColorInput/Bas
 import { HTMLAttributes, InputHTMLAttributes } from 'vue';
 import { IconType } from '../../types/Icon';
 export type BbColorInputProps = {
+    /**
+     * Enable the alpha channel. Shows an opacity slider and uses `#RRGGBBAA` hex8 format.
+     */
+    alpha?: boolean;
     /**
      * Name of the icon to be added at the end of the input.
      */
@@ -95,6 +99,19 @@ export type BbColorInputProps = {
      * Reverses the layout. Applicable in every direction the order of the label and the input is swapped.
      */
     reverse?: boolean;
+    /**
+     * Show an eyedropper button to sample any color on screen.
+     * Uses the native EyeDropper API — hidden automatically on unsupported browsers.
+     * @default false
+     */
+    picker?: boolean;
+    /**
+     * Controls swatches display in the picker:
+     * - `true`       — show the built-in Material-palette swatches
+     * - `string[][]` — show custom swatches (each inner array = a column of shades)
+     * - `false` / omitted — no swatches section
+     */
+    swatches?: boolean | string[][];
 };
 export type BbColorInputEvents = BaseColorInputEvents;
 export type BbColorInputSlots = BaseColorInputSlots & {

package/dist/components/BbColorPalette/BbColorPalette.vue.d.ts

@@ -0,0 +1,207 @@
+import { CommonProps } from '../../types/CommonProps';
+export type BbColorPaletteProps = Pick<CommonProps, 'arrowPadding' | 'eager' | 'offset' | 'padding' | 'placement' | 'transitionDuration'> & {
+    /**
+     * v-model: the current color as a `#RRGGBB` hex string (or `#RRGGBBAA` when
+     * `alpha` is enabled), or `null` when empty.
+     */
+    modelValue: string | null;
+    /**
+     * Enable the alpha channel. The picker shows an opacity slider and emits
+     * `#RRGGBBAA` hex8 values.
+     */
+    alpha?: boolean;
+    /**
+     * Controls swatches display in the picker:
+     * - `true`       — show the built-in Material-palette swatches
+     * - `string[][]` — show custom swatches (each inner array = a column of shades)
+     * - `false` / omitted — no swatches section
+     */
+    swatches?: boolean | string[][];
+    /**
+     * External activator element or component ref.
+     * When provided, the `activator` slot is not rendered and click listeners are
+     * attached programmatically to the referenced element — mirroring the
+     * BbDropdown activator API.
+     */
+    activator?: HTMLElement | Record<string, any> | null;
+    /**
+     * Element or component ref the popover positions itself relative to.
+     * Defaults to the activator element when omitted, allowing the popover to
+     * be anchored to a larger container (e.g. the full input row) while a
+     * smaller element (e.g. a color dot) remains the click target.
+     */
+    anchor?: HTMLElement | Record<string, any> | null;
+    /**
+     * Constrains the popover within a bounding element.
+     * Accepts an HTMLElement, a Vue component ref, or a CSS selector string.
+     */
+    boundary?: HTMLElement | Record<string, any> | string | null;
+    /**
+     * Whether to flip the popover to the opposite side when there is not enough space.
+     * @default true
+     */
+    flip?: boolean;
+    /**
+     * Show the popover arrow. Hidden by default since the palette has its own visual frame.
+     * @default false
+     */
+    showArrow?: boolean;
+    /**
+     * Disable all interaction (activator and palette).
+     */
+    disabled?: boolean;
+    /**
+     * Prevent opening the palette while keeping the activator visible.
+     */
+    readonly?: boolean;
+    /**
+     * Accessible label applied to the activator element via `aria-label`.
+     * Defaults to the locale string for "Open color picker" when omitted.
+     */
+    label?: string;
+    /**
+     * Show an eyedropper button inside the palette to sample any color on screen.
+     * Uses the native EyeDropper API — hidden automatically on unsupported browsers.
+     * @default false
+     */
+    picker?: boolean;
+};
+export type BbColorPaletteEvents = {
+    (e: 'update:modelValue', value: string | null): void;
+    /** Fires whenever the popover opens or closes. */
+    (e: 'update:open', value: boolean): void;
+};
+export type BbColorPaletteSlots = {
+    /**
+     * Custom activator element.
+     * Apply `v-bind="props"` to the element you want to use as the trigger —
+     * this wires up the ref callback that lets BbColorPalette track the element.
+     *
+     * @example
+     * ```vue
+     * <BbColorPalette v-model="color">
+     *   <template #activator="{ props: dotProps, open, color }">
+     *     <button v-bind="dotProps" :style="{ background: color }">Pick</button>
+     *   </template>
+     * </BbColorPalette>
+     * ```
+     */
+    activator?: (props: {
+        /**
+         * Spread onto your activator element to register the ref.
+         * ARIA attributes (`aria-haspopup`, `aria-expanded`, `aria-label`) are set
+         * programmatically so they stay correct for both the slot and external activator paths.
+         */
+        props: {
+            ref: (el: unknown) => void;
+        };
+        /**
+         * Spread onto a wrapping element when you want the popover to anchor to
+         * something larger than the click target (e.g. the full input row).
+         * When unused the activator element is also the anchor.
+         */
+        anchorProps: {
+            ref: (el: unknown) => void;
+        };
+        /** Whether the palette popover is currently open. */
+        open: boolean;
+        /** The current color value (mirrors `modelValue`). */
+        color: string | null;
+        disabled?: boolean;
+    }) => any;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: Readonly<BbColorPaletteSlots> & BbColorPaletteSlots;
+    refs: {
+        paletteRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../BaseColorInput/ColorPalette.vue').ColorPaletteProps> & Readonly<{
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        }>, {
+            el: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+        }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+            "update:modelValue": (value: string) => any;
+        }, import('vue').PublicProps, {
+            alpha: boolean;
+            picker: boolean;
+        }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+            pickerRef: HTMLDivElement;
+            canvasWrapRef: HTMLDivElement;
+            mainCanvasRef: HTMLCanvasElement;
+            hueWrapRef: HTMLDivElement;
+            hueCanvasRef: HTMLCanvasElement;
+            alphaWrapRef: HTMLDivElement;
+            alphaCanvasRef: HTMLCanvasElement;
+        }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+            P: {};
+            B: {};
+            D: {};
+            C: {};
+            M: {};
+            Defaults: {};
+        }, Readonly<import('../BaseColorInput/ColorPalette.vue').ColorPaletteProps> & Readonly<{
+            "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        }>, {
+            el: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+        }, {}, {}, {}, {
+            alpha: boolean;
+            picker: boolean;
+        }> | null;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<BbColorPaletteProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+    "update:modelValue": (value: string | null) => any;
+    "update:open": (value: boolean) => any;
+}, string, import('vue').PublicProps, Readonly<BbColorPaletteProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: string | null) => any) | undefined;
+    "onUpdate:open"?: ((value: boolean) => any) | undefined;
+}>, {
+    transitionDuration: number;
+    offset: number;
+    padding: number;
+    alpha: boolean;
+    picker: boolean;
+    flip: boolean;
+    showArrow: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    paletteRef: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<import('../BaseColorInput/ColorPalette.vue').ColorPaletteProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    }>, {
+        el: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {} & {
+        "update:modelValue": (value: string) => any;
+    }, import('vue').PublicProps, {
+        alpha: boolean;
+        picker: boolean;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        pickerRef: HTMLDivElement;
+        canvasWrapRef: HTMLDivElement;
+        mainCanvasRef: HTMLCanvasElement;
+        hueWrapRef: HTMLDivElement;
+        hueCanvasRef: HTMLCanvasElement;
+        alphaWrapRef: HTMLDivElement;
+        alphaCanvasRef: HTMLCanvasElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import('../BaseColorInput/ColorPalette.vue').ColorPaletteProps> & Readonly<{
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+    }>, {
+        el: import('vue').Ref<HTMLDivElement | null, HTMLDivElement | null>;
+    }, {}, {}, {}, {
+        alpha: boolean;
+        picker: boolean;
+    }> | null;
+}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BbSelectPopover/BbSelectPopover.vue.d.ts

@@ -0,0 +1,277 @@
+import { HTMLAttributes, InputHTMLAttributes } from 'vue';
+import { CommonProps } from '../../types/CommonProps';
+export type BbSelectPopoverProps<Item> = {
+    /**
+     * External activator element or component ref.
+     * When provided, the activator slot is not rendered and event listeners
+     * are attached programmatically to the referenced element.
+     */
+    activator?: HTMLElement | Record<string, any> | null;
+    /**
+     * Controls whether the search input is shown inside the popover panel.
+     * Use `'not-mobile'` to hide the search input on mobile.
+     * @default false
+     */
+    allowWriting?: boolean | 'not-mobile';
+    /**
+     * Browser autocomplete hint for the popover search input.
+     * @default 'off'
+     */
+    autocomplete?: InputHTMLAttributes['autocomplete'];
+    /**
+     * Apply the compact density variant.
+     */
+    compact?: boolean;
+    /**
+     * Space the arrow keeps from popover edges.
+     * Useful with rounded corners.
+     * @default 10
+     */
+    arrowPadding?: CommonProps['arrowPadding'];
+    /**
+     * Constrains the popover to a specific boundary element.
+     */
+    boundary?: HTMLElement | Record<string, any> | string | null;
+    /**
+     * Additional dependencies that trigger item reloading when changed.
+     * @default []
+     */
+    dependencies?: any[];
+    /**
+     * Debounce delay (ms) for dependency-triggered reloads.
+     * @default 0
+     */
+    depsDebounceTime?: number;
+    /**
+     * Disables the component.
+     */
+    disabled?: boolean;
+    /**
+     * Marks the component as being in error state.
+     */
+    hasErrors?: boolean;
+    /**
+     * Explicit invalid state for accessibility semantics.
+     * Falls back to `hasErrors` when not provided.
+     */
+    ariaInvalid?: boolean;
+    /**
+     * Space-separated IDREF(s) that describe this field for assistive technologies.
+     * Accepts either a string or array of ids.
+     */
+    ariaDescribedby?: string | string[];
+    /**
+     * Enable or disable floating flip behavior.
+     * @default true
+     */
+    flip?: boolean;
+    /**
+     * Whether the floating arrow is hidden.
+     * @default true
+     */
+    hideArrow?: boolean;
+    /**
+     * Reset modelValue to `null` or empty array if it no longer matches available items.
+     */
+    enforceCoherence?: boolean;
+    /**
+     * Controls how options are filtered during search.
+     * Options are always filtered by display text, but can also match additional properties
+     * when set to a string path, array of paths, or custom function.
+     * Set to `false` to disable filtering, or `'not_stashed'` to exclude stashed items.
+     * @default () => []
+     */
+    filterBy?: string | string[] | false | 'not_stashed' | ((value: any, item: any, query: string | null) => boolean) | null;
+    groupBy?: string | ((item: Item) => string | number | symbol);
+    /**
+     * Height of group headers in the listbox (px). Defaults to 24px (compact) or 32px.
+     * Only applies when `groupBy` is set.
+     */
+    headerHeight?: number;
+    /**
+     * Explicit id for the component. Used to generate ids for listbox and options.
+     */
+    id?: HTMLAttributes['id'];
+    /**
+     * Array of items or function to load them asynchronously.
+     * Functions receive `(query, prefill, modelValue)` and can return a promise.
+     * @default []
+     */
+    items: Item[] | ((query: string, prefill: boolean, modelValue: any[]) => Promise<Item[]>) | ((query: string, prefill: boolean, modelValue: any[]) => Item[]);
+    /**
+     * Height of the options in the listbox (px).
+     * @default 40
+     */
+    itemHeight?: number;
+    /**
+     * Path to item property for display text or function to extract it.
+     */
+    itemText?: string | ((item: Item) => string) | undefined;
+    /**
+     * Path to item property for value or function to extract it.
+     */
+    itemValue?: string | ((item: Item) => string) | undefined;
+    /**
+     * Display the loading state styles.
+     */
+    loading?: boolean;
+    /**
+     * Message shown while items are being loaded.
+     */
+    loadingText?: string;
+    /**
+     * Maximum number of selectable items (limits selection when `multiple` is true).
+     * @default Infinity
+     */
+    max?: number;
+    /**
+     * v-model value. Single value for single select, array for multiple select.
+     */
+    modelValue: any;
+    /**
+     * Debounce delay (ms) for modelValue change handling.
+     * @default 0
+     */
+    modelValueDebounceTime?: number;
+    /**
+     * Enable multiple item selection. When true, modelValue must be an array.
+     */
+    multiple?: boolean;
+    /**
+     * Message displayed when no items are available.
+     */
+    noDataText?: string;
+    /**
+     * Distance (px) between the activator and the popover.
+     * @default 4
+     */
+    offset?: number;
+    /**
+     * Minimum page padding used by floating shift middleware.
+     * @default 0
+     */
+    padding?: CommonProps['padding'];
+    /**
+     * Floating placement of the popover.
+     * @default 'bottom'
+     */
+    placement?: CommonProps['placement'];
+    /**
+     * Controls when items are pre-loaded.
+     * `'interaction'` loads on first user interaction (first popover open),
+     * `true` loads immediately, `false` loads only on explicit search/open flows.
+     * @default 'interaction'
+     */
+    prefill?: boolean | 'interaction';
+    /**
+     * Debounce delay (ms) before triggering search queries after user input stops.
+     * @default 500
+     */
+    queryDebounceTime?: number;
+    /**
+     * Prevents opening the popover while keeping the activator accessible.
+     */
+    readonly?: boolean;
+    /**
+     * Accessible label used by the search input rendered inside the popover.
+     * @default 'Search options'
+     */
+    searchInputAriaLabel?: string;
+    /**
+     * Accumulate selected items across searches instead of replacing them.
+     */
+    stash?: boolean;
+    /**
+     * Transition duration (ms) for popover show/hide animations.
+     * @default 300
+     */
+    transitionDuration?: number;
+    /**
+     * Width of the popover in pixels, percentage, or `'auto'`.
+     */
+    width?: number | string;
+};
+export type BbSelectPopoverEvents = {
+    (e: 'blur', event: FocusEvent): void;
+    (e: 'change', event: Event): void;
+    (e: 'click', event: MouseEvent): void;
+    (e: 'focus', event: FocusEvent): void;
+    (e: 'inactive'): void;
+    (e: 'input', event: Event): void;
+    (e: 'update:modelValue', value: any): void;
+    (e: 'option:add', text: string): void;
+};
+export type BbSelectPopoverSlots<Item> = {
+    activator?: (props: {
+        props: {
+            ref: (reference: unknown) => void;
+        };
+        shown: boolean;
+        disabled: boolean | undefined;
+        readonly: boolean | undefined;
+        loading: boolean;
+        query: string;
+        clear: () => void;
+        open: () => Promise<void>;
+        close: () => Promise<void>;
+        toggle: () => Promise<void>;
+    }) => any;
+    loading?: (props: {
+        query: string;
+    }) => any;
+    'no-data'?: (props: {
+        query: string;
+        focus: () => void;
+    }) => any;
+    option?: (props: {
+        disabled: boolean;
+        focused: boolean;
+        index: number;
+        item: Item;
+        loading: boolean;
+        selected: boolean;
+        text: string;
+        value: any;
+    }) => any;
+    group?: (props: {
+        text: string;
+        item: Item;
+        index: number;
+        length: number;
+        disabled: boolean;
+    }) => any;
+    'options:append'?: (props: {
+        focus: () => void;
+    }) => any;
+    'options:append:outer'?: (props: {
+        focus: () => void;
+    }) => any;
+    'options:prepend'?: (props: {
+        focus: () => void;
+    }) => any;
+    'options:prepend:outer'?: (props: {
+        focus: () => void;
+    }) => any;
+};
+declare const _default: <Item = any>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
+    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
+        readonly onInput?: ((event: Event) => any) | undefined;
+        readonly "onUpdate:modelValue"?: ((value: any) => any) | undefined;
+        readonly onBlur?: ((event: FocusEvent) => any) | undefined;
+        readonly onChange?: ((event: Event) => any) | undefined;
+        readonly onClick?: ((event: MouseEvent) => any) | undefined;
+        readonly onFocus?: ((event: FocusEvent) => any) | undefined;
+        readonly onInactive?: (() => any) | undefined;
+        readonly "onOption:add"?: ((text: string) => any) | undefined;
+    } & import('vue').VNodeProps & import('vue').AllowedComponentProps & import('vue').ComponentCustomProps, never>, "onFocus" | "onBlur" | "onChange" | "onInput" | "onClick" | "onUpdate:modelValue" | "onInactive" | "onOption:add"> & BbSelectPopoverProps<Item> & Partial<{}>> & import('vue').PublicProps;
+    expose(exposed: import('vue').ShallowUnwrapRef<{}>): void;
+    attrs: any;
+    slots: Readonly<BbSelectPopoverSlots<Item>> & BbSelectPopoverSlots<Item>;
+    emit: BbSelectPopoverEvents;
+}>) => import('vue').VNode & {
+    __ctx?: Awaited<typeof __VLS_setup>;
+};
+export default _default;
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};