@moubing/bing-ui 0.1.0 → 0.2.0

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

@@ -0,0 +1,63 @@
+export type BingResizableDirection = 'top' | 'right' | 'bottom' | 'left' | 'top-left' | 'top-right' | 'bottom-left' | 'bottom-right';
+export type BingResizableMode = 'fixed' | 'mirror';
+export type BingResizableSnapMode = 'live' | 'end';
+export type BingResizableSizeValue = number | string;
+export interface BingResizableSize {
+    width?: BingResizableSizeValue;
+    height?: BingResizableSizeValue;
+}
+export interface BingResizableResolvedSize {
+    width: number;
+    height: number;
+}
+export interface BingResizablePosition {
+    x: number;
+    y: number;
+}
+export type BingResizableStep = number | {
+    x?: number;
+    y?: number;
+};
+export interface BingResizableDelta {
+    x: number;
+    y: number;
+}
+export interface BingResizablePayload {
+    direction: BingResizableDirection;
+    size: BingResizableResolvedSize;
+    position: BingResizablePosition;
+    delta: BingResizableDelta;
+    event: PointerEvent | KeyboardEvent;
+}
+export interface BingResizableProps {
+    size?: BingResizableSize;
+    defaultSize?: BingResizableSize;
+    position?: Partial<BingResizablePosition>;
+    defaultPosition?: Partial<BingResizablePosition>;
+    minWidth?: BingResizableSizeValue;
+    minHeight?: BingResizableSizeValue;
+    maxWidth?: BingResizableSizeValue;
+    maxHeight?: BingResizableSizeValue;
+    mode?: BingResizableMode;
+    snapMode?: BingResizableSnapMode;
+    directions?: BingResizableDirection[];
+    step?: BingResizableStep;
+    disabled?: boolean;
+    lockAspectRatio?: boolean;
+    contain?: boolean;
+    showSize?: boolean;
+    handleSize?: number;
+    ariaLabel?: string;
+}
+export interface BingResizableEmits {
+    'update:size': [size: BingResizableResolvedSize];
+    'update:position': [position: BingResizablePosition];
+    'resize-start': [payload: BingResizablePayload];
+    resize: [payload: BingResizablePayload];
+    'resize-end': [payload: BingResizablePayload];
+}
+export interface BingResizableExpose {
+    reset: () => void;
+    getSize: () => BingResizableResolvedSize;
+    getPosition: () => BingResizablePosition;
+}

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

@@ -0,0 +1,50 @@
+import { BingResizableDirection, BingResizableExpose, BingResizablePayload, BingResizablePosition, BingResizableProps, BingResizableResolvedSize, BingResizableSize } from './BingResizable.types';
+declare var __VLS_1: {}, __VLS_3: {
+    direction: BingResizableDirection;
+    active: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+} & {
+    handle?: (props: typeof __VLS_3) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingResizableProps, BingResizableExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    resize: (payload: BingResizablePayload) => any;
+    "update:size": (size: BingResizableResolvedSize) => any;
+    "update:position": (position: BingResizablePosition) => any;
+    "resize-start": (payload: BingResizablePayload) => any;
+    "resize-end": (payload: BingResizablePayload) => any;
+}, string, import('vue').PublicProps, Readonly<BingResizableProps> & Readonly<{
+    onResize?: ((payload: BingResizablePayload) => any) | undefined;
+    "onUpdate:size"?: ((size: BingResizableResolvedSize) => any) | undefined;
+    "onUpdate:position"?: ((position: BingResizablePosition) => any) | undefined;
+    "onResize-start"?: ((payload: BingResizablePayload) => any) | undefined;
+    "onResize-end"?: ((payload: BingResizablePayload) => any) | undefined;
+}>, {
+    disabled: boolean;
+    maxHeight: import('./BingResizable.types').BingResizableSizeValue;
+    maxWidth: import('./BingResizable.types').BingResizableSizeValue;
+    minHeight: import('./BingResizable.types').BingResizableSizeValue;
+    minWidth: import('./BingResizable.types').BingResizableSizeValue;
+    position: Partial<BingResizablePosition>;
+    ariaLabel: string;
+    size: BingResizableSize;
+    mode: import('./BingResizable.types').BingResizableMode;
+    defaultSize: BingResizableSize;
+    defaultPosition: Partial<BingResizablePosition>;
+    snapMode: import('./BingResizable.types').BingResizableSnapMode;
+    directions: BingResizableDirection[];
+    step: import('./BingResizable.types').BingResizableStep;
+    lockAspectRatio: boolean;
+    contain: boolean;
+    showSize: boolean;
+    handleSize: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingResizable/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingResizable } from './BingResizable.vue';
+export type { BingResizableDelta, BingResizableDirection, BingResizableEmits, BingResizableExpose, BingResizableMode, BingResizablePayload, BingResizablePosition, BingResizableProps, BingResizableResolvedSize, BingResizableSize, BingResizableSizeValue, BingResizableStep, } from './BingResizable.types';

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

