import { List } from './List';
import { Construct } from './Constructor';
import { PlainSort, Sort } from './Sort';
import { GetProperty } from './Get';
import { ArrayLike } from './Array';
import { Optional } from './Types';
import type { Id } from './Id';
export type FilterValue = {
    label?: string;
    value: any;
    count?: number;
};
export type Filter = {
    label?: string;
    field: string;
    shortField?: string;
    values: FilterValue[];
};
export declare const toFilter: (field: string, value: any) => Filter;
export declare const toShortFilter: (field: string, shortField: string, value: any) => Filter;
export type PageOptions = {
    take?: number;
    skip?: number;
    sort?: Sort[];
    sorts?: PlainSort;
    filters?: Filter[];
};
export type PageListOptions = Exclude<PageOptions, 'sort'> & {
    total?: number;
};
export declare class PageList<T> extends List<T> {
    private _options?;
    get options(): Optional<PageListOptions>;
    get take(): number;
    get skip(): number;
    get total(): Optional<number>;
    get sorts(): Optional<PlainSort>;
    get filters(): Optional<Filter[]>;
    get meta(): PageListOptions;
    get ids(): PageList<Id>;
    asc(p: GetProperty<T, any>): PageList<T>;
    desc(p: GetProperty<T, any>): PageList<T>;
    diff(others: ArrayLike<T>): PageList<T>;
    diffByKey<U = T>(others: ArrayLike<U>, key: keyof T & keyof U): PageList<T>;
    symmetricDiff(others: ArrayLike<T>): PageList<T>;
    symmetricDiffByKey(others: ArrayLike<T>, key: keyof T): PageList<T>;
    intersect(others: ArrayLike<T>): PageList<T>;
    intersectByKey<U>(others: ArrayLike<U>, key: keyof T & keyof U): PageList<T>;
    map<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): PageList<U>;
    flatMap<U, This = unknown>(f: (this: This, value: T, index: number, array: T[]) => ReadonlyArray<U> | U, params?: This): PageList<U>;
    mapDefined<U>(f: (value: T, index: number, array: T[]) => U, params?: unknown): PageList<NonNullable<U>>;
    mapAsync(f: (i: T) => Promise<T>): Promise<PageList<T>>;
    areEqual(...items: ArrayLike<T>): boolean;
    distinct(): PageList<T>;
    distinctByKey(key: keyof T): PageList<T>;
    distinctByValue(): PageList<T>;
    filter(p: (value: T, index: number, array: T[]) => unknown, params?: unknown): PageList<T>;
    accumulate(...keys: (keyof T)[]): PageList<T>;
    concat(...items: ConcatArray<T>[]): PageList<T>;
    concat(...items: (T | ConcatArray<T>)[]): PageList<T>;
    reverse(): PageList<T>;
    splice(start: number, deleteCount?: number): PageList<T>;
    splice(start: number, deleteCount: number, ...items: T[]): PageList<T>;
    remove(item: T): PageList<T>;
    replace(key: keyof T, item: T): PageList<T>;
    switch(item: T): PageList<T>;
    defined(): PageList<NonNullable<T>>;
    orElse(...alt: ArrayLike<T>): Optional<PageList<T>>;
    slice(start?: number, end?: number): PageList<T>;
    update<U = T>(p: (value: T, index: number, array: T[]) => unknown, val: T | ((v: U) => T)): PageList<T>;
    updateFirst<U = T>(p: (value: T, index: number, array: T[]) => unknown, val: T | ((v: U) => T)): PageList<T>;
    updateFirstById<U = T>(id: Id, val: T | ((v: U) => T)): PageList<T>;
    updateById<U = T>(id: Id, val: T | ((v: U) => T)): PageList<T>;
    private setPageOptions;
}
export declare const isPageList: <T>(l?: unknown) => l is PageList<T>;
export declare const toPageList: <T>(items?: T[], options?: Omit<PageOptions, "sort"> & {
    total?: number;
}) => PageList<T>;
export declare const asPageList: <T, U>(c: Construct<T>, items?: PageList<U>) => PageList<T>;