@adyen/bento-vue3 0.9.3

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

@@ -0,0 +1,170 @@
+export declare enum BentoCurrencyISOCode {
+    AFA = "AFA",
+    ALL = "ALL",
+    DZD = "DZD",
+    AOA = "AOA",
+    ARS = "ARS",
+    AMD = "AMD",
+    AWG = "AWG",
+    AUD = "AUD",
+    AZN = "AZN",
+    BSD = "BSD",
+    BHD = "BHD",
+    BDT = "BDT",
+    BBD = "BBD",
+    BYR = "BYR",
+    BEF = "BEF",
+    BZD = "BZD",
+    BMD = "BMD",
+    BTN = "BTN",
+    BTC = "BTC",
+    BOB = "BOB",
+    BAM = "BAM",
+    BWP = "BWP",
+    BRL = "BRL",
+    GBP = "GBP",
+    BND = "BND",
+    BGN = "BGN",
+    BIF = "BIF",
+    KHR = "KHR",
+    CAD = "CAD",
+    CVE = "CVE",
+    KYD = "KYD",
+    XOF = "XOF",
+    XAF = "XAF",
+    XPF = "XPF",
+    CLP = "CLP",
+    CLF = "CLF",
+    CNY = "CNY",
+    COP = "COP",
+    KMF = "KMF",
+    CDF = "CDF",
+    CRC = "CRC",
+    HRK = "HRK",
+    CUC = "CUC",
+    CZK = "CZK",
+    DKK = "DKK",
+    DJF = "DJF",
+    DOP = "DOP",
+    XCD = "XCD",
+    EGP = "EGP",
+    ERN = "ERN",
+    EEK = "EEK",
+    ETB = "ETB",
+    EUR = "EUR",
+    FKP = "FKP",
+    FJD = "FJD",
+    GMD = "GMD",
+    GEL = "GEL",
+    DEM = "DEM",
+    GHS = "GHS",
+    GIP = "GIP",
+    GRD = "GRD",
+    GTQ = "GTQ",
+    GNF = "GNF",
+    GYD = "GYD",
+    HTG = "HTG",
+    HNL = "HNL",
+    HKD = "HKD",
+    HUF = "HUF",
+    ISK = "ISK",
+    INR = "INR",
+    IDR = "IDR",
+    IRR = "IRR",
+    IQD = "IQD",
+    ILS = "ILS",
+    ITL = "ITL",
+    JMD = "JMD",
+    JPY = "JPY",
+    JOD = "JOD",
+    KZT = "KZT",
+    KES = "KES",
+    KWD = "KWD",
+    KGS = "KGS",
+    LAK = "LAK",
+    LVL = "LVL",
+    LBP = "LBP",
+    LSL = "LSL",
+    LRD = "LRD",
+    LYD = "LYD",
+    LTC = "LTC",
+    LTL = "LTL",
+    MOP = "MOP",
+    MKD = "MKD",
+    MGA = "MGA",
+    MWK = "MWK",
+    MYR = "MYR",
+    MVR = "MVR",
+    MRO = "MRO",
+    MUR = "MUR",
+    MXN = "MXN",
+    MDL = "MDL",
+    MNT = "MNT",
+    MAD = "MAD",
+    MZM = "MZM",
+    MMK = "MMK",
+    NAD = "NAD",
+    NPR = "NPR",
+    ANG = "ANG",
+    TWD = "TWD",
+    NZD = "NZD",
+    NIO = "NIO",
+    NGN = "NGN",
+    KPW = "KPW",
+    NOK = "NOK",
+    OMR = "OMR",
+    PKR = "PKR",
+    PAB = "PAB",
+    PGK = "PGK",
+    PYG = "PYG",
+    PEN = "PEN",
+    PHP = "PHP",
+    PLN = "PLN",
+    QAR = "QAR",
+    RON = "RON",
+    RUB = "RUB",
+    RWF = "RWF",
+    SVC = "SVC",
+    WST = "WST",
+    STD = "STD",
+    SAR = "SAR",
+    RSD = "RSD",
+    SCR = "SCR",
+    SLL = "SLL",
+    SGD = "SGD",
+    SKK = "SKK",
+    SBD = "SBD",
+    SOS = "SOS",
+    ZAR = "ZAR",
+    KRW = "KRW",
+    SSP = "SSP",
+    XDR = "XDR",
+    LKR = "LKR",
+    SHP = "SHP",
+    SDG = "SDG",
+    SRD = "SRD",
+    SZL = "SZL",
+    SEK = "SEK",
+    CHF = "CHF",
+    SYP = "SYP",
+    TJS = "TJS",
+    TZS = "TZS",
+    THB = "THB",
+    TOP = "TOP",
+    TTD = "TTD",
+    TND = "TND",
+    TRY = "TRY",
+    TMT = "TMT",
+    UGX = "UGX",
+    UAH = "UAH",
+    AED = "AED",
+    UYU = "UYU",
+    USD = "USD",
+    UZS = "UZS",
+    VUV = "VUV",
+    VEF = "VEF",
+    VND = "VND",
+    YER = "YER",
+    ZMK = "ZMK",
+    ZWL = "ZWL"
+}

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

