import { AfterViewInit, DoCheck, EventEmitter, IterableDiffers, KeyValueChanges, KeyValueDiffers, OnDestroy, OnInit } from '@angular/core';
import { LoggerService } from '@sowatech/shared/logger';
import { DsDatasourceDefaultConfig } from '@sowatech/shared/shared-config';
import { Subject } from 'rxjs';
import { AggregateFunctionsService } from './aggregate-functions.service';
import { CSVConfig, DatasourceCSVService } from './ds-csv/ds-csv.service';
import { FilterItem, FilterOperator, PaginationInfo, RefreshParams, RefreshResult, RefreshType, SortItem } from './ds-dtos.model';
import { FilterHelper } from './ds-filter-helper.service';
import { PaginationHelper } from './ds-pagination-helper.service';
import { RefreshParamsStoreHelper } from './ds-refreshparams-store.service';
import { SelectionListHelper } from './ds-selection-list-helper.service';
import { SortHelper } from './ds-sort-helper.service';
import * as i0 from "@angular/core";
type FieldName<T> = Extract<keyof T, string>;
type ModelId = any;
export declare class DatasourceComponent<Model = any, ExternalRefreshDto = any> implements OnInit, AfterViewInit, OnDestroy, DoCheck {
    private loggerService;
    private selectionList;
    private sortHelper;
    private filterHelper;
    private paginationHelper;
    private refreshParamsStoreHelper;
    private iterableDiffers;
    private keyValueDiffers;
    private config;
    private csvService;
    aggregateFunctions: AggregateFunctionsService<Model>;
    constructor(loggerService: LoggerService, selectionList: SelectionListHelper, sortHelper: SortHelper, filterHelper: FilterHelper, paginationHelper: PaginationHelper, refreshParamsStoreHelper: RefreshParamsStoreHelper, iterableDiffers: IterableDiffers, keyValueDiffers: KeyValueDiffers, config: DsDatasourceDefaultConfig, csvService: DatasourceCSVService, aggregateFunctions: AggregateFunctionsService<Model>);
    private readonly subscriptions;
    ngOnInit(): void;
    private onAfterViewInit;
    ngAfterViewInit(): void;
    ngDoCheck(): void;
    ngOnDestroy(): void;
    set sourceData(data: Model[]);
    /** Liste der Datensätze für die Datasource. Im Gegensatz zum `src` Input, wird das Array nicht direkt bearbeitet */
    readonly models: import("@angular/core").InputSignal<Model[]>;
    set _changeTracking(value: boolean);
    private hasChangeTracking;
    set doSetPageSize(value: number);
    storeKey: string;
    idfield: FieldName<Model>;
    set sortBy(fieldname: FieldName<Model>);
    autoSelect: boolean;
    /**
     * Refresh Mechanismus, der in der Datasource benutzt wird
     * @default internal
     */
    refreshType: import("@angular/core").ModelSignal<RefreshType>;
    /** externalRefreshCallback oder externalRefreshInput */
    isExternalRefresh: import("@angular/core").Signal<boolean>;
    private refreshTypeEffectFn;
    onAfterRefresh: Subject<void>;
    onBeforeRefresh: Subject<void>;
    onAfterInitDatasoure: Subject<void>;
    set externalRefresh(method: (params: RefreshParams) => Promise<RefreshResult<ExternalRefreshDto> | RefreshResult<Model>>);
    get externalRefresh(): (params: RefreshParams) => Promise<RefreshResult<ExternalRefreshDto> | RefreshResult<Model>>;
    private _externalRefresh;
    readonly externalRefreshParams: import("@angular/core").WritableSignal<RefreshParams>;
    readonly refreshResultRequested: import("@angular/core").OutputEmitterRef<RefreshParams>;
    readonly externalRefreshResult: import("@angular/core").InputSignal<RefreshResult<ExternalRefreshDto> | RefreshResult<Model>>;
    private externalRefreshResultEffectFn;
    dataBackup: Model[];
    private dataBackupIterableDiffer;
    private dataItemDifferDictionary;
    private initDataBackupDiffer;
    private getDataItemId;
    dataChanged: EventEmitter<DataChangeEvent>;
    private dataBackupChanged;
    get dataFiltered(): Model[];
    get hasData(): boolean;
    data: Model[];
    getDataItem(id: ModelId): Model;
    getDataDistinct(fieldname: string): Model[];
    focusNextOrFirstRow(): void;
    focusPreviousRow(): void;
    initDataSource(data: Model[]): Promise<void>;
    autoSelectFirstItem(): void;
    private autoDetectIdField;
    private blockedRefreshRequested;
    private blockCounter;
    get refreshIsBlocked(): boolean;
    addRefreshBlocker(): void;
    removeRefreshBlocker(catchUpRefresh?: boolean): void;
    private catchUpRefresh;
    refresh(): Promise<void>;
    private afterRefresh;
    refreshAggregateFunctionsExternal(): Promise<void>;
    private doInternalRefresh;
    getExternalRefreshParams(): RefreshParams;
    private externalRefreshRunning;
    private nextExternalRefresh?;
    private doExternalRefresh;
    private requestNewRefreshResult;
    private emitRefreshResultRequested;
    private setExternalRefreshParams;
    /**Für Inline Updates der externalRefreshParams */
    private updateExternalRefreshParams;
    private handleRefreshResult;
    private handleExternalRefreshResult;
    private pushModelsToArray;
    private getNextExternalRefreshResult;
    externalDataItem2ViewModel: (externalDataItem: ExternalRefreshDto) => Model;
    private getPageIndexById;
    downloadDataAsCSV(fileName?: string, config?: CSVConfig): Promise<void>;
    private assembleCSVName;
    private getCSVData;
    private externalCSVDataRefresh;
    setSort(field: string): void;
    get onSortItems(): Subject<Array<SortItem>>;
    getSortItems(): Array<SortItem>;
    sortAsc(fieldname: string, addSorting?: boolean): void;
    sortDesc(fieldname: string, addSorting?: boolean): void;
    sort(sortItems: SortItem | SortItem[]): void;
    clearSort(): void;
    setFixedSort(fieldnames: string[]): void;
    get onFilterItems(): Subject<Array<FilterItem>>;
    setFilter(filterItems: Array<FilterItem>): any;
    setFilter(fieldnames: string | string[], fieldvalues: string | string[], filteroperator?: FilterOperator): any;
    addFilter(filterItems: FilterItem[]): any;
    addFilter(fieldnames: string | string[], fieldvalues: string | string[], filteroperator?: FilterOperator): any;
    private filterItemsEqual;
    clearFilter(): void;
    getFilterItems(): Array<FilterItem>;
    getFirstFilterValueByFieldname(fieldnames: string[], filterOperator: FilterOperator): string;
    readonly onSelectedIdsChanges: Subject<any[]>;
    readonly onFocusedIdChanges: Subject<any>;
    readonly onFocus: Subject<any>;
    readonly notFoundSelectedIds: import("@angular/core").WritableSignal<any[]>;
    private initSelectionList;
    private checkSelectedIdsCanBeFound;
    get selectedCount(): number;
    get selectedIds(): ModelId[];
    isSelected(id: ModelId): boolean;
    private focusAfterRefreshId;
    focusAfterRefresh(id: ModelId): void;
    focus(id: ModelId, gotoPage?: boolean): Promise<void>;
    get focusedId(): ModelId;
    get focusedItem(): Model;
    setSelection(ids: ModelId[]): any;
    setSelection(id: ModelId): any;
    addSelection(ids: ModelId[]): any;
    addSelection(id: ModelId): any;
    removeSelection(id: ModelId): void;
    toggleSelection(id: ModelId): void;
    clearSelection(): void;
    selectAll(): void;
    onPaginationChanged: Subject<PaginationInfo>;
    private initPaginationHelper;
    setPageSize(pageSize: number): void;
    get paginationInfo(): PaginationInfo;
    gotoPage(pageIndex: number): void;
    gotoPageOfFocusedItem(): Promise<void>;
    get currentPageIndex(): number;
    get maxPageIndex(): number;
    toggleAllFilteredSelected(selectAllFiltered: boolean): void;
    private initRefreshParamsStoreHelper;
    private refreshParamsStore;
    private deepCopy;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceComponent<any, any>, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatasourceComponent<any, any>, "ds-datasource", never, { "sourceData": { "alias": "src"; "required": false; }; "models": { "alias": "models"; "required": false; "isSignal": true; }; "_changeTracking": { "alias": "changeTracking"; "required": false; }; "doSetPageSize": { "alias": "pageSize"; "required": false; }; "storeKey": { "alias": "store-key"; "required": false; }; "idfield": { "alias": "idfield"; "required": false; }; "sortBy": { "alias": "sortBy"; "required": false; }; "autoSelect": { "alias": "autoSelect"; "required": false; }; "refreshType": { "alias": "refreshType"; "required": false; "isSignal": true; }; "externalRefreshResult": { "alias": "externalRefreshResult"; "required": false; "isSignal": true; }; }, { "refreshType": "refreshTypeChange"; "onAfterRefresh": "onAfterRefresh"; "onBeforeRefresh": "onBeforeRefresh"; "onAfterInitDatasoure": "onAfterInitDatasoure"; "refreshResultRequested": "refreshResultRequested"; }, never, never, false, never>;
}
export declare class DataChangeEvent {
    dataItemChanges: {
        [id: string]: KeyValueChanges<any, any>;
    };
}
export {};