import { AdjustOverflow } from 'ant-design-vue/es/tooltip';
import { AlignType } from 'ant-design-vue/es/vc-trigger/interface';
import { AllowedComponentProps } from 'vue';
import { App } from 'vue';
import { BuildInPlacements } from 'ant-design-vue/es/vc-trigger/interface';
import { ButtonProps } from 'ant-design-vue/lib/button';
import { ColProps } from 'ant-design-vue/lib/grid/Col';
import { ColumnsType } from 'ant-design-vue/es/table';
import { ColumnType } from 'ant-design-vue/es/vc-table/interface';
import { ColumnType as ColumnType_2 } from 'ant-design-vue/es/table';
import { ComponentCustomProps } from 'vue';
import { ComponentOptionsMixin } from 'vue';
import { ComponentProvideOptions } from 'vue';
import { ComputedRef } from 'vue';
import { CreateComponentPublicInstanceWithMixins } from 'vue';
import { CSSProperties } from 'vue';
import { CustomSlotsType } from 'ant-design-vue/es/_util/type';
import { ExpandedRowRender } from 'ant-design-vue/es/vc-table/interface';
import { ExtractPropTypes } from 'vue';
import { FilterValue } from 'ant-design-vue/es/table/interface';
import { FormProps } from 'ant-design-vue/lib/form/Form';
import { GetComponentProps } from 'ant-design-vue/es/vc-table/interface';
import { GetPopupContainer } from 'ant-design-vue/es/table/interface';
import { GetRowKey } from 'ant-design-vue/es/vc-table/interface';
import { GlobalComponents } from 'vue';
import { GlobalDirectives } from 'vue';
import { JSX } from 'vue/jsx-runtime';
import { Key } from 'ant-design-vue/es/vc-table/interface';
import { LiteralUnion } from 'ant-design-vue/es/_util/type';
import { PanelRender } from 'ant-design-vue/es/vc-table/interface';
import { PresetColorType } from 'ant-design-vue/es/_util/colors';
import { PropType } from 'vue';
import { PublicProps } from 'vue';
import { Ref } from 'vue';
import { RenderExpandIcon } from 'ant-design-vue/es/vc-table/interface';
import { RenderExpandIconProps } from 'ant-design-vue/es/vc-table/interface';
import { RowClassName } from 'ant-design-vue/es/vc-table/interface';
import { Rule as Rule_2 } from 'ant-design-vue/lib/form';
import { ShallowUnwrapRef } from 'vue';
import { SizeType } from 'ant-design-vue/es/button';
import { SorterResult } from 'ant-design-vue/es/table/interface';
import { SortOrder } from 'ant-design-vue/es/table/interface';
import { SpinSize } from 'ant-design-vue/es/spin/Spin';
import { TableColumnGroupType } from 'ant-design-vue';
import { TableColumnType } from 'ant-design-vue';
import { TableComponents } from 'ant-design-vue/es/vc-table/interface';
import { TableCurrentDataSource } from 'ant-design-vue/es/table/interface';
import { TableLayout } from 'ant-design-vue/es/vc-table/interface';
import { TableLocale } from 'ant-design-vue/es/table/interface';
import { TablePaginationConfig } from 'ant-design-vue';
import { TableProps } from 'ant-design-vue';
import { TableRowSelection } from 'ant-design-vue/es/table/interface';
import { TableSticky } from 'ant-design-vue/es/vc-table/interface';
import { TooltipPlacement } from 'ant-design-vue/es/tooltip';
import { TooltipProps } from 'ant-design-vue';
import { TransformCellText } from 'ant-design-vue/es/vc-table/interface';
import { TriggerType } from 'ant-design-vue/es/tooltip/abstractTooltipProps';
import { UnwrapRefSimple } from '@vue/reactivity';
import { VNode } from 'vue';
import { VNodeProps } from 'vue';
import { WatchHandle } from 'vue';
import { WatchOptions } from 'vue';
import { WatchSource } from 'vue';

declare type __VLS_PrettifyLocal<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_PrettifyLocal_2<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_PrettifyLocal_3<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_PrettifyLocal_4<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_PrettifyLocal_5<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_PrettifyLocal_6<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_PrettifyLocal_7<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_PrettifyLocal_8<T> = {
    [K in keyof T]: T[K];
} & {};

declare type __VLS_PrettifyLocal_9<T> = {
    [K in keyof T]: T[K];
} & {};

export declare const addFormatter: (formatter: Record<string, (a: CellFuncArg, ...args: any[]) => any>) => void;

export declare const addRender: (name: string, { renderItemContent, renderDefault, renderReadonly, renderEdit }: RenderWorkshop) => void;

export declare interface AjaxConfig<F extends Recordable = Recordable> {
    query: (Q: {
        page?: IPage;
        form: Partial<F>;
    }) => Promise<Recordable>;
    multiDelete?: HandlerMultiDel;
}

declare type Align = 'left' | 'center' | 'right';

/**
 * 宽/高先按「视口内从元素左上角到右/下边缘」计算。
 *
 * 宽度会再与**直接父元素**布局框取较小值，避免嵌套在侧栏 + flex 列等窄容器里仍按整屏宽度赋值，
 * 从而撑出页面级横向滚动条。
 *
 * 高度不做 parent 截断：autoBoxSize 的语义就是「一直撑到视口底」。若对 parent 取 min，
 * 遇到「父容器没有明确高度、靠子元素内容撑开」的常见布局（外层未写死高度，p-grid 根节点
 * 自身决定可视高度），会形成循环依赖（子依赖父、父又靠子撑开），导致高度被截成极小值，
 * 反映到 PGrid 上就是表体下方出现大面积空白。
 */
export declare function applyViewportRestSize(el: HTMLElement, offset: AutoViewportBoxOffset): void;

declare type AutofillOptions = {
    enable: boolean;
    xArr: number[];
    yArr: number[];
};

export declare interface AutoViewportBoxController {
    attach: () => void;
    /** 暂停尺寸监听，保留当前写入的宽高，用于 keep-alive 停用场景 */
    detach: () => void;
    update: () => void;
    destroy: () => void;
}

export declare interface AutoViewportBoxControllerOptions {
    /** 每次尺寸写回后回调（例如触发内部表格 resize） */
    onLayout?: () => void;
}

export declare interface AutoViewportBoxOffset {
    right: number;
    bottom: number;
}

/**
 * 按视口从元素左上角铺满宽高（与 storybook 中 v-rest / v-height / v-width 同源思路），
 * 用于外层未声明高度、需由根节点自行占满可视区域的场景。
 */
export declare type AutoViewportBoxOffsetInput = number | string | {
    right?: number;
    bottom?: number;
} | undefined;

declare class BaseCell {
    ctx: Context;
    x: number;
    y: number;
    width: number;
    height: number;
    visibleWidth: number;
    visibleHeight: number;
    fixed?: Fixed;
    cellType: CellType;
    drawX: number;
    drawY: number;
    cellImages: Map<string, CellImage>;
    constructor(ctx: Context, x: number, y: number, width: number, height: number, cellType: CellType, fixed?: Fixed);
    isHorizontalVisible(): boolean;
    isVerticalVisible(): boolean;
    getDrawX(): number;
    getDrawY(): number;
    getLeftFixedX(): number;
    isInside(x: number, y: number): boolean;
    /**
     * 判断是否在可见区域,合并单元格用
     * @param x
     * @param y
     * @returns
     */
    isInsideVisible(x: number, y: number): boolean;
    setImage(key: string, image: CellImage): void;
    getImages(): Map<string, CellImage>;
    getImage(key: string): CellImage | undefined;
    isImageInside(key: string, e: MouseEvent): boolean;
    getImageClickDirection(key: string, e: MouseEvent): "up-left" | "up-right" | "down-left" | "down-right" | null;
}

declare type BeforeAutofillDataMethod = (changeList: BeforeChangeItem[], xArr: number[], yArr: number[]) => BeforeChangeItem[] | Promise<BeforeChangeItem[]>;

declare type BeforeBodyContextMenuMethod = (params: ContextMenuItemParams) => MenuItem[] | Promise<MenuItem[]>;

declare type BeforeCellValueChangeMethod = (changeList: BeforeValueChangeItem[]) => BeforeValueChangeItem[] | Promise<BeforeValueChangeItem[]>;

declare type BeforeChangeItem = {
    rowKey: string;
    key: string;
    value: any;
    oldValue: any;
    row: any;
};

declare type BeforeCopyMethod = (params: BeforeCopyParams) => BeforeCopyParams | undefined;

declare type BeforeCopyParams = {
    focusCell?: Cell;
    data: any;
    xArr: number[];
    yArr: number[];
};

declare type BeforeDragRowMethod = (params: BeforeDragRowParams) => boolean | Promise<boolean>;

declare type BeforeDragRowParams = {
    source: Cell;
    target: Cell;
    position: TreeUtilPosition;
};

declare type BeforeHeaderContextMenuMethod = (params: ContextMenuItemParams) => MenuItem[] | Promise<MenuItem[]>;

declare type BeforePasteDataMethod = (changeList: BeforeChangeItem[], xArr: number[], yArr: number[], textArr: string[][]) => BeforeChangeItem[] | Promise<BeforeChangeItem[]>;

declare type BeforeSetAutofillMethod = (params: BeforeSetAutofillParams) => BeforeSetAutofillParams | undefined;

declare type BeforeSetAutofillParams = {
    focusCell?: Cell;
    xArr: number[];
    yArr: number[];
};

declare type BeforeSetSelectorMethod = (params: BeforeSetSelectorParams) => BeforeSetSelectorParams | undefined;

declare type BeforeSetSelectorParams = {
    focusCell?: Cell;
    xArr: number[];
    yArr: number[];
};

declare type BeforeValueChangeItem = {
    rowKey: string;
    key: string;
    value: any;
    oldValue?: any;
    row?: any;
    errorTip?: boolean;
};

declare type BodyOptions = {
    x: number;
    y: number;
    width: number;
    height: number;
    visibleHeight: number;
    visibleWidth: number;
    headIndex: number;
    tailIndex: number;
    visibleRows: any[];
    renderRows: Row[];
    data: any[];
};

export declare type BorderConfigValue = boolean | BorderStyle;

export declare type BorderStyle = 'default' | 'outer' | 'inner' | 'none';

export declare interface CanvasColumnProps<T extends Recordable = Recordable> extends Omit<Column, 'children' | 'formatter' | 'key'> {
    key?: string;
    field?: string;
    children?: CanvasColumnProps<T>[];
    formatter?: string | [string, ...Array<any>] | ((arg: PartialByKeys<CellFuncArg<T>, 'cellValue'>) => any);
    slots?: {
        default?: ({ row, column, rowIndex, }: {
            row: T;
            column: CanvasColumnProps<T>;
            rowIndex: number;
        }) => any;
        edit?: ({ row, column, rowIndex, }: {
            row: T;
            column: CanvasColumnProps<T>;
            rowIndex: number;
        }) => any;
        title?: ({ column }: {
            column: CanvasColumnProps<T>;
        }) => any;
    };
    cellRender?: CellRender;
    editRender?: CellRender;
}

export declare interface CanvasTableProps<T extends Recordable = Recordable, B extends Recordable = Recordable> {
    columns: CanvasColumnProps<T>[];
    data: T[];
    config?: ConfigType;
    footerData?: B[];
    loading?: boolean;
}

declare class Cell extends BaseCell {
    parentRowKey: string;
    parentRowKeys: string[];
    formatter?: FormatterMethod;
    formatterFinderValue?: FinderFormatterMethod;
    formatterFinderFooterValue?: FinderFormatterMethod;
    formatterFooter?: FormatterMethod;
    hoverIconName?: string;
    operation: boolean;
    align: Align;
    verticalAlign: VerticalAlign;
    fixed?: Fixed;
    type: Type | '';
    editorType: string;
    editorProps: any;
    cellType: CellType;
    level: number;
    colspan: number;
    rowspan: number;
    mergeRow: boolean;
    mergeCol: boolean;
    relationRowKeys: string[];
    relationColKeys: string[];
    key: string;
    column: Column;
    rowIndex: number;
    colIndex: number;
    rowKey: string;
    row: any;
    value: any;
    render: Render;
    renderFooter: Render;
    style: any;
    domDataset: any;
    rules: Rules | Rule;
    message: string;
    text: string;
    displayText: string;
    visibleWidth: number;
    visibleHeight: number;
    isHasChanged: boolean;
    drawX: number;
    drawY: number;
    drawCellBgColor: string;
    drawCellSkyBgColor: string;
    drawTextColor: string;
    drawTextFont: string;
    drawTextX: number;
    drawTextY: number;
    drawTextWidth: number;
    drawTextHeight: number;
    autoRowHeight: boolean;
    calculatedHeight: number;
    ellipsis: boolean;
    rowExpand: boolean;
    rowHasChildren: boolean;
    overflowTooltipShow: boolean;
    selectorCellValueType: SelectorCellValueType;
    overflowTooltipMaxWidth: number;
    overflowTooltipPlacement: OverflowTooltipPlacement;
    maxLineClamp: LineClampType;
    precision?: number;
    min?: number;
    max?: number;
    maxlength?: number;
    mixedRender?: boolean;
    renderType: RenderType;
    renderFooterType: RenderType;
    constructor(ctx: Context, rowIndex: number, colIndex: number, x: number, y: number, width: number, height: number, column: Column, row: any, cellType?: CellType, isUpdate?: boolean);
    setWidthHeight(width: number, height: number): void;
    getValidationMessage(): string;
    update(): void;
    updateSpan(): void;
    updateSpanInfo(): void;
    updateType(): void;
    updateEditor(): void;
    updateRender(): void;
    validate(): void;
    /**
     * 更新样式
     */
    updateStyle(): void;
    isInsideVisible(x: number, y: number): boolean;
    private updateTree;
    private updateDragImage;
    private drawTreeLine;
    private updateContainer;
    private updateSelection;
    private updateHoverIcon;
    /**
     * 获取自动高度
     * @returns
     */
    getAutoHeight(): number;
    getSpanInfo(): SpanInfo;
    /**
     * 获取显示文本
     * @returns
     */
    getDisplayText(text?: string): string;
    /**
     * 获取文本
     * @returns
     */
    getText(): any;
    getFinderText(): string;
    getValue(): any;
    setValue(value: any): void;
    /**
     * 获取样式
     */
    getOverlayerViewsStyle(): {
        position: string;
        overflow: string;
        left: string;
        top: string;
        width: string;
        height: string;
        pointerEvents: string;
        userSelect: string;
    };
    drawContainer(): void;
    drawHorizontalBorder(): void;
    private drawAutofillPiont;
    draw(): void;
    /**
     * 根据列的索引获取列的宽度
     * @param {Number} colIndex
     */
    private getWidthByColIndexColSpan;
    private drawText;
    private drawImage;
    private drawSelector;
    private drawErrorTip;
    private drawBorder;
}

declare type CellEditorMethod = (params: CellParams) => EditorOptions | void;

export declare interface CellFuncArg<D extends Recordable = Recordable> {
    row: D;
    column?: ColumnProps<D>;
    rowIndex: number;
    cellValue: any;
}

declare class CellHeader extends BaseCell {
    align: Align;
    hideHeaderSelection: boolean;
    verticalAlign: VerticalAlign;
    fixed?: Fixed;
    minWidth?: number;
    maxWidth?: number;
    formatterFinderHeaderValue?: FinderHeaderFormatterMethod;
    widthFillDisable: boolean;
    type: Type | '';
    operation: boolean;
    editorType: string;
    level: number;
    text: string;
    hide: boolean;
    displayText: string;
    colspan: number;
    rowspan: number;
    row: any;
    key: string;
    required: boolean;
    readonly: boolean;
    ellipsis: boolean;
    overflowTooltipShow: boolean;
    children: Column[];
    column: Column;
    colIndex: number;
    rowKey: string;
    rules?: Rules | Rule;
    hasChildren: boolean;
    render: Render;
    style: Partial<CSSStyleDeclaration>;
    drawX: number;
    drawY: number;
    sortIconName: string;
    sortAscIconName: string;
    sortDescIconName: string;
    visibleWidth: number;
    visibleHeight: number;
    maxLineClampHeader: LineClampType;
    domDataset: any;
    textOffsetRight: number;
    textOffsetLeft: number;
    textInfo: TextInfo | undefined;
    drawTextX: number;
    drawTextY: number;
    drawTextWidth: number;
    drawTextHeight: number;
    drawCellBgColor: string;
    drawTextColor: string;
    drawTextFont: string;
    drawSelectionImageX: number;
    drawSelectionImageY: number;
    drawSelectionImageWidth: number;
    drawSelectionImageHeight: number;
    drawSelectionImageName: string;
    drawSelectionImageSource?: HTMLImageElement;
    drawSortImageX: number;
    drawSortImageY: number;
    drawSortImageWidth: number;
    drawSortImageHeight: number;
    drawSortImageName: string;
    drawSortImageSource?: HTMLImageElement;
    renderHeaderType: RenderType;
    constructor(ctx: Context, colIndex: number, x: number, y: number, width: number, height: number, column: Column);
    /**
     * 是否可见，覆盖基类方法，表头是跟y滚动条没有关系的所以不需要加滚动参数
     * @returns
     */
    isVerticalVisible(): boolean;
    /**
     * 更新样式
     */
    updateStyle(): void;
    updateContainer(): void;
    private updateOffset;
    update(): void;
    draw(): void;
    drawImages(): void;
    getFinderText(): string;
    private drawEdge;
    private drawColumnDivider;
    private drawHorizontalDivider;
    private drawText;
    private drawRequired;
    private drawBg;
    private updateSelection;
    private updateSortIcon;
    getText(): string;
    /**
     * 获取样式
     */
    getOverlayerViewsStyle(): {
        position: string;
        overflow: string;
        left: string;
        top: string;
        width: string;
        height: string;
        pointerEvents: string;
        userSelect: string;
    };
}

