@adyen/bento-vue2 1.9.0 → 1.11.0

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

@@ -4,6 +4,8 @@ export interface BentoButtonActionObject extends BentoButtonProps {
     title: string;
     event?: (event: Event) => void;
     icon?: VueNodeElement;
+    iconLeft?: VueNodeElement;
+    iconRight?: VueNodeElement;
     state?: BentoLoadingButtonState | `${BentoLoadingButtonState}`;
 }
 export type BentoButtonActionsList = Array<BentoButtonActionObject>;

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

@@ -14,7 +14,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         default: boolean;
     };
     state: {
-        type: PropType<"start" | "loading" | BentoLoadingButtonState | "success" | "fail">;
+        type: PropType<"start" | "loading" | "success" | BentoLoadingButtonState | "fail">;
         default: BentoLoadingButtonState;
         validator: (value: BentoLoadingButtonState) => boolean;
     };
@@ -39,7 +39,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
         default: boolean;
     };
     state: {
-        type: PropType<"start" | "loading" | BentoLoadingButtonState | "success" | "fail">;
+        type: PropType<"start" | "loading" | "success" | BentoLoadingButtonState | "fail">;
         default: BentoLoadingButtonState;
         validator: (value: BentoLoadingButtonState) => boolean;
     };
@@ -53,7 +53,7 @@ declare const _default: __VLS_WithTemplateSlots<import("vue").DefineComponent<{
     condensed: boolean;
     disabled: boolean;
     inverse: boolean;
-    state: "start" | "loading" | BentoLoadingButtonState | "success" | "fail";
+    state: "start" | "loading" | "success" | BentoLoadingButtonState | "fail";
 }>, {
     default: (_: {}) => any;
 }>;

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

