@adyen/bento-vue2 1.18.0 → 1.19.0

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

@@ -45,6 +45,7 @@ import {
     BentoMenu,
     BentoModal,
     BentoModalFullscreen,
+    BentoModalFullscreenPage,
     BentoPagination,
     BentoPaymentMethod,
     BentoPopover,
@@ -74,6 +75,7 @@ import {
     BentoTimelineItem,
     BentoToast,
     BentoToggle,
+    BentoToggleButton,
     BentoTutorial,
     BentoTypography,
 } from './index';
@@ -126,6 +128,7 @@ declare module 'vue' {
         BentoMenu: typeof BentoMenu;
         BentoModal: typeof BentoModal;
         BentoModalFullscreen: typeof BentoModalFullscreen;
+        BentoModalFullscreenPage: typeof BentoModalFullscreenPage;
         BentoPagination: typeof BentoPagination;
         BentoPaymentMethod: typeof BentoPaymentMethod;
         BentoPopover: typeof BentoPopover;
@@ -154,6 +157,7 @@ declare module 'vue' {
         BentoTimelineItem: typeof BentoTimelineItem;
         BentoToast: typeof BentoToast;
         BentoToggle: typeof BentoToggle;
+        BentoToggleButton: typeof BentoToggleButton;
         BentoTutorial: typeof BentoTutorial;
         BentoTypography: typeof BentoTypography;
         BentoTextarea: typeof BentoTextarea;

package/dist/@types/packages/vue2/src/components/button/components/toggle-button/index.d.ts

@@ -0,0 +1 @@
+export { default as BentoToggleButton } from './toggle-button.vue';

package/dist/@types/packages/vue2/src/components/button/components/toggle-button/toggle-button.vue.d.ts

@@ -0,0 +1,65 @@
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    condensed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    inverse: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    variant: {
+        type: import("vue").PropType<"primary" | "secondary" | "tertiary" | import("../../../../../../core/src/components/button/button.types.js").BentoButtonVariant>;
+        default: string;
+        validator: (value: import("../../../../../../core/src/components/button/button.types.js").BentoButtonVariant) => boolean;
+    };
+    toggled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {}, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {
+    click: (event: MouseEvent) => void;
+} & {
+    "update:toggled": (newToggleState: boolean) => void;
+}, string, Readonly<import("vue").ExtractPropTypes<{
+    condensed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    inverse: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    variant: {
+        type: import("vue").PropType<"primary" | "secondary" | "tertiary" | import("../../../../../../core/src/components/button/button.types.js").BentoButtonVariant>;
+        default: string;
+        validator: (value: import("../../../../../../core/src/components/button/button.types.js").BentoButtonVariant) => boolean;
+    };
+    toggled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    variant: "primary" | "secondary" | "tertiary" | import("../../../../../../core/src/components/button/button.types.js").BentoButtonVariant;
+    condensed: boolean;
+    disabled: boolean;
+    inverse: boolean;
+    toggled: boolean;
+}>, Record<string, (_: {
+    key: string | number;
+} | {
+    key?: undefined;
+}) => any>>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/@types/packages/vue2/src/components/button/components/toggle-button/toggle.types.d.ts

@@ -0,0 +1 @@
+export type BentoToggleState = 'default' | 'toggled';

package/dist/@types/packages/vue2/src/components/button/index.d.ts

@@ -2,3 +2,4 @@ export { default as BentoButton } from './button.vue';
 export * from "../../../../core/src/components/button/button.types";
 export * from './components/button-actions';
 export * from './components/loading-button';
+export * from './components/toggle-button';

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

@@ -1,12 +1,7 @@
 import type { BentoTag } from "../tag";
-export type BentoMultiCheckboxType = Array<string | number>;
-export type BentoCheckboxType = boolean | BentoMultiCheckboxType;
-export declare enum BentoCheckboxState {
-    UNCHECKED = "unchecked",
-    DISABLED = "disabled",
-    ERROR = "error",
-    READONLY = "readonly"
-}
+import type { BentoCheckboxType, BentoMultiCheckboxType } from '../internal/checkbox-input';
+import { BentoCheckboxState } from '../internal/checkbox-input';
+export { BentoCheckboxState, BentoCheckboxType, BentoMultiCheckboxType };
 export declare enum BentoCheckboxEvent {
     UPDATE = "update:model-value",
     INPUT = "input"

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

@@ -88,20 +88,17 @@ declare const _default: import("vue").DefineComponent<{
     conditionalClass: import("vue").ComputedRef<{
         [x: string]: boolean;
     }>;
-    conditionalClassOutline: import("vue").ComputedRef<{
-        [x: string]: boolean;
-    }>;
     defaultSlotValue: string;
     descriptionSlotValue: string;
     isCheckboxGroup: import("vue").ComputedRef<boolean>;
     isChecked: import("vue").ComputedRef<boolean>;
     isIndeterminate: import("vue").ComputedRef<boolean>;
+    shouldShowError: import("vue").ComputedRef<boolean>;
     shouldShowErrorMessage: import("vue").ComputedRef<boolean>;
     contentSlotAvailable: import("vue").ComputedRef<boolean>;
     hasContentSlot: import("vue").ComputedRef<boolean>;
     hasSlot: (name: string) => boolean;
-    onChange: (event: Event) => void;
-    onClick: (event: Event) => void;
+    onChange: (newValue: BentoCheckboxType | BentoCheckboxGroupItems) => void;
     t: (key: "required" | "optional" | "ariaLabelFallback", values?: import("vue-i18n").default.Values) => string;
 }, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, BentoCheckboxEvent[], string, Readonly<import("vue").ExtractPropTypes<{
     ariaLabel: {
@@ -189,8 +186,8 @@ declare const _default: import("vue").DefineComponent<{
     readonly: boolean;
     errorMessage: string;
     ariaLabel: string;
-    modelValue: BentoCheckboxType | BentoCheckboxGroupItems;
     hasError: boolean;
     indeterminate: boolean;
+    modelValue: BentoCheckboxType | BentoCheckboxGroupItems;
 }>;
 export default _default;

package/dist/@types/packages/vue2/src/components/checkbox/components/checkbox-group/checkbox-group.vue.d.ts

@@ -165,8 +165,8 @@ declare const _default: import("vue").DefineComponent<{
     tooltipText: string;
     hideLabel: boolean;
     errorMessage: string;
-    modelValue: (string | number)[];
     hasError: boolean;
+    modelValue: (string | number)[];
     formId: string;
 }>;
 export default _default;

package/dist/@types/packages/vue2/src/components/data-grid/components/data-grid-cell/data-grid-cell.types.d.ts

@@ -5,7 +5,7 @@ export declare enum DataGridCellPropClass {
     NUMERIC = "numeric",
     CONDENSED = "condensed",
     FROZEN = "frozen",
-    OVERFLOW_ELLIPSIS = "ellipsis",
+    OVERFLOW_ELLIPSIS = "overflow-ellipsis",
     IS_COLUMN_REORDERING = "is-column-re-ordering",
     IS_COLUMN_REORDERING_TARGET_LEFT = "is-column-re-order-target-left",
     IS_COLUMN_REORDERING_TARGET_RIGHT = "is-column-re-order-target-right"

package/dist/@types/packages/vue2/src/components/date-range-picker/components/date-range-picker-calendar/date-range-picker-calendar.vue.d.ts

@@ -1,4 +1,5 @@
 import { PropType } from 'vue';
+import { CalendarGranularityType } from "../../../internal";
 import { type BentoSegmentedControlItem } from "../../../segmented-control";
 import { DateRangePickerCalendarEvent, DateRangePickerCalendarFormData, DateRangePickerCalendarRangeSelectorItems } from './date-range-picker-calendar.types';
 import type { BentoDateRangePickerGranularityConfig, BentoDateRangePickerValue } from '../../date-range-picker.types';
@@ -22,7 +23,7 @@ declare const _default: import("vue").DefineComponent<{
         validator: (value: import("../../../internal").CalendarFirstDayOfWeek) => boolean;
     };
     granularities: {
-        type: PropType<BentoDateRangePickerGranularityConfig<import("../../../internal").CalendarGranularityType>[]>;
+        type: PropType<BentoDateRangePickerGranularityConfig<CalendarGranularityType>[]>;
         default: any;
     };
     isDateDisabled: {
@@ -57,7 +58,7 @@ declare const _default: import("vue").DefineComponent<{
     };
 }, {
     internalRangeDate: {
-        granularity?: import("../../../internal").CalendarGranularityType;
+        granularity?: CalendarGranularityType;
         startDate: {
             toString: () => string;
             toDateString: () => string;
@@ -196,7 +197,7 @@ declare const _default: import("vue").DefineComponent<{
     endDateError: import("vue").Ref<boolean>;
     endTimeError: import("vue").Ref<boolean>;
     granularityItems: import("vue").ComputedRef<BentoSegmentedControlItem[]>;
-    selectedGranularity: import("vue").ComputedRef<BentoDateRangePickerGranularityConfig<import("../../../internal").CalendarGranularityType>>;
+    selectedGranularity: import("vue").ComputedRef<BentoDateRangePickerGranularityConfig<CalendarGranularityType>>;
     computedMinMax: import("vue").ComputedRef<{
         min: Date;
         max: Date;
@@ -218,6 +219,7 @@ declare const _default: import("vue").DefineComponent<{
     onEndDateInput: (endDateText: string) => void;
     onEndDateSelected: (newEndDate: Date) => void;
     onEndTimeInput: (endDateText: string) => void;
+    onGranularityInput: (value: CalendarGranularityType) => void;
     onRangeSelectorInput: (newCustomRangeValue: string) => void;
     onStartDateInput: (startDateText: string) => void;
     onStartDateSelected: (newStartDate: Date) => void;
@@ -243,7 +245,7 @@ declare const _default: import("vue").DefineComponent<{
         validator: (value: import("../../../internal").CalendarFirstDayOfWeek) => boolean;
     };
     granularities: {
-        type: PropType<BentoDateRangePickerGranularityConfig<import("../../../internal").CalendarGranularityType>[]>;
+        type: PropType<BentoDateRangePickerGranularityConfig<CalendarGranularityType>[]>;
         default: any;
     };
     isDateDisabled: {
@@ -286,7 +288,7 @@ declare const _default: import("vue").DefineComponent<{
     numberOfMonths: number;
     allowTimeInput: boolean;
     dateFormData: DateRangePickerCalendarFormData;
-    granularities: BentoDateRangePickerGranularityConfig<import("../../../internal").CalendarGranularityType>[];
+    granularities: BentoDateRangePickerGranularityConfig<CalendarGranularityType>[];
     quickSelectRanges: DateRangePickerCalendarRangeSelectorItems;
 }>;
 export default _default;

package/dist/@types/packages/vue2/src/components/{internal/calendar → date-range-picker}/composables/use-granularity-memory.types.d.ts

@@ -1,4 +1,4 @@
-import type { CalendarGranularityType } from '../calendar.types';
+import type { CalendarGranularityType } from '../../internal/calendar/calendar.types';
 export type UseGranularityMemory = () => {
     savedRanges: {
         daily: {
@@ -18,5 +18,5 @@ export type UseGranularityMemory = () => {
         startDate: Date;
         endDate: Date;
     }) => void;
-    resetSavedRange: (type: CalendarGranularityType) => void;
+    resetSavedRanges: () => void;
 };

package/dist/@types/packages/vue2/src/components/dropdown/components/dropdown-base-textbox/dropdown-base-textbox.types.d.ts

@@ -54,10 +54,10 @@ export declare enum DropdownBaseTextboxState {
     ERROR = "error"
 }
 export declare enum DropdownBaseTextboxEvent {
-    OPEN = "open",
-    KEYDOWN = "keydown",
-    CLOSE = "close",
-    INPUT = "input",
-    CLEAR = "clear"
+    OPEN = "dropdown-base-open",
+    KEYDOWN = "dropdown-base-keydown",
+    CLOSE = "dropdown-base-close",
+    INPUT = "dropdown-base-input",
+    CLEAR = "dropdown-base-clear"
 }
 export default DropdownBaseTextboxProps;

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

@@ -70,15 +70,15 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         default: boolean;
     };
 }, {}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {
-    clear: () => void;
+    "dropdown-base-clear": () => void;
 } & {
-    close: () => void;
+    "dropdown-base-close": () => void;
 } & {
-    input: (searchValue: string) => void;
+    "dropdown-base-input": (searchValue: string) => void;
 } & {
-    keydown: (event: KeyboardEvent) => void;
+    "dropdown-base-keydown": (event: KeyboardEvent) => void;
 } & {
-    open: () => void;
+    "dropdown-base-open": () => void;
 }, string, Readonly<import("vue").ExtractPropTypes<{
     additionalItemsSelected: {
         type: PropType<string | number>;

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

@@ -1,7 +1,6 @@
 import { PropType } from 'vue';
 import { BentoListboxOptionItem, Booleanish } from "../../../../types";
-import { DropdownBaseTextboxEvent } from '../dropdown-base-textbox/dropdown-base-textbox.types';
-declare const _default: import("vue").DefineComponent<{
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     additionalItemsSelected: {
         type: PropType<string | number>;
         default: number;
@@ -70,22 +69,17 @@ declare const _default: import("vue").DefineComponent<{
         type: BooleanConstructor;
         default: boolean;
     };
-}, {
-    DropdownBaseTextboxEvent: typeof DropdownBaseTextboxEvent;
-    conditionalClasses: import("vue").ComputedRef<{
-        [x: string]: boolean;
-        'b-dropdown-default-textbox--condensed': boolean;
-    }>;
-    isDropdownOpen: import("vue").ComputedRef<boolean>;
-    slots: import("vue/types/v3-setup-context").Slots;
-    listeners: {
-        input: (e: Event) => void;
-        open: (e: Event) => void;
-        close: (e: Event) => void;
-        clear: (e: Event) => void;
-        keydown: (e: Event) => void;
-    };
-}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, DropdownBaseTextboxEvent[], string, Readonly<import("vue").ExtractPropTypes<{
+}, {}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {
+    clear: () => void;
+} & {
+    close: () => void;
+} & {
+    input: (newInput: string) => void;
+} & {
+    keydown: (keydownEvent: KeyboardEvent) => void;
+} & {
+    open: () => void;
+}, string, Readonly<import("vue").ExtractPropTypes<{
     additionalItemsSelected: {
         type: PropType<string | number>;
         default: number;
@@ -170,5 +164,10 @@ declare const _default: import("vue").DefineComponent<{
     isInvalid: boolean;
     selectedValueItem: BentoListboxOptionItem | BentoListboxOptionItem[];
     showSlotContentInMultiple: boolean;
-}>;
+}>, Record<string, (_: any) => any>>;
 export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -54,9 +54,9 @@ declare const _default: import("vue").DefineComponent<{
         default: string;
     };
 }, {}, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {
-    close: () => void;
-} & {
     open: () => void;
+} & {
+    close: () => void;
 }, string, Readonly<import("vue").ExtractPropTypes<{
     additionalItemsSelected: {
         type: PropType<string | number>;

package/dist/@types/packages/vue2/src/components/filter-bar/components/all-filters-modal/all-filters-modal.vue.d.ts

@@ -1,6 +1,6 @@
 import { PropType } from 'vue';
 import { BentoModalEvent } from "../../../modal";
-import { BentoFilterBarModel, BentoFilterItemType, BentoFilterModel } from "../..";
+import { BentoFilterBarModel, BentoFilterItemType, BentoFilterModel } from "../../filter-bar.types";
 import { AllFiltersModalEvent } from './all-filters-modal.types';
 declare const _default: import("vue").DefineComponent<{
     value: {

package/dist/@types/packages/vue2/src/components/internal/calendar/calendar.types.d.ts

@@ -21,8 +21,8 @@ interface UseCalendarPaneProps {
     selectedDate: Ref<CalendarValue>;
     granularity?: Ref<CalendarGranularityConfig>;
     firstDayOfWeek: Day;
-    min?: Date;
-    max?: Date;
+    min?: Ref<Date>;
+    max?: Ref<Date>;
 }
 export type UseCalendarPane = (propRefs: UseCalendarPaneProps, emit: any) => {
     internalValue: UnwrapNestedRefs<CalendarRangeDateValue>;

package/dist/@types/packages/vue2/src/components/internal/calendar/composables/use-granularity-adjustments.types.d.ts

@@ -1,14 +1,14 @@
-export type UseGranularityAdjustments = (firstDayOfWeek: Day, min?: Date, max?: Date) => {
-    adjustDateForWeekly: (date: Date, endDate?: Date) => {
+export type UseGranularityAdjustments = (firstDayOfWeek: Day) => {
+    adjustDateForWeekly: (date: Date, endDate?: Date, min?: Date, max?: Date) => {
         startDate: Date;
         endDate: Date;
     };
-    adjustDateForMonthly: (date: Date, endDate?: Date) => {
+    adjustDateForMonthly: (date: Date, endDate?: Date, min?: Date, max?: Date) => {
         startDate: Date;
         endDate: Date;
     };
-    adjustStartDateInputForWeekly: (date: string, formatDate: (dateToFormat?: Date) => string) => string;
-    adjustEndDateInputForWeekly: (date: string, formatDate: (dateToFormat?: Date) => string) => string;
-    adjustStartDateInputForMonthly: (date: string, formatDate: (dateToFormat?: Date) => string) => string;
-    adjustEndDateInputForMonthly: (date: string, formatDate: (dateToFormat?: Date) => string) => string;
+    adjustStartDateInputForWeekly: (date: string, formatDate: (dateToFormat?: Date) => string, min?: Date, max?: Date) => string;
+    adjustEndDateInputForWeekly: (date: string, formatDate: (dateToFormat?: Date) => string, min?: Date, max?: Date) => string;
+    adjustStartDateInputForMonthly: (date: string, formatDate: (dateToFormat?: Date) => string, min?: Date, max?: Date) => string;
+    adjustEndDateInputForMonthly: (date: string, formatDate: (dateToFormat?: Date) => string, min?: Date, max?: Date) => string;
 };

package/dist/@types/packages/vue2/src/components/internal/checkbox-input/checkbox-input.types.d.ts

@@ -0,0 +1,20 @@
+export type MultiCheckboxInputType = Array<string | number>;
+export type CheckboxInputType = boolean | MultiCheckboxInputType;
+export declare enum CheckboxInputState {
+    UNCHECKED = "unchecked",
+    DISABLED = "disabled",
+    ERROR = "error",
+    READONLY = "readonly"
+}
+export declare enum CheckboxInputEvent {
+    UPDATE = "update:model-value"
+}
+interface CheckboxInputGroupItem {
+    value: string | number;
+    disabled?: boolean;
+    hasError?: boolean;
+    errorMessage?: string;
+    readonly?: boolean;
+}
+export type CheckboxInputGroupItems = Array<CheckboxInputGroupItem>;
+export {};

package/dist/@types/packages/vue2/src/components/internal/checkbox-input/checkbox-input.vue.d.ts

@@ -0,0 +1,90 @@
+import { PropType } from 'vue';
+import { CheckboxInputGroupItems, CheckboxInputType } from './checkbox-input.types';
+declare const _default: import("vue").DefineComponent<{
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    ariaDescribedby: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasError: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: any;
+    };
+    indeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modelValue: {
+        type: PropType<CheckboxInputType | CheckboxInputGroupItems>;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: any;
+    };
+}, {}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {
+    "update:model-value": (value: boolean | (string | number)[]) => void;
+}, string, Readonly<import("vue").ExtractPropTypes<{
+    ariaLabel: {
+        type: StringConstructor;
+        default: string;
+    };
+    ariaDescribedby: {
+        type: StringConstructor;
+        default: string;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasError: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    id: {
+        type: StringConstructor;
+        default: any;
+    };
+    indeterminate: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    modelValue: {
+        type: PropType<CheckboxInputType | CheckboxInputGroupItems>;
+        default: boolean;
+    };
+    readonly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    value: {
+        type: (StringConstructor | NumberConstructor)[];
+        default: any;
+    };
+}>>, {
+    value: string | number;
+    disabled: boolean;
+    readonly: boolean;
+    id: string;
+    ariaLabel: string;
+    ariaDescribedby: string;
+    hasError: boolean;
+    indeterminate: boolean;
+    modelValue: CheckboxInputType | CheckboxInputGroupItems;
+}>;
+export default _default;

package/dist/@types/packages/vue2/src/components/internal/checkbox-input/index.d.ts

@@ -0,0 +1,3 @@
+export { default as CheckboxInput } from './checkbox-input.vue';
+export type { CheckboxInputType as BentoCheckboxType, MultiCheckboxInputType as BentoMultiCheckboxType, } from './checkbox-input.types';
+export { CheckboxInputState as BentoCheckboxState } from './checkbox-input.types';

package/dist/@types/packages/vue2/src/components/internal/dialog-page/dialog-page.keys.d.ts

@@ -0,0 +1,2 @@
+export declare const DIALOG_PAGE_REGISTER_PAGE_INJECTION_KEY: unique symbol;
+export declare const DIALOG_PAGE_CONFIG_INJECTION_KEY: unique symbol;

package/dist/@types/packages/vue2/src/components/internal/dialog-page/dialog-page.types.d.ts

@@ -0,0 +1,16 @@
+import { Ref } from 'vue';
+export declare enum BentoDialogPageAnimation {
+    TRANSITION_LEVEL_DEEPER = "b-dialog-page__animation--level-deeper",
+    TRANSITION_LEVEL_UPPER = "b-dialog-page__animation--level-upper"
+}
+export interface BentoDialogPageConfigData {
+    activePage: Ref<string>;
+    animation: Ref<string>;
+    isOpen: Ref<boolean>;
+    pages: Ref<string[]>;
+    previousPages: Ref<string[]>;
+    updatePage: (page: string) => void;
+}
+export type BentoDialogPageRegisterPage = (pageId: string) => {
+    unregisterPage: () => void;
+};

package/dist/@types/packages/vue2/src/components/internal/dialog-page/dialog-page.vue.d.ts

@@ -0,0 +1,54 @@
+import { PropType } from 'vue';
+import type { CSSProperties } from 'vue/types/jsx';
+declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
+    pageId: {
+        type: StringConstructor;
+        default: any;
+    };
+    alwaysShowBorder: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    backButtonStyling: {
+        type: PropType<CSSProperties>;
+        default: any;
+    };
+    previousPage: {
+        type: StringConstructor;
+        default: any;
+    };
+}, {}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {
+    animationend: () => void;
+}, string, Readonly<import("vue").ExtractPropTypes<{
+    pageId: {
+        type: StringConstructor;
+        default: any;
+    };
+    alwaysShowBorder: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    backButtonStyling: {
+        type: PropType<CSSProperties>;
+        default: any;
+    };
+    previousPage: {
+        type: StringConstructor;
+        default: any;
+    };
+}>>, {
+    pageId: string;
+    alwaysShowBorder: boolean;
+    backButtonStyling: CSSProperties;
+    previousPage: string;
+}>, {
+    header: (_: {}) => any;
+    content: (_: {}) => any;
+    footer: (_: {}) => any;
+}>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/@types/packages/vue2/src/components/internal/dialog-page/index.d.ts

@@ -0,0 +1,3 @@
+export { default as DialogPage } from './dialog-page.vue';
+export * from './dialog-page.types';
+export * from './dialog-page.keys';

package/dist/@types/packages/vue2/src/components/internal/index.d.ts

@@ -2,6 +2,7 @@ export * from './avatar';
 export * from './calendar';
 export * from './copy';
 export * from './controls-group';
+export * from './dialog-page';
 export * from './error-message';
 export * from './field-label';
 export * from './fixed-scroller';

package/dist/@types/packages/vue2/src/components/internal/listbox/composables/use-cached-selected-values/use-cached-selected-values.d.ts

@@ -0,0 +1,14 @@
+import { BentoListboxOptions, BentoListboxSelectedValue, BentoListboxValue } from "../../../../../types";
+import { Ref } from 'vue';
+export declare const useCachedSelectedValues: (items: Ref<BentoListboxOptions>, selectedValues: Ref<BentoListboxSelectedValue>, multiple: Ref<boolean>) => {
+    cachedSelectedValues: Ref<{
+        data?: unknown;
+        description?: string;
+        value: BentoListboxValue;
+        items?: any[];
+        label: string;
+    }[]>;
+    simpleSelectedValuesCache: Ref<BentoListboxSelectedValue>;
+    resetCache: () => void;
+    setCachedValues: (newSelectedValues: BentoListboxOptions) => void;
+};

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

@@ -1,3 +1,4 @@
 export { default as BentoListbox } from './listbox.vue';
 export { ListboxOptionTag } from './components/listbox-option-tag';
 export { useMultiLevelItems } from './composables/use-multi-level-items/use-multi-level-items';
+export { useCachedSelectedValues } from './composables/use-cached-selected-values/use-cached-selected-values';

package/dist/@types/packages/vue2/src/components/internal/radio-input/index.d.ts

@@ -0,0 +1,3 @@
+export { default as RadioInput } from './radio-input.vue';
+export type { RadioInputValue } from './radio-input.types';
+export { RadioInputStateClass } from './radio-input.types';

package/dist/@types/packages/vue2/src/components/internal/radio-input/radio-input.types.d.ts

@@ -0,0 +1,6 @@
+export type RadioInputValue = string | number;
+export declare enum RadioInputStateClass {
+    DISABLED = "disabled",
+    READONLY = "readonly",
+    ERROR = "error"
+}