declare type CellHeaderParams = {
    colIndex: number;
    column: Column;
};

declare type CellHeaderStyleMethod = (params: CellHeaderParams) => CellStyleOptions | void;

declare type CellHoverIconMethod = (params: CellParams) => string | void;

declare class CellImage {
    source?: HTMLImageElement;
    name: string;
    x: number;
    y: number;
    width: number;
    height: number;
    visible: boolean;
    constructor(name: string, x: number, y: number, width: number, height: number, source?: HTMLImageElement);
    drawWrapper(ctx: Context, options: RectOptions): void;
    setVisible(visible: boolean): void;
    isInside(mouseX: number, mouseY: number): boolean;
}

declare type CellParams = {
    row: any;
    rowIndex: number;
    colIndex: number;
    column: Column;
    value: any;
};

declare type CellReadonlyMethod = (params: CellParams) => boolean | void;

export declare interface CellRender {
    name: string;
    props?: Recordable;
    attrs?: Recordable;
    children?: Recordable[];
}

declare type CellRenderMethod = (params: CellParams) => string | void;

declare type CellRulesMethod = (params: CellParams) => Rules | void;

declare type CellStyleMethod = (params: CellStyleParams) => CellStyleOptions | void;

declare type CellStyleOptions = {
    color?: string;
    backgroundColor?: string;
    font?: string;
};

declare type CellStyleParams = CellParams & {
    isHasChanged?: boolean;
};

declare type CellType = 'header' | 'body' | 'footer';

declare type CellTypeMethod = (params: CellParams) => Type | void;

declare type ChangeItem = {
    value: any;
    key: string;
    rowKey: string;
    row: any;
    oldValue?: any;
};

export declare const cleanCol: (col: ColumnProps) => TableColumnType | TableColumnGroupType<Recordable>;

declare interface Column {
    key: string;
    title: string;
    type?: Type;
    operation?: boolean;
    editorType?: string;
    editorProps?: any;
    hoverIconName?: string;
    placeholder?: string;
    width?: number;
    minWidth?: number;
    maxWidth?: number;
    widthFillDisable?: boolean;
    headerAlign?: Align;
    headerVerticalAlign?: VerticalAlign;
    hideHeaderSelection?: boolean;
    align?: Align;
    verticalAlign?: VerticalAlign;
    fixed?: Fixed;
    level?: number;
    text?: string;
    colspan?: number;
    rowspan?: number;
    sort?: number;
    sortBy?: SortByType;
    sortIconType?: 'up-down' | 'left-right' | 'loop';
    sortIconName?: string;
    sortAscIconName?: string;
    sortDescIconName?: string;
    parentKey?: string;
    hide?: boolean | Function;
    render?: Function | string;
    renderFooter?: Function | string;
    renderHeader?: Function | string;
    renderType?: RenderType;
    renderHeaderType?: RenderType;
    renderFooterType?: RenderType;
    formatter?: FormatterMethod;
    formatterFinderValue?: FinderFormatterMethod;
    formatterFinderHeaderValue?: FinderHeaderFormatterMethod;
    formatterFinderFooterValue?: FinderFormatterMethod;
    formatterFooter?: FormatterMethod;
    autoRowHeight?: boolean;
    overflowTooltipShow?: boolean;
    overflowTooltipHeaderShow?: boolean;
    overflowTooltipMaxWidth?: number;
    overflowTooltipPlacement?: OverflowTooltipPlacement;
    required?: boolean;
    readonly?: boolean | CellReadonlyMethod;
    children?: Column[];
    column?: Column;
    rules?: Rules | Rule;
    options?: any;
    dragRow?: boolean;
    dragDisabled?: boolean;
    hideDisabled?: boolean;
    fixedDisabled?: boolean;
    selectorCellValueType?: SelectorCellValueType;
    formatterSelectorValue?: FormatterMethod;
    maxLineClamp?: LineClampType;
    maxLineClampHeader?: LineClampType;
    precision?: number;
    min?: number;
    max?: number;
    maxlength?: number;
    mixedRender?: boolean;
    canValueChange?: (changeItem: BeforeValueChangeItem) => Promise<boolean> | boolean;
    valueChange?: (changeItem: BeforeValueChangeItem) => void;
}

export declare interface ColumnProps<D extends Recordable = Recordable> extends Omit<TableColumnType, 'slots'> {
    field?: string;
    children?: ColumnProps<D>[];
    formatter?: string | [string, ...Array<any>] | ((arg: PartialByKeys<CellFuncArg<D>, 'cellValue'>) => any);
    slots?: {
        default?: ({ row, column, rowIndex }: PartialByKeys<CellFuncArg<D>, 'cellValue'>) => any;
        title?: ({ column }: {
            column: ColumnProps<D>;
        }) => any;
    };
    cellRender?: CellRender;
}

declare class Config {
    private _config;
    /** CSS 类名前缀 */
    CSS_PREFIX: string;
    /** 图标集合 */
    ICONS: IconType[];
    /** 行的唯一标识：字段名，或返回唯一标识的方法 */
    ROW_KEY: string | RowKeyMethod;
    /** 禁用编辑,优先等级最高 */
    DISABLED: boolean;
    /** 表头字体 */
    HEADER_FONT: string;
    /** 单元格字体 */
    BODY_FONT: string;
    /** 边框 */
    BORDER: BorderConfigValue;
    /** 斑马纹 */
    STRIPE: boolean;
    /** 斑马纹颜色 */
    STRIPE_COLOR: string;
    /** 区域边框颜色 */
    BORDER_COLOR: string;
    /** 固定列阴影靠近边界的颜色 */
    FIXED_COLUMN_SHADOW_COLOR: string;
    /** 固定列阴影渐隐末端的颜色 */
    FIXED_COLUMN_SHADOW_FADE_COLOR: string;
    /** 固定列阴影宽度 */
    FIXED_COLUMN_SHADOW_WIDTH: number;
    /** 高度，为 0 表示自适应 */
    HEIGHT: number;
    /** 占位文本颜色 */
    PLACEHOLDER_COLOR: string;
    /** 空数据 body 高度 */
    EMPTY_BODY_HEIGHT: number;
    /** 自定义空样式 */
    EMPTY_CUSTOM_STYLE: Partial<CSSStyleDeclaration>;
    /** 空数据文本 */
    EMPTY_TEXT: string;
    /** 加载文本 */
    LOADING_TEXT: string;
    /** 最大高度，为 0 表示自适应高度根据 HEIGHT	 */
    MAX_HEIGHT: number;
    /** 区域边框圆角 */
    BORDER_RADIUS: number;
    /** 启用偏移高度内部计算表格高度 */
    ENABLE_OFFSET_HEIGHT: boolean;
    /** 偏移高度 */
    OFFSET_HEIGHT: number;
    /** 表头高度 */
    HEADER_HEIGHT: number;
    /** 启用头部固定,需要外面实现覆盖层，或者所有表头都要是元素 */
    ENABLE_HEADER_STICKY: boolean;
    /** 表头背景色 */
    HEADER_BG_COLOR: string;
    /** body 背景色 */
    BODY_BG_COLOR: string;
    /** 表头文本颜色 */
    HEADER_TEXT_COLOR: string;
    /** 必填*颜色 */
    REQUIRED_COLOR: string;
    /** body文本颜色 */
    BODY_TEXT_COLOR: string;
    /** footer文本颜色 */
    FOOTER_TEXT_COLOR: string;
    /** 加载 svg 图标 */
    LOADING_ICON_SVG: string;
    /** 加载 svg 图标颜色 */
    LOADING_ICON_COLOR: string;
    /** 树形展开svg 图标 */
    EXPAND_ICON_SVG: string;
    /** 树形收缩svg 图标 */
    SHRINK_ICON_SVG: string;
    /** 展开图标颜色 */
    EXPAND_ICON_COLOR: string;
    /** 收缩图标颜色 */
    SHRINK_ICON_COLOR: string;
    /** 错误提示颜色 */
    ERROR_TIP_ICON_COLOR: string;
    /** 错误提示图标大小 */
    ERROR_TIP_ICON_SIZE: number;
    /** 所有列对齐方式 */
    COLUMNS_ALIGN: Align;
    /** 所有列垂直对齐方式 */
    COLUMNS_VERTICAL_ALIGN: VerticalAlign;
    /** 是否开启懒加载	 */
    EXPAND_LAZY: boolean;
    /** 默认展开全部	 */
    DEFAULT_EXPAND_ALL: boolean;
    /** 表格 body 部分的宽度 */
    CELL_WIDTH: number;
    /** body 单元格默认行高 */
    CELL_HEIGHT: number;
    /** 表格 body 部分的 padding */
    CELL_PADDING: number;
    /** hover编辑图标大小 */
    CELL_HOVER_ICON_SIZE: number;
    /** hover编辑图标背景色 */
    CELL_HOVER_ICON_BG_COLOR: string;
    /** hover编辑图标边框颜色 */
    CELL_HOVER_ICON_BORDER_COLOR: string;
    /** 滚动条轨道尺寸 */
    SCROLLER_TRACK_SIZE: number;
    /** 滚动条模式，outer 为外部预留区域，inner 为覆盖在内容上 */
    scrollbarMode: ScrollbarMode_2;
    /** 内部滚动条悬停后显示延迟 */
    SCROLLBAR_SHOW_DELAY: number;
    /** 滚动条滑块尺寸 */
    SCROLLER_SIZE: number;
    /** 滚动条滑块颜色 */
    SCROLLER_COLOR: string;
    /** 轨道颜色 */
    SCROLLER_TRACK_COLOR: string;
    /** 滚动条滑块聚焦时的颜色 */
    SCROLLER_FOCUS_COLOR: string;
    /** 选中区域边框颜色 */
    SELECT_BORDER_COLOR: string;
    /** 选中区域背景颜色 */
    SELECT_AREA_COLOR: string;
    /** 当前焦点单元格所在行、列的背景色 */
    SELECT_ROW_COL_BG_COLOR: string;
    /** 填充点的边框颜色 */
    AUTOFILL_POINT_BORDER_COLOR: string;
    /** 可编辑背景色 */
    EDIT_BG_COLOR: string;
    /** 选择 key,合并时用 */
    CHECKBOX_KEY: string;
    /** 选择框颜色 */
    CHECKBOX_COLOR: string;
    /** 查找结果当前行颜色 */
    FINDER_CELL_BG_COLOR: string;
    /** 启用查找 */
    ENABLE_FINDER: boolean;
    /** 选择框大小 */
    CHECKBOX_SIZE: number;
    /** 选择框禁用图标 */
    CHECKBOX_DISABLED_SVG: string;
    /** 选择框禁用图标颜色 */
    CHECKBOX_DISABLED_COLOR: string;
    /** 选择框选中图标 */
    CHECKBOX_CHECK_SVG: string;
    /** 选择框未中图标 */
    CHECKBOX_UNCHECK_SVG: string;
    /** 选择框未中图标颜色 */
    CHECKBOX_UNCHECK_COLOR: string;
    /** 选择框半选中图标 */
    CHECKBOX_INDETERMINATE_SVG: string;
    /** 选择框选中禁用图标 */
    CHECKBOX_CHECK_DISABLED_SVG: string;
    /** 选择框选中禁用图标颜色 */
    CHECKBOX_CHECK_DISABLED_COLOR: string;
    /** 编辑图标 */
    ICON_EDIT_SVG: string;
    /** 编辑图标颜色 */
    ICON_EDIT_COLOR: string;
    /** 选择图标 */
    ICON_SELECT_SVG: string;
    /** 选择图标颜色 */
    ICON_SELECT_COLOR: string;
    /** 启用严格排序，即不支持多列排序 */
    SORT_STRICTLY: boolean;
    /** 排序升序图标 */
    SORT_ASC_ICON_SVG: string;
    /** 排序降序图标 */
    SORT_DESC_ICON_SVG: string;
    /** 排序默认图标 */
    SORTABLE_ICON_SVG: string;
    /** 排序图标颜色 */
    SORT_ICON_COLOR: string;
    /** 单元格只读背景色 */
    READONLY_COLOR: string;
    /** 单元格只读文本颜色 */
    READONLY_TEXT_COLOR: string;
    /**启用单元格只读触发校验 */
    ENABLE_READONLY_VALIDATE: boolean;
    /** 单元格错误提示文本颜色 */
    ERROR_TIP_COLOR: string;
    /** 合计底部背景色 */
    FOOTER_BG_COLOR: string;
    /** 合计底部固定 */
    FOOTER_FIXED: boolean;
    /** 合计底部位置 */
    FOOTER_POSITION: FooterPosition;
    /** 单元格底部高度 */
    CELL_FOOTER_HEIGHT: number;
    /** 启用选择器 */
    ENABLE_SELECTOR: boolean;
    /** 树形选择模式 */
    TREE_SELECT_MODE: TreeSelectMode;
    /** 树形子项key名称 */
    TREE_CHILDREN_KEY: string;
    /** 树形缩进宽度 */
    TREE_INDENT: number;
    /** 树形图标大小 */
    TREE_ICON_SIZE: number;
    /**树形划线 */
    TREE_LINE: boolean;
    /** 树形划线颜色 */
    TREE_LINE_COLOR: string;
    /** 启用单点击立马编辑 */
    ENABLE_EDIT_SINGLE_CLICK: boolean;
    /** 启用点击选择器编辑 */
    ENABLE_EDIT_CLICK_SELECTOR: boolean;
    /** 选择器X最小范围 */
    SELECTOR_AREA_MIN_X: number;
    /** 选择器X最大范围colMax - offset */
    SELECTOR_AREA_MAX_X_OFFSET: number;
    /** 选择器X最大范围,0默认最大colMax */
    SELECTOR_AREA_MAX_X: number;
    /** 选择器Y最小范围 */
    SELECTOR_AREA_MIN_Y: number;
    /** 选择器Y最大范围,0默认rowMax */
    SELECTOR_AREA_MAX_Y: number;
    /** 选择器Y最大范围,0默认rowMax */
    SELECTOR_AREA_MAX_Y_OFFSET: number;
    /** 选择器值类型，value，displayText,区别displayText受format影响 */
    SELECTOR_CELL_VALUE_TYPE: SelectorCellValueType;
    /** 启用自动主题 */
    ENABLE_AUTO_THEME: boolean;
    /** 启用选择器-选择器单选 */
    ENABLE_SELECTOR_SINGLE: boolean;
    /** 启用选择器-批量跨列选择 */
    ENABLE_SELECTOR_SPAN_COL: boolean;
    /** 启用选择器-批量跨行选择 */
    ENABLE_SELECTOR_SPAN_ROW: boolean;
    /** 启用选择器-批量选中列 */
    ENABLE_SELECTOR_ALL_ROWS: boolean;
    /** 启用选择器-批量选中行 */
    ENABLE_SELECTOR_ALL_COLS: boolean;
    /** 启用合并格子数据关联 */
    ENABLE_MERGE_CELL_LINK: boolean;
    /** 启用填充器 */
    ENABLE_AUTOFILL: boolean;
    /** 启用选择器-批量跨列选择 */
    ENABLE_AUTOFILL_SPAN_COL: boolean;
    /** 启用选择器-批量跨行选择 */
    ENABLE_AUTOFILL_SPAN_ROW: boolean;
    /** 启用body右键菜单 */
    ENABLE_CONTEXT_MENU: boolean;
    /** 启用表头右键菜单 */
    ENABLE_HEADER_CONTEXT_MENU: boolean;
    /** 启用文字选中复制 */
    ENABLE_TEXT_SELECTION: boolean;
    /** 启用复制 */
    ENABLE_COPY: boolean;
    /** 启用粘贴 */
    ENABLE_PASTER: boolean;
    /** 启用调整行高 */
    ENABLE_RESIZE_ROW: boolean;
    /** 启用列宽可调整 */
    ENABLE_RESIZE_COLUMN: boolean;
    /** 可调整列宽时的表头静态列分割线颜色 */
    RESIZE_COLUMN_DIVIDER_COLOR: string | undefined;
    /** 行调整线颜色 */
    RESIZE_ROW_LINE_COLOR: string;
    /** 列调整线颜色 */
    RESIZE_COLUMN_LINE_COLOR: string;
    /** 启用列调整文本 */
    ENABLE_RESIZE_COLUMN_TEXT: boolean;
    /** 列调整线颜色 */
    RESIZE_COLUMN_TEXT_COLOR: string;
    /** 列调整线文本背景色 */
    RESIZE_COLUMN_TEXT_BG_COLOR: string;
    /** 最小调整行高 */
    RESIZE_ROW_MIN_HEIGHT: number;
    /** 列宽最小值 */
    RESIZE_COLUMN_MIN_WIDTH: number;
    /** 拖拽提示背景色 */
    DRAG_TIP_BG_COLOR: string;
    /** 拖拽提示线颜色 */
    DRAG_TIP_LINE_COLOR: string;
    /** 拖拽提示文本颜色 */
    /** 启用键盘 */
    ENABLE_KEYBOARD: boolean;
    /** 启用历史 */
    ENABLE_HISTORY: boolean;
    ENABLE_VALIDATOR_IMMEDIATE: boolean;
    /** 历史栈数量 */
    HISTORY_NUM: number;
    /** 启用悬浮高亮 */
    HIGHLIGHT_HOVER_ROW: boolean;
    /** 悬浮颜色 */
    HIGHLIGHT_HOVER_ROW_COLOR: string;
    /** 高亮选中当前行 */
    HIGHLIGHT_SELECTED_ROW: boolean;
    /** 高亮当前行颜色 */
    HIGHLIGHT_SELECTED_ROW_COLOR: string;
    /** 提示背景颜色 */
    TOOLTIP_BG_COLOR: string;
    /** 提示文本颜色 */
    TOOLTIP_TEXT_COLOR: string;
    /** 提示层级 */
    TOOLTIP_ZINDEX: number;
    /** 自定义提示样式 */
    TOOLTIP_CUSTOM_STYLE: Partial<CSSStyleDeclaration>;
    /** 自定义右键菜单 */
    CONTEXT_MENU: MenuItem[];
    CUSTOM_BODY_CONTEXT_MENU: MenuItem[];
    HEADER_CONTEXT_MENU: MenuItem[];
    CUSTOM_HEADER_CONTEXT_MENU: MenuItem[];
    /** 格子多行文本行高,isAutoRowHeight才会生效 */
    CELL_LINE_HEIGHT: number;
    /** 全局自动行高 */
    AUTO_ROW_HEIGHT: boolean;
    /** 启用拖拽表头 */
    ENABLE_DRAG_COLUMN: boolean;
    /** 启用拖拽行 */
    ENABLE_DRAG_ROW: boolean;
    /** 启用拖拽行跨级,针对tree数据结构 */
    ENABLE_DRAG_ROW_CROSS_LEVEL: boolean;
    /** 启用拖拽行自定义 */
    ENABLE_DRAG_ROW_CUSTOM: boolean;
    /** 拖拽提示线颜色 */
    DRAG_ROW_TIP_LINE_COLOR: string;
    /** 拖拽行图标 */
    DRAG_ROW_ICON_SVG: string;
    /** 拖拽行图标大小 */
    DRAG_ROW_ICON_SIZE: number;
    /** 拖拽行图标颜色 */
    DRAG_ROW_ICON_COLOR: string;
    /** header 格子样式 */
    HEADER_CELL_STYLE_METHOD?: CellHeaderStyleMethod;
    /** body 格子样式 */
    BODY_CELL_STYLE_METHOD?: CellStyleMethod;
    /** footer 格子样式 */
    FOOTER_CELL_STYLE_METHOD?: CellStyleMethod;
    /** 自定义只读 */
    BODY_CELL_READONLY_METHOD?: CellReadonlyMethod;
    /** 格式化方法更改（formatter优先等级比较高） */
    BODY_CELL_FORMATTER_METHOD?: FormatterMethod;
    /** 自定义校验规则 */
    BODY_CELL_RULES_METHOD?: CellRulesMethod;
    /** 自定义只读 */
    BODY_CELL_TYPE_METHOD?: CellTypeMethod;
    /** 自定义编辑器类型 */
    BODY_CELL_EDITOR_METHOD?: CellEditorMethod;
    /** 自定义只读 */
    BODY_CELL_RENDER_METHOD?: CellRenderMethod;
    /** 自定义只读 */
    BODY_CELL_HOVER_ICON_METHOD?: CellHoverIconMethod;
    /** 自定义跨列/行渲染 */
    SPAN_METHOD?: SpanMethod;
    /** 自定义选择禁用 */
    SELECTABLE_METHOD?: SelectableMethod;
    /** 自定义选择禁用 */
    EXPAND_LAZY_METHOD?: ExpandLazyMethod;
    /** 数值改变前回调 */
    BEFORE_VALUE_CHANGE_METHOD?: BeforeCellValueChangeMethod;
    /** 粘贴前回调 */
    BEFORE_PASTE_DATA_METHOD?: BeforePasteDataMethod;
    /** 数值填充前回调 */
    BEFORE_AUTOFILL_DATA_METHOD?: BeforeAutofillDataMethod;
    /** 设置选择器前回调 */
    BEFORE_SET_SELECTOR_METHOD?: BeforeSetSelectorMethod;
    /** 设置填充器前回调 */
    BEFORE_SET_AUTOFILL_METHOD?: BeforeSetAutofillMethod;
    /** 自定义表头右键菜单 */
    BEFORE_HEADER_CONTEXT_MENU_METHOD?: BeforeHeaderContextMenuMethod;
    /** 自定义BODY右键菜单 */
    BEFORE_BODY_CONTEXT_MENU_METHOD?: BeforeBodyContextMenuMethod;
    /** 数据复制前回调 */
    BEFORE_COPY_METHOD?: BeforeCopyMethod;
    BEFORE_DRAG_ROW_METHOD?: BeforeDragRowMethod;
    constructor(config: Partial<Config>);
    /** 初始化 */
    init(config: ConfigType): void;
    /** 同步css 样式变量 */
    updateCssVar(): void;
}