@@ -0,0 +1,32 @@
+import { PropType } from 'vue';
+import { BentoTypographyElement, BentoTypographyVariant } from '@/components/typography';
+import { BentoCurrencyISOCode } from '@/components/currency/currency.types';
+declare const _default: import("vue").DefineComponent<{
+    currency: {
+        type: PropType<BentoCurrencyISOCode>;
+        default: BentoCurrencyISOCode;
+        validator: (value: BentoCurrencyISOCode) => boolean;
+    };
+    majorUnits: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    formattedCurrency: import("vue").ComputedRef<string>;
+    BentoTypographyVariant: typeof BentoTypographyVariant;
+    BentoTypographyElement: typeof BentoTypographyElement;
+}, {}, {}, {}, import("vue/types/v3-component-options.js").ComponentOptionsMixin, import("vue/types/v3-component-options.js").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    currency: {
+        type: PropType<BentoCurrencyISOCode>;
+        default: BentoCurrencyISOCode;
+        validator: (value: BentoCurrencyISOCode) => boolean;
+    };
+    majorUnits: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    currency: BentoCurrencyISOCode;
+    majorUnits: boolean;
+}>;
+export default _default;

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

@@ -0,0 +1,2 @@
+export { default as BentoCurrency } from './currency.vue';
+export * from './currency.types';

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

@@ -0,0 +1,17 @@
+import { BentoColumn } from '../../data-grid.types';
+export declare enum DatagridColumnsEvent {
+    COLUMN_RESIZE = "column-resize",
+    COLUMN_RESIZING = "column-resizing",
+    SORT = "sort",
+    SELECT_ALL_ROWS = "select-all-rows",
+    COLUMN_MOVE = "column-move",
+    COLUMN_UPDATE = "column-update",
+    COLUMN_DRAG_START = "column-dragstart",
+    COLUMN_DRAG_ENTER = "column-dragenter",
+    COLUMN_DRAG_END = "column-dragend",
+    COLUMN_DROP = "column-drop"
+}
+export interface BentoDatagridDraggingColumnState {
+    dragging?: BentoColumn;
+    target?: BentoColumn;
+}

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