@@ -0,0 +1,20 @@
+export interface BingScrollbarProps {
+    height?: string | number;
+    maxHeight?: string | number;
+    minThumbSize?: number;
+    overflowTolerance?: number;
+    vertical?: boolean;
+    horizontal?: boolean;
+    always?: boolean;
+    disabled?: boolean;
+    ariaLabel?: string;
+}
+export interface BingScrollbarEmits {
+    scroll: [event: Event];
+}
+export interface BingScrollbarExpose {
+    scrollBy: (options: ScrollToOptions | number) => void;
+    scrollTo: (options: ScrollToOptions | number) => void;
+    update: () => void;
+    viewport: HTMLElement | null;
+}

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

@@ -0,0 +1,28 @@
+import { BingScrollbarExpose, BingScrollbarProps } from './BingScrollbar.types';
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingScrollbarProps, BingScrollbarExpose, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    scroll: (event: Event) => any;
+}, string, import('vue').PublicProps, Readonly<BingScrollbarProps> & Readonly<{
+    onScroll?: ((event: Event) => any) | undefined;
+}>, {
+    always: boolean;
+    disabled: boolean;
+    height: string | number;
+    maxHeight: string | number;
+    ariaLabel: string;
+    horizontal: boolean;
+    vertical: boolean;
+    minThumbSize: number;
+    overflowTolerance: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingScrollbar/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingScrollbar } from './BingScrollbar.vue';
+export type { BingScrollbarEmits, BingScrollbarExpose, BingScrollbarProps, } from './BingScrollbar.types';

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

@@ -0,0 +1,57 @@
+import { BingGlassEffectProps } from '../../utils/glass';
+export type BingSelectValue = string | number;
+export type BingSelectModelValue = BingSelectValue | BingSelectValue[] | null;
+export type BingSelectSize = 'sm' | 'md' | 'lg';
+export type BingSelectVirtualMode = boolean | 'auto';
+export type BingSelectSearchable = boolean | 'auto';
+export type BingSelectOptionMetaValue = string | number | boolean | null | undefined;
+export interface BingSelectOption {
+    label: string;
+    value: BingSelectValue;
+    disabled?: boolean;
+    description?: string;
+    detail?: string;
+    meta?: Record<string, BingSelectOptionMetaValue>;
+    [key: string]: unknown;
+}
+export interface BingSelectProps extends BingGlassEffectProps {
+    id?: string;
+    modelValue?: BingSelectModelValue;
+    options?: BingSelectOption[];
+    multiple?: boolean;
+    placeholder?: string;
+    disabled?: boolean;
+    clearable?: boolean;
+    showSelectAll?: boolean;
+    selectAllText?: string;
+    clearAllText?: string;
+    emptyText?: string;
+    searchable?: BingSelectSearchable;
+    searchPlaceholder?: string;
+    noSearchResultsText?: string;
+    size?: BingSelectSize;
+    block?: boolean;
+    width?: string | number;
+    minWidth?: string | number;
+    panelMinHeight?: string | number;
+    panelMaxHeight?: string | number;
+    virtual?: BingSelectVirtualMode;
+    virtualThreshold?: number;
+    virtualItemHeight?: number;
+    virtualOverscan?: number;
+    ariaLabel?: string;
+    ariaDescribedby?: string;
+    status?: 'default' | 'error' | 'success' | 'warning';
+}
+export interface BingSelectChangePayload {
+    value: BingSelectModelValue;
+    option?: BingSelectOption;
+    options: BingSelectOption[];
+}
+export interface BingSelectEmits {
+    'update:modelValue': [value: BingSelectModelValue];
+    change: [payload: BingSelectChangePayload];
+    clear: [];
+    open: [];
+    close: [];
+}

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