declare type ConfigColorNameType = 'LOADING_ICON_COLOR' | 'EXPAND_ICON_COLOR' | 'SHRINK_ICON_COLOR' | 'CHECKBOX_COLOR' | 'SORT_ICON_COLOR' | 'ICON_EDIT_COLOR' | 'ICON_SELECT_COLOR' | 'CHECKBOX_DISABLED_COLOR' | 'CHECKBOX_UNCHECK_COLOR';

declare type ConfigType = Partial<Config>;

declare type ConfigTypeName = 'LOADING_ICON_SVG' | 'EXPAND_ICON_SVG' | 'SHRINK_ICON_SVG' | 'CHECKBOX_UNCHECK_SVG' | 'CHECKBOX_CHECK_SVG' | 'CHECKBOX_DISABLED_SVG' | 'ICON_EDIT_SVG' | 'ICON_SELECT_SVG' | 'CHECKBOX_CHECK_DISABLED_SVG' | 'CHECKBOX_INDETERMINATE_SVG' | 'SORT_ASC_ICON_SVG' | 'SORT_DESC_ICON_SVG' | 'SORTABLE_ICON_SVG' | 'DRAG_ROW_ICON_SVG';

declare type containerElementOptions = {
    containerElement: HTMLDivElement;
    stageElement: HTMLDivElement;
    canvasElement: HTMLCanvasElement;
    overlayerElement: HTMLDivElement;
    editorElement: HTMLDivElement;
    emptyElement?: HTMLDivElement;
    contextMenuElement?: HTMLDivElement;
    loadingElement?: HTMLDivElement;
};

declare class Context {
    private eventBus;
    private eventBrowser;
    private eventTable;
    locale: Locale;
    containerElement: HTMLDivElement;
    stageElement: HTMLDivElement;
    canvasElement: HTMLCanvasElement;
    overlayerElement: HTMLDivElement;
    editorElement: HTMLDivElement;
    emptyElement?: HTMLDivElement;
    contextMenuElement?: HTMLDivElement;
    loadingElement?: HTMLDivElement;
    stageWidth: number;
    stageHeight: number;
    paint: Paint;
    icons: Icons;
    domSelectionStr: string;
    textSelectionStr: string;
    textSelecting: boolean;
    isMouseoverTargetContainer: boolean;
    mousedown: boolean;
    isEmpty: boolean;
    rowResizing: boolean;
    columnResizing: boolean;
    scrollerMove: boolean;
    scrollerFocus: boolean;
    autofillMove: boolean;
    selectorMove: boolean;
    disableHoverIconClick: boolean;
    selectColsIng: boolean;
    selectRowsIng: boolean;
    dragHeaderIng: boolean;
    dragRowIng: boolean;
    finding: boolean;
    contextMenuIng: boolean;
    editing: boolean;
    loading: boolean;
    onlyMergeCell: boolean;
    selectOnlyOne: boolean;
    hasSelection: boolean;
    hasTree: boolean;
    scrollY: number;
    scrollX: number;
    fixedLeftWidth: number;
    fixedRightWidth: number;
    lastCenterColIndex: number;
    maxColIndex: number;
    maxRowIndex: number;
    hoverRow?: Row;
    clickCell?: Cell;
    focusCell?: Cell;
    currentCell?: Cell;
    hoverCell?: Cell;
    clickCellHeader?: CellHeader;
    focusCellHeader?: CellHeader;
    hoverCellHeader?: CellHeader;
    mouseX: number;
    mouseY: number;
    body: BodyOptions;
    footer: FooterOptions;
    header: HeaderOptions;
    selector: SelectorOptions;
    autofill: AutofillOptions;
    finderBar: FinderResult;
    database: Database;
    history: History_2;
    config: Config;
    constructor(containerOptions: containerElementOptions, options: EVirtTableOptions);
    setConfig(config: Config): void;
    setItemValueByEditor(rowKey: string, key: string, value: any, history?: boolean, reDraw?: boolean, checkReadonly?: boolean): void;
    batchSetItemValueByEditor(_list: ChangeItem[], history?: boolean, checkReadonly?: boolean): void;
    setFocusCell(cell: Cell): void;
    clearSelector(): void;
    clearSelectorCopy(): void;
    clearAutofill(): void;
    /**
     * 获取选中的数据
     * @returns
     */
    getSelectedData(): {
        xArr: number[];
        yArr: number[];
        text: string;
        value: any[][];
    };
    setScroll(x: number, y: number): void;
    setScrollX(x: number): void;
    setScrollY(y: number): void;
    startAdjustPosition(e: MouseEvent): void;
    stopAdjustPosition(): void;
    isTarget(e: Event): boolean;
    getOffset(e: MouseEvent): {
        offsetX: number;
        offsetY: number;
    };
    hasEvent(event: string): boolean;
    on(event: string, callback: EventCallback): void;
    once(event: string, callback: EventCallback): void;
    off(event: string, callback: EventCallback): void;
    emit(event: string, ...args: any[]): void;
    destroy(): void;
}

declare type ContextMenuItemParams = {
    list: MenuItem[];
    cell: CellHeader | Cell;
    hide: () => void;
};

export declare function createAutoViewportBoxController(getEl: () => HTMLElement | null | undefined, getOffset: () => AutoViewportBoxOffset, options?: AutoViewportBoxControllerOptions): AutoViewportBoxController;

declare type CustomHeader = {
    fixedData?: Record<string, Fixed | ''>;
    sortData?: Record<string, number>;
    hideData?: Record<string, boolean>;
    resizableData?: Record<string, number>;
};

