@scvzerng/element-ui-ag-grid-vue2 0.0.8

package/dist/types/render/types/ICellRendererParamsExt.d.ts

@@ -0,0 +1,13 @@
+import type { ICellRendererParams } from 'ag-grid-community';
+import type { VNode } from 'vue';
+interface EditCellRendererParams<T, V> extends ICellRendererParams<T, V> {
+    hostObject: T;
+    hostArrayHook: (hook: (array: T[]) => void) => void;
+}
+export type EditCellRender<T, V> = (params: EditCellRendererParams<T, V>) => VNode | VNode[] | undefined | null;
+export type ICustomCellRendererParams<T, V> = ICellRendererParams<T, V> & {
+    render?: (params: ICellRendererParams<T>) => VNode | VNode[] | undefined | null;
+    footerRender?: (params: ICellRendererParams<T>) => VNode | VNode[] | undefined | null;
+    editeRender?: EditCellRender<T, V>;
+};
+export {};

package/dist/types/renders.d.ts

@@ -0,0 +1,35 @@
+import { ColDef, ColGroupDef, type ICellRendererParams } from 'ag-grid-community';
+import type { VNode } from 'vue';
+import { GridRow } from './model/row/GridRow';
+export declare const withRender: (column: ColDef) => CellRenderAdapter;
+type CellRender<ROW = any, VALUE = any> = (params: ICellRendererParams<ROW, VALUE>) => VNode | VNode[] | undefined | string;
+type EditCellRender<HOST_OBJECT = any> = (params: ICellRendererParams<HOST_OBJECT> & {
+    hostObject: HOST_OBJECT;
+    hostArrayHook: (hook: (array: HOST_OBJECT[]) => void) => void;
+}) => VNode | VNode[] | undefined | string;
+/**
+ * 简化自定义渲染列的构建
+ */
+export declare class CellRenderAdapter {
+    private readonly colDef;
+    private readonly agGridCellRenderParams;
+    constructor(colDef: ColDef);
+    cellRender<ROW, VALUE>(render: CellRender<ROW, VALUE>): this;
+    footerRender<FOOT_ROW = any, VALUE = any>(render: CellRender<FOOT_ROW, VALUE>): this;
+    editeRender<HOST_OBJECT>(render: EditCellRender<HOST_OBJECT>): this;
+    build(): ColDef<any, any>;
+}
+export declare const withColumnRenderBuilder: (colDefs: (ColDef | ColGroupDef)[]) => ColumnRendersBuilder;
+export declare class ColumnRendersBuilder {
+    private readonly colDefs;
+    private readonly rendersMap;
+    constructor(colDefs: (ColDef | ColGroupDef)[]);
+    private eachColDef;
+    private getRenderParams;
+    render<ROW, VALUE>(colId: string, render: CellRender<GridRow<ROW>, VALUE>): this;
+    footerRender<ROW = any, VALUE = any>(colId: string, render: CellRender<ROW, VALUE>): this;
+    editRender<HOST_OBJECT>(colId: string, render: EditCellRender<HOST_OBJECT>): this;
+    alwaysRender(colId: string): void;
+    build(): (ColDef<any, any> | ColGroupDef<any>)[];
+}
+export {};

package/dist/types/search/DrawerSearch.vue.d.ts

@@ -0,0 +1,45 @@
+import { SearchCallback } from './use-search';
+import type { Searchable } from './Searchable';
+type __VLS_Props = {
+    /**
+     * 搜索项
+     */
+    search?: Searchable[];
+    /**
+     *  element-plus 各组件的teleported属性
+     */
+    teleported?: boolean;
+    /**
+     * 外部搜索回调
+     */
+    searchRemote: SearchCallback;
+    attached?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            loading: boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: HTMLDivElement;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/dist/types/search/PopoverSearch.vue.d.ts

@@ -0,0 +1,45 @@
+import { SearchCallback } from './use-search';
+import type { Searchable } from './Searchable';
+type __VLS_Props = {
+    /**
+     * 搜索项
+     */
+    search?: Searchable[];
+    /**
+     *  element-plus 各组件的teleported属性
+     */
+    teleported?: boolean;
+    /**
+     * 外部搜索回调
+     */
+    searchRemote: SearchCallback;
+    field: string;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {
+            loading: boolean;
+        }): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>>, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};

package/dist/types/search/Search.vue.d.ts

