import { EventBus, EventHandler } from '../events/EventBus';
import { SortDescription } from '../models/SortDescription';
import { PropertyGroupDescription } from '../models/GroupDescription';
import { CollectionViewGroup } from './CollectionViewGroup';
export type ChangeAction = 'add' | 'remove' | 'change' | 'reset';
export interface CollectionChange<T> {
    action: ChangeAction;
    item?: T;
    index?: number;
}
interface CollectionViewEvents<T> {
    collectionChanged: CollectionChange<T>;
    currentChanged: void;
    pageChanged: void;
}
export interface CollectionViewOptions<T> {
    trackChanges?: boolean;
    newItemCreator?: () => T;
    pageSize?: number;
}
/**
 * Exposes a plain array as an editable view and, when {@link trackChanges} is on,
 * records which items were added, removed, or edited so callers can sync a server.
 * Supports sorting, filtering, current-item navigation, and change tracking. The
 * view mirrors the source order until a filter or sort is applied.
 */
export declare class CollectionView<T = Record<string, unknown>> {
    /** Items added since tracking was enabled (via addNew/commitNew). */
    readonly itemsAdded: T[];
    /** Items removed since tracking was enabled (via remove/removeAt). */
    readonly itemsRemoved: T[];
    /** Items edited since tracking was enabled (via editItem/commitEdit). */
    readonly itemsEdited: T[];
    newItemCreator?: () => T;
    /**
     * Converts a value before sorting. The grid uses it to sort data-mapped
     * columns by their display text instead of the raw key.
     */
    sortConverter?: (sd: SortDescription, item: T, value: unknown) => unknown;
    protected source: T[];
    protected view: T[];
    protected events: EventBus<CollectionViewEvents<T>>;
    protected _position: number;
    protected _filter: ((item: T) => boolean) | null;
    protected _sorts: SortDescription[];
    protected _groups: PropertyGroupDescription<T>[];
    protected _groupTree: CollectionViewGroup<T>[];
    protected _pageSize: number;
    protected _pageIndex: number;
    protected _totalItemCount: number;
    private _trackChanges;
    private editTarget;
    private editSnapshot;
    private addTarget;
    private updateDepth;
    private refreshPending;
    constructor(source?: T[], options?: CollectionViewOptions<T>);
    on<K extends keyof CollectionViewEvents<T>>(type: K, handler: EventHandler<CollectionViewEvents<T>[K]>): () => void;
    /** The items in view order. Holds the same object references as the source. */
    get items(): T[];
    get sourceCollection(): T[];
    set sourceCollection(value: T[]);
    get trackChanges(): boolean;
    set trackChanges(value: boolean);
    get canSort(): boolean;
    get canFilter(): boolean;
    /** Predicate that keeps an item in the view, or null to show everything. */
    get filter(): ((item: T) => boolean) | null;
    set filter(value: ((item: T) => boolean) | null);
    /** Sort order applied to the view. Assigning a new array re-sorts. */
    get sortDescriptions(): SortDescription[];
    set sortDescriptions(value: SortDescription[]);
    /** Group-by descriptors applied to the view. Assigning rebuilds the group tree. */
    get groupDescriptions(): PropertyGroupDescription<T>[];
    set groupDescriptions(value: PropertyGroupDescription<T>[]);
    /** The root groups, or an empty array when the view isn't grouped. */
    get groups(): CollectionViewGroup<T>[];
    get canChangePage(): boolean;
    /** Items per page. 0 disables paging (the default). */
    get pageSize(): number;
    set pageSize(value: number);
    /** Zero-based index of the current page. */
    get pageIndex(): number;
    /** Total number of pages given the page size and total item count. */
    get pageCount(): number;
    /** Total items across all pages (before paging). */
    get totalItemCount(): number;
    moveToPage(index: number): boolean;
    moveToFirstPage(): boolean;
    moveToLastPage(): boolean;
    moveToNextPage(): boolean;
    moveToPreviousPage(): boolean;
    get isEmpty(): boolean;
    get itemCount(): number;
    get currentItem(): T | null;
    get currentPosition(): number;
    get isAddingNew(): boolean;
    get isEditingItem(): boolean;
    get currentAddItem(): T | null;
    get currentEditItem(): T | null;
    contains(item: T): boolean;
    moveCurrentToPosition(index: number): boolean;
    moveCurrentToFirst(): boolean;
    moveCurrentToLast(): boolean;
    moveCurrentToNext(): boolean;
    moveCurrentToPrevious(): boolean;
    moveCurrentTo(item: T): boolean;
    /** Begin an edit transaction. Snapshots the item so cancelEdit can restore it. */
    editItem(item: T): void;
    commitEdit(): void;
    cancelEdit(): void;
    /** Add an item to the collection. Defers tracking until commitNew unless commit is true. */
    addNew(item?: T, commit?: boolean): T;
    commitNew(): void;
    cancelNew(): void;
    remove(item: T): void;
    removeAt(index: number): void;
    /** Drop all tracked changes. Call after pushing them to a server. */
    clearChanges(): void;
    beginUpdate(): void;
    endUpdate(): void;
    get isUpdating(): boolean;
    deferUpdate(fn: () => void): void;
    refresh(): void;
    protected arrange(): T[];
    private page;
    private applySort;
    private sortValue;
    private trackEdit;
    private trackRemove;
    protected onChanged(action: ChangeAction, item?: T, index?: number): void;
}
export {};