declare class Database {
    private ctx;
    private data;
    private columns;
    private footerData;
    private rowKeyMap;
    private colIndexKeyMap;
    private headerMap;
    private rowIndexRowKeyMap;
    private rowKeyRowIndexMap;
    private checkboxKeyMap;
    private selectionMap;
    private expandMap;
    private originalDataMap;
    private changedDataMap;
    private validationErrorMap;
    private itemRowKeyMap;
    private bufferData;
    private customHeader;
    overlayerAutoHeightMap: Map<string, number>;
    private maxRowHeightCellMap;
    private bufferCheckState;
    private sumHeight;
    private filterMethod;
    private positions;
    private sortState;
    constructor(ctx: Context, options: EVirtTableOptions);
    init(isClear?: boolean): void;
    /**
     * 清除缓存数据
     */
    clearBufferData(): void;
    /**
     * 解析行唯一标识，统一转为 string
     */
    private resolveRowKey;
    /**
     * 初始化数据
     * @param dataList
     * @param level
     */
    private initData;
    /**
     *
     * @param rowKey 设置Row高度
     * @param height
     */
    setRowHeight(rowIndex: number, height: number): void;
    setBatchRowHeight(rowIndexHeightList: {
        rowIndex: number;
        height: number;
    }[]): void;
    setBatchCalculatedRowHeight(rowIndexHeightList: {
        rowIndex: number;
        height: number;
    }[]): boolean;
    /**
     * 获取所有行数据（平铺）
     * @returns 获取转化平铺数据
     */
    getAllRowsData(): any[];
    private generateColumns;
    getColumns(): Column[];
    setColumns(columns: Column[]): void;
    setData(data: any[]): void;
    getOriginalData(): any[];
    /**
     * 统一转化数据，给画body使用，包括过滤树状等，统一入口
     * @returns
     */
    getData(): {
        data: any[];
        sumHeight: number;
        positions: Position[];
    };
    setFooterData(data: any[]): void;
    getFooterData(): any[];
    /**
     * 设置过滤方法
     */
    setFilterMethod(filterMethod: FilterMethod): void;
    /**
     * 清空过滤方法
     */
    clearFilterMethod(): void;
    /**
     * 获取排序状态
     */
    getSortState(key: string): SortStateMapItem;
    /**
     * 设置排序状态
     */
    setSortState(key: string, direction: 'asc' | 'desc' | 'none'): void;
    /**
     * 清除所有排序状态
     */
    clearSort(): void;
    /**
     * 递归排序方法，支持树形数据
     * @param data 要排序的数据
     * @param sortedEntries 排序条目，按时间戳排序
     * @returns 排序后的数据
     */
    private sortDataRecursive;
    /**
     * 对数组进行单列排序
     * @param data 要排序的数据
     * @param key 排序的列键
     * @param direction 排序方向
     * @param sortBy 排序类型
     * @returns 排序后的数据
     */
    private applySingleColumnSort;
    /**
     * 根据rowKey,控制指定展开行
     * @param rowKey
     * @param expand
     */
    expandItem(rowKey: string, expand?: boolean): void;
    setExpandRowKeys(rowKeys: any[], expand?: boolean): void;
    getExpandRowKeys(): string[];
    expandAll(expand: boolean): void;
    expandLoading(rowKey: string, loading?: boolean): void;
    setExpandChildren(rowKey: string, children: any[]): void;
    getIsExpandLoading(rowKey: string): any;
    getIsExpandLazy(rowKey: string): any;
    /**
     * 根据rowKey获取是否展开
     * @param rowKey
     * @returns
     */
    getIsExpand(rowKey: string): any;
    /**
     * 根据rowKey获取行数据
     * @param rowKey
     * @returns
     */
    getRowForRowKey(rowKey: string): any;
    getRowForRowIndex(rowIndex: number): any;
    /**
     * 根据rowIndex获取rowKey
     * @param rowKey
     * @returns
     */
    getRowKeyForRowIndex(rowIndex: number): string;
    getRowKeyByItem(item: any): any;
    getRowIndexForRowKey(rowKey: string): number | undefined;
    /**
     * 根据rowIndex和colIndex获取单元格数据
     * @param rowIndex
     * @param colIndex
     * @returns
     */
    getItemValueForRowIndexAndColIndex(rowIndex: number, colIndex: number): {
        rowKey: string;
        key: string;
        value: any;
    } | null;
    /**
     * 根据rowKey和key获取单元格数据
     * @param rowKey
     * @param key
     * @returns
     */
    getItemValue(rowKey: string, key: string): any;
    /**
     * 批量设置数据
     * @param list
     * @param history
     * @returns
     */
    batchSetItemValue(_list: ChangeItem[], history?: boolean, checkReadonly?: boolean, historyAcion?: HistoryAction): Promise<void>;
    /**
     *设置单一数据
     * @param rowKey
     * @param key
     * @param value
     * @param history 是否添加历史记录
     * @param reDraw 是否刷新重绘
     * @param isEditor 是否是编辑器
     * @param checkReadonly 是否检查只读
     * @returns
     */
    setItemValue(rowKey: string, key: string, _value: any, history?: boolean, reDraw?: boolean, isEditor?: boolean, checkReadonly?: boolean): Promise<{
        oldValue?: undefined;
        newValue?: undefined;
    } | {
        oldValue: any;
        newValue: any;
    }>;
    /**
     * 根据rowKey 获取行数据
     * @param rowKey
     * @returns
     */
    getRowDataItemForRowKey(rowKey: string): any;
    /**
     *
     * @param rowKey 设置选中状态ByCheckboxKey，用于合并Checkbox单元格时声明唯一key
     * @param check
     */
    private setRowSelectionByCheckboxKey;
    /**
     * 根据rowKey 取反选中
     * @param rowKey
     */
    toggleRowSelection(rowKey: string, cellType?: string): void;
    toggleTreeSelection(rowKey: string): void;
    private selectTreeSelectionRecursive;
    private clearTreeSelectionRecursive;
    private updateParentTreeSelection;
    /**
     * 根据rowKey 设置选中状态
     * @param rowKey
     */
    setRowSelection(rowKey: string, check: boolean, draw?: boolean): void;
    setRowSelectionByParent(rowKey: string, check: boolean): void;
    getSelectionRows(): any[];
    /**
     * 根据rowKey 获取选中状态
     * @param rowKey
     */
    getRowSelection(rowKey: string): boolean;
    getTreeSelectionState(rowKey: string): {
        checked: boolean;
        indeterminate: boolean;
    };
    getTreeChildren(rowKey: string): string[];
    getTreeParent(rowKey: string): string | null;
    /**
     * 根据rowKey 获取选中状态
     * @param rowKey
     */
    getRowSelectable(rowKey: string): any;
    /**
     * 全选
     * @param rowKey
     */
    toggleAllSelection(): void;
    /**
     * 清除选中
     * @param rowKey
     */
    clearSelection(ignoreReserve?: boolean): void;
    /**
     * 获取选中状态，表头用
     * @param rowKey
     */
    getCheckedState(): {
        check: boolean;
        indeterminate: boolean;
        selectable: boolean;
    };
    /**
     * 更新列索引
     * @param list 表头末级列表
     */
    updateColIndexKeyMap(list?: CellHeader[]): void;
    getColumnByColIndex(colIndex: number): Column | undefined;
    getColumnByKey(key: string): CellHeader | undefined;
    getColIndexForKey(key: string): number | undefined;
    getColHeaderByIndex(colIndex: number): CellHeader | undefined;
    /**
     * 获取以改变数据
     */
    getChangedData(): {
        rowKey: string;
        colKey: string;
        row: any;
        originalValue: any;
        value: any;
    }[];
    getChangedRows(): any[];
    /**
     * 获取改变值是否已经改变
     * @param rowKey
     * @param key
     * @returns
     */
    isHasChangedData(rowKey: string, key: string): boolean;
    getPositionForRowIndex(rowIndex: number): Position;
    setHeader(key: string, cellHeader: CellHeader): boolean;
    getReadonly(rowKey: string, key: string): any;
    clearValidate(): void;
    hasValidationError(): boolean;
    getValidator(rowKey: string, key: string): Promise<unknown>;
    getHeightByRowIndexRowSpan(rowIndex: number, rowSpan: number): number;
    getSpanInfo(cell: Cell): SpanInfo;
    setValidationErrorByRowKey(rowKey: string, key: string, message: string): void;
    setValidationError(rowKey: string, key: string, errors: ValidateResult): void;
    clearValidationError(rowKey: string, key: string): void;
    getValidationError(rowKey: string, key: string): ValidateResult;
    getVirtualBodyCell(rowIndex: number, colIndex: number, isUpdate?: boolean): Cell | undefined;
    getVirtualBodyCellByKey(rowKey: string, key: string): Cell | undefined;
    hasMergeCell(xArr: number[], yArr: number[]): boolean;
    /**
     * 计算树形数据的最大深度
     * @param data 树形数据
     * @param currentDepth 当前深度
     * @returns 最大深度
     */
    private calculateMaxTreeDepth;
    setOverlayerAutoHeightMap(map: Map<string, number>): void;
    getOverlayerAutoHeightMap(): Map<string, number>;
    getOverlayerAutoHeight(rowIndex: number, colIndex: number): number;
    setCustomHeader(customHeader: CustomHeader, ignoreEmit?: boolean): void;
    resetCustomHeader(): void;
    getCustomHeader(): CustomHeader;
    setCustomHeaderResizableData(key: string, width: number): void;
    setCustomHeaderHideData(keys: string[], hide: boolean): void;
    setCustomHeaderFixedData(keys: string[], fixed: Fixed | ''): void;
    clearCustomHeaderInvalidValues(columns: Column[]): CustomHeader;
    setMaxRowHeightItem(rowKey: string, key: string, height: number): void;
    getMaxRowHeightItem(rowKey: string): RowMaxHeightData | undefined;
    clearChangeData(): void;
}

declare const _default: {
    install(app: App): void;
    addFormatter: (formatter: Record<string, (a: CellFuncArg, ...args: any[]) => any>) => void;
    addRender: (name: string, { renderItemContent, renderDefault, renderReadonly, renderEdit }: RenderWorkshop) => void;
    setup: typeof setup;
};
export default _default;

declare const _default_2: {
    numberErrorTip: string;
    emptyText: string;
    loadingText: string;
    copy: string;
    cut: string;
    paste: string;
    clearSelected: string;
    fixedLeft: string;
    fixedRight: string;
    fixedNone: string;
    hide: string;
    visible: string;
    resetHeader: string;
    invalidNumber: string;
    mergeCellNoFill: string;
    mergeCellNoCopy: string;
    mergeCellNoPaste: string;
    numberTruncated: string;
    batchSetItemValueError: string;
    numberMin: string;
    numberMax: string;
    stringMaxlength: string;
};

declare type DefaultFactory<T> = (() => T) | T

export declare const defaultItemResponsive: Responsive;

export declare const defaultLabelCol: Responsive;

declare type DefaultType<T> = T extends NativeType ? T : DefaultFactory<T>

declare type DrawTextOptions = {
    font?: string;
    color?: string;
    align?: Align;
    padding?: number;
    verticalAlign?: VerticalAlign;
    autoRowHeight?: boolean;
    lineHeight?: number;
    maxLineClamp?: LineClampType;
    offsetLeft?: number;
    offsetRight?: number;
    textCallback?: (textInfo: TextInfo) => void;
    layoutCallback?: (layout: TextLayout) => void;
    cacheTextKey?: string;
};

declare type EditorOptions = {
    type: string;
    props: any;
};

declare type EventCallback = (...args: any[]) => void;

declare type EventCallback_2 = (...args: any[]) => void;

declare class EVirtTable {
    static locale: LangConfig;
    private options;
    private scroller;
    private header;
    private body;
    private footer;
    private selector;
    private autofill;
    private tooltip;
    private editor;
    private empty;
    private overlayer;
    private contextMenu;
    private loading;
    private finderBar;
    private textSelector;
    private animationFrameId;
    ctx: Context;
    static useLocale(langConfig: LangConfig): void;
    constructor(target: HTMLDivElement, options: EVirtTableOptions);
    private createContainer;
    private doDraw;
    private updateStageBorder;
    draw(ignoreOverlayer?: boolean): void;
    loadConfig(_config: ConfigType): void;
    loadColumns(columns: Column[]): void;
    loadData(data: any[]): void;
    loadFooterData(data: any[]): void;
    setCustomHeader(customHeader: CustomHeader, ignoreEmit?: boolean): void;
    getCustomHeader(): {
        columns: Column[];
        customHeader: CustomHeader;
    };
    showColumns(keys: string[], show?: boolean): void;
    fixedColumns(keys: string[], fixed: Fixed | ''): void;
    setLoading(loading: boolean): void;
    on(event: string, callback: EventCallback_2): void;
    emit(event: string, ...args: any[]): void;
    off(event: string, callback: EventCallback_2): void;
    filterMethod(func: FilterMethod): void;
    editCell(rowIndex: number, colIndex: number): void;
    setItemValue(rowKey: string, key: string, value: any, history?: boolean, reDraw?: boolean, isEditor?: boolean, checkReadonly?: boolean): void;
    batchSetItemValue(list: ChangeItem[], history?: boolean, checkReadonly?: boolean): void;
    setItemValueByEditor(rowKey: string, key: string, value: any, history?: boolean, reDraw?: boolean, checkReadonly?: boolean): void;
    clearEditableData(value?: null): ChangeItem[];
    clearEditor(): void;
    doLayout(): void;
    getChangedData(): {
        rowKey: string;
        colKey: string;
        row: any;
        originalValue: any;
        value: any;
    }[];
    getChangedRows(): any[];
    setCurrentRowByRowIndex(rowIndex: number): void;
    setCurrentRow(rowKey: string): void;
    getCurrentRow(): RowParams | undefined;
    clearValidate(): void;
    validateFields(ValidateFields: ValidateField[], scrollError?: boolean): Promise<unknown>;
    validate(scrollError?: boolean): Promise<unknown>;
    setValidations(errors: ValidateItemError[]): void;
    getValidations(): Promise<unknown>;
    hasValidationError(): boolean;
    scrollTo(x: number, y: number): void;
    scrollXTo(x: number): void;
    scrollToColkey(key: string): void;
    scrollToRowkey(key: string): void;
    scrollToColIndex(colIndex: number): void;
    scrollToRowIndex(rowIndex: number): void;
    scrollYTo(y: number): void;
    setExpandRowKeys(keys: any[], expand?: boolean): void;
    getExpandRowKeys(): string[];
    clearSelection(): void;
    toggleRowSelection(row: any): void;
    setSelectionByRows(rows: any[], selected?: boolean): void;
    setSelectionByRowKeys(keys: string[], selected?: boolean): void;
    toggleAllSelection(): void;
    toggleRowExpand(rowKey: string, expand: boolean): void;
    toggleExpandAll(expand: boolean): void;
    getSelectionRows(): any[];
    getPositionForRowIndex(rowIndex: number): Position;
    getCellValue(rowKey: string, key: string): any;
    getCellValueByIndex(rowIndex: number, colIndex: number): {
        rowKey: string;
        key: string;
        value: any;
    } | null;
    clearSort(): void;
    contextMenuHide(): void;
    getUtils(): {
        mergeColCell: typeof mergeColCell;
        mergeRowCell: typeof mergeRowCell;
        getSpanArrByRow: typeof getSpanArrByRow;
        getSpanObjByColumn: typeof getSpanObjByColumn;
    };
    getColumnByKey(key: string): Column | undefined;
    clearChangeData(): void;
    getReadonly(rowKey: string, key: string): any;
    useLocale(langConfig: LangConfig): void;
    /**
     * 销毁
     */
    destroy(): void;
}

declare type EVirtTableOptions = {
    data: Record<string, any>[];
    footerData?: Record<string, any>[];
    columns: Column[];
    config?: ConfigType;
    overlayerElement?: HTMLDivElement;
    editorElement?: HTMLDivElement;
    emptyElement?: HTMLDivElement;
    contextMenuElement?: HTMLDivElement;
    loadingElement?: HTMLDivElement;
};

declare type ExpandLazyMethod = (params: CellParams) => Promise<any[]>;

declare type FilterMethod = (rows: any[]) => any[];

declare type FinderCellParams = CellParams & {
    displayText: string;
};

declare type FinderFormatterMethod = (params: FinderCellParams) => string | void;

declare type FinderHeaderFormatterMethod = (params: FinderHeaderParams) => string | void;

declare type FinderHeaderParams = CellHeaderParams & {
    rowIndex: number;
    value: string;
    displayText: string;
};

declare interface FinderResult {
    type: CellType;
    rowIndex: number;
    colIndex: number;
    text: string;
    colKey?: string;
}

declare type Fixed = 'left' | 'right' | '';

declare type FooterOptions = {
    x: number;
    y: number;
    width: number;
    height: number;
    visibleHeight: number;
    visibleWidth: number;
    renderRows: Row[];
};

declare type FooterPosition = 'top' | 'bottom';

export declare type FormatterFunc = (c: CellFuncArg, ...args: any[]) => any;

declare type FormatterMethod = (params: CellParams) => string | void;

export declare const get24rest: (exist: number[]) => number;

export declare const getButtonResponsive: (itemResponsive: number | Responsive[]) => any;

declare function getSpanArrByRow(list: any, key: string, relationRowKeys?: string[]): number[];

declare function getSpanObjByColumn(row: any, columns: any): any;

export declare function getTooltipRenderer(): UIKitConfig['renderTooltip'];

export declare function getUIKitConfig(): UIKitConfig;

export declare interface GroupMenuItem<F extends Recordable = Recordable> {
    content: string;
    icon?: string;
    code: string;
    visibleMethod?: ({ data, index }: {
        data: Partial<F>;
        index: number;
    }) => boolean;
}

export declare type GroupMenuItemHandler<F extends Recordable = Recordable> = ({ index, data, code, }: {
    index: number;
    code: string;
    data: Partial<F & {
        __index: number;
    }>;
}) => void;

export declare type HandlerMultiDel = (ids: Array<string | number>) => any;

declare type HeaderOptions = {
    x: number;
    y: number;
    width: number;
    height: number;
    visibleHeight: number;
    visibleWidth: number;
    visibleLeafColumns: Column[];
    leafCellHeaders: CellHeader[];
    renderLeafCellHeaders: CellHeader[];
    renderCellHeaders: CellHeader[];
    fixedLeftCellHeaders: [];
    fixedRightCellHeaders: [];
    renderCenterCellHeaders: [];
    allCellHeaders: CellHeader[];
};

/**
 * 数据历史堆栈
 */
declare class History_2 {
    private ctx;
    private history;
    private historyIndex;
    constructor(ctx: Context);
    private init;
    pushState(changeList: HistoryItem): void;
    backState(): void;
    forwardState(): void;
    clear(): void;
}

declare type HistoryAction = 'back' | 'forward' | 'none';

declare type HistoryItem = {
    changeList: HistoryItemData[];
    scrollY: number;
    scrollX: number;
    type: 'single' | 'multiple';
};

declare type HistoryItemData = {
    oldValue: any;
    newValue: any;
    key: string;
    rowKey: string;
};

declare class Icons {
    private ctx;
    private list;
    icons: Map<string, HTMLImageElement>;
    constructor(ctx: Context);
    init(): Promise<void>;
    private createImageFromSVG;
    get(name: string): HTMLImageElement | undefined;
    getSvg(name: string): SvgIcon | undefined;
}

declare interface IconType {
    name: string;
    svg: string;
    color: string;
    isBlob?: boolean;
}

export declare interface ItemFuncArg<F extends Recordable = Recordable> {
    data: F;
    field?: string;
}

export declare interface ItemRender {
    name: string;
    defaultValue?: any;
    props?: Recordable;
    attrs?: Recordable;
    options?: IOption[];
    children?: Recordable[];
    events?: {
        [key: string]: (...args: any[]) => any;
    };
}

export declare const labelColDict: Record<number, Responsive>;

declare type LangConfig = typeof _default_2;

declare type LineClampType = number | 'auto';

declare type LineOptions = {
    lineCap?: CanvasLineCap;
    lineDash?: number[];
    lineDashOffset?: number;
    lineJoin?: CanvasLineJoin;
    borderWidth?: number;
    borderColor?: string | CanvasGradient | CanvasPattern;
    fillColor?: string | CanvasGradient | CanvasPattern;
};

declare class Locale {
    private langConfig?;
    use(langConfig: LangConfig): void;
    getText(key: string, params?: Record<string, any>): string;
}

declare type MenuItem = {
    label?: string;
    value: string | MenuItemEvent;
    event?: Function;
    icon?: string;
    divider?: boolean;
    disabled?: boolean;
    children?: MenuItem[];
    key?: string;
};

declare type MenuItemEvent = 'copy' | 'paste' | 'cut' | 'clearSelected' | 'fixedLeft' | 'fixedRight' | 'fixedNone' | 'hide' | 'resetHeader' | 'visible';

declare function mergeColCell(params: SpanParams, mergeColKeys?: string[]): {
    rowspan: number;
    colspan: any;
    relationColKeys: string[];
    mergeCol: boolean;
} | undefined;