@@ -0,0 +1,72 @@
+import { BingSelectChangePayload, BingSelectModelValue, BingSelectOption, BingSelectProps } from './BingSelect.types';
+declare var __VLS_1: {
+    selectedOptions: BingSelectOption[];
+    placeholder: string;
+}, __VLS_77: {
+    option: BingSelectOption;
+    selected: boolean;
+}, __VLS_79: {
+    option: BingSelectOption;
+    selected: boolean;
+    index: number;
+};
+type __VLS_Slots = {} & {
+    value?: (props: typeof __VLS_1) => any;
+} & {
+    option?: (props: typeof __VLS_77) => any;
+} & {
+    'option-detail'?: (props: typeof __VLS_79) => any;
+};
+declare const __VLS_base: import('vue').DefineComponent<BingSelectProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    clear: () => any;
+    "update:modelValue": (value: BingSelectModelValue) => any;
+    change: (payload: BingSelectChangePayload) => any;
+    close: () => any;
+    open: () => any;
+}, string, import('vue').PublicProps, Readonly<BingSelectProps> & Readonly<{
+    onClear?: (() => any) | undefined;
+    "onUpdate:modelValue"?: ((value: BingSelectModelValue) => any) | undefined;
+    onChange?: ((payload: BingSelectChangePayload) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+}>, {
+    disabled: boolean;
+    minWidth: string | number;
+    width: string | number;
+    glass: boolean;
+    ariaLabel: string;
+    modelValue: BingSelectModelValue;
+    size: import('./BingSelect.types').BingSelectSize;
+    block: boolean;
+    glassBlur: string | number;
+    glassOpacity: number;
+    glassSaturation: number;
+    id: string;
+    ariaDescribedby: string;
+    status: "default" | "error" | "success" | "warning";
+    placeholder: string;
+    clearable: boolean;
+    panelMaxHeight: string | number;
+    options: BingSelectOption[];
+    multiple: boolean;
+    showSelectAll: boolean;
+    selectAllText: string;
+    clearAllText: string;
+    emptyText: string;
+    searchable: import('./BingSelect.types').BingSelectSearchable;
+    searchPlaceholder: string;
+    noSearchResultsText: string;
+    panelMinHeight: string | number;
+    virtual: import('./BingSelect.types').BingSelectVirtualMode;
+    virtualThreshold: number;
+    virtualItemHeight: number;
+    virtualOverscan: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingSelect/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingSelect } from './BingSelect.vue';
+export type { BingSelectChangePayload, BingSelectEmits, BingSelectModelValue, BingSelectOption, BingSelectProps, BingSelectSize, BingSelectValue, BingSelectVirtualMode, } from './BingSelect.types';

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

@@ -0,0 +1,62 @@
+import { ComponentPublicInstance, HTMLAttributes } from 'vue';
+export type BingSortableListKey = string | number;
+export type BingSortableListAxis = 'vertical' | 'horizontal';
+export type BingSortableListReorderMode = 'drop' | 'live';
+export type BingSortableListItemKey<T> = keyof T | ((item: T, index: number) => BingSortableListKey);
+export type BingSortableListItemDisabled<T> = keyof T | ((item: T, index: number) => boolean);
+export interface BingSortableListPayload<T = Record<string, unknown>> {
+    key: BingSortableListKey;
+    item: T;
+    from: number;
+    to: number;
+    order: BingSortableListKey[];
+    event?: PointerEvent | KeyboardEvent;
+}
+export interface BingSortableListDragPayload<T = Record<string, unknown>> {
+    key: BingSortableListKey;
+    item: T;
+    index: number;
+    order: BingSortableListKey[];
+    event: PointerEvent;
+}
+export interface BingSortableListProps<T = Record<string, unknown>> {
+    items?: T[];
+    order?: BingSortableListKey[];
+    itemKey?: BingSortableListItemKey<T>;
+    itemDisabled?: BingSortableListItemDisabled<T>;
+    disabledKeys?: BingSortableListKey[];
+    axis?: BingSortableListAxis;
+    disabled?: boolean;
+    keyboard?: boolean;
+    flip?: boolean;
+    reorderMode?: BingSortableListReorderMode;
+    duration?: number;
+    settleDuration?: number;
+    dragThreshold?: number;
+    ariaLabel?: string;
+    handleAriaLabel?: string | ((item: T, index: number) => string);
+}
+export interface BingSortableListEmits<T = Record<string, unknown>> {
+    'update:order': [order: BingSortableListKey[]];
+    reorder: [payload: BingSortableListPayload<T>];
+    'drag-start': [payload: BingSortableListDragPayload<T>];
+    drag: [payload: BingSortableListDragPayload<T>];
+    'drag-end': [payload: BingSortableListDragPayload<T>];
+}
+export interface BingSortableListHandleProps extends HTMLAttributes {
+    ref: (element: Element | ComponentPublicInstance | null) => void;
+    role: 'button';
+    tabindex: number;
+    'aria-label': string;
+    'aria-disabled': 'true' | 'false';
+    onKeydown: (event: KeyboardEvent) => void;
+}
+export interface BingSortableListSlotProps<T = Record<string, unknown>> {
+    item: T;
+    key: BingSortableListKey;
+    index: number;
+    active: boolean;
+    dragging: boolean;
+    disabled: boolean;
+    handleProps: BingSortableListHandleProps;
+}

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

@@ -0,0 +1,51 @@
+import { BingSortableListDragPayload, BingSortableListKey, BingSortableListPayload, BingSortableListProps } from './BingSortableList.types';
+type ListItem = any;
+type __VLS_Props = BingSortableListProps<ListItem>;
+type __VLS_Slots = {
+    default?(props: {
+        item: ListItem;
+        key: BingSortableListKey;
+        index: number;
+        active: boolean;
+        dragging: boolean;
+        disabled: boolean;
+        handleProps: any;
+    }): unknown;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    drag: (payload: BingSortableListDragPayload<any>) => any;
+    "update:order": (order: BingSortableListKey[]) => any;
+    reorder: (payload: BingSortableListPayload<any>) => any;
+    "drag-start": (payload: BingSortableListDragPayload<any>) => any;
+    "drag-end": (payload: BingSortableListDragPayload<any>) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDrag?: ((payload: BingSortableListDragPayload<any>) => any) | undefined;
+    "onUpdate:order"?: ((order: BingSortableListKey[]) => any) | undefined;
+    onReorder?: ((payload: BingSortableListPayload<any>) => any) | undefined;
+    "onDrag-start"?: ((payload: BingSortableListDragPayload<any>) => any) | undefined;
+    "onDrag-end"?: ((payload: BingSortableListDragPayload<any>) => any) | undefined;
+}>, {
+    disabled: boolean;
+    order: BingSortableListKey[];
+    ariaLabel: string;
+    items: any[];
+    duration: number;
+    flip: boolean;
+    itemKey: import('./BingSortableList.types').BingSortableListItemKey<any>;
+    axis: import('./BingSortableList.types').BingSortableListAxis;
+    itemDisabled: import('./BingSortableList.types').BingSortableListItemDisabled<any>;
+    disabledKeys: BingSortableListKey[];
+    keyboard: boolean;
+    reorderMode: import('./BingSortableList.types').BingSortableListReorderMode;
+    settleDuration: number;
+    dragThreshold: number;
+    handleAriaLabel: string | ((item: any, index: number) => string);
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingSortableList/BingSortableListItem.vue.d.ts

@@ -0,0 +1,34 @@
+import { BingSortableListAxis, BingSortableListKey, BingSortableListSlotProps } from './BingSortableList.types';
+type ListItem = any;
+type __VLS_Props = {
+    item: ListItem;
+    itemKey: BingSortableListKey;
+    index: number;
+    activeKey: BingSortableListKey | null;
+    disabled?: boolean;
+    axis?: BingSortableListAxis;
+    flip?: boolean;
+    duration?: number;
+    handleLabel: string;
+};
+type __VLS_Slots = {
+    default?(props: BingSortableListSlotProps<ListItem>): unknown;
+};
+declare const __VLS_base: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "keyboard-move": (event: KeyboardEvent) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    "onKeyboard-move"?: ((event: KeyboardEvent) => any) | undefined;
+}>, {
+    disabled: boolean;
+    duration: number;
+    flip: boolean;
+    axis: BingSortableListAxis;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/BingSortableList/index.d.ts

@@ -0,0 +1,2 @@
+export { default as BingSortableList } from './BingSortableList.vue';
+export type { BingSortableListAxis, BingSortableListDragPayload, BingSortableListEmits, BingSortableListHandleProps, BingSortableListItemDisabled, BingSortableListItemKey, BingSortableListKey, BingSortableListPayload, BingSortableListProps, BingSortableListReorderMode, BingSortableListSlotProps, } from './BingSortableList.types';

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

@@ -0,0 +1,156 @@
+export type BingTableKey = string | number;
+export type BingTableAlign = 'left' | 'center' | 'right';
+export type BingTableFixed = 'left' | 'right';
+export type BingTableSize = 'sm' | 'md' | 'lg';
+export type BingTableVirtualMode = boolean | 'auto';
+export type BingTableSelectionMode = 'multiple' | 'single';
+export type BingTableSortOrder = 'asc' | 'desc' | null;
+export type BingTableRow = Record<string, unknown>;
+export type BingTableRowKeyGetter = (row: BingTableRow, index: number, path: number[]) => BingTableKey;
+export type BingTableRowClass = string | ((row: BingTableRow, index: number) => string | undefined);
+export type BingTableRowDisabled = string | ((row: BingTableRow, index: number) => boolean);
+export interface BingTableColumn {
+    key: string;
+    title?: string;
+    dataKey?: string;
+    width?: number | string;
+    minWidth?: number;
+    maxWidth?: number;
+    fixed?: BingTableFixed;
+    hidden?: boolean;
+    align?: BingTableAlign;
+    headerAlign?: BingTableAlign;
+    sortable?: boolean;
+    resizable?: boolean;
+    description?: string;
+    ellipsis?: boolean;
+    class?: string;
+    headerClass?: string;
+    sorter?: (left: BingTableRow, right: BingTableRow) => number;
+}
+export interface BingTableColumnResizePayload {
+    key: string;
+    width: number;
+    widths: Record<string, number>;
+}
+export interface BingTableColumnReorderPayload {
+    key: string;
+    from: number;
+    to: number;
+    order: string[];
+}
+export interface BingTableColumnVisibilityPayload {
+    key: string;
+    hidden: boolean;
+    hiddenColumnKeys: string[];
+}
+export interface BingTableColumnFixedPayload {
+    key: string;
+    fixed: BingTableFixed | null;
+    columnFixed: Record<string, BingTableFixed | null>;
+}
+export interface BingTableSelectionPayload {
+    keys: BingTableKey[];
+    rows: BingTableRow[];
+}
+export interface BingTableExpandPayload {
+    key: BingTableKey;
+    row: BingTableRow;
+    expanded: boolean;
+    expandedRowKeys: BingTableKey[];
+}
+export interface BingTablePageChangePayload {
+    page: number;
+    pageSize: number;
+}
+export interface BingTableSortPayload {
+    key: string | null;
+    order: BingTableSortOrder;
+    column?: BingTableColumn;
+}
+export interface BingTableProps {
+    data?: BingTableRow[];
+    columns?: BingTableColumn[];
+    rowKey?: string | BingTableRowKeyGetter;
+    childrenKey?: string;
+    height?: number | string;
+    maxHeight?: number | string;
+    size?: BingTableSize;
+    bordered?: boolean;
+    striped?: boolean;
+    loading?: boolean;
+    emptyText?: string;
+    loadingText?: string;
+    selectable?: boolean;
+    selectionMode?: BingTableSelectionMode;
+    selectedRowKeys?: BingTableKey[];
+    defaultSelectedRowKeys?: BingTableKey[];
+    rowDisabled?: BingTableRowDisabled;
+    selectOnRowClick?: boolean;
+    selectionFixed?: boolean;
+    selectionColumnWidth?: number;
+    expandedRowKeys?: BingTableKey[];
+    defaultExpandedRowKeys?: BingTableKey[];
+    defaultExpandAll?: boolean;
+    treeColumnKey?: string;
+    indentSize?: number;
+    columnWidths?: Record<string, number>;
+    defaultColumnWidths?: Record<string, number>;
+    columnOrder?: string[];
+    defaultColumnOrder?: string[];
+    hiddenColumnKeys?: string[];
+    defaultHiddenColumnKeys?: string[];
+    columnFixed?: Record<string, BingTableFixed | null>;
+    defaultColumnFixed?: Record<string, BingTableFixed | null>;
+    resizableColumns?: boolean;
+    reorderableColumns?: boolean;
+    showColumnControls?: boolean;
+    virtual?: BingTableVirtualMode;
+    virtualThreshold?: number;
+    virtualRowHeight?: number;
+    virtualOverscan?: number;
+    pagination?: boolean;
+    remotePagination?: boolean;
+    preservePageHeight?: boolean;
+    page?: number;
+    defaultPage?: number;
+    pageSize?: number;
+    defaultPageSize?: number;
+    pageSizeOptions?: number[];
+    total?: number;
+    sortKey?: string | null;
+    defaultSortKey?: string | null;
+    sortOrder?: BingTableSortOrder;
+    defaultSortOrder?: BingTableSortOrder;
+    rowClass?: BingTableRowClass;
+    ariaLabel?: string;
+}
+export interface BingTableEmits {
+    'update:selectedRowKeys': [keys: BingTableKey[]];
+    'selection-change': [payload: BingTableSelectionPayload];
+    'update:expandedRowKeys': [keys: BingTableKey[]];
+    'expand-change': [payload: BingTableExpandPayload];
+    'update:columnWidths': [widths: Record<string, number>];
+    'column-resize': [payload: BingTableColumnResizePayload];
+    'update:columnOrder': [order: string[]];
+    'column-reorder': [payload: BingTableColumnReorderPayload];
+    'update:hiddenColumnKeys': [keys: string[]];
+    'column-visibility-change': [payload: BingTableColumnVisibilityPayload];
+    'update:columnFixed': [columnFixed: Record<string, BingTableFixed | null>];
+    'column-fixed-change': [payload: BingTableColumnFixedPayload];
+    'update:page': [page: number];
+    'update:pageSize': [pageSize: number];
+    'page-change': [payload: BingTablePageChangePayload];
+    'update:sortKey': [key: string | null];
+    'update:sortOrder': [order: BingTableSortOrder];
+    'sort-change': [payload: BingTableSortPayload];
+    'row-click': [row: BingTableRow, event: MouseEvent];
+    scroll: [event: Event];
+}
+export interface BingTableExpose {
+    clearSelection: () => void;
+    toggleRowSelection: (key: BingTableKey, selected?: boolean) => void;
+    toggleRowExpansion: (key: BingTableKey, expanded?: boolean) => void;
+    resetColumns: () => void;
+    scrollTo: (top: number) => void;
+}