@@ -0,0 +1,159 @@
+import { PropType } from 'vue';
+import { BentoColumn, BentoDatagridAllItemsSelectedState, BentoDatagridSortByColumn, BentoDatagridSortDirection } from '../../data-grid.types';
+import { BentoTypographyElement } from '@/components/typography';
+import { BentoDatagridDraggingColumnState, DatagridColumnsEvent } from './data-grid-columns-types';
+import type { BentoMenuItem } from '@/components/menu/components';
+import { BentoButtonVariant } from '@/components/button';
+declare const _default: import("vue").DefineComponent<{
+    columns: {
+        type: PropType<BentoColumn[]>;
+        required: true;
+    };
+    draggingColumns: {
+        type: PropType<BentoDatagridDraggingColumnState>;
+        default: any;
+    };
+    hasDraggableColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasResizableColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasColumnPanel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasFirstColumnPanelRightAligned: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isFrozenColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allItemsSelectedState: {
+        type: PropType<BentoDatagridAllItemsSelectedState>;
+        default: any;
+    };
+    sortBy: {
+        type: PropType<BentoDatagridSortByColumn[]>;
+        default: () => any[];
+    };
+}, {
+    DATAGRID_SELECT_FIELD_NAME: string;
+    conditionalColumnClasses: (column: BentoColumn) => {
+        'b-data-grid-columns__column--sortable': boolean;
+        'b-data-grid-columns__column--padding-left-unset': boolean;
+        'b-data-grid-columns__column--padding-right-unset': boolean;
+        'b-data-grid-columns__column--numeric': boolean;
+        'b-data-grid-columns__column--frozen': boolean;
+        'b-data-grid-columns__column--is-re-ordering': boolean;
+        'b-data-grid-columns__column--is-re-ordering-target': boolean;
+    };
+    conditionalColumnSeparatorClasses: import("vue").ComputedRef<{
+        'b-data-grid-columns__column-separator-container--is-resizeable': boolean;
+    }>;
+    conditionalColumnsClasses: import("vue").ComputedRef<{
+        'b-data-grid-columns--frozen': boolean;
+        'b-data-grid-columns--unfrozen'?: undefined;
+        'b-data-grid-columns--config-settings-margin'?: undefined;
+    } | {
+        'b-data-grid-columns--unfrozen': boolean;
+        'b-data-grid-columns--config-settings-margin': boolean;
+        'b-data-grid-columns--frozen'?: undefined;
+    }>;
+    allItemsSelectedCheckboxState: import("vue").Ref<{
+        allItemsSelected: boolean;
+        isIndeterminate: boolean;
+    }>;
+    onAllRowSelect: (areAllItemsSelected: boolean) => void;
+    conditionalSortDirectionClasses: (field: string, direction: BentoDatagridSortDirection) => {
+        'b-data-grid-columns__column-sort-icon--sorted': boolean;
+    };
+    sortByColumnField: (field: string) => void;
+    startResize: (hasResizableColumns: boolean, field: string, event: MouseEvent) => void;
+    isResizing: import("vue").Ref<boolean>;
+    draggingEventsForColumn: import("vue").ComputedRef<(column: BentoColumn) => {
+        dragstart?: undefined;
+        dragover?: undefined;
+        dragenter?: undefined;
+        drop?: undefined;
+        dragend?: undefined;
+    } | {
+        dragstart: (e: DragEvent & Event) => void;
+        dragover: (e: DragEvent) => void;
+        dragenter: (e: DragEvent) => void;
+        drop: () => void;
+        dragend: () => void;
+    }>;
+    contextualMenuData: import("vue").ComputedRef<(col: BentoColumn) => BentoMenuItem[]>;
+    BentoButtonVariant: typeof BentoButtonVariant;
+    BentoDatagridSortDirection: typeof BentoDatagridSortDirection;
+    BentoTypographyElement: typeof BentoTypographyElement;
+    BentoPopoverPositions: {
+        AUTO: import("../../../popper-container").PopperContainerPositionExtended.AUTO;
+        AUTO_START: import("../../../popper-container").PopperContainerPositionExtended.AUTO_START;
+        AUTO_END: import("../../../popper-container").PopperContainerPositionExtended.AUTO_END;
+        TOP_START: import("../../../popper-container").PopperContainerPositionExtended.TOP_START;
+        TOP_END: import("../../../popper-container").PopperContainerPositionExtended.TOP_END;
+        RIGHT_START: import("../../../popper-container").PopperContainerPositionExtended.RIGHT_START;
+        RIGHT_END: import("../../../popper-container").PopperContainerPositionExtended.RIGHT_END;
+        BOTTOM_START: import("../../../popper-container").PopperContainerPositionExtended.BOTTOM_START;
+        BOTTOM_END: import("../../../popper-container").PopperContainerPositionExtended.BOTTOM_END;
+        LEFT_START: import("../../../popper-container").PopperContainerPositionExtended.LEFT_START;
+        LEFT_END: import("../../../popper-container").PopperContainerPositionExtended.LEFT_END;
+        TOP: import("../../../popper-container").PopperContainerPositionBasic.TOP;
+        RIGHT: import("../../../popper-container").PopperContainerPositionBasic.RIGHT;
+        BOTTOM: import("../../../popper-container").PopperContainerPositionBasic.BOTTOM;
+        LEFT: import("../../../popper-container").PopperContainerPositionBasic.LEFT;
+    };
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, (DatagridColumnsEvent.COLUMN_RESIZE | DatagridColumnsEvent.SORT | DatagridColumnsEvent.SELECT_ALL_ROWS | DatagridColumnsEvent.COLUMN_MOVE | DatagridColumnsEvent.COLUMN_UPDATE | DatagridColumnsEvent.COLUMN_DRAG_START | DatagridColumnsEvent.COLUMN_DRAG_ENTER | DatagridColumnsEvent.COLUMN_DRAG_END | DatagridColumnsEvent.COLUMN_DROP)[], string, Readonly<import("vue").ExtractPropTypes<{
+    columns: {
+        type: PropType<BentoColumn[]>;
+        required: true;
+    };
+    draggingColumns: {
+        type: PropType<BentoDatagridDraggingColumnState>;
+        default: any;
+    };
+    hasDraggableColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasResizableColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasColumnPanel: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    hasFirstColumnPanelRightAligned: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    isFrozenColumns: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    allItemsSelectedState: {
+        type: PropType<BentoDatagridAllItemsSelectedState>;
+        default: any;
+    };
+    sortBy: {
+        type: PropType<BentoDatagridSortByColumn[]>;
+        default: () => any[];
+    };
+}>>, {
+    isFrozenColumns: boolean;
+    draggingColumns: any;
+    hasDraggableColumns: boolean;
+    hasResizableColumns: boolean;
+    hasColumnPanel: boolean;
+    hasFirstColumnPanelRightAligned: boolean;
+    allItemsSelectedState: BentoDatagridAllItemsSelectedState;
+    sortBy: BentoDatagridSortByColumn[];
+}>;
+export default _default;

package/dist/@types/components/data-grid/components/data-grid-config-settings/components/data-grid-config-settings-column-row/data-grid-config-settings-column-row.vue.d.ts

@@ -0,0 +1,38 @@
+import { PropType } from 'vue';
+import { BentoTypographyElement, BentoTypographyVariant } from '@/components/typography';
+import { AdlLabelPosition } from '@/types';
+import { BentoColumn } from '@/components/data-grid';
+declare const _default: import("vue").DefineComponent<{
+    isColumnVisibilityToggleDisabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    column: {
+        type: PropType<BentoColumn>;
+        required: true;
+    };
+}, {
+    isFreezeIconOptionShown: import("vue").Ref<boolean>;
+    isColumnFrozen: import("vue").ComputedRef<boolean>;
+    freezeIconConditionalClasses: import("vue").ComputedRef<{
+        "b-data-grid-config-settings-column-row__freeze-icon--frozen": boolean;
+    }>;
+    isColumnVisible: import("vue").ComputedRef<boolean>;
+    toggleColumnVisibility: () => void;
+    showFreezeIcon: () => void;
+    hideFreezeIcon: () => void;
+    toggleColumnFreeze: () => void;
+    AdlLabelPosition: typeof AdlLabelPosition;
+    BentoTypographyElement: typeof BentoTypographyElement;
+    BentoTypographyVariant: typeof BentoTypographyVariant;
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, ("visible-column" | "updated-column")[], string, Readonly<import("vue").ExtractPropTypes<{
+    isColumnVisibilityToggleDisabled: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    column: {
+        type: PropType<BentoColumn>;
+        required: true;
+    };
+}>>, {}>;
+export default _default;

package/dist/@types/components/data-grid/components/data-grid-config-settings/data-grid-config-settings.types.d.ts

@@ -0,0 +1,4 @@
+export declare enum DatagridConfigSettingsEvent {
+    CONFIG_SETTINGS = "config-settings",
+    UPDATE_COLUMNS = "update:columns"
+}

package/dist/@types/components/data-grid/components/data-grid-config-settings/data-grid-config-settings.vue.d.ts

@@ -0,0 +1,66 @@
+import { PropType } from 'vue';
+import { BentoButtonVariant } from '@/components/button';
+import { BentoTypographyElement, BentoTypographyVariant } from '@/components/typography';
+import { AdlLabelPosition } from '@/types';
+import { BentoColumn } from '../../data-grid.types';
+import { DatagridConfigSettingsEvent } from './data-grid-config-settings.types';
+declare const _default: import("vue").DefineComponent<{
+    columns: {
+        type: PropType<BentoColumn[]>;
+        required: true;
+    };
+    condensed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}, {
+    configSettingsButtonRef: any;
+    isConfigSettingsPanelOpen: import("vue").Ref<boolean>;
+    allColumnsVisbilityToggleState: import("vue").Ref<boolean>;
+    filteredColumnVisibilityColumns: import("vue").ComputedRef<BentoColumn[]>;
+    searchTerm: import("vue").Ref<string>;
+    isColumnVisibilityFilterShown: import("vue").Ref<boolean>;
+    searchBarRef: any;
+    setConfigSettingsPanelVisibility: (isVisible: boolean) => void;
+    emitCondensedToggle: (isCompactView: boolean) => void;
+    toggleAllColumnVisibility: (toggleState: boolean) => void;
+    clearAction: () => void;
+    toggleColumnFilter: () => void;
+    emitVisibleColumns: (updatedColumn: BentoColumn) => void;
+    emitFrozenColumns: (updatedColumn: BentoColumn) => void;
+    onClickOutside: () => void;
+    isColumnVisibilityToggleDisabled: (column: BentoColumn) => boolean;
+    AdlLabelPosition: typeof AdlLabelPosition;
+    BentoTypographyElement: typeof BentoTypographyElement;
+    BentoTypographyVariant: typeof BentoTypographyVariant;
+    BentoButtonVariant: typeof BentoButtonVariant;
+    BentoPopoverPositions: {
+        AUTO: import("../../../popper-container").PopperContainerPositionExtended.AUTO;
+        AUTO_START: import("../../../popper-container").PopperContainerPositionExtended.AUTO_START;
+        AUTO_END: import("../../../popper-container").PopperContainerPositionExtended.AUTO_END;
+        TOP_START: import("../../../popper-container").PopperContainerPositionExtended.TOP_START;
+        TOP_END: import("../../../popper-container").PopperContainerPositionExtended.TOP_END;
+        RIGHT_START: import("../../../popper-container").PopperContainerPositionExtended.RIGHT_START;
+        RIGHT_END: import("../../../popper-container").PopperContainerPositionExtended.RIGHT_END;
+        BOTTOM_START: import("../../../popper-container").PopperContainerPositionExtended.BOTTOM_START;
+        BOTTOM_END: import("../../../popper-container").PopperContainerPositionExtended.BOTTOM_END;
+        LEFT_START: import("../../../popper-container").PopperContainerPositionExtended.LEFT_START;
+        LEFT_END: import("../../../popper-container").PopperContainerPositionExtended.LEFT_END;
+        TOP: import("../../../popper-container").PopperContainerPositionBasic.TOP;
+        RIGHT: import("../../../popper-container").PopperContainerPositionBasic.RIGHT;
+        BOTTOM: import("../../../popper-container").PopperContainerPositionBasic.BOTTOM;
+        LEFT: import("../../../popper-container").PopperContainerPositionBasic.LEFT;
+    };
+}, {}, {}, {}, import("vue/types/v3-component-options").ComponentOptionsMixin, import("vue/types/v3-component-options").ComponentOptionsMixin, DatagridConfigSettingsEvent[], string, Readonly<import("vue").ExtractPropTypes<{
+    columns: {
+        type: PropType<BentoColumn[]>;
+        required: true;
+    };
+    condensed: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+}>>, {
+    condensed: boolean;
+}>;
+export default _default;

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

@@ -0,0 +1,2 @@
+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';

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

@@ -0,0 +1,6 @@
+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 { useColumnReorderer } from './useColumnReorderer/useColumnReorderer';
+export { useConfigSettings } from './useConfigSettings/useConfigSettings';

package/dist/@types/components/data-grid/composables/useCalculateColumnWidth/useCalculateColumnWidth.d.ts

@@ -0,0 +1,31 @@
+import { BentoColumn, BentoColumnWidthOverridesLookup } from '../../data-grid.types';
+import { CalculateColumnWidthOptions } from './useCalculateColumnWidth.types';
+import { MaybeRef } from '@/types';
+export declare const DEFAULT_COLUMN_WIDTH = 100;
+export declare const DEFAULT_COLUMN_MIN_WIDTH = 50;
+export declare const DATAGRID_SELECT_FIELD_NAME = "b-select";
+export declare const useCalculateColumnWidth: (newColumns: MaybeRef<BentoColumn[]>, bodyRef: MaybeRef<HTMLDivElement | undefined>, options?: CalculateColumnWidthOptions) => {
+    columnDefs: import("vue").ComputedRef<{
+        width: number;
+        field: string;
+        label: string;
+        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;
+    }[]>;
+    gridColumnWidthStyle: import("vue").ComputedRef<{
+        width: string;
+    }>;
+    onColumnWidthOverride: (newColumnWidthOverridesLookup: BentoColumnWidthOverridesLookup) => void;
+};
+export default useCalculateColumnWidth;

package/dist/@types/components/data-grid/composables/useCalculateColumnWidth/useCalculateColumnWidth.types.d.ts

@@ -0,0 +1,10 @@
+import { Ref } from 'vue';
+import { BentoColumn } from '../../data-grid.types';
+export type FlexColumnLookup = Record<BentoColumn['field'], {
+    flex: number;
+    computedWidth: number;
+    frozen: boolean;
+}>;
+export interface CalculateColumnWidthOptions {
+    hasSelectableColumn?: Ref<boolean>;
+}

package/dist/@types/components/data-grid/composables/useColumnReorderer/useColumnReorderer.d.ts

@@ -0,0 +1,64 @@
+import { MaybeRef } from '@/types';
+import { BentoColumn } from '../../data-grid.types';
+import type { EmitFn } from 'vue/types/v3-setup-context';
+export declare const useColumnReorderer: (columnsRef: MaybeRef<BentoColumn[]>, hasDraggableColumnsRef: MaybeRef<boolean>, emit: EmitFn) => {
+    draggingColumns: {
+        dragging?: {
+            field: string;
+            label: string;
+            width?: number;
+            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;
+        };
+        target?: {
+            field: string;
+            label: string;
+            width?: number;
+            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;
+        };
+    };
+    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) => 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;
+};