@@ -0,0 +1,85 @@
+import type { SearchCallback } from './use-search';
+import type { Searchable } from './Searchable';
+type __VLS_Props = {
+    /**
+     * 搜索项
+     */
+    search?: Searchable[];
+    /**
+     *  element-plus 各组件的teleported属性
+     */
+    teleported?: boolean;
+    /**
+     * 外部搜索回调
+     */
+    searchRemote: SearchCallback;
+    id?: string;
+    /**
+     * 确认按钮文案
+     */
+    confirmButtonText?: string;
+    /**
+     * 重置按钮文案
+     */
+    resetButtonText?: string;
+    /**
+     * 是否开启重置条件自动搜索
+     * 某些计费服务需要主动关闭否则会浪费付费服务次数
+     */
+    autoResetSearch?: boolean;
+    /**
+     * 是否开启
+     */
+    enable?: boolean;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {
+        searchForm: unknown;
+    };
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    confirmButtonText: string;
+    resetButtonText: string;
+    enable: boolean;
+    autoResetSearch: boolean;
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    confirmButtonText: string;
+    resetButtonText: string;
+    enable: boolean;
+    autoResetSearch: boolean;
+}>>>, {
+    confirmButtonText: string;
+    resetButtonText: string;
+    autoResetSearch: boolean;
+    enable: boolean;
+}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $scopedSlots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = {
+    [K in keyof T]: T[K];
+} & {};

package/dist/types/search/SearchItem.vue.d.ts

@@ -0,0 +1,22 @@
+import { type PropType } from 'vue';
+import type { Searchable } from './Searchable';
+declare const _default: import("vue").DefineComponent<{
+    search: {
+        type: PropType<Searchable>;
+        required: true;
+    };
+    teleported: {
+        type: BooleanConstructor;
+    };
+}, () => import("vue").VNode | undefined, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, Readonly<import("vue").ExtractPropTypes<{
+    search: {
+        type: PropType<Searchable>;
+        required: true;
+    };
+    teleported: {
+        type: BooleanConstructor;
+    };
+}>>, {
+    teleported: boolean;
+}>;
+export default _default;

package/dist/types/search/Searchable.d.ts

@@ -0,0 +1,38 @@
+import type { VNode } from 'vue';
+export type TransformCallback<T> = (value: T) => Record<string, any>;
+export declare class Searches {
+    record: Record<string, any>;
+    constructor(record: Record<string, any>);
+    static from(searches: Searchable[]): Searches;
+    transform<T>(field: string, transformCallback: TransformCallback<T>): Searches;
+    toCondition<T>(record?: Record<string, any>): T;
+}
+export interface Searchable {
+    /**
+     * 属性名
+     */
+    field: string;
+    /**
+     * 描述
+     */
+    label: string;
+    /**
+     * 绑定数据
+     */
+    value?: any;
+    /**
+     * 初始化数据
+     */
+    initValue?: any;
+    visible?: boolean;
+    width?: number;
+    /**
+     * 是否支持搜索条件持久化
+     */
+    transient?: boolean;
+    /**
+     * 渲染器
+     * @param row
+     */
+    render: (value: Searchable) => VNode | undefined;
+}

package/dist/types/search/index.d.ts

@@ -0,0 +1,4 @@
+export { default as ClSearch } from './Search.vue';
+export { default as ClPopoverSearch } from './PopoverSearch.vue';
+export { default as ClDrawerSearch } from './DrawerSearch.vue';
+export * from './Searchable';

package/dist/types/search/use-search.d.ts

@@ -0,0 +1,26 @@
+import type { Searchable } from './Searchable';
+export type SearchCallback = () => Promise<void>;
+export type SearchProps = {
+    /**
+     * 搜索项
+     */
+    search?: Searchable[];
+    /**
+     *  element-plus 各组件的teleported属性
+     */
+    teleported?: boolean;
+    /**
+     * 外部搜索回调
+     */
+    searchRemote: SearchCallback;
+};
+export declare const useSearch: (searchRemote: SearchCallback, props: SearchProps, search?: Searchable | Searchable[]) => {
+    visible: import("vue").Ref<any>;
+    loading: import("vue").Ref<boolean>;
+    width: import("vue").ComputedRef<number | undefined>;
+    loadingClass: import("vue").ComputedRef<string[]>;
+    hasCondition: import("vue").ComputedRef<boolean>;
+    hasConditionColor: import("vue").ComputedRef<"var(--el-color-primary)" | undefined>;
+    doSearch: () => Promise<void>;
+    reset: () => void;
+};

