@adyen/bento-vue2 0.1.5 → 0.3.0

package/dist/@types/components/filter-bar/components/base-filter/base-filter.vue.d.ts

@@ -1,8 +1,16 @@
 import { BentoButtonVariant } from '@/components/button';
 declare const _default: import("vue").DefineComponent<{
+    appliedFiltersCount: {
+        type: NumberConstructor;
+        default: any;
+    };
     disableApplyButton: {
         type: BooleanConstructor;
-        deafault: boolean;
+        default: boolean;
+    };
+    disableClearButton: {
+        type: BooleanConstructor;
+        default: boolean;
     };
     field: {
         type: StringConstructor;
@@ -12,16 +20,30 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         required: true;
     };
-    isOpen: {
-        type: BooleanConstructor;
-        required: true;
-    };
     value: {
-        type: StringConstructor;
+        type: (StringConstructor | {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        })[];
         default: any;
     };
 }, {
-    activeAppliedFilterCount: import("vue").ComputedRef<number>;
+    actions: import("vue").ComputedRef<{
+        title: string;
+        event: () => void;
+        disabled: boolean;
+    }[]>;
+    isFilterOpen: import("vue").Ref<boolean>;
     BentoPopoverPositions: {
         AUTO: import("../../../popper-container").PopperContainerPositionExtended.AUTO;
         AUTO_START: import("../../../popper-container").PopperContainerPositionExtended.AUTO_START;
@@ -49,12 +71,28 @@ declare const _default: import("vue").DefineComponent<{
     onClickApply: () => void;
     onClickClear: () => void;
     onClickOutside: () => void;
+    closePopover: () => void;
     filterButtonRef: any;
     BentoButtonVariant: typeof BentoButtonVariant;
-}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, ("open" | "clear" | "close" | "dismiss" | "apply")[], string, Readonly<import("vue").ExtractPropTypes<{
+    BentoButtonActionsLayout: {
+        BUTTONS_START: import("@/components/button").BentoButtonActionsLayoutExtended.BUTTONS_START;
+        BUTTONS_END: import("@/components/button").BentoButtonActionsLayoutBasic.BUTTONS_END;
+        FILL_CONTAINER: import("@/components/button").BentoButtonActionsLayoutBasic.FILL_CONTAINER;
+        SPACE_BETWEEN: import("@/components/button").BentoButtonActionsLayoutBasic.SPACE_BETWEEN;
+        VERTICAL_STACK: import("@/components/button").BentoButtonActionsLayoutBasic.VERTICAL_STACK;
+    };
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, ("open" | "clear" | "close" | "apply")[], string, Readonly<import("vue").ExtractPropTypes<{
+    appliedFiltersCount: {
+        type: NumberConstructor;
+        default: any;
+    };
     disableApplyButton: {
         type: BooleanConstructor;
-        deafault: boolean;
+        default: boolean;
+    };
+    disableClearButton: {
+        type: BooleanConstructor;
+        default: boolean;
     };
     field: {
         type: StringConstructor;
@@ -64,16 +102,27 @@ declare const _default: import("vue").DefineComponent<{
         type: StringConstructor;
         required: true;
     };
-    isOpen: {
-        type: BooleanConstructor;
-        required: true;
-    };
     value: {
-        type: StringConstructor;
+        type: (StringConstructor | {
+            (arrayLength: number): string[];
+            (...items: string[]): string[];
+            new (arrayLength: number): string[];
+            new (...items: string[]): string[];
+            isArray(arg: any): arg is any[];
+            readonly prototype: any[];
+            from<T>(arrayLike: ArrayLike<T>): T[];
+            from<T_1, U>(arrayLike: ArrayLike<T_1>, mapfn: (v: T_1, k: number) => U, thisArg?: any): U[];
+            from<T_2>(iterable: Iterable<T_2> | ArrayLike<T_2>): T_2[];
+            from<T_3, U_1>(iterable: Iterable<T_3> | ArrayLike<T_3>, mapfn: (v: T_3, k: number) => U_1, thisArg?: any): U_1[];
+            of<T_4>(...items: T_4[]): T_4[];
+            readonly [Symbol.species]: ArrayConstructor;
+        })[];
         default: any;
     };
 }>>, {
-    value: string;
+    value: string | string[];
+    appliedFiltersCount: number;
     disableApplyButton: boolean;
+    disableClearButton: boolean;
 }>;
 export default _default;

package/dist/@types/components/filter-bar/components/base-filter/composables/use-base-filter.d.ts

@@ -0,0 +1,6 @@
+import type { Ref } from 'vue';
+export declare const useBaseFilter: <T>(appliedFilter: Ref<T>) => {
+    internalFilterValue: Ref<import("vue").UnwrapRef<T>>;
+    isClearButtonDisabled: import("vue").ComputedRef<boolean>;
+    isApplyButtonDisabled: import("vue").ComputedRef<boolean>;
+};

package/dist/@types/components/filter-bar/components/base-filter/index.d.ts

@@ -1 +1,2 @@
 export { default as BentoBaseFilter } from './base-filter.vue';
+export * from './composables/use-base-filter';

package/dist/@types/components/filter-bar/components/boolean-filter/boolean-filter.vue.d.ts

@@ -0,0 +1,43 @@
+declare const _default: import("vue").DefineComponent<{
+    field: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    value: {
+        type: StringConstructor;
+        default: any;
+    };
+}, {
+    items: import("vue").Ref<{
+        value: string;
+        label: string;
+    }[]>;
+    appliedFiltersCount: import("vue").ComputedRef<number>;
+    internalFilterValue: import("vue").Ref<string>;
+    isApplyButtonDisabled: import("vue").ComputedRef<boolean>;
+    isClearButtonDisabled: import("vue").ComputedRef<boolean>;
+    onInput: (event: any) => void;
+    updateFilter: () => void;
+    clearFilter: () => void;
+    openFilter: () => void;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, "update"[], string, Readonly<import("vue").ExtractPropTypes<{
+    field: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    value: {
+        type: StringConstructor;
+        default: any;
+    };
+}>>, {
+    value: string;
+}>;
+export default _default;

package/dist/@types/components/filter-bar/components/boolean-filter/index.d.ts

@@ -0,0 +1 @@
+export { default as BentoBooleanFilter } from './boolean-filter.vue';

package/dist/@types/components/filter-bar/components/range-filter/range-filter.vue.d.ts

@@ -0,0 +1,42 @@
+import { PropType } from 'vue';
+import { BentoInputFieldType } from '@/components/input-field';
+declare const _default: import("vue").DefineComponent<{
+    field: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    value: {
+        type: PropType<string[]>;
+        required: true;
+    };
+}, {
+    BentoInputFieldType: typeof BentoInputFieldType;
+    inputTextRef: any;
+    appliedFiltersCount: import("vue").ComputedRef<number>;
+    internalFilterValue: import("vue").Ref<string[]>;
+    isApplyButtonDisabled: import("vue").ComputedRef<boolean>;
+    isClearButtonDisabled: import("vue").ComputedRef<boolean>;
+    updateFrom: (newValue: any) => void;
+    updateTo: (newValue: any) => void;
+    updateFilter: () => void;
+    clearFilter: () => void;
+    openFilter: () => void;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, "update"[], string, Readonly<import("vue").ExtractPropTypes<{
+    field: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    value: {
+        type: PropType<string[]>;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/dist/@types/components/filter-bar/components/select-filter/index.d.ts

@@ -0,0 +1 @@
+export { default as BentoSelectFilter } from './select-filter.vue';

package/dist/@types/components/filter-bar/components/select-filter/select-filter.vue.d.ts

@@ -0,0 +1,55 @@
+import { PropType } from 'vue';
+import { BentoListboxOptionItem, BentoListboxSelectedValue } from '@/types';
+import { BentoSelectFilterOptions } from '../../filter-bar.types';
+declare const _default: import("vue").DefineComponent<{
+    field: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    options: {
+        type: PropType<BentoSelectFilterOptions>;
+        default: any;
+    };
+    value: {
+        type: PropType<BentoListboxSelectedValue>;
+        default: any;
+    };
+}, {
+    appliedFiltersCount: import("vue").ComputedRef<number>;
+    filteredItems: import("vue").ComputedRef<BentoListboxOptionItem[]>;
+    internalFilterValue: import("vue").Ref<import("@/types").BentoListboxValue | import("@/types").BentoListboxValue[]>;
+    isApplyButtonDisabled: import("vue").ComputedRef<boolean>;
+    isClearButtonDisabled: import("vue").ComputedRef<boolean>;
+    listboxFilterId: import("vue").ComputedRef<string>;
+    searchTerm: import("vue").Ref<string>;
+    clearFilter: () => void;
+    closeFilter: () => void;
+    onOptionSelected: (selectedValue: BentoListboxSelectedValue) => void;
+    openFilter: () => void;
+    updateFilter: () => void;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, "update"[], string, Readonly<import("vue").ExtractPropTypes<{
+    field: {
+        type: StringConstructor;
+        required: true;
+    };
+    label: {
+        type: StringConstructor;
+        required: true;
+    };
+    options: {
+        type: PropType<BentoSelectFilterOptions>;
+        default: any;
+    };
+    value: {
+        type: PropType<BentoListboxSelectedValue>;
+        default: any;
+    };
+}>>, {
+    value: BentoListboxSelectedValue;
+    options: BentoSelectFilterOptions;
+}>;
+export default _default;

package/dist/@types/components/filter-bar/components/text-filter/text-filter.vue.d.ts

@@ -12,16 +12,15 @@ declare const _default: import("vue").DefineComponent<{
         default: any;
     };
 }, {
-    internalValue: import("vue").Ref<string>;
-    isFilterOpen: import("vue").Ref<boolean>;
+    appliedFiltersCount: import("vue").ComputedRef<number>;
+    internalFilterValue: import("vue").Ref<string>;
     isApplyButtonDisabled: import("vue").ComputedRef<boolean>;
+    isClearButtonDisabled: import("vue").ComputedRef<boolean>;
     inputTextRef: any;
     updateFilter: () => void;
     clearFilter: () => void;
     openFilter: () => void;
-    closeFilter: () => void;
-    dismissFilter: () => void;
-}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, ("update" | "dismiss")[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, "update"[], string, Readonly<import("vue").ExtractPropTypes<{
     field: {
         type: StringConstructor;
         required: true;

package/dist/@types/components/filter-bar/filter-bar.types.d.ts

@@ -1,14 +1,25 @@
-export interface BentoFilterOptions {
-    values: Array<unknown>;
+import { BentoListboxIsOptionDisabled, BentoListboxOptions, BentoListboxSelectedValue } from '../../types';
+export interface BentoSelectFilterOptions {
+    listboxItems: BentoListboxOptions;
+    multiple?: boolean;
+    isOptionDisabled?: BentoListboxIsOptionDisabled;
 }
+export type BentoTextFilterValue = string | null;
+export type BentoSelectFilterValue = BentoListboxSelectedValue;
+export type BentoBooleanFilterValue = string | null;
+export type BentoFilterBarValue = BentoTextFilterValue | BentoSelectFilterValue | BentoBooleanFilterValue;
+export type BentoFilterOptions = BentoSelectFilterOptions | undefined;
 export declare enum BentoFilterItemType {
-    TEXT = "BentoTextFilter"
+    TEXT = "BentoTextFilter",
+    SELECT = "BentoSelectFilter",
+    BOOLEAN = "BentoBooleanFilter",
+    RANGE = "BentoRangeFilter"
 }
 export interface BentoFilterModel {
     field: string;
     label: string;
     type: BentoFilterItemType;
     options?: BentoFilterOptions;
-    value?: string | null;
+    value?: BentoFilterBarValue;
 }
 export type BentoFilterBarModel = Array<BentoFilterModel>;

package/dist/@types/components/filter-bar/filter-bar.vue.d.ts

@@ -2,22 +2,33 @@ import { PropType } from 'vue';
 import { BentoFilterBarModel, BentoFilterModel } from './filter-bar.types';
 import { BentoButtonVariant } from '@/components/button';
 declare const _default: import("vue").DefineComponent<{
+    searchTerm: {
+        type: StringConstructor;
+        default: string;
+    };
     value: {
         type: PropType<BentoFilterBarModel>;
         default: () => any[];
     };
 }, {
-    isClearAllDisabled: import("vue").ComputedRef<boolean>;
+    isClearAllVisible: import("vue").ComputedRef<boolean>;
+    searchBarAriaLabel: string;
     BentoButtonVariant: typeof BentoButtonVariant;
-    dismissFilterHandler: (dismissedFilter: BentoFilterModel) => void;
     updateFilterHandler: (updatedFilter: BentoFilterModel) => void;
     clearAllFilters: () => void;
-}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, "input"[], string, Readonly<import("vue").ExtractPropTypes<{
+    onSearchbarClear: () => void;
+    onSearchbarInput: (newSearchTerm: string) => void;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, ("input" | "search-clear" | "search-input" | "update:search-term")[], string, Readonly<import("vue").ExtractPropTypes<{
+    searchTerm: {
+        type: StringConstructor;
+        default: string;
+    };
     value: {
         type: PropType<BentoFilterBarModel>;
         default: () => any[];
     };
 }>>, {
     value: BentoFilterBarModel;
+    searchTerm: string;
 }>;
 export default _default;

package/dist/@types/components/info-icon/index.d.ts

@@ -0,0 +1 @@
+export { default as BentoInfoIcon } from './info-icon.vue';

package/dist/@types/components/info-icon/info-icon.vue.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import("vue").DefineComponent<{
+    tooltipText: {
+        type: StringConstructor;
+        required: true;
+    };
+}, {}, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    tooltipText: {
+        type: StringConstructor;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/dist/@types/components/input-field/input-field.types.d.ts

@@ -13,5 +13,6 @@ export declare enum BentoInputFieldStateClass {
 }
 export declare enum BentoInputFieldType {
     SEARCH = "search",
-    TEXT = "text"
+    TEXT = "text",
+    NUMBER = "number"
 }

package/dist/@types/components/input-field/input-field.vue.d.ts

@@ -49,6 +49,7 @@ declare const _default: import("vue").DefineComponent<{
         [x: string]: boolean;
     }>;
     inputFieldElement: any;
+    inputFieldId: string;
     shouldDisplayStaticValueAtStart: import("vue").ComputedRef<boolean>;
     shouldDisplayStaticValueAtEnd: import("vue").ComputedRef<boolean>;
 }, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, ("input" | "escape-pressed")[], string, Readonly<import("vue").ExtractPropTypes<{

package/dist/@types/components/internal/index.d.ts

@@ -0,0 +1 @@
+export * from './listbox';

package/dist/@types/components/internal/listbox/components/listbox-multi-select/index.d.ts

@@ -0,0 +1 @@
+export { default as BentoListboxMultiSelect } from './listbox-multi-select.vue';

package/dist/@types/components/{dropdown/components/dropdown-options-container/components/dropdown-multi-select/dropdown-multi-select.vue.d.ts → internal/listbox/components/listbox-multi-select/listbox-multi-select.vue.d.ts}

@@ -1,42 +1,51 @@
 import { PropType } from 'vue';
 import { BentoTypographyElement } from '@/components/typography';
-import type { BentoDropdownIsOptionDisabled, BentoDropdownOptions, BentoDropdownSelectedValue, BentoDropdownValue } from '../../../../dropdown.types';
+import { BentoListboxIsOptionDisabled, BentoListboxOptions, BentoListboxSelectedValue, BentoListboxValue } from '@/types';
 declare const _default: import("vue").DefineComponent<{
     isOptionDisabled: {
-        type: PropType<BentoDropdownIsOptionDisabled>;
+        type: PropType<BentoListboxIsOptionDisabled>;
         default: () => false;
     };
     items: {
-        type: PropType<BentoDropdownOptions>;
+        type: PropType<BentoListboxOptions>;
         required: true;
     };
+    searching: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     selectedValues: {
-        type: PropType<BentoDropdownSelectedValue>;
-        default: BentoDropdownSelectedValue;
+        type: PropType<BentoListboxSelectedValue>;
+        default: () => BentoListboxSelectedValue;
     };
 }, {
     isAllSelected: import("vue").ComputedRef<boolean>;
     isIndeterminate: import("vue").ComputedRef<boolean>;
-    selectedItemsList: import("vue").Ref<BentoDropdownValue[]>;
+    selectedItemsList: import("vue").Ref<BentoListboxValue[]>;
     selectAllCheckboxText: import("vue").ComputedRef<import("vue-i18n").default.TranslateResult>;
     BentoTypographyElement: typeof BentoTypographyElement;
-    toggleCheckboxSelection: (value: BentoDropdownValue) => void;
+    toggleCheckboxSelection: (value: BentoListboxValue) => void;
     toggleSelectAll: (selectedValue: boolean) => void;
 }, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, "select"[], string, Readonly<import("vue").ExtractPropTypes<{
     isOptionDisabled: {
-        type: PropType<BentoDropdownIsOptionDisabled>;
+        type: PropType<BentoListboxIsOptionDisabled>;
         default: () => false;
     };
     items: {
-        type: PropType<BentoDropdownOptions>;
+        type: PropType<BentoListboxOptions>;
         required: true;
     };
+    searching: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     selectedValues: {
-        type: PropType<BentoDropdownSelectedValue>;
-        default: BentoDropdownSelectedValue;
+        type: PropType<BentoListboxSelectedValue>;
+        default: () => BentoListboxSelectedValue;
     };
 }>>, {
-    isOptionDisabled: BentoDropdownIsOptionDisabled;
-    selectedValues: BentoDropdownSelectedValue;
+    isOptionDisabled: BentoListboxIsOptionDisabled;
+    searching: boolean;
+    selectedValues: BentoListboxSelectedValue;
 }>;
 export default _default;

package/dist/@types/components/internal/listbox/components/listbox-option/index.d.ts

@@ -0,0 +1 @@
+export { default as BentoListboxOption } from './listbox-option.vue';

package/dist/@types/components/{dropdown/components/dropdown-options-container/components/dropdown-option/dropdown-option.vue.d.ts → internal/listbox/components/listbox-option/listbox-option.vue.d.ts}

@@ -9,8 +9,8 @@ declare const _default: import("vue").DefineComponent<{
     };
 }, {
     conditionalClasses: import("vue").ComputedRef<{
-        'b-dropdown-option--disabled': boolean;
-        'b-dropdown-option--selected': boolean;
+        'b-listbox-option--disabled': boolean;
+        'b-listbox-option--selected': boolean;
     }>;
     onClick: (e: Event) => void;
 }, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, ("click" | "escape-pressed" | "enter-pressed")[], string, Readonly<import("vue").ExtractPropTypes<{

package/dist/@types/components/internal/listbox/components/listbox-option-tag/index.d.ts

@@ -0,0 +1 @@
+export { default as ListboxOptionTag } from './listbox-option-tag.vue';

package/dist/@types/components/internal/listbox/components/listbox-option-tag/listbox-option-tag.vue.d.ts

@@ -0,0 +1,19 @@
+import { PropType } from 'vue';
+import type { BentoListboxOptionItem } from '@/types';
+import { BentoTagVariant } from '../../../../tag';
+import { BentoTypographyElement } from '../../../../typography';
+declare const _default: import("vue").DefineComponent<{
+    option: {
+        type: PropType<BentoListboxOptionItem>;
+        required: true;
+    };
+}, {
+    variant: import("vue").ComputedRef<BentoTagVariant>;
+    BentoTypographyElement: typeof BentoTypographyElement;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    option: {
+        type: PropType<BentoListboxOptionItem>;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/dist/@types/components/internal/listbox/components/listbox-single-select-option/index.d.ts

@@ -0,0 +1 @@
+export { default as BentoListboxSingleSelectOption } from './listbox-single-select-option.vue';

package/dist/@types/components/{dropdown/components/dropdown-options-container/components/dropdown-single-select-option/dropdown-single-select-option.vue.d.ts → internal/listbox/components/listbox-single-select-option/listbox-single-select-option.vue.d.ts}

@@ -1,27 +1,19 @@
 import { PropType } from 'vue';
 import { BentoTypographyElement } from '@/components/typography';
-import type { BentoDropdownValue } from '@/components/dropdown/dropdown.types';
+import type { BentoListboxOptionItem } from '@/types';
 declare const _default: import("vue").DefineComponent<{
     disabled: {
         type: BooleanConstructor;
         default: boolean;
     };
-    description: {
-        type: StringConstructor;
-        default: any;
-    };
-    label: {
-        type: StringConstructor;
+    option: {
+        type: PropType<BentoListboxOptionItem>;
         required: true;
     };
     selected: {
         type: BooleanConstructor;
         default: boolean;
     };
-    value: {
-        type: PropType<BentoDropdownValue>;
-        required: true;
-    };
 }, {
     ariaDisabled: import("vue").ComputedRef<boolean>;
     ariaSelected: import("vue").ComputedRef<boolean>;
@@ -33,25 +25,16 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-    description: {
-        type: StringConstructor;
-        default: any;
-    };
-    label: {
-        type: StringConstructor;
+    option: {
+        type: PropType<BentoListboxOptionItem>;
         required: true;
     };
     selected: {
         type: BooleanConstructor;
         default: boolean;
     };
-    value: {
-        type: PropType<BentoDropdownValue>;
-        required: true;
-    };
 }>>, {
     disabled: boolean;
-    description: string;
     selected: boolean;
 }>;
 export default _default;

package/dist/@types/components/internal/listbox/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BentoListbox } from './listbox.vue';
+export { ListboxOptionTag } from './components/listbox-option-tag';

package/dist/@types/components/internal/listbox/listbox.vue.d.ts

@@ -0,0 +1,70 @@
+import { PropType } from 'vue';
+import { BentoListboxIsOptionDisabled, BentoListboxOptions, BentoListboxSelectedValue } from '@/types';
+declare const _default: import("vue").DefineComponent<{
+    ariaLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+    isOptionDisabled: {
+        type: PropType<BentoListboxIsOptionDisabled>;
+        default: any;
+    };
+    items: {
+        type: PropType<BentoListboxOptions>;
+        required: true;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searching: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectedValue: {
+        type: PropType<BentoListboxSelectedValue>;
+        default: any;
+    };
+}, {
+    onOptionSelected: (selectedValue: BentoListboxSelectedValue) => void;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, "select"[], string, Readonly<import("vue").ExtractPropTypes<{
+    ariaLabel: {
+        type: StringConstructor;
+        default: any;
+    };
+    id: {
+        type: StringConstructor;
+        required: true;
+    };
+    isOptionDisabled: {
+        type: PropType<BentoListboxIsOptionDisabled>;
+        default: any;
+    };
+    items: {
+        type: PropType<BentoListboxOptions>;
+        required: true;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    searching: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectedValue: {
+        type: PropType<BentoListboxSelectedValue>;
+        default: any;
+    };
+}>>, {
+    ariaLabel: string;
+    multiple: boolean;
+    isOptionDisabled: BentoListboxIsOptionDisabled;
+    searching: boolean;
+    selectedValue: BentoListboxSelectedValue;
+}>;
+export default _default;