declare function mergeRowCell(params: SpanParams, mergeRowkey: string, relationRowKeys?: string[]): {
    rowspan: number;
    colspan: number;
    relationRowKeys: string[];
    mergeRow: boolean;
};

declare type NativeType = string | boolean | number | null | undefined | Function

declare type OverflowTooltipPlacement = 'top' | 'top-start' | 'top-end' | 'right' | 'right-start' | 'right-end' | 'left' | 'left-start' | 'left-end' | 'bottom' | 'bottom-start' | 'bottom-end';

export declare interface PageConfig {
    pageSizes?: number[];
    pageSize?: number;
    showSizeChanger?: boolean;
    showQuickJumper?: boolean;
}

declare class Paint {
    private ctx;
    private textCacheMap;
    constructor(target: HTMLCanvasElement);
    getCtx(): CanvasRenderingContext2D;
    clearTextCache(): void;
    scale(dpr: number): void;
    save(): void;
    restore(): void;
    translate(x: number, y: number): void;
    setCursor(cursor?: string): void;
    clear(x?: number, y?: number, width?: number, height?: number): void;
    /**
     * 在 Canvas 上绘制单侧阴影
     * @param {number} x - 矩形的 x 坐标
     * @param {number} y - 矩形的 y 坐标
     * @param {number} width - 矩形的宽度
     * @param {number} height - 矩形的高度
     * @param {string} side - 阴影的位置（'left', 'right', 'top', 'bottom'）
     * @param {number} shadowWidth - 阴影的宽度
     * @param {string} color - 阴影的颜色
     */
    drawShadow(x: number, y: number, width: number, height: number, options: ShodowOptions): void;
    drawLine(points: number[], options: LineOptions): void;
    drawImage(img: CanvasImageSource, x: number, y: number, width: number, height: number): void;
    drawRect(x: number, y: number, width: number, height: number, { borderWidth, borderColor, fillColor, radius }?: RectOptions): void;
    /**
     * 画文本
     * @param text
     * @param x
     * @param y
     * @param width
     * @param height
     * @param options
     * @returns 是否溢出
     */
    drawText(text: string | undefined, x: number, y: number, width: number, height: number, options?: DrawTextOptions): boolean;
    private buildTextLayout;
    private wrapTextToLines;
    private buildEllipsisLine;
    private buildLineSegments;
    /**
     * 将文本按宽度换行
     * @param text
     * @param maxWidth
     * @returns
     */
    private wrapText;
    /**
     * 计算文本自适应高度
     * @param text
     * @param width
     * @param options
     * @returns 计算出的高度
     */
    calculateTextHeight(text: string | undefined, width: number, options?: DrawTextOptions): number;
    handleEllipsis(text: string, width: number, padding?: number, font?: string): {
        _text: string;
        ellipsis: boolean;
    };
}

/** 解析与 v-rest 一致的偏移：数字/字符串同时作用于 right+bottom；对象可单独指定 */
export declare function parseAutoViewportBoxOffset(value: AutoViewportBoxOffsetInput): AutoViewportBoxOffset;

export declare interface PBlockProps<F extends Recordable = Recordable> {
    name?: string;
    getFormSetting: (data: Partial<F>) => PFormProps<Partial<F>>;
    source: Partial<F>;
}

export declare interface PButtonProps extends Omit<ButtonProps, 'type'> {
    content?: string | (() => any);
    icon?: string;
    /** 与 `a-button` 一致，便于模板类型检查 */
    type?: ButtonProps['type'];
}

export declare const PCanvasGrid: <D extends Recordable = Recordable, F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_5<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_5<Pick<Partial<{}> & Omit<{
        readonly onPick?: ((data: {
            row: D;
            field: string;
        }) => any) | undefined;
        readonly onToolbarButtonClick?: ((data: {
            data: D[];
            code: string;
            selectedKeys: Array<string | number>;
            records: D[];
        }) => any) | undefined;
        readonly onToolbarToolClick?: ((data: {
            data: D[];
            code: string;
            selectedKeys: Array<string | number>;
            records: D[];
        }) => any) | undefined;
        readonly onResetQuery?: (() => any) | undefined;
        readonly onSortChange?: ((value: Map<string, {
            direction: "asc" | "desc" | "none";
            timestamp: number;
        }>) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onPick" | "onToolbarButtonClick" | "onToolbarToolClick" | "onResetQuery" | "onSortChange"> & PCanvasGridProps<D, F> & any> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {
    commitProxy: {
    query: (this: any, ...args: any[]) => any;
    reload: () => void;
    reloadPage: () => Promise<D[]>;
    passQuery: (params: Partial<F>, lazy?: boolean) => any;
    forcePassQuery: (params: Partial<F>, lazy?: boolean) => any;
    };
    $canvasTable: ComputedRef<PCanvasTableInstance<D> | undefined>;
    selectedRowKeys: ComputedRef<(string | number)[]>;
    setBtnLoading: (code: string, value: boolean) => void;
    selectedRecords: ComputedRef<D[]>;
    clearSelection: () => void;
    $form: ComputedRef<Recordable<any> | undefined>;
    getFormData: () => Partial<F>;
    setLoadings: (value: boolean | Record<string, boolean>) => void;
    resizeTable: () => void;
    }>): void;
    attrs: any;
    slots: any;
    emit: {
        (event: "toolbarButtonClick", data: {
            data: D[];
            code: string;
            selectedKeys: Array<string | number>;
            records: D[];
        }): void;
        (event: "toolbarToolClick", data: {
            data: D[];
            code: string;
            selectedKeys: Array<string | number>;
            records: D[];
        }): void;
        (event: "pick", data: {
            row: D;
            field: string;
        }): void;
        (event: "resetQuery"): void;
        (event: "sortChange", value: Map<string, {
            direction: "asc" | "desc" | "none";
            timestamp: number;
        }>): void;
    };
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare interface PCanvasGridProps<D extends Recordable = Recordable, F extends Recordable = Recordable> {
    staticConfig?: {
        selectable?: boolean;
        showCount?: boolean;
        tree?: boolean;
    };
    manualFetch?: boolean;
    formConfig?: PGridFormConfig<F>;
    columns: CanvasColumnProps<D>[];
    toolbarConfig?: ToolbarConfig;
    pageConfig?: PageConfig;
    proxyConfig?: ProxyConfig<D, F>;
    config?: ConfigType;
    /**
     * 表格边框样式，映射 e-virt-table `BORDER`。
     * - `true` / `'default'`：完整单元格边框
     * - `'outer'`：仅外边框
     * - `'inner'` / `false`：仅内部横线
     * - `'none'`：无边框
     * 显式传入时优先于 `config.BORDER`。
     */
    border?: BorderConfigValue;
    /**
     * 滚动条模式，映射 e-virt-table `scrollbarMode`。
     * - `'outer'`：外部预留滚动条轨道（默认）
     * - `'inner'`：覆盖在内容上，悬停表格内部后显示
     * 显式传入时优先于 `config.scrollbarMode`。
     */
    scrollbarMode?: ScrollbarMode;
    /**
     * 内部滚动条（`scrollbarMode: 'inner'`）悬停后显示延迟（ms），映射 `SCROLLBAR_SHOW_DELAY`。
     * 显式传入时优先于 `config.SCROLLBAR_SHOW_DELAY`。
     */
    scrollbarShowDelay?: number;
    lazyReset?: boolean;
    /**
     * 适应展示区到页面顶部的高度，通常和容器最上的y值有关（正比）
     */
    fitHeight?: number;
    /**
     * 开启后组件根节点按视口从其左上角铺满宽高，与 PGrid 的 autoBoxSize 行为一致。
     * 外层未声明固定高度、需组件自身占满可视区域时使用。
     */
    autoBoxSize?: boolean;
    /**
     * `autoBoxSize` 时距视口右侧/底部的预留像素；数字或 `"12px"` 同时作用于两侧；对象可分别指定 `right` / `bottom`。
     * 未传时使用 `setUIKitConfig({ grid: { autoBoxSizeOffset } })` 的全局值。
     */
    autoBoxSizeOffset?: number | string | {
        right?: number;
        bottom?: number;
    };
}

export declare const PCanvasTable: <T extends Recordable = Recordable, B extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_4<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_4<Pick<Partial<{}> & Omit<{
        readonly onChange?: ((value: any[]) => any) | undefined;
        readonly onSelectionChange?: ((value: T[]) => any) | undefined;
        readonly onSortChange?: ((value: Map<string, {
            direction: "asc" | "desc" | "none";
            timestamp: number;
        }>) => any) | undefined;
        readonly onReady?: ((value: EVirtTable) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onChange" | "onSelectionChange" | "onSortChange" | "onReady"> & CanvasTableProps<T, B> & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {
    readonly $table: EVirtTable | null;
    selectedRecords: ComputedRef<UnwrapRefSimple<T>[]>;
    clearSelection: () => void;
    reloadData: () => void;
    }>): void;
    attrs: any;
    slots: Partial<Record<string, (_: {
        cell: Cell | CellHeader;
        parentRowKey: string;
        parentRowKeys: string[];
        formatter?: FormatterMethod;
        formatterFinderValue?: FinderFormatterMethod;
        formatterFinderFooterValue?: FinderFormatterMethod;
        formatterFooter?: FormatterMethod;
        hoverIconName?: string;
        operation: boolean;
        align: Align;
        verticalAlign: VerticalAlign;
        fixed?: Fixed;
        type: Type | "";
        editorType: string;
        editorProps: any;
        cellType: CellType;
        level: number;
        colspan: number;
        rowspan: number;
        mergeRow: boolean;
        mergeCol: boolean;
        relationRowKeys: string[];
        relationColKeys: string[];
        key: string;
        column: Column;
        rowIndex: number;
        colIndex: number;
        rowKey: string;
        row: any;
        value: any;
        render: Render;
        renderFooter: Render;
        style: any;
        domDataset: any;
        rules: Rules | Rule;
        message: string;
        text: string;
        displayText: string;
        visibleWidth: number;
        visibleHeight: number;
        isHasChanged: boolean;
        drawX: number;
        drawY: number;
        drawCellBgColor: string;
        drawCellSkyBgColor: string;
        drawTextColor: string;
        drawTextFont: string;
        drawTextX: number;
        drawTextY: number;
        drawTextWidth: number;
        drawTextHeight: number;
        autoRowHeight: boolean;
        calculatedHeight: number;
        ellipsis: boolean;
        rowExpand: boolean;
        rowHasChildren: boolean;
        overflowTooltipShow: boolean;
        selectorCellValueType: SelectorCellValueType;
        overflowTooltipMaxWidth: number;
        overflowTooltipPlacement: OverflowTooltipPlacement;
        maxLineClamp: LineClampType;
        precision?: number;
        min?: number;
        max?: number;
        maxlength?: number;
        mixedRender?: boolean;
        renderType: RenderType;
        renderFooterType: RenderType;
        ctx: Context;
        x: number;
        y: number;
        width: number;
        height: number;
        cellImages: Map<string, CellImage>;
    } | {
        cell: Cell | CellHeader;
        align: Align;
        hideHeaderSelection: boolean;
        verticalAlign: VerticalAlign;
        fixed?: Fixed;
        minWidth?: number;
        maxWidth?: number;
        formatterFinderHeaderValue?: FinderHeaderFormatterMethod;
        widthFillDisable: boolean;
        type: Type | "";
        operation: boolean;
        editorType: string;
        level: number;
        text: string;
        hide: boolean;
        displayText: string;
        colspan: number;
        rowspan: number;
        row: any;
        key: string;
        required: boolean;
        readonly: boolean;
        ellipsis: boolean;
        overflowTooltipShow: boolean;
        children: Column[];
        column: Column;
        colIndex: number;
        rowKey: string;
        rules?: Rules | Rule;
        hasChildren: boolean;
        render: Render;
        style: Partial<CSSStyleDeclaration>;
        drawX: number;
        drawY: number;
        sortIconName: string;
        sortAscIconName: string;
        sortDescIconName: string;
        visibleWidth: number;
        visibleHeight: number;
        maxLineClampHeader: LineClampType;
        domDataset: any;
        textOffsetRight: number;
        textOffsetLeft: number;
        textInfo: TextInfo | undefined;
        drawTextX: number;
        drawTextY: number;
        drawTextWidth: number;
        drawTextHeight: number;
        drawCellBgColor: string;
        drawTextColor: string;
        drawTextFont: string;
        drawSelectionImageX: number;
        drawSelectionImageY: number;
        drawSelectionImageWidth: number;
        drawSelectionImageHeight: number;
        drawSelectionImageName: string;
        drawSelectionImageSource?: HTMLImageElement;
        drawSortImageX: number;
        drawSortImageY: number;
        drawSortImageWidth: number;
        drawSortImageHeight: number;
        drawSortImageName: string;
        drawSortImageSource?: HTMLImageElement;
        renderHeaderType: RenderType;
        ctx: Context;
        x: number;
        y: number;
        width: number;
        height: number;
        cellType: CellType;
        cellImages: Map<string, CellImage>;
    }) => any>> & {
        empty?(_: {}): any;
    };
    emit: {
        (e: "change", value: any[]): void;
        (e: "selectionChange", value: T[]): void;
        (e: "sortChange", value: Map<string, {
            direction: "asc" | "desc" | "none";
            timestamp: number;
        }>): void;
        (e: "ready", value: EVirtTable): void;
    };
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare interface PCanvasTableInstance<T extends Recordable = Recordable> {
    $table: InstanceType<typeof EVirtTable>;
    selectedRecords: T[];
    clearSelection: () => void;
    setLoading: (value: boolean) => void;
}

export declare const PDescription: <D extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_9<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_9<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & PDescriptionProps<D> & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {}>): void;
    attrs: any;
    slots: {
        title?(_: {}): any;
        extra?(_: {}): any;
    };
    emit: {};
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare interface PDescriptionItemProps<D extends Recordable = Recordable> {
    field?: string;
    label?: string;
    span?: number;
    labelStyle?: Recordable;
    contentStyle?: Recordable;
    /** 只读展示渲染器，派发到 renderStore.renderDefault */
    readonlyRender?: ItemRender;
    slots?: {
        label?: () => any;
        default?: ({ data, field }: {
            data: D;
            field?: string;
        }) => any;
    };
}

export declare interface PDescriptionProps<D extends Recordable = Recordable> {
    /** 数据源 */
    data: D;
    items: PDescriptionItemProps<D>[];
    /** 透传 a-descriptions */
    title?: string;
    extra?: string;
    bordered?: boolean;
    size?: 'default' | 'small' | 'middle';
    column?: number | Partial<Record<'xxs' | 'xs' | 'sm' | 'md' | 'lg' | 'xl' | 'xxl', number>>;
    layout?: 'horizontal' | 'vertical';
    colon?: boolean;
    labelStyle?: Recordable;
    contentStyle?: Recordable;
    /** 缺省占位，row[field] 为空时展示 */
    emptyText?: string;
}

export declare const PForm: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal<Pick<Partial<{}> & Omit<{
        readonly onReset?: ((...args: any[]) => any) | undefined;
        readonly onApply?: ((...args: any[]) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onReset" | "onApply"> & (PFormProps<F> & {
        data: F;
    }) & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {
    reset: () => void;
    $form: ComputedRef<any>;
    }>): void;
    attrs: any;
    slots: {};
    emit: (event: "reset" | "apply", ...args: any[]) => void;
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare type PFormatter = Record<string, FormatterFunc>;

export declare interface PFormBlockInstance {
    $form: Recordable;
}

export declare const PFormGroup: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_6<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_6<Pick<Partial<{}> & Omit<{
        readonly "onUpdate:modelValue"?: ((value: Partial<F & {
            __index: number;
        }>[]) => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onUpdate:modelValue"> & ({
        modelValue?: Partial<F & {
            __index: number;
        }>[];
    } & PFormGroupProps<F>) & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {
    collapse: () => void;
    expand: () => void;
    activeKey: ComputedRef<number>;
    setActiveKey: (key: number) => void;
    removeItem: (idx: number) => void;
    validateAll: () => Promise<PromiseSettledResult<any>[]>;
    validate: (__index: number, ignoreTabError?: boolean) => Promise<void>;
    validateFields: (__index: number, fields: string[], ignoreTabError?: boolean) => Promise<void>;
    }>): void;
    attrs: any;
    slots: Readonly<{
        [key: string]: any;
        rightExtra?: () => any;
    }> & {
        [key: string]: any;
        rightExtra?: () => any;
    };
    emit: (evt: "update:modelValue", value: Partial<F & {
        __index: number;
    }>[]) => void;
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare interface PFormGroupInstance {
    activeKey: number;
    setActiveKey: (activeKey: number) => void;
    /** 按数组下标删除一项，并清理校验缓存 / 激活态 */
    removeItem: (index: number) => void;
    validateAll: () => Promise<void>;
    validate: (index: number, ignoreTabError?: boolean) => Promise<void>;
    validateFields: (index: number, fields: string[], ignoreTabError?: boolean) => Promise<void>;
    collapse: () => void;
    expand: () => void;
}