package/dist/types/selection/baseSelectionService.d.ts

@@ -0,0 +1,45 @@
+import { BeanStub, IRowComp, RowContainerType } from 'ag-grid-community';
+import type { AgColumn, IsRowSelectable, RowNode, SelectionEventSourceType, IRowNode, ISetNodesSelectedParams, RowCtrl, ChangedPath } from 'ag-grid-community';
+import { CheckboxSelectionComponent } from './checkboxSelectionComponent';
+import { RowRangeSelectionContext } from './rowRangeSelectionContext';
+import { SelectAllFeature } from './selectAllFeature';
+type RowGui = {
+    rowComp: IRowComp;
+    element: HTMLElement;
+    containerType: RowContainerType;
+    compBean: BeanStub;
+};
+export declare abstract class BaseSelectionService extends BeanStub {
+    protected isRowSelectable?: IsRowSelectable;
+    protected selectionCtx: RowRangeSelectionContext;
+    postConstruct(): void;
+    destroy(): void;
+    createCheckboxSelectionComponent(): CheckboxSelectionComponent;
+    createSelectAllFeature(column: AgColumn): SelectAllFeature | undefined;
+    protected isMultiSelect(): boolean;
+    onRowCtrlSelected(rowCtrl: RowCtrl, hasFocusFunc: (gui: RowGui) => void, gui?: RowGui): void;
+    announceAriaRowSelection(rowNode: RowNode): void;
+    updateGroupsFromChildrenSelections?(source: SelectionEventSourceType, changedPath?: ChangedPath): boolean;
+    abstract setNodesSelected(params: ISetNodesSelectedParams): number;
+    protected abstract updateSelectable(changedPath?: ChangedPath): void;
+    protected isRowSelectionBlocked(rowNode: RowNode): boolean;
+    updateRowSelectable(rowNode: RowNode, suppressSelectionUpdate?: boolean): boolean;
+    protected setRowSelectable(rowNode: RowNode, newVal: boolean, suppressSelectionUpdate?: boolean): void;
+    protected calculateSelectedFromChildren(rowNode: RowNode): boolean | undefined | null;
+    selectRowNode(rowNode: RowNode, newValue?: boolean, e?: Event, source?: SelectionEventSourceType): boolean;
+    isCellCheckboxSelection(column: AgColumn, rowNode: IRowNode): boolean;
+    protected inferNodeSelections(node: RowNode, shiftKey: boolean, metaKey: boolean, source: SelectionEventSourceType): null | NodeSelection;
+}
+interface SingleNodeSelection {
+    node: RowNode;
+    newValue: boolean;
+    clearSelection: boolean;
+    keepDescendants?: boolean;
+}
+interface MultiNodeSelection {
+    select: readonly RowNode[];
+    deselect: readonly RowNode[];
+    reset: boolean;
+}
+type NodeSelection = SingleNodeSelection | MultiNodeSelection;
+export {};

package/dist/types/selection/checkboxSelectionComponent.d.ts

@@ -0,0 +1,24 @@
+import { Component } from 'ag-grid-community';
+import type { AgColumn, CheckboxSelectionCallback, RowNode, GroupCheckboxSelectionCallback } from 'ag-grid-community';
+export declare class CheckboxSelectionComponent extends Component {
+    private readonly eCheckbox;
+    private rowNode;
+    private column;
+    private overrides?;
+    constructor();
+    postConstruct(): void;
+    private onDataChanged;
+    private onSelectableChanged;
+    private onSelectionChanged;
+    init(params: {
+        rowNode: RowNode;
+        column?: AgColumn;
+        overrides?: {
+            isVisible: boolean | CheckboxSelectionCallback | GroupCheckboxSelectionCallback | undefined;
+            callbackParams: any;
+            removeHidden: boolean;
+        };
+    }): void;
+    private showOrHideSelect;
+    private getIsVisible;
+}

package/dist/types/selection/rowRangeSelectionContext.d.ts