@@ -61,6 +61,8 @@ declare const _default: import("vue").DefineComponent<{
     isChecked: import("vue").ComputedRef<boolean>;
     isIndeterminate: 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;

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

@@ -73,6 +73,7 @@ declare const _default: import("vue").DefineComponent<{
         validator: (value: BentoCheckboxGroupVariant) => boolean;
     };
 }, {
+    COMPONENT_NAME: string;
     errorId: string;
     isReadOnly: import("vue").ComputedRef<boolean>;
     shouldShowGroupError: import("vue").ComputedRef<boolean>;
@@ -81,6 +82,7 @@ declare const _default: import("vue").DefineComponent<{
         'b-checkbox-group__checkboxes--horizontal': boolean;
     }>;
     inputValue: import("vue").Ref<(string | number)[]>;
+    hasContentSlot: (name: any) => boolean;
     onInput: (value: any) => void;
 }, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, BentoCheckboxEvent[], string, Readonly<import("vue").ExtractPropTypes<{
     description: {

package/dist/@types/packages/vue2/src/components/code-snippet/{composables/useLanguage.d.ts → utils/get-lang-loader.d.ts}

@@ -3,6 +3,4 @@ import { json } from '@codemirror/lang-json';
 import { xml } from '@codemirror/lang-xml';
 import { javascript } from '@codemirror/lang-javascript';
 import { java } from '@codemirror/lang-java';
-export declare const useLanguage: (language: BentoCodeSnippetSupportedLanguage | `${BentoCodeSnippetSupportedLanguage}`) => {
-    loadLang: () => Promise<typeof json | typeof xml | typeof javascript | typeof java>;
-};
+export declare const getLangLoader: (language: BentoCodeSnippetSupportedLanguage | `${BentoCodeSnippetSupportedLanguage}`) => () => Promise<typeof json | typeof xml | typeof javascript | typeof java>;

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

@@ -1,3 +1,3 @@
-export { useCountryCapital } from './useCountryCapital/useCountryCapital';
-export { useCountryName } from './useCountryName/useCountryName';
-export { useCountryPhoneCode } from './useCountryPhoneCode/useCountryPhoneCode';
+export { useCountryCapital } from './use-country-capital/use-country-capital';
+export { useCountryName } from './use-country-name/use-country-name';
+export { useCountryPhoneCode } from './use-country-phone-code/use-country-phon-code';

package/dist/@types/packages/vue2/src/components/country/composables/{useCountryCapital/useCountryCapital.d.ts → use-country-capital/use-country-capital.d.ts}

@@ -1,3 +1,3 @@
 import { MaybeRef } from "../../../../types";
-export declare const useCountryCapital: (code: MaybeRef<string>, locale: MaybeRef<string>, useFallback?: boolean) => import("vue").ComputedRef<any>;
+export declare const useCountryCapital: (code: MaybeRef<string>, locale: MaybeRef<string>, useFallback?: boolean) => import("vue").ComputedRef<string>;
 export default useCountryCapital;

package/dist/@types/packages/vue2/src/components/country/composables/{useCountryName/useCountryName.d.ts → use-country-name/use-country-name.d.ts}

@@ -1,2 +1,2 @@
 import { MaybeRef } from "../../../../types";
-export declare const useCountryName: (code: MaybeRef<string>, locale: MaybeRef<string>, useFallback?: boolean) => import("vue").ComputedRef<any>;
+export declare const useCountryName: (code: MaybeRef<string>, locale: MaybeRef<string>, useFallback?: boolean) => import("vue").ComputedRef<string>;

package/dist/@types/packages/vue2/src/components/country/composables/{useCountryPhoneCode/useCountryPhoneCode.d.ts → use-country-phone-code/use-country-phon-code.d.ts}

@@ -1,3 +1,3 @@
 import { MaybeRef } from "../../../../types";
-export declare const useCountryPhoneCode: (countryCode: MaybeRef<string>) => import("vue").ComputedRef<any>;
+export declare const useCountryPhoneCode: (countryCode: MaybeRef<string>) => import("vue").ComputedRef<string>;
 export default useCountryPhoneCode;

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

@@ -16,7 +16,7 @@ declare const _default: import("vue").DefineComponent<{
         validator: (value: BentoCountryVariant) => boolean;
     };
 }, {
-    countryName: import("vue").ComputedRef<any>;
+    countryName: import("vue").ComputedRef<string>;
     countryLabel: import("vue").Ref<string>;
     isSummaryGridLayout: boolean;
 }, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{

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

@@ -0,0 +1,14 @@
+import type { BentoButtonActionObject } from "../../../button";
+import type { BentoMenuItem } from "../../../menu/components";
+import type { BentoDatagridDataItem } from "../..";
+import { OmitStrict } from "../../../../types";
+export type BentoColumnCellActionVariant = 'copy' | 'edit' | 'open' | 'more';
+export type BentoColumnCellAction = OmitStrict<BentoButtonActionObject, 'variant' | 'event' | 'title' | 'icon' | 'state'> & {
+    title?: string;
+    event?: (rowDataItem: BentoDatagridDataItem, columnKey: string) => void;
+    isShort?: true;
+    variant?: BentoColumnCellActionVariant;
+    menuData?: BentoMenuItem[];
+    getCopyData?: (rowDataItem: BentoDatagridDataItem, columnKey: string) => string;
+};
+export type BentoColumnCellActions = BentoColumnCellAction[];

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

@@ -0,0 +1,33 @@
+import { PropType } from 'vue';
+import { BentoDatagridDataItem } from "../../data-grid.types";
+import type { BentoColumnCellActions } from './data-grid-cell-actions.types';
+declare const _default: import("vue").DefineComponent<{
+    cellActions: {
+        type: PropType<BentoColumnCellActions>;
+        required: true;
+        validator: (value: BentoColumnCellActions) => boolean;
+    };
+    columnKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    rowDataItem: {
+        type: PropType<BentoDatagridDataItem>;
+        required: true;
+    };
+}, {}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    cellActions: {
+        type: PropType<BentoColumnCellActions>;
+        required: true;
+        validator: (value: BentoColumnCellActions) => boolean;
+    };
+    columnKey: {
+        type: StringConstructor;
+        required: true;
+    };
+    rowDataItem: {
+        type: PropType<BentoDatagridDataItem>;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

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

@@ -4,6 +4,7 @@ export declare enum DatagridColumnsEvent {
     COLUMN_RESIZING = "column-resizing",
     SORT = "sort",
     SELECT_ALL_ROWS = "select-all-rows",
+    SELECT_ALL_ACROSS_PAGES = "select-all-across-pages",
     COLUMN_MOVE = "column-move",
     COLUMN_UPDATE = "column-update",
     COLUMN_MENU_OPEN = "column-menu-open",

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

@@ -39,6 +39,10 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<BentoDatagridAllItemsSelectedState>;
         default: any;
     };
+    selectableAcrossPages: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     sortBy: {
         type: PropType<BentoDatagridSortByColumn[]>;
         default: () => any[];
@@ -67,12 +71,12 @@ declare const _default: import("vue").DefineComponent<{
         'b-data-grid-columns--config-settings-margin': boolean;
         'b-data-grid-columns--frozen'?: undefined;
     }>;
-    allItemsSelectedCheckboxState: import("vue").Ref<{
-        allItemsSelected: boolean;
-        isIndeterminate: boolean;
-    }>;
     isSelectColumn: (column: BentoColumn) => boolean;
     onAllRowSelect: (areAllItemsSelected: boolean) => void;
+    selectAllMenu: import("vue").ComputedRef<{
+        text: string;
+        handler: () => void;
+    }[]>;
     conditionalSortDirectionClasses: (field: string, direction: BentoDatagridSortDirection) => {
         'b-data-grid-columns__column-sort-icon--sorted': boolean;
     };
@@ -100,6 +104,13 @@ declare const _default: import("vue").DefineComponent<{
     computeMenuPosition: (hasFirstColumnPanelRightAligned: any, index: any) => import("../../../popper-container").PopperContainerPositionExtended.BOTTOM_START | import("../../../popper-container").PopperContainerPositionExtended.BOTTOM_END;
     BentoDatagridSortDirection: typeof BentoDatagridSortDirection;
     DatagridColumnsEvent: typeof DatagridColumnsEvent;
+    t: import("vue-i18n-bridge").ComposerTranslation<import("../../../../utils/ts/i18n").i18nMessages, string, import("@intlify/core-base").RemoveIndexSignature<{
+        [x: string]: import("vue-i18n-bridge").LocaleMessageValue<import("vue-i18n-bridge").VueMessageType>;
+    }>, never, import("@intlify/core-base")._ResourcePath<{
+        [key: string]: string;
+    }>, import("@intlify/core-base")._ResourcePath<{
+        [key: string]: string;
+    }>> | ((key: "selectAll" | "freezeColumn" | "hideColumn" | "moveColumnLeft" | "moveColumnRight" | "selectPage" | "selectionMenu" | "showColumn" | "unfreezeColumn", values?: import("vue-i18n").default.Values) => string);
 }, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, DatagridColumnsEvent[], string, Readonly<import("vue").ExtractPropTypes<{
     columns: {
         type: PropType<BentoColumn[]>;
@@ -137,6 +148,10 @@ declare const _default: import("vue").DefineComponent<{
         type: PropType<BentoDatagridAllItemsSelectedState>;
         default: any;
     };
+    selectableAcrossPages: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
     sortBy: {
         type: PropType<BentoDatagridSortByColumn[]>;
         default: () => any[];
@@ -150,6 +165,7 @@ declare const _default: import("vue").DefineComponent<{
     hasFirstColumnPanelRightAligned: boolean;
     isOnlyOneVisibleColumn: boolean;
     allItemsSelectedState: BentoDatagridAllItemsSelectedState;
+    selectableAcrossPages: boolean;
     sortBy: BentoDatagridSortByColumn[];
 }>;
 export default _default;

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

@@ -1,3 +1,4 @@
 export { default as DataGridColumns } from './data-grid-columns/data-grid-columns.vue';
 export { default as BentoDataGridConfigSettings } from './data-grid-config-settings/data-grid-config-settings.vue';
 export { default as DataGridLazyLoad } from './data-grid-lazy-load/data-grid-lazy-load.vue';
+export { default as DataGridCellActions } from './data-grid-cell-actions/data-grid-cell-actions.vue';

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

@@ -1,8 +1,10 @@
-export { default as useResizer } from './useResizer';
-export { default as useCalculateColumnWidth, DATAGRID_SELECT_FIELD_NAME, } from './useCalculateColumnWidth/useCalculateColumnWidth';
-export { useSorter } from './useSorter';
-export { useSelector } from './useSelector';
-export { useKeyboardNavigator } from './useKeyboardNavigator/useKeyboardNavigator';
-export { useLazyLoading } from './useLazyLoading/useLazyLoading';
-export { useColumnReorderer } from './useColumnReorderer/useColumnReorderer';
-export { useConfigSettings } from './useConfigSettings/useConfigSettings';
+export { useResizer } from './use-resizer';
+export * from './use-calculate-column-width';
+export { useSelector } from './use-selector';
+export { useSorter } from './use-sorter';
+export { useKeyboardNavigator } from './use-keyboard-navigator/use-keyboard-navigator';
+export { useLazyLoading } from './use-lazy-loading/use-lazy-loading';
+export { useColumnReorderer } from './use-column-reorderer/use-column-reorderer';
+export { useConfigSettings } from './use-config-settings/use-config-settings';
+export { useCalculateStickyElementHeight } from './use-calculate-sticky-element-height/use-calculate-sticky-element-height';
+export { useScroller } from './use-scroller/use-scroller';

package/dist/@types/packages/vue2/src/components/data-grid/composables/use-calculate-column-width/index.d.ts

@@ -0,0 +1,2 @@
+export * from './use-calculate-column-width';
+export * from './use-calculate-column-width.types';

package/dist/@types/packages/vue2/src/components/data-grid/composables/{useCalculateColumnWidth/useCalculateColumnWidth.d.ts → use-calculate-column-width/use-calculate-column-width.d.ts}

@@ -1,5 +1,5 @@
 import { BentoColumn, BentoColumnWidthOverridesLookup, BentoDatagridData } from '../../data-grid.types';
-import { CalculateColumnWidthOptions } from './useCalculateColumnWidth.types';
+import { CalculateColumnWidthOptions } from './use-calculate-column-width.types';
 import { MaybeRef } from "../../../../types";
 export declare const DEFAULT_COLUMN_WIDTH = 100;
 export declare const DEFAULT_COLUMN_MIN_WIDTH = 50;
@@ -25,6 +25,7 @@ export declare const useCalculateColumnWidth: (newColumns: MaybeRef<BentoColumn[
         visible?: boolean;
         mandatory?: boolean;
         frozen?: boolean;
+        cellActions?: import("../../components/data-grid-cell-actions/data-grid-cell-actions.types").BentoColumnCellActions;
     }[]>;
     gridColumnWidthStyle: import("vue").ComputedRef<{
         width: string;
@@ -32,4 +33,3 @@ export declare const useCalculateColumnWidth: (newColumns: MaybeRef<BentoColumn[
     onColumnWidthOverride: (newColumnWidthOverridesLookup: BentoColumnWidthOverridesLookup) => void;
     isMeasuringColumnWidths: import("vue").Ref<boolean>;
 };
-export default useCalculateColumnWidth;

package/dist/@types/packages/vue2/src/components/data-grid/composables/use-column-reorderer/use-column-reorderer.d.ts

@@ -0,0 +1,121 @@
+import { MaybeRef } from "../../../../types";
+import { BentoColumn } from '../../data-grid.types';
+import type { SetupContext } from 'vue/types/v3-setup-context';
+export declare const useColumnReorderer: (columnsRef: MaybeRef<BentoColumn[]>, hasDraggableColumnsRef: MaybeRef<boolean>, emit: SetupContext['emit']) => {
+    draggingColumns: {
+        dragging?: {
+            field: string;
+            label: string;
+            width?: number;
+            autoWidth?: boolean;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: import("../../data-grid.types").BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+            cellActions?: {
+                link?: object;
+                type?: string;
+                condensed?: boolean;
+                critical?: boolean;
+                disabled?: boolean;
+                inverse?: boolean;
+                iconLeft?: object | Element | (object | Element)[];
+                iconRight?: object | Element | (object | Element)[];
+                title?: string;
+                event?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => void;
+                isShort?: true;
+                variant?: import("../../components/data-grid-cell-actions/data-grid-cell-actions.types").BentoColumnCellActionVariant;
+                menuData?: {
+                    text: string;
+                    handler: () => void;
+                    secondaryText?: string;
+                    items?: any[];
+                    disabled?: boolean;
+                    chevron?: boolean;
+                    icon?: object | Element | (object | Element)[];
+                    critical?: boolean;
+                    indent?: boolean;
+                    addDivider?: boolean;
+                }[];
+                getCopyData?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => string;
+            }[];
+        };
+        dragToLeft?: boolean;
+        target?: {
+            field: string;
+            label: string;
+            width?: number;
+            autoWidth?: boolean;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: import("../../data-grid.types").BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+            cellActions?: {
+                link?: object;
+                type?: string;
+                condensed?: boolean;
+                critical?: boolean;
+                disabled?: boolean;
+                inverse?: boolean;
+                iconLeft?: object | Element | (object | Element)[];
+                iconRight?: object | Element | (object | Element)[];
+                title?: string;
+                event?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => void;
+                isShort?: true;
+                variant?: import("../../components/data-grid-cell-actions/data-grid-cell-actions.types").BentoColumnCellActionVariant;
+                menuData?: {
+                    text: string;
+                    handler: () => void;
+                    secondaryText?: string;
+                    items?: any[];
+                    disabled?: boolean;
+                    chevron?: boolean;
+                    icon?: object | Element | (object | Element)[];
+                    critical?: boolean;
+                    indent?: boolean;
+                    addDivider?: boolean;
+                }[];
+                getCopyData?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => string;
+            }[];
+        };
+    };
+    draggingEventsForColumns: import("vue").ComputedRef<{
+        "column-dragstart"?: undefined;
+        "column-dragenter"?: undefined;
+        "column-drop"?: undefined;
+        "column-dragend"?: undefined;
+    } | {
+        "column-dragstart": (column: BentoColumn, e: DragEvent & Event) => void;
+        "column-dragenter": (column: BentoColumn, dragEvent: DragEvent) => void;
+        "column-drop": (column: BentoColumn) => void;
+        "column-dragend": () => void;
+    }>;
+    draggingEventsForRowCell: import("vue").ComputedRef<(column: BentoColumn) => {
+        dragenter?: undefined;
+        drop?: undefined;
+        dragover?: undefined;
+    } | {
+        dragenter: (e: DragEvent) => void;
+        drop: () => void;
+        dragover: (e: DragEvent) => void;
+    }>;
+    onMoveColumnByOffset: (movingColumn: BentoColumn, offset?: number) => void;
+};

package/dist/@types/packages/vue2/src/components/data-grid/composables/use-config-settings/use-config-settings.d.ts

@@ -0,0 +1,154 @@
+import { MaybeRef } from "../../../../types";
+import { BentoColumn } from '../../data-grid.types';
+import type { SetupContext } from 'vue/types/v3-setup-context';
+export declare const useConfigSettings: (columnsRef: MaybeRef<BentoColumn[]>, emit: SetupContext['emit']) => {
+    columnSets: import("vue").ComputedRef<({
+        columnSet: (BentoColumn | {
+            field: string;
+            label: string;
+            width?: number;
+            autoWidth?: boolean;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: import("../../data-grid.types").BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+            cellActions?: {
+                link?: object;
+                type?: string;
+                condensed?: boolean;
+                critical?: boolean;
+                disabled?: boolean;
+                inverse?: boolean;
+                iconLeft?: object | Element | (object | Element)[];
+                iconRight?: object | Element | (object | Element)[];
+                title?: string;
+                event?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => void;
+                isShort?: true;
+                variant?: import("../../components/data-grid-cell-actions/data-grid-cell-actions.types").BentoColumnCellActionVariant;
+                menuData?: {
+                    text: string;
+                    handler: () => void;
+                    secondaryText?: string;
+                    items?: any[];
+                    disabled?: boolean;
+                    chevron?: boolean;
+                    icon?: object | Element | (object | Element)[];
+                    critical?: boolean;
+                    indent?: boolean;
+                    addDivider?: boolean;
+                }[];
+                getCopyData?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => string;
+            }[];
+        })[];
+        id: string;
+        isFrozenColumns: boolean;
+    } | {
+        columnSet: (BentoColumn | {
+            field: string;
+            label: string;
+            width?: number;
+            autoWidth?: boolean;
+            minWidth?: number;
+            flex?: number;
+            sortable?: boolean;
+            numeric?: boolean;
+            infoIconTooltip?: string;
+            padding?: {
+                left?: boolean;
+                right?: boolean;
+            };
+            overflow?: import("../../data-grid.types").BentoColumnOverflow;
+            visible?: boolean;
+            mandatory?: boolean;
+            frozen?: boolean;
+            cellActions?: {
+                link?: object;
+                type?: string;
+                condensed?: boolean;
+                critical?: boolean;
+                disabled?: boolean;
+                inverse?: boolean;
+                iconLeft?: object | Element | (object | Element)[];
+                iconRight?: object | Element | (object | Element)[];
+                title?: string;
+                event?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => void;
+                isShort?: true;
+                variant?: import("../../components/data-grid-cell-actions/data-grid-cell-actions.types").BentoColumnCellActionVariant;
+                menuData?: {
+                    text: string;
+                    handler: () => void;
+                    secondaryText?: string;
+                    items?: any[];
+                    disabled?: boolean;
+                    chevron?: boolean;
+                    icon?: object | Element | (object | Element)[];
+                    critical?: boolean;
+                    indent?: boolean;
+                    addDivider?: boolean;
+                }[];
+                getCopyData?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => string;
+            }[];
+        })[];
+        id: string;
+        isFrozenColumns?: undefined;
+    })[]>;
+    isOnlyOneVisibleColumn: import("vue").ComputedRef<boolean>;
+    sortedColumns: import("vue").ComputedRef<(BentoColumn | {
+        field: string;
+        label: string;
+        width?: number;
+        autoWidth?: boolean;
+        minWidth?: number;
+        flex?: number;
+        sortable?: boolean;
+        numeric?: boolean;
+        infoIconTooltip?: string;
+        padding?: {
+            left?: boolean;
+            right?: boolean;
+        };
+        overflow?: import("../../data-grid.types").BentoColumnOverflow;
+        visible?: boolean;
+        mandatory?: boolean;
+        frozen?: boolean;
+        cellActions?: {
+            link?: object;
+            type?: string;
+            condensed?: boolean;
+            critical?: boolean;
+            disabled?: boolean;
+            inverse?: boolean;
+            iconLeft?: object | Element | (object | Element)[];
+            iconRight?: object | Element | (object | Element)[];
+            title?: string;
+            event?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => void;
+            isShort?: true;
+            variant?: import("../../components/data-grid-cell-actions/data-grid-cell-actions.types").BentoColumnCellActionVariant;
+            menuData?: {
+                text: string;
+                handler: () => void;
+                secondaryText?: string;
+                items?: any[];
+                disabled?: boolean;
+                chevron?: boolean;
+                icon?: object | Element | (object | Element)[];
+                critical?: boolean;
+                indent?: boolean;
+                addDivider?: boolean;
+            }[];
+            getCopyData?: (rowDataItem: import("../../data-grid.types").BentoDatagridDataItem, columnKey: string) => string;
+        }[];
+    })[]>;
+    onConfigSettingsUpdate: (isCondensedView: boolean) => void;
+    onConfigSettingsColumnsUpdate: (newColumns: BentoColumn[]) => void;
+    onConfigSettingsColumnUpdate: (updatedColumn: BentoColumn) => void;
+};

package/dist/@types/packages/vue2/src/components/data-grid/composables/{useKeyboardNavigator/useKeyboardNavigator.d.ts → use-keyboard-navigator/use-keyboard-navigator.d.ts}

@@ -1,5 +1,5 @@
 import { Ref } from 'vue';
-import { BentoDatagridNavigationKeyCode } from './useKeyboardNavigator.types';
+import { BentoDatagridNavigationKeyCode } from './use-keyboard-navigator.types';
 import type { BentoColumn } from '../../data-grid.types';
 export declare const useKeyboardNavigator: (gridcellRefs: Ref<{
     [key: string]: HTMLDivElement[];

package/dist/@types/packages/vue2/src/components/data-grid/composables/{useResizer.d.ts → use-resizer.d.ts}

@@ -7,4 +7,3 @@ export declare const useResizer: (columns: Ref<BentoColumn[]>, emit: (event: Dat
     startResize: (hasResizableColumns: boolean, field: BentoColumn['field'], event: MouseEvent) => void;
     isResizing: Ref<boolean>;
 };
-export default useResizer;

package/dist/@types/packages/vue2/src/components/data-grid/composables/{useScroller/useScroller.d.ts → use-scroller/use-scroller.d.ts}

@@ -2,5 +2,5 @@ import { Ref } from 'vue';
 export declare const useScroller: (body: Ref<HTMLDivElement>, columnsRef: Ref<HTMLDivElement>, verticalScrollPosition: Ref<number>) => {
     scrollLeftPosition: Ref<number>;
     updateScrollPosition: (event: Event) => void;
-    updateScrollPositionOnFrozenColumnsNavigation: () => void;
+    updateScrollPositionOnFrozenColumnsNavigation: (event: KeyboardEvent) => void;
 };

package/dist/@types/packages/vue2/src/components/data-grid/composables/{useSelector.d.ts → use-selector.d.ts}

@@ -1,7 +1,7 @@
 import { Ref } from 'vue';
 import { BentoDatagridData, BentoDatagridDataItemId, BentoDatagridGetDataItemIdFn, BentoDatagridIsDataItemDisabledFn } from '../data-grid.types';
 export declare const useSelector: (selection: Ref<BentoDatagridDataItemId[]>, emit: (event: string, emitedSelectedItems: BentoDatagridDataItemId[]) => void, data: Ref<BentoDatagridData>, getDataItemId: BentoDatagridGetDataItemIdFn, isDataItemDisabled: BentoDatagridIsDataItemDisabledFn) => {
-    onAllRowSelect: (allItemsSelected: boolean) => void;
+    onAllRowSelect: (selectAllItems: boolean) => void;
     onRowSelect: (value: BentoDatagridDataItemId[]) => void;
     allItemsSelectedState: {
         allItemsSelected: boolean;

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

@@ -1,5 +1,6 @@
-import { BentoPagination } from "../pagination";
-import { BentoEmptyState } from "../empty-state";
+import type { BentoPagination } from "../pagination";
+import type { BentoEmptyState } from "../empty-state";
+import type { BentoColumnCellActions } from './components/data-grid-cell-actions/data-grid-cell-actions.types';
 export declare enum BentoColumnOverflow {
     WRAP = "wrap",
     ELLIPSIS = "ellipsis"
@@ -22,6 +23,7 @@ export interface BentoColumn {
     visible?: boolean;
     mandatory?: boolean;
     frozen?: boolean;
+    cellActions?: BentoColumnCellActions;
 }
 export declare enum BentoDatagridStyleState {
     OUTLINE = "outline",
@@ -73,6 +75,7 @@ export declare enum BentoDatagridEvent {
     UPDATE_SORT_BY = "update:sort-by",
     ROW_CLICK = "row-click",
     SELECT = "select",
+    SELECT_ALL_ACROSS_PAGES = "select-all-across-pages",
     SORT = "sort"
 }
 export declare enum BentoDatagridAriaSortValue {