export declare interface PFormGroupProps<F extends Recordable = Recordable> {
    name?: string;
    getFormSetting: (data: Partial<F>) => PFormProps<Partial<F>>;
    title?: string;
    tabLabel?: string;
    /**
     * 获取完整标签页标签
     * @param data 数据
     * @param idx 实际索引
     * @returns 标签页标签
     */
    getTabLabel?: (data: Partial<F>, idx: number) => string;
    editAble?: boolean;
    showAdd?: boolean;
    collapsible?: boolean;
    /** 是否默认折叠 */
    defaultCollapsed?: boolean;
    lazyErrorMark?: boolean;
    forceRender?: boolean;
    keepSerial?: boolean;
    loading?: boolean;
    itemMenus?: Array<GroupMenuItem<F>>;
    createItem?: ({ list }: {
        list?: Partial<F>[];
    }) => Promise<Partial<F>>;
    max?: number;
    menuHandler?: GroupMenuItemHandler<F>;
}

export declare interface PFormInstance {
    reset: () => void;
    $form: Recordable;
}

export declare interface PFormItemProps<F extends Recordable = Recordable> {
    field?: string;
    title?: string;
    span?: number;
    colon?: boolean;
    labelCol?: ColProps;
    wrapperCol?: ColProps;
    forceRequired?: boolean;
    align?: 'left' | 'right' | 'center';
    col?: ColProps;
    rule?: Rule_2[];
    itemRender?: ItemRender;
    tooltipConfig?: TooltipConfig;
    slots?: {
        title?: () => any;
        default?: ({ data, field }: ItemFuncArg<F>, passTrigger?: (cusFields?: string | string[]) => void, passDelayTrigger?: (cusFields?: string | string[], time?: number) => void) => any;
        defaultValue?: any;
    };
}

export declare interface PFormProps<F extends Recordable = Recordable> extends FormProps {
    name?: string;
    items: PFormItemProps<F>[];
    customReset?: () => void;
}