@@ -0,0 +1,54 @@
+import type { RowNode, IRowModel, IPinnedRowModel } from 'ag-grid-community';
+interface RangePartition {
+    keep: readonly RowNode[];
+    discard: readonly RowNode[];
+}
+/**
+ * The context of a row range selection operation.
+ *
+ * Used to model the stateful range selection behaviour found in things like Excel and
+ * various file explorers, in particular Windows File Explorer, where a given cell/row
+ * represents the "root" of a selection range, and subsequent selections are based off that root.
+ *
+ * See AG-9620 for more
+ */
+export declare class RowRangeSelectionContext {
+    private readonly rowModel;
+    private readonly pinnedRowModel?;
+    /** Whether the user is currently selecting all nodes either via the header checkbox or API */
+    selectAll: boolean;
+    private rootId;
+    /**
+     * Note that the "end" `RowNode` may come before or after the "root" `RowNode` in the
+     * actual grid.
+     */
+    private endId;
+    private cachedRange;
+    constructor(rowModel: IRowModel, pinnedRowModel?: IPinnedRowModel | undefined);
+    reset(): void;
+    setRoot(node: RowNode): void;
+    setEndRange(end: RowNode): void;
+    getRange(): readonly RowNode[];
+    isInRange(node: RowNode): boolean;
+    getRoot(fallback?: RowNode): RowNode | undefined;
+    private getEnd;
+    private getRowNode;
+    /**
+     * Truncates the range to the given node (assumed to be within the current range).
+     * Returns nodes that remain in the current range and those that should be removed
+     *
+     * @param node - Node at which to truncate the range
+     * @returns Object of nodes to either keep or discard (i.e. deselect) from the range
+     */
+    truncate(node: RowNode): RangePartition;
+    /**
+     * Extends the range to the given node. Returns nodes that remain in the current range
+     * and those that should be removed.
+     *
+     * @param node - Node marking the new end of the range
+     * @returns Object of nodes to either keep or discard (i.e. deselect) from the range
+     */
+    extend(node: RowNode, groupSelectsChildren?: boolean): RangePartition;
+    private getNodesInRange;
+}
+export {};

package/dist/types/selection/rowSelectionApi.d.ts

@@ -0,0 +1,18 @@
+import type { BeanCollection, SelectAllMode, SelectionEventSourceType, IRowNode } from 'ag-grid-community';
+export declare function setNodesSelected(beans: BeanCollection, params: {
+    nodes: IRowNode[];
+    newValue: boolean;
+    source?: SelectionEventSourceType;
+}): void;
+export declare function selectAll(beans: BeanCollection, selectAll?: SelectAllMode, source?: SelectionEventSourceType): void;
+export declare function deselectAll(beans: BeanCollection, selectAll?: SelectAllMode, source?: SelectionEventSourceType): void;
+/** @deprecated v33 */
+export declare function selectAllFiltered(beans: BeanCollection, source?: SelectionEventSourceType): void;
+/** @deprecated v33 */
+export declare function deselectAllFiltered(beans: BeanCollection, source?: SelectionEventSourceType): void;
+/** @deprecated v33 */
+export declare function selectAllOnCurrentPage(beans: BeanCollection, source?: SelectionEventSourceType): void;
+/** @deprecated v33 */
+export declare function deselectAllOnCurrentPage(beans: BeanCollection, source?: SelectionEventSourceType): void;
+export declare function getSelectedNodes<TData = any>(beans: BeanCollection): IRowNode<TData>[];
+export declare function getSelectedRows<TData = any>(beans: BeanCollection): TData[];

package/dist/types/selection/rowSelectionModule.d.ts

@@ -0,0 +1,9 @@
+import type { _ModuleWithApi, _ModuleWithoutApi } from 'ag-grid-community';
+/**
+ * @internal
+ */
+export declare const SharedRowSelectionModule: _ModuleWithApi<any>;
+/**
+ * @feature Selection -> Row Selection
+ */
+export declare const RowSelectionModule: _ModuleWithoutApi;

package/dist/types/selection/selectAllFeature.d.ts

@@ -0,0 +1,28 @@
+import type { BeanCollection, HeaderCellCtrl, AgColumn } from 'ag-grid-community';
+import { BeanStub } from 'ag-grid-community';
+export declare class SelectAllFeature extends BeanStub {
+    private readonly column;
+    private cbSelectAllVisible;
+    private processingEventFromCheckbox;
+    private headerCellCtrl?;
+    private cbSelectAll?;
+    constructor(column: AgColumn);
+    onSpaceKeyDown(e: KeyboardEvent): void;
+    getCheckboxGui(): HTMLElement;
+    setComp(ctrl: HeaderCellCtrl): void;
+    private onDisplayedColumnsChanged;
+    private showOrHideSelectAll;
+    private updateStateOfCheckbox;
+    private refreshSelectAllLabel;
+    private checkSelectionType;
+    private checkRightRowModelType;
+    private onCbSelectAll;
+    /**
+     * Checkbox is enabled when either the `headerCheckbox` option is enabled in the new selection API
+     * or `headerCheckboxSelection` is enabled in the legacy API.
+     */
+    private isCheckboxSelection;
+    private getSelectAllMode;
+    destroy(): void;
+}
+export declare function isCheckboxSelection({ gos, selectionColSvc }: BeanCollection, column: AgColumn): boolean;

