export declare class ISortItem {
    fieldname: string;
    reverse: boolean;
}
export declare class SortItem implements ISortItem {
    constructor(sortItemData: ISortItem);
    constructor(fieldname: string);
    constructor(fieldname: string, reverse: boolean);
    fieldname: string;
    reverse: boolean;
    static createSortItems(src: ISortItem[]): SortItem[];
}
export declare class IFilterItem {
    fieldnames: string[];
    fieldvalues: string[];
    filterOperator: FilterOperator;
}
export declare class FilterItem implements IFilterItem {
    constructor(filterItemData: IFilterItem);
    constructor(fieldnames: Array<string>, fieldvalue: string, filterOperator?: FilterOperator);
    constructor(fieldnames: Array<string>, fieldvalues: Array<string>, filterOperator?: FilterOperator);
    fieldnames: string[];
    fieldvalues: string[];
    filterOperator: FilterOperator;
    fieldnamesAreEqual(fieldnames: string[]): boolean;
    fieldnamesAreEqual(fieldname: string): boolean;
    get hasFieldValue(): boolean;
    valueMatchesFilter(comparer: (filtervalue: string) => boolean): boolean;
    static createFilterItems(src: IFilterItem[]): FilterItem[];
    equals(other: FilterItem): boolean;
    clone(): FilterItem;
}
export declare enum FilterOperator {
    StartsWith = 0,
    IsEqual = 1,
    Contains = 2,
    IsGreaterOrEqual = 3,
    IsLessOrEqual = 4
}
export declare class PaginationInfo {
    currentPageIndex: number;
    currentPageNumOfItems: number;
    maxPageIndex: number;
    totalNumOfItems: number;
    pageSize: number;
    /** falls gesetzt, wird beim externalRefresh der PageIndex anhand der Id raus gesucht */
    goToPageOfId?: string;
}
export interface AggregateItem<DTO = any> {
    fieldname: Extract<keyof DTO, string>;
    operator: AggregateFunctionOperator;
    includedData: 'selected' | 'all';
}
export declare class AggregateParam {
    items: AggregateItem[];
    /** falls includedData = 'selected' */
    selectedIds: string[];
    /**
     * wenn `true`: Beim Refresh werden nur die Aggregatfunktionen aktualisiert zurück gegeben.
     * Es werden nicht die Daten neu geladen.
     */
    aggregatesOnly: boolean;
}
export declare class RefreshParams {
    paginationInfo: PaginationInfo;
    sortItems: SortItem[];
    filterItems: FilterItem[];
    aggregateParam: AggregateParam;
    idField?: string;
}
export interface AggregateResult<T> {
    fieldname: Extract<keyof T, string>;
    operator: AggregateFunctionOperator;
    value: number;
}
export declare class RefreshResult<T> {
    refreshParams: RefreshParams;
    data: T[];
    aggregateResults?: AggregateResult<T>[];
}
export type AggregateFunctionOperator = 'sum' | 'min' | 'max' | 'count';
export type AggregateFunctionFieldConfig<T> = {
    fieldname?: Extract<keyof T, string>;
    aggregateFunctions?: AggregateFunctionConfig[];
    includedAggregateData?: 'selected' | 'all';
    unit?: string;
    digitInfo?: string;
};
export type AggregateFunctionDefinition = {
    defaultPrefix: string;
    calc: (values: number[]) => number | undefined;
};
export interface AggregateFunctionConfig {
    operator: AggregateFunctionOperator;
    /** @default GridColumn.unit */
    unit?: string;
    /** @default GridColumn.digitInfo */
    format?: string;
    /** @default AggregateFunctionDefinition.defaultPrefix // aus shared (z.B. 'sum' => 'Σ ') */
    prefix?: string;
}
/**Refresh Mechanismus, der in der Datasource benutzt wird */
export declare enum RefreshType {
    /**
     * Der Datasource werden alle Daten übergeben und sie kümmert sich selbst um das Managen der Daten
     */
    internal = 0,
    /**
     *In der Datasource wird ein Asynchroner Callback ("externalRefresh") gesetzt, der mit RefreshParams ein RefreshResult lädt
     */
    externalRefreshCallback = 1,
    /**
     * Das Laden der Daten passiert außerhalb der Datasource.
     * Es wird von einem Output (refreshResultRequested) ausgelöst und das Ergebnis wird per Input (externalRefreshResult) in die Datasource übergeben
     */
    externalRefreshInput = 2
}