export declare const PGrid: <D extends Recordable = Recordable, F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_3<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_3<Pick<Partial<{}> & Omit<{
        readonly onPick?: ((data: {
            row: D;
            field: string;
        }) => any) | undefined;
        readonly onToolbarButtonClick?: ((data: {
            data: D[];
            code: string;
            selectedKeys: Array<string | number>;
            records: D[];
        }) => any) | undefined;
        readonly onToolbarToolClick?: ((data: {
            data: D[];
            code: string;
            selectedKeys: Array<string | number>;
            records: D[];
        }) => any) | undefined;
        readonly onResetQuery?: (() => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onPick" | "onToolbarButtonClick" | "onToolbarToolClick" | "onResetQuery"> & PGridProps<D, F> & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {
    commitProxy: {
    query: (this: any, ...args: any[]) => any;
    reload: () => void;
    reloadPage: () => Promise<D[]>;
    passQuery: (params: Partial<F>, lazy?: boolean) => any;
    forcePassQuery: (params: Partial<F>, lazy?: boolean) => any;
    };
    $table: ComputedRef<CreateComponentPublicInstanceWithMixins<Readonly<ExtractPropTypes<    {
    prefixCls: {
    type: PropType<string>;
    default: string;
    };
    columns: {
    type: PropType<ColumnsType<any>>;
    default: ColumnsType<any>;
    };
    rowKey: {
    type: PropType<string | GetRowKey<any>>;
    default: string | GetRowKey<any>;
    };
    tableLayout: {
    type: PropType<TableLayout>;
    default: TableLayout;
    };
    rowClassName: {
    type: PropType<string | RowClassName<any>>;
    default: string | RowClassName<any>;
    };
    title: {
    type: PropType<PanelRender<any>>;
    default: PanelRender<any>;
    };
    footer: {
    type: PropType<PanelRender<any>>;
    default: PanelRender<any>;
    };
    id: {
    type: PropType<string>;
    default: string;
    };
    showHeader: {
    type: BooleanConstructor;
    default: boolean;
    };
    components: {
    type: PropType<TableComponents<any>>;
    default: TableComponents<any>;
    };
    customRow: {
    type: PropType<GetComponentProps<any>>;
    default: GetComponentProps<any>;
    };
    customHeaderRow: {
    type: PropType<GetComponentProps<ColumnType<any>[]>>;
    default: GetComponentProps<ColumnType<any>[]>;
    };
    direction: {
    type: PropType<"rtl" | "ltr">;
    default: "rtl" | "ltr";
    };
    expandFixed: {
    type: PropType<boolean | "left" | "right">;
    default: boolean | "left" | "right";
    };
    expandColumnWidth: NumberConstructor;
    expandedRowKeys: {
    type: PropType<Key[]>;
    default: Key[];
    };
    defaultExpandedRowKeys: {
    type: PropType<Key[]>;
    default: Key[];
    };
    expandedRowRender: {
    type: PropType<ExpandedRowRender<any>>;
    default: ExpandedRowRender<any>;
    };
    expandRowByClick: {
    type: BooleanConstructor;
    default: boolean;
    };
    expandIcon: {
    type: PropType<RenderExpandIcon<any>>;
    default: RenderExpandIcon<any>;
    };
    onExpand: {
    type: PropType<(expanded: boolean, record: any) => void>;
    default: (expanded: boolean, record: any) => void;
    };
    onExpandedRowsChange: {
    type: PropType<(expandedKeys: Key[]) => void>;
    default: (expandedKeys: Key[]) => void;
    };
    'onUpdate:expandedRowKeys': {
    type: PropType<(expandedKeys: Key[]) => void>;
    default: (expandedKeys: Key[]) => void;
    };
    defaultExpandAllRows: {
    type: BooleanConstructor;
    default: boolean;
    };
    indentSize: NumberConstructor;
    expandIconColumnIndex: NumberConstructor;
    showExpandColumn: {
    type: BooleanConstructor;
    default: boolean;
    };
    expandedRowClassName: {
    type: PropType<RowClassName<any>>;
    default: RowClassName<any>;
    };
    childrenColumnName: {
    type: PropType<string>;
    default: string;
    };
    rowExpandable: {
    type: PropType<(record: any) => boolean>;
    default: (record: any) => boolean;
    };
    sticky: {
    type: PropType<boolean | TableSticky>;
    default: boolean | TableSticky;
    };
    dropdownPrefixCls: StringConstructor;
    dataSource: {
    type: PropType<any[]>;
    default: any[];
    };
    pagination: {
    type: PropType<false | TablePaginationConfig>;
    default: false | TablePaginationConfig;
    };
    loading: {
    type: PropType<boolean | Partial<ExtractPropTypes<    {
    prefixCls: StringConstructor;
    spinning: {
    type: BooleanConstructor;
    default: any;
    };
    size: PropType<SpinSize>;
    wrapperClassName: StringConstructor;
    tip: VueTypeValidableDef<any>;
    delay: NumberConstructor;
    indicator: VueTypeValidableDef<any>;
    }>>>;
    default: boolean | Partial<ExtractPropTypes<    {
    prefixCls: StringConstructor;
    spinning: {
    type: BooleanConstructor;
    default: any;
    };
    size: PropType<SpinSize>;
    wrapperClassName: StringConstructor;
    tip: VueTypeValidableDef<any>;
    delay: NumberConstructor;
    indicator: VueTypeValidableDef<any>;
    }>>;
    };
    size: {
    type: PropType<SizeType>;
    default: SizeType;
    };
    bordered: {
    type: BooleanConstructor;
    default: boolean;
    };
    locale: {
    type: PropType<TableLocale>;
    default: TableLocale;
    };
    onChange: {
    type: PropType<(pagination: TablePaginationConfig, filters: Record<string, FilterValue>, sorter: SorterResult<any> | SorterResult<any>[], extra: TableCurrentDataSource<any>) => void>;
    default: (pagination: TablePaginationConfig, filters: Record<string, FilterValue>, sorter: SorterResult<any> | SorterResult<any>[], extra: TableCurrentDataSource<any>) => void;
    };
    onResizeColumn: {
    type: PropType<(w: number, col: ColumnType_2<any>) => void>;
    default: (w: number, col: ColumnType_2<any>) => void;
    };
    rowSelection: {
    type: PropType<TableRowSelection<any>>;
    default: TableRowSelection<any>;
    };
    getPopupContainer: {
    type: PropType<GetPopupContainer>;
    default: GetPopupContainer;
    };
    scroll: {
    type: PropType<    {
    x?: string | number | true;
    y?: string | number;
    } & {
    scrollToFirstRowOnChange?: boolean;
    }>;
    default: {
    x?: string | number | true;
    y?: string | number;
    } & {
    scrollToFirstRowOnChange?: boolean;
    };
    };
    sortDirections: {
    type: PropType<SortOrder[]>;
    default: SortOrder[];
    };
    showSorterTooltip: {
    type: PropType<boolean | Partial<ExtractPropTypes<    {
    title: VueTypeValidableDef<any>;
    trigger: PropType<TriggerType | TriggerType[]>;
    open: {
    type: BooleanConstructor;
    default: any;
    };
    visible: {
    type: BooleanConstructor;
    default: any;
    };
    placement: PropType<TooltipPlacement>;
    color: PropType<LiteralUnion<PresetColorType>>;
    transitionName: StringConstructor;
    overlayStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayInnerStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayClassName: StringConstructor;
    openClassName: StringConstructor;
    prefixCls: StringConstructor;
    mouseEnterDelay: NumberConstructor;
    mouseLeaveDelay: NumberConstructor;
    getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
    arrowPointAtCenter: {
    type: BooleanConstructor;
    default: any;
    };
    arrow: {
    type: PropType<boolean | {
    pointAtCenter?: boolean;
    }>;
    default: boolean | {
    pointAtCenter?: boolean;
    };
    };
    autoAdjustOverflow: {
    type: PropType<boolean | AdjustOverflow>;
    default: boolean | AdjustOverflow;
    };
    destroyTooltipOnHide: {
    type: BooleanConstructor;
    default: any;
    };
    align: {
    type: PropType<AlignType>;
    default: AlignType;
    };
    builtinPlacements: {
    type: PropType<BuildInPlacements>;
    default: BuildInPlacements;
    };
    children: ArrayConstructor;
    onVisibleChange: PropType<(vis: boolean) => void>;
    "onUpdate:visible": PropType<(vis: boolean) => void>;
    onOpenChange: PropType<(vis: boolean) => void>;
    "onUpdate:open": PropType<(vis: boolean) => void>;
    }>>>;
    default: boolean | Partial<ExtractPropTypes<    {
    title: VueTypeValidableDef<any>;
    trigger: PropType<TriggerType | TriggerType[]>;
    open: {
    type: BooleanConstructor;
    default: any;
    };
    visible: {
    type: BooleanConstructor;
    default: any;
    };
    placement: PropType<TooltipPlacement>;
    color: PropType<LiteralUnion<PresetColorType>>;
    transitionName: StringConstructor;
    overlayStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayInnerStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayClassName: StringConstructor;
    openClassName: StringConstructor;
    prefixCls: StringConstructor;
    mouseEnterDelay: NumberConstructor;
    mouseLeaveDelay: NumberConstructor;
    getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
    arrowPointAtCenter: {
    type: BooleanConstructor;
    default: any;
    };
    arrow: {
    type: PropType<boolean | {
    pointAtCenter?: boolean;
    }>;
    default: boolean | {
    pointAtCenter?: boolean;
    };
    };
    autoAdjustOverflow: {
    type: PropType<boolean | AdjustOverflow>;
    default: boolean | AdjustOverflow;
    };
    destroyTooltipOnHide: {
    type: BooleanConstructor;
    default: any;
    };
    align: {
    type: PropType<AlignType>;
    default: AlignType;
    };
    builtinPlacements: {
    type: PropType<BuildInPlacements>;
    default: BuildInPlacements;
    };
    children: ArrayConstructor;
    onVisibleChange: PropType<(vis: boolean) => void>;
    "onUpdate:visible": PropType<(vis: boolean) => void>;
    onOpenChange: PropType<(vis: boolean) => void>;
    "onUpdate:open": PropType<(vis: boolean) => void>;
    }>>;
    };
    transformCellText: {
    type: PropType<TransformCellText<any>>;
    default: TransformCellText<any>;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, PublicProps, {
    scroll: {
    x?: string | number | true;
    y?: string | number;
    } & {
    scrollToFirstRowOnChange?: boolean;
    };
    size: SizeType;
    footer: PanelRender<any>;
    title: PanelRender<any>;
    onChange: (pagination: TablePaginationConfig, filters: Record<string, FilterValue>, sorter: SorterResult<any> | SorterResult<any>[], extra: TableCurrentDataSource<any>) => void;
    components: TableComponents<any>;
    direction: "rtl" | "ltr";
    tableLayout: TableLayout;
    columns: ColumnsType<any>;
    sticky: boolean | TableSticky;
    prefixCls: string;
    id: string;
    getPopupContainer: GetPopupContainer;
    rowClassName: string | RowClassName<any>;
    locale: TableLocale;
    expandIcon: RenderExpandIcon<any>;
    loading: boolean | Partial<ExtractPropTypes<    {
    prefixCls: StringConstructor;
    spinning: {
    type: BooleanConstructor;
    default: any;
    };
    size: PropType<SpinSize>;
    wrapperClassName: StringConstructor;
    tip: VueTypeValidableDef<any>;
    delay: NumberConstructor;
    indicator: VueTypeValidableDef<any>;
    }>>;
    bordered: boolean;
    onExpand: (expanded: boolean, record: any) => void;
    pagination: false | TablePaginationConfig;
    dataSource: any[];
    rowKey: string | GetRowKey<any>;
    expandedRowKeys: Key[];
    defaultExpandedRowKeys: Key[];
    expandedRowRender: ExpandedRowRender<any>;
    expandRowByClick: boolean;
    onExpandedRowsChange: (expandedKeys: Key[]) => void;
    defaultExpandAllRows: boolean;
    showExpandColumn: boolean;
    expandedRowClassName: RowClassName<any>;
    childrenColumnName: string;
    rowExpandable: (record: any) => boolean;
    transformCellText: TransformCellText<any>;
    onResizeColumn: (w: number, col: ColumnType_2<any>) => void;
    customHeaderRow: GetComponentProps<ColumnType<any>[]>;
    customRow: GetComponentProps<any>;
    expandFixed: boolean | "left" | "right";
    showHeader: boolean;
    'onUpdate:expandedRowKeys': (expandedKeys: Key[]) => void;
    sortDirections: SortOrder[];
    showSorterTooltip: boolean | Partial<ExtractPropTypes<    {
    title: VueTypeValidableDef<any>;
    trigger: PropType<TriggerType | TriggerType[]>;
    open: {
    type: BooleanConstructor;
    default: any;
    };
    visible: {
    type: BooleanConstructor;
    default: any;
    };
    placement: PropType<TooltipPlacement>;
    color: PropType<LiteralUnion<PresetColorType>>;
    transitionName: StringConstructor;
    overlayStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayInnerStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayClassName: StringConstructor;
    openClassName: StringConstructor;
    prefixCls: StringConstructor;
    mouseEnterDelay: NumberConstructor;
    mouseLeaveDelay: NumberConstructor;
    getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
    arrowPointAtCenter: {
    type: BooleanConstructor;
    default: any;
    };
    arrow: {
    type: PropType<boolean | {
    pointAtCenter?: boolean;
    }>;
    default: boolean | {
    pointAtCenter?: boolean;
    };
    };
    autoAdjustOverflow: {
    type: PropType<boolean | AdjustOverflow>;
    default: boolean | AdjustOverflow;
    };
    destroyTooltipOnHide: {
    type: BooleanConstructor;
    default: any;
    };
    align: {
    type: PropType<AlignType>;
    default: AlignType;
    };
    builtinPlacements: {
    type: PropType<BuildInPlacements>;
    default: BuildInPlacements;
    };
    children: ArrayConstructor;
    onVisibleChange: PropType<(vis: boolean) => void>;
    "onUpdate:visible": PropType<(vis: boolean) => void>;
    onOpenChange: PropType<(vis: boolean) => void>;
    "onUpdate:open": PropType<(vis: boolean) => void>;
    }>>;
    rowSelection: TableRowSelection<any>;
    }, true, {}, CustomSlotsType<    {
    emptyText?: any;
    expandIcon?: RenderExpandIconProps<any>;
    title?: any;
    footer?: any;
    summary?: any;
    expandedRowRender?: any;
    expandColumnTitle?: any;
    bodyCell?: (props: {
    text: any;
    value: any;
    record: Record<string, any>;
    index: number;
    column: ColumnType_2<any>;
    }) => void;
    headerCell?: (props: {
    title: any;
    column: ColumnType_2<any>;
    }) => void;
    customFilterIcon?: any;
    customFilterDropdown?: any;
    default: any;
    }>, GlobalComponents, GlobalDirectives, string, {}, any, ComponentProvideOptions, {
    P: {};
    B: {};
    D: {};
    C: {};
    M: {};
    Defaults: {};
    }, Readonly<ExtractPropTypes<    {
    prefixCls: {
    type: PropType<string>;
    default: string;
    };
    columns: {
    type: PropType<ColumnsType<any>>;
    default: ColumnsType<any>;
    };
    rowKey: {
    type: PropType<string | GetRowKey<any>>;
    default: string | GetRowKey<any>;
    };
    tableLayout: {
    type: PropType<TableLayout>;
    default: TableLayout;
    };
    rowClassName: {
    type: PropType<string | RowClassName<any>>;
    default: string | RowClassName<any>;
    };
    title: {
    type: PropType<PanelRender<any>>;
    default: PanelRender<any>;
    };
    footer: {
    type: PropType<PanelRender<any>>;
    default: PanelRender<any>;
    };
    id: {
    type: PropType<string>;
    default: string;
    };
    showHeader: {
    type: BooleanConstructor;
    default: boolean;
    };
    components: {
    type: PropType<TableComponents<any>>;
    default: TableComponents<any>;
    };
    customRow: {
    type: PropType<GetComponentProps<any>>;
    default: GetComponentProps<any>;
    };
    customHeaderRow: {
    type: PropType<GetComponentProps<ColumnType<any>[]>>;
    default: GetComponentProps<ColumnType<any>[]>;
    };
    direction: {
    type: PropType<"rtl" | "ltr">;
    default: "rtl" | "ltr";
    };
    expandFixed: {
    type: PropType<boolean | "left" | "right">;
    default: boolean | "left" | "right";
    };
    expandColumnWidth: NumberConstructor;
    expandedRowKeys: {
    type: PropType<Key[]>;
    default: Key[];
    };
    defaultExpandedRowKeys: {
    type: PropType<Key[]>;
    default: Key[];
    };
    expandedRowRender: {
    type: PropType<ExpandedRowRender<any>>;
    default: ExpandedRowRender<any>;
    };
    expandRowByClick: {
    type: BooleanConstructor;
    default: boolean;
    };
    expandIcon: {
    type: PropType<RenderExpandIcon<any>>;
    default: RenderExpandIcon<any>;
    };
    onExpand: {
    type: PropType<(expanded: boolean, record: any) => void>;
    default: (expanded: boolean, record: any) => void;
    };
    onExpandedRowsChange: {
    type: PropType<(expandedKeys: Key[]) => void>;
    default: (expandedKeys: Key[]) => void;
    };
    'onUpdate:expandedRowKeys': {
    type: PropType<(expandedKeys: Key[]) => void>;
    default: (expandedKeys: Key[]) => void;
    };
    defaultExpandAllRows: {
    type: BooleanConstructor;
    default: boolean;
    };
    indentSize: NumberConstructor;
    expandIconColumnIndex: NumberConstructor;
    showExpandColumn: {
    type: BooleanConstructor;
    default: boolean;
    };
    expandedRowClassName: {
    type: PropType<RowClassName<any>>;
    default: RowClassName<any>;
    };
    childrenColumnName: {
    type: PropType<string>;
    default: string;
    };
    rowExpandable: {
    type: PropType<(record: any) => boolean>;
    default: (record: any) => boolean;
    };
    sticky: {
    type: PropType<boolean | TableSticky>;
    default: boolean | TableSticky;
    };
    dropdownPrefixCls: StringConstructor;
    dataSource: {
    type: PropType<any[]>;
    default: any[];
    };
    pagination: {
    type: PropType<false | TablePaginationConfig>;
    default: false | TablePaginationConfig;
    };
    loading: {
    type: PropType<boolean | Partial<ExtractPropTypes<    {
    prefixCls: StringConstructor;
    spinning: {
    type: BooleanConstructor;
    default: any;
    };
    size: PropType<SpinSize>;
    wrapperClassName: StringConstructor;
    tip: VueTypeValidableDef<any>;
    delay: NumberConstructor;
    indicator: VueTypeValidableDef<any>;
    }>>>;
    default: boolean | Partial<ExtractPropTypes<    {
    prefixCls: StringConstructor;
    spinning: {
    type: BooleanConstructor;
    default: any;
    };
    size: PropType<SpinSize>;
    wrapperClassName: StringConstructor;
    tip: VueTypeValidableDef<any>;
    delay: NumberConstructor;
    indicator: VueTypeValidableDef<any>;
    }>>;
    };
    size: {
    type: PropType<SizeType>;
    default: SizeType;
    };
    bordered: {
    type: BooleanConstructor;
    default: boolean;
    };
    locale: {
    type: PropType<TableLocale>;
    default: TableLocale;
    };
    onChange: {
    type: PropType<(pagination: TablePaginationConfig, filters: Record<string, FilterValue>, sorter: SorterResult<any> | SorterResult<any>[], extra: TableCurrentDataSource<any>) => void>;
    default: (pagination: TablePaginationConfig, filters: Record<string, FilterValue>, sorter: SorterResult<any> | SorterResult<any>[], extra: TableCurrentDataSource<any>) => void;
    };
    onResizeColumn: {
    type: PropType<(w: number, col: ColumnType_2<any>) => void>;
    default: (w: number, col: ColumnType_2<any>) => void;
    };
    rowSelection: {
    type: PropType<TableRowSelection<any>>;
    default: TableRowSelection<any>;
    };
    getPopupContainer: {
    type: PropType<GetPopupContainer>;
    default: GetPopupContainer;
    };
    scroll: {
    type: PropType<    {
    x?: string | number | true;
    y?: string | number;
    } & {
    scrollToFirstRowOnChange?: boolean;
    }>;
    default: {
    x?: string | number | true;
    y?: string | number;
    } & {
    scrollToFirstRowOnChange?: boolean;
    };
    };
    sortDirections: {
    type: PropType<SortOrder[]>;
    default: SortOrder[];
    };
    showSorterTooltip: {
    type: PropType<boolean | Partial<ExtractPropTypes<    {
    title: VueTypeValidableDef<any>;
    trigger: PropType<TriggerType | TriggerType[]>;
    open: {
    type: BooleanConstructor;
    default: any;
    };
    visible: {
    type: BooleanConstructor;
    default: any;
    };
    placement: PropType<TooltipPlacement>;
    color: PropType<LiteralUnion<PresetColorType>>;
    transitionName: StringConstructor;
    overlayStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayInnerStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayClassName: StringConstructor;
    openClassName: StringConstructor;
    prefixCls: StringConstructor;
    mouseEnterDelay: NumberConstructor;
    mouseLeaveDelay: NumberConstructor;
    getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
    arrowPointAtCenter: {
    type: BooleanConstructor;
    default: any;
    };
    arrow: {
    type: PropType<boolean | {
    pointAtCenter?: boolean;
    }>;
    default: boolean | {
    pointAtCenter?: boolean;
    };
    };
    autoAdjustOverflow: {
    type: PropType<boolean | AdjustOverflow>;
    default: boolean | AdjustOverflow;
    };
    destroyTooltipOnHide: {
    type: BooleanConstructor;
    default: any;
    };
    align: {
    type: PropType<AlignType>;
    default: AlignType;
    };
    builtinPlacements: {
    type: PropType<BuildInPlacements>;
    default: BuildInPlacements;
    };
    children: ArrayConstructor;
    onVisibleChange: PropType<(vis: boolean) => void>;
    "onUpdate:visible": PropType<(vis: boolean) => void>;
    onOpenChange: PropType<(vis: boolean) => void>;
    "onUpdate:open": PropType<(vis: boolean) => void>;
    }>>>;
    default: boolean | Partial<ExtractPropTypes<    {
    title: VueTypeValidableDef<any>;
    trigger: PropType<TriggerType | TriggerType[]>;
    open: {
    type: BooleanConstructor;
    default: any;
    };
    visible: {
    type: BooleanConstructor;
    default: any;
    };
    placement: PropType<TooltipPlacement>;
    color: PropType<LiteralUnion<PresetColorType>>;
    transitionName: StringConstructor;
    overlayStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayInnerStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayClassName: StringConstructor;
    openClassName: StringConstructor;
    prefixCls: StringConstructor;
    mouseEnterDelay: NumberConstructor;
    mouseLeaveDelay: NumberConstructor;
    getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
    arrowPointAtCenter: {
    type: BooleanConstructor;
    default: any;
    };
    arrow: {
    type: PropType<boolean | {
    pointAtCenter?: boolean;
    }>;
    default: boolean | {
    pointAtCenter?: boolean;
    };
    };
    autoAdjustOverflow: {
    type: PropType<boolean | AdjustOverflow>;
    default: boolean | AdjustOverflow;
    };
    destroyTooltipOnHide: {
    type: BooleanConstructor;
    default: any;
    };
    align: {
    type: PropType<AlignType>;
    default: AlignType;
    };
    builtinPlacements: {
    type: PropType<BuildInPlacements>;
    default: BuildInPlacements;
    };
    children: ArrayConstructor;
    onVisibleChange: PropType<(vis: boolean) => void>;
    "onUpdate:visible": PropType<(vis: boolean) => void>;
    onOpenChange: PropType<(vis: boolean) => void>;
    "onUpdate:open": PropType<(vis: boolean) => void>;
    }>>;
    };
    transformCellText: {
    type: PropType<TransformCellText<any>>;
    default: TransformCellText<any>;
    };
    }>> & Readonly<{}>, () => JSX.Element, {}, {}, {}, {
    scroll: {
    x?: string | number | true;
    y?: string | number;
    } & {
    scrollToFirstRowOnChange?: boolean;
    };
    size: SizeType;
    footer: PanelRender<any>;
    title: PanelRender<any>;
    onChange: (pagination: TablePaginationConfig, filters: Record<string, FilterValue>, sorter: SorterResult<any> | SorterResult<any>[], extra: TableCurrentDataSource<any>) => void;
    components: TableComponents<any>;
    direction: "rtl" | "ltr";
    tableLayout: TableLayout;
    columns: ColumnsType<any>;
    sticky: boolean | TableSticky;
    prefixCls: string;
    id: string;
    getPopupContainer: GetPopupContainer;
    rowClassName: string | RowClassName<any>;
    locale: TableLocale;
    expandIcon: RenderExpandIcon<any>;
    loading: boolean | Partial<ExtractPropTypes<    {
    prefixCls: StringConstructor;
    spinning: {
    type: BooleanConstructor;
    default: any;
    };
    size: PropType<SpinSize>;
    wrapperClassName: StringConstructor;
    tip: VueTypeValidableDef<any>;
    delay: NumberConstructor;
    indicator: VueTypeValidableDef<any>;
    }>>;
    bordered: boolean;
    onExpand: (expanded: boolean, record: any) => void;
    pagination: false | TablePaginationConfig;
    dataSource: any[];
    rowKey: string | GetRowKey<any>;
    expandedRowKeys: Key[];
    defaultExpandedRowKeys: Key[];
    expandedRowRender: ExpandedRowRender<any>;
    expandRowByClick: boolean;
    onExpandedRowsChange: (expandedKeys: Key[]) => void;
    defaultExpandAllRows: boolean;
    showExpandColumn: boolean;
    expandedRowClassName: RowClassName<any>;
    childrenColumnName: string;
    rowExpandable: (record: any) => boolean;
    transformCellText: TransformCellText<any>;
    onResizeColumn: (w: number, col: ColumnType_2<any>) => void;
    customHeaderRow: GetComponentProps<ColumnType<any>[]>;
    customRow: GetComponentProps<any>;
    expandFixed: boolean | "left" | "right";
    showHeader: boolean;
    'onUpdate:expandedRowKeys': (expandedKeys: Key[]) => void;
    sortDirections: SortOrder[];
    showSorterTooltip: boolean | Partial<ExtractPropTypes<    {
    title: VueTypeValidableDef<any>;
    trigger: PropType<TriggerType | TriggerType[]>;
    open: {
    type: BooleanConstructor;
    default: any;
    };
    visible: {
    type: BooleanConstructor;
    default: any;
    };
    placement: PropType<TooltipPlacement>;
    color: PropType<LiteralUnion<PresetColorType>>;
    transitionName: StringConstructor;
    overlayStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayInnerStyle: {
    type: PropType<CSSProperties>;
    default: CSSProperties;
    };
    overlayClassName: StringConstructor;
    openClassName: StringConstructor;
    prefixCls: StringConstructor;
    mouseEnterDelay: NumberConstructor;
    mouseLeaveDelay: NumberConstructor;
    getPopupContainer: PropType<(triggerNode: HTMLElement) => HTMLElement>;
    arrowPointAtCenter: {
    type: BooleanConstructor;
    default: any;
    };
    arrow: {
    type: PropType<boolean | {
    pointAtCenter?: boolean;
    }>;
    default: boolean | {
    pointAtCenter?: boolean;
    };
    };
    autoAdjustOverflow: {
    type: PropType<boolean | AdjustOverflow>;
    default: boolean | AdjustOverflow;
    };
    destroyTooltipOnHide: {
    type: BooleanConstructor;
    default: any;
    };
    align: {
    type: PropType<AlignType>;
    default: AlignType;
    };
    builtinPlacements: {
    type: PropType<BuildInPlacements>;
    default: BuildInPlacements;
    };
    children: ArrayConstructor;
    onVisibleChange: PropType<(vis: boolean) => void>;
    "onUpdate:visible": PropType<(vis: boolean) => void>;
    onOpenChange: PropType<(vis: boolean) => void>;
    "onUpdate:open": PropType<(vis: boolean) => void>;
    }>>;
    rowSelection: TableRowSelection<any>;
    }> | undefined>;
    selectedRowKeys: ComputedRef<(string | number)[]>;
    setBtnLoading: (code: string, value: boolean) => void;
    selectedRecords: ComputedRef<D[]>;
    $form: ComputedRef<Recordable<any> | undefined>;
    getFormData: () => Partial<F>;
    setLoadings: (value: boolean | Record<string, boolean>) => void;
    resizeTable: () => void;
    }>): void;
    attrs: any;
    slots: {};
    emit: {
        (event: "toolbarButtonClick", data: {
            data: D[];
            code: string;
            selectedKeys: Array<string | number>;
            records: D[];
        }): void;
        (event: "toolbarToolClick", data: {
            data: D[];
            code: string;
            selectedKeys: Array<string | number>;
            records: D[];
        }): void;
        (event: "pick", data: {
            row: D;
            field: string;
        }): void;
        (event: "resetQuery"): void;
    };
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare type PGridFormConfig<F extends Recordable = Recordable> = Omit<PFormProps<F>, 'items'> & {
    /** 查询表单项；传入后自动追加查询、重置按钮，并优先于 items */
    searchItems?: PFormItemProps<F>[];
    /** 兼容旧用法，按原配置渲染，不自动追加按钮 */
    items?: PFormItemProps<F>[];
};

export declare interface PGridInstance<D extends Recordable = Recordable, F extends Recordable = Recordable> {
    commitProxy: {
        query: () => Promise<D[]>;
        reload: () => Promise<D[]>;
        reloadPage: () => Promise<D[]>;
        passQuery: (query: Partial<F>, lazy?: boolean) => Promise<void | D[]>;
        forcePassQuery: (query: Partial<F>, lazy?: boolean) => Promise<void | D[]>;
    };
    selectedRowKeys: string[] | number[];
    selectedRecords: D[];
    $table: Recordable;
    $form: Recordable;
    getFormData: () => Partial<F>;
    setLoadings: (value: boolean) => void;
    setBtnLoading: (code: string, status: boolean) => void;
    resizeTable: () => void;
}

export declare type PGridProps<D extends Recordable = Recordable, F extends Recordable = Recordable> = {
    selectConfig?: SelectConfig<D>;
    rowKey?: string;
    striped?: boolean;
    manualFetch?: boolean;
    align?: 'left' | 'right' | 'center';
    formConfig?: PGridFormConfig<F>;
    columns?: ColumnProps<D>[];
    toolbarConfig?: ToolbarConfig;
    pageConfig?: PageConfig;
    proxyConfig?: ProxyConfig<D, F>;
    tableConfig?: TableProps<D>;
    scrollMode?: 'outer' | 'inner';
    /**
     * 为 true 时根容器按视口从左上角铺满（与 v-rest 同源），用于外层未声明高度、靠内部撑开的布局。
     * 偏移见 `autoBoxSizeOffset`。
     */
    autoBoxSize?: boolean;
    /**
     * `autoBoxSize` 时距视口右侧/底部的预留像素；数字或 `"12px"` 同时作用于两侧；对象可分别指定 `right` / `bottom`。
     * 未传时使用 `setUIKitConfig({ grid: { autoBoxSizeOffset } })` 的全局值。
     */
    autoBoxSizeOffset?: number | string | {
        right?: number;
        bottom?: number;
    };
    lazyReset?: boolean;
    /**
     * 表格纵向滚动区额外预留像素：在 `tableWrapper` 高度内扣减表头、底栏后，再从 body 可滚动高度中减去本值，避免末行与滚动条贴边或被裁切。可通过 `setUIKitConfig({ grid: { fitHeight } })` 或组件 `fitHeight` 按项目微调；库内全局默认见 `config`。
     */
    fitHeight?: number;
    /**
     * 适应展示区到页面顶部的canvas渲染高度 通常比table的小
     */
    fitCanvasHeight?: number;
    /**
     * 虚拟列表 Y区计算高度
     */
    renderY?: number;
    /**
     * 适应「外层高度由内容撑开」的布局（典型如弹窗 `PromisePicker`）。
     *
     * 开启后：
     * - 根容器/表体宿主不再 `flex:1` 强行撑满（避免父无固定高度时塌陷到 0）；
     * - `a-table` 的纵向 `scroll.y` 作为「最多滚动到多少」的上限，由 `renderY` 显式指定；
     *   若不传 `renderY`，使用基于视口的默认值。内容少时不会出现行区域下方的大片空白。
     */
    fitContent?: boolean;
};

export declare const PGroupBlock: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_7<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_7<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & PBlockProps<F> & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {
    $form: ComputedRef<Recordable<any> | undefined>;
    }>): void;
    attrs: any;
    slots: {};
    emit: {};
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

declare type Position = {
    height: number;
    top: number;
    bottom: number;
    calculatedHeight: number;
};

export declare const PromisePicker: <D extends Recordable = Recordable, F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_8<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_8<Pick<Partial<{}> & Omit<{} & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, never> & PromisePickerProps<D, F> & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {
    pick: () => Promise<D[] | {
    row: D;
    field?: string;
    }>;
    pickMultiple: () => Promise<D[] | {
    row: D;
    field?: string;
    }>;
    grid: Ref<PGridInstance<D, Recordable<any>> | undefined, PGridInstance<D, Recordable<any>> | undefined>;
    hide: () => void;
    }>): void;
    attrs: any;
    slots: {};
    emit: {};
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare interface PromisePickerInstance<D extends Recordable = Recordable> {
    pick: () => Promise<{
        row: D;
        field?: string;
    }>;
    pickMultiple: () => Promise<D[]>;
    grid: PGridInstance<D>;
    hide: () => void;
}