package/dist/types/selection/selectionColService.d.ts

@@ -0,0 +1,38 @@
+import type { AgProvidedColumnGroup, PropertyValueChangedEvent, IColumnCollectionService, ColKey, NamedBean } from 'ag-grid-community';
+import { BeanStub, AgColumn } from 'ag-grid-community';
+export interface ColumnCollections {
+    tree: (AgColumn | AgProvidedColumnGroup)[];
+    treeDepth: number;
+    list: AgColumn[];
+    map: {
+        [id: string]: AgColumn;
+    };
+}
+export declare class SelectionColService extends BeanStub implements NamedBean, IColumnCollectionService {
+    beanName: "selectionColSvc";
+    columns: ColumnCollections | null;
+    postConstruct(): void;
+    addColumns(cols: ColumnCollections): void;
+    createColumns(cols: ColumnCollections, updateOrders: (callback: (cols: AgColumn[] | null) => AgColumn[] | null) => void): void;
+    updateColumns(event: PropertyValueChangedEvent<'selectionColumnDef'>): void;
+    getColumn(key: ColKey): AgColumn | null;
+    getColumns(): AgColumn[] | null;
+    isSelectionColumnEnabled(): boolean;
+    private createSelectionColDef;
+    private generateSelectionCols;
+    private onSelectionOptionsChanged;
+    destroy(): void;
+    /**
+     * Refreshes visibility of the selection column based on which columns are currently visible.
+     * Called by the VisibleColsService with the columns that are currently visible in left/center/right
+     * containers. This method *MUTATES* those arrays directly.
+     *
+     * The selection column should be visible if all of the following are true
+     * - The selection column is not disabled
+     * - The number of visible columns excluding the selection column and row numbers column is greater than 0
+     * @param leftCols Visible columns in the left-pinned container
+     * @param centerCols Visible columns in the center viewport
+     * @param rightCols Visible columns in the right-pinned container
+     */
+    refreshVisibility(leftCols: AgColumn[], centerCols: AgColumn[], rightCols: AgColumn[]): void;
+}

package/dist/types/selection/selectionService.d.ts

@@ -0,0 +1,73 @@
+import type { NamedBean, ServerSideRowGroupSelectionState, ServerSideRowSelectionState, ISelectionService, ISetNodesSelectedParams, GridApi, GridOptions, SelectionEventSourceType, SelectAllMode } from 'ag-grid-community';
+import { ChangedPath, RowNode } from 'ag-grid-community';
+import { BaseSelectionService } from './baseSelectionService';
+export declare class SelectionService extends BaseSelectionService implements NamedBean, ISelectionService {
+    beanName: "selectionSvc";
+    private selectedNodes;
+    /** Only used to track detail grid selection state when master/detail is enabled */
+    private detailSelection;
+    private groupSelectsDescendants;
+    private groupSelectsFiltered;
+    private mode?;
+    private masterSelectsDetail;
+    postConstruct(): void;
+    destroy(): void;
+    handleSelectionEvent(event: MouseEvent | KeyboardEvent, rowNode: RowNode, source: SelectionEventSourceType): number;
+    setNodesSelected({ newValue, clearSelection, suppressFinishActions, nodes, event, source, keepDescendants, }: ISetNodesSelectedParams & {
+        keepDescendants?: boolean;
+    }): number;
+    private selectRange;
+    private selectChildren;
+    getSelectedNodes(): RowNode[];
+    getSelectedRows(): any[];
+    getSelectionCount(): number;
+    /**
+     * This method is used by the CSRM to remove groups which are being disposed of,
+     * events do not need fired in this case
+     */
+    filterFromSelection(predicate: (node: RowNode) => boolean): void;
+    updateGroupsFromChildrenSelections(source: SelectionEventSourceType, changedPath?: ChangedPath): boolean;
+    private clearOtherNodes;
+    private onRowSelected;
+    syncInRowNode(rowNode: RowNode, oldNode?: RowNode): void;
+    createDaemonNode(rowNode: RowNode): RowNode | undefined;
+    private syncInOldRowNode;
+    private syncInNewRowNode;
+    reset(source: SelectionEventSourceType): void;
+    private resetNodes;
+    getBestCostNodeSelection(): RowNode[] | undefined;
+    isEmpty(): boolean;
+    deselectAllRowNodes({ source, selectAll, }: {
+        source: SelectionEventSourceType;
+        selectAll?: SelectAllMode;
+    }): void;
+    private getSelectedCounts;
+    getSelectAllState(selectAll?: SelectAllMode): boolean | null;
+    hasNodesToSelect(selectAll: SelectAllMode): boolean;
+    /**
+     * @param selectAll See `MultiRowSelectionOptions.selectAll`
+     * @returns all nodes including unselectable nodes which are the target of this selection attempt
+     */
+    private getNodesToSelect;
+    private forEachNodeOnPage;
+    selectAllRowNodes(params: {
+        source: SelectionEventSourceType;
+        selectAll?: SelectAllMode;
+    }): void;
+    getSelectionState(): string[] | null;
+    setSelectionState(state: string[] | ServerSideRowSelectionState | ServerSideRowGroupSelectionState | undefined, source: SelectionEventSourceType, clearSelection?: boolean): void;
+    private canSelectAll;
+    /**
+     * Updates the selectable state for a node by invoking isRowSelectable callback.
+     * If the node is not selectable, it will be deselected.
+     *
+     * Callers:
+     *  - property isRowSelectable changed
+     *  - after grouping / treeData via `updateSelectableAfterGrouping`
+     */
+    protected updateSelectable(changedPath?: ChangedPath): void;
+    updateSelectableAfterGrouping(changedPath: ChangedPath | undefined): void;
+    refreshMasterNodeState(node: RowNode, e?: Event): void;
+    setDetailSelectionState(masterNode: RowNode, detailGridOptions: GridOptions, detailApi: GridApi): void;
+    private dispatchSelectionChanged;
+}

package/dist/types/selection/utils.d.ts

@@ -0,0 +1,12 @@
+import type { GridOptionsService, IPinnedRowModel, LocaleTextFunc, RowNode, RowPinnedType, RowSelectionOptions, SelectAllMode } from 'ag-grid-community';
+export declare function _getMasterSelects(gos: GridOptionsService): NonNullable<RowSelectionOptions['masterSelects']>;
+/** Whether the given node is pinned manually to the top or bottom container */
+export declare function _isManualPinnedRow(rowNode: RowNode): boolean;
+export declare function _getSelectAll(gos: GridOptionsService, defaultValue?: boolean): SelectAllMode | undefined;
+export declare function _getAriaCheckboxStateName(translate: LocaleTextFunc, state?: boolean): string;
+export declare function _getNodesInRangeForSelection(rowModel: IPinnedRowModel, float: NonNullable<RowPinnedType>, start: RowNode | undefined, end: RowNode | undefined): RowNode[];
+/** Get the display configuration for disabled checkboxes. Defaults to displaying disabled checkboxes. */
+export declare function _getHideDisabledCheckboxes(selection: RowSelectionOptions): boolean;
+export declare function _getEnableDeselection(gos: GridOptionsService): boolean;
+export declare function _getEnableSelection(gos: GridOptionsService): boolean;
+export declare function _getEnableSelectionWithoutKeys(gos: GridOptionsService): boolean;

package/dist/types/tokens.d.ts

@@ -0,0 +1,22 @@
+import type { GridApi, GridOptions } from 'ag-grid-community';
+import type { RefreshCallback } from './use-grid';
+import type { InjectionKey, Ref } from 'vue';
+import { GridRow } from './model/row/GridRow';
+export declare const GRID_CONTEXT: InjectionKey<GridContext>;
+export type GridContext = {
+    refresh: RefreshCallback;
+    api: Ref<GridApi | undefined>;
+    resetGridState: () => void;
+};
+export type GridInstance<T> = {
+    setFooterData<T>(data: T[]): void;
+    updateGridOptions(gridOptions: GridOptions): void;
+    reload(): void;
+    refresh(): void;
+    getRows(): GridRow<T>[];
+    createRow(data: T, transient: boolean): GridRow<T>;
+    existRow(row: GridRow<T>): void;
+    insertRows(rows: GridRow<T>[], index?: number): void;
+    startEditing(): void;
+    stopEditing(): void;
+};