export declare interface PromisePickerProps<D extends Recordable = Recordable, F extends Recordable = Recordable> {
    gridSetting: PGridProps<D, F>;
    title?: string;
    width?: string | number;
    multipleAllowEmpty?: boolean;
    bodyStyle?: Recordable;
    beforePick?: (rowOrRows: D | Array<D>) => Promise<void>;
}

declare interface PropOptions<T = any, D = T> {
    type?: PropType<T> | true | null
    required?: boolean
    default?: D | ((props: Record<string, unknown>) => D) | null | undefined
    validator?(value: unknown): boolean
}

export declare interface ProxyConfig<D extends Recordable = Recordable, F extends Recordable = Recordable> {
    response?: ResponsePathConfig<D>;
    ajax: AjaxConfig<F>;
}

export declare const PSearchForm: <F extends Recordable = Recordable>(__VLS_props: NonNullable<Awaited<typeof __VLS_setup>>["props"], __VLS_ctx?: __VLS_PrettifyLocal_2<Pick<NonNullable<Awaited<typeof __VLS_setup>>, "attrs" | "emit" | "slots">>, __VLS_expose?: NonNullable<Awaited<typeof __VLS_setup>>["expose"], __VLS_setup?: Promise<{
    props: __VLS_PrettifyLocal_2<Pick<Partial<{}> & Omit<{
        readonly onSearch?: ((data: F) => any) | undefined;
        readonly onReset?: (() => any) | undefined;
    } & VNodeProps & AllowedComponentProps & ComponentCustomProps, never>, "onReset" | "onSearch"> & PSearchFormProps<F> & Partial<{}>> & PublicProps;
    expose(exposed: ShallowUnwrapRef<    {
    reset: () => void | undefined;
    $form: ComputedRef<Recordable<any> | undefined>;
    }>): void;
    attrs: any;
    slots: {};
    emit: ((evt: "search", data: F) => void) & ((evt: "reset") => void);
}>) => VNode & {
    __ctx?: Awaited<typeof __VLS_setup>;
};

export declare interface PSearchFormProps<F extends Recordable = Recordable> extends Omit<PFormProps<F>, 'items'> {
    data: F;
    items: PFormItemProps<F>[];
    loading?: boolean;
    /** 是否通过 PForm 的原有 reset 流程重置 data，默认 true */
    autoReset?: boolean;
    /** 是否自动追加查询、重置操作项，默认 true */
    showActions?: boolean;
}

declare type RectOptions = {
    borderWidth?: number;
    borderColor?: string;
    fillColor?: string;
    radius?: number | [number, number, number, number];
};

declare type Render = Function | string | undefined;

export declare interface RenderFormParams<F extends Recordable = Recordable> {
    data: F;
    field?: string;
}

export declare interface RenderOptions {
    /**
     * 渲染器名称
     */
    name?: string;
    /**
     * 目标组件渲染的参数
     */
    props?: {
        [key: string]: any;
    };
    /**
     * 目标组件渲染的属性
     */
    attrs?: {
        [key: string]: any;
    };
    /**
     * 目标组件渲染的事件
     */
    events?: {
        [key: string]: (...args: any[]) => any;
    };
    /**
     * 多目标渲染
     */
    children?: any[];
    /**
     * 选项
     */
    options?: IOption[];
    /**
     * 默认值
     */
    defaultValue?: any;
    /**
     * 校验触发器
     * @param cusFields field或者field数组
     */
    handleTrigger?: (cusFields?: string | string[]) => void;
    /**
     * 延迟校验触发器
     * @param cusFields field或者field数组
     * @param time 延迟时间
     */
    handleDelayTrigger?: (cusFields?: string | string[], time?: number) => void;
}

export declare interface RenderReadonlyParams<D extends Recordable = Recordable> {
    data: D;
    field?: string;
    title?: string;
}

export declare interface RenderTableParams<D extends Recordable = Recordable> {
    data?: D[];
    row: D;
    rowIndex?: number;
    field?: string;
    title?: string;
}

declare type RenderType = 'default' | 'both';

declare interface RenderWorkshop {
    renderItemContent?: (options: RenderOptions, params: RenderFormParams, defaultHandler: Recordable) => any;
    renderDefault?: (options: RenderOptions, params: RenderTableParams, defaultHandler: Recordable) => any;
    renderReadonly?: (options: RenderOptions, params: RenderReadonlyParams, defaultHandler: Recordable) => any;
    renderEdit?: (model: Ref<any>, options: RenderOptions, params: RenderTableParams, emit?: (e: 'blur', value: any) => void) => any;
}

export declare function resetUIKitConfig(): void;

export declare interface ResponsePathConfig<D extends Recordable = Recordable> {
    list?: string | ((res: Recordable) => D[]);
    result?: string | ((res: Recordable) => D[]);
    total?: string | ((res: Recordable) => D[]);
    message?: string | ((res: Recordable) => string | {
        status: string;
        content: string;
        icon?: string;
    });
}

export declare interface Responsive {
    xxs?: number;
    xs?: number;
    sm?: number;
    md?: number;
    lg?: number;
    xl?: number;
    xxl?: number;
}

declare class Row {
    private ctx;
    x: number;
    y: number;
    width: number;
    height: number;
    cells: Cell[];
    fixedCells: Cell[];
    noFixedCells: Cell[];
    calculatedHeightCells: Cell[];
    rowIndex: number;
    rowKey: string;
    rowType: RowType;
    data: any;
    calculatedHeight: number;
    constructor(ctx: Context, rowIndex: number, x: number | undefined, y: number | undefined, width: number | undefined, height: number | undefined, data: any, rowType?: RowType);
    update(): void;
    updateCalculatedHeight(): number;
    drawCenter(): void;
    drawFixed(): void;
    drawContainer(): void;
    drawFixedContainer(): void;
    drawHorizontalBorder(): void;
    drawFixedHorizontalBorder(): void;
}

/** 自定义行唯一标识，需返回稳定的字符串 */
declare type RowKeyMethod = (row: any) => string;

declare type RowMaxHeightData = {
    key: string;
    height: number;
};

declare type RowParams = {
    row: any;
    rowIndex: number;
    rowKey: string;
};

declare type RowType = CellType;

declare type Rule = {
    required?: boolean;
    pattern?: RegExp;
    validator?: RuleValidator;
    message?: string;
};

declare type RuleParam = {
    field: string;
    fieldValue: string;
    value: string;
    column: Column;
    colIndex: number;
    rowIndex: number;
    row: any;
    key: string;
    rowKey: string;
} & Rule;

declare type Rules = Rule[];

declare type RuleValidator = (rule: Rule, value: any, callback: (message?: string) => void) => void;

/** 与 e-virt-table `scrollbarMode` 对齐：`outer` 外部预留，`inner` 内部悬停显示 */
export declare type ScrollbarMode = 'outer' | 'inner';

declare type ScrollbarMode_2 = 'outer' | 'inner';

declare type SelectableMethod = (params: SelectableParams) => boolean | void;

declare type SelectableParams = {
    row: any;
    rowIndex: number;
};

export declare interface SelectConfig<D extends Recordable = Recordable> {
    multiple?: boolean;
    showCount?: boolean;
    getCheckboxProps?: (record: D) => {
        disabled?: boolean;
    };
}

declare type SelectorCellValueType = 'displayText' | 'value';

declare type SelectorOptions = {
    enable: boolean;
    xArr: number[];
    yArr: number[];
    xArrCopy: number[];
    yArrCopy: number[];
};

export declare function setUIKitConfig(config: Partial<UIKitConfig>): void;

export declare function setup(config?: Partial<UIKitConfig>): void;

declare type ShodowOptions = {
    side: 'left' | 'right' | 'top' | 'bottom';
    shadowWidth: number;
    colorStart: string;
    colorEnd: string;
    fillColor?: string | CanvasGradient | CanvasPattern;
};

declare type SortByType = 'number' | 'string' | 'date' | 'api' | ((a: any, b: any) => number);

declare type SortDirection = 'asc' | 'desc' | 'none';

declare type SortStateMapItem = {
    direction: SortDirection;
    timestamp: number;
};

declare type SpanInfo = {
    xArr: number[];
    yArr: number[];
    rowspan: number;
    colspan: number;
    height: number;
    width: number;
    offsetTop: number;
    offsetLeft: number;
    dataList: ChangeItem[];
};

declare type SpanMethod = (params: SpanParams) => SpanType | void;

declare type SpanParams = CellParams & {
    visibleLeafColumns: Column[];
    headIndex: number;
    headPosition: Position;
    visibleRows: any[];
    rows: any[];
};

declare type SpanType = {
    rowspan: number;
    colspan: number;
    relationRowKeys?: string[];
    relationColKeys?: string[];
    mergeRow?: boolean;
    mergeCol?: boolean;
};

declare interface SvgIcon extends IconType {
    configName?: ConfigTypeName;
    configColorName?: ConfigColorNameType;
}

declare type TextGlyph = {
    char: string;
    index: number;
    line: number;
    x: number;
    y: number;
    width: number;
    height: number;
};

declare type TextInfo = {
    x: number;
    y: number;
    width: number;
    height: number;
    left: number;
    right: number;
    top: number;
    bottom: number;
};

declare type TextLayout = {
    text: string;
    chars: string[];
    glyphs: TextGlyph[];
    lines: TextLayoutLine[];
    box: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    contentBox: {
        x: number;
        y: number;
        width: number;
        height: number;
    };
    contentY: number;
    lineHeight: number;
    font: string;
    color: string;
    align: Align;
    ellipsis: boolean;
};

declare type TextLayoutLine = {
    items: TextLineItem[];
    text: string;
    caretIndex: number;
    lineIndex: number;
    drawX: number;
    drawY: number;
    width: number;
    segments: TextLineSegment[];
};

declare type TextLineItem = {
    char: string;
    sourceIndex: number;
    ellipsis?: boolean;
};

declare type TextLineSegment = {
    char: string;
    itemIndex: number;
    sourceIndex: number;
    x: number;
    width: number;
};

export declare interface ToolbarButtonProps extends PButtonProps {
    code?: string;
    dropdowns?: ToolbarButtonProps[];
}

export declare interface ToolbarConfig {
    buttons?: Array<ToolbarButtonProps>;
    tools?: Array<ToolbarToolProps>;
    disabled?: boolean;
}

export declare interface ToolbarToolProps extends PButtonProps {
    code: string;
}

export declare interface TooltipConfig extends TooltipProps {
    title: TooltipProps['title'] | (() => any);
}

declare type TreeSelectMode = 'auto' | 'cautious' | 'strictly';

declare type TreeUtilPosition = 'none' | 'before' | 'after' | 'inside';

declare type Type = 'index' | 'selection' | 'index-selection' | 'tree' | 'selection-tree' | 'tree-selection' | 'number';

export declare interface UIKitConfig {
    form?: {
        labelCol?: any;
        wrapperCol?: any;
    };
    grid?: {
        align?: 'left' | 'right' | 'center';
        lazyReset?: boolean;
        fitHeight?: number;
        fitCanvasHeight?: number;
        striped?: boolean;
        /** `PGrid` / `PCanvasGrid` 分页是否显示「跳至」；`pageConfig.showQuickJumper` 优先 */
        showQuickJumper?: boolean;
        /** `PGrid` 开启 `autoBoxSize` 且未传 `autoBoxSizeOffset` 时的视口边距，与 props 类型一致 */
        autoBoxSizeOffset?: AutoViewportBoxOffsetInput;
    };
    canvasTable?: ConfigType;
    /**
     * 自定义 tooltip 渲染函数，替换全局所有 a-tooltip。
     * @param defaultSlot 原 tooltip 触发元素（图标等）
     * @param content tooltip 内容，字符串或返回 VNode 的函数
     */
    renderTooltip?: (defaultSlot: () => VNode, content: string | (() => VNode)) => VNode;
    /**
     * 自定义图标：按 `icon` 名字渲染；返回值为真时优先于 `@ant-design/icons-vue` 同名组件。
     */
    icon?: {
        render?: (name: string) => unknown;
        /**
         * CollapseCard / PFormGroup 折叠箭头：
         * - `string`：单图标，靠旋转区分（默认收起 0° / 展开 -90°）
         * - `[collapsed, expanded]`：双图标切换，不旋转
         */
        collapseExpandIcon?: string | [collapsed: string, expanded: string];
    };
}

declare type ValidateField = {
    key: string;
    rowKey: string;
};

declare type ValidateItemError = {
    rowKey: string;
    rowIndex?: number;
    key: string;
    message: string;
};

declare type ValidateResult = RuleParam[];

declare type ValidatorFunction<T> = (value: T) => boolean

declare type VerticalAlign = 'top' | 'middle' | 'bottom';

declare interface VueTypeBaseDef<
T = unknown,
D = DefaultType<T>,
U = T extends NativeType ? T : () => T
> extends PropOptions<T> {
    _vueTypes_name: string
    readonly def: (
    def?: D,
    ) => this & {
        default: U
    }
    readonly isRequired: this & { required: true }
}

declare interface VueTypeValidableDef<T = unknown> extends VueTypeBaseDef<T> {
    readonly validate: (
    fn: ValidatorFunction<T | unknown>,
    ) => this & { validator: ValidatorFunction<T | unknown> }
}

export declare function watchPreviousDeep<T extends object>(source: WatchSource<T>, cb: (value: T, oldValue: T, onCleanup: () => void) => void, options?: WatchOptions): WatchHandle;

export { }