import * as i0 from '@angular/core';
import { EventEmitter, OnInit, AfterViewInit, OnDestroy, DoCheck, IterableDiffers, KeyValueDiffers, KeyValueChanges, ElementRef } from '@angular/core';
import { LoggerService } from '@sowatech/shared/logger';
import { DsDatasourceDefaultConfig, IDatasourceDefaultCSVConfig, PaginationInfoVariant } from '@sowatech/shared/shared-config';
import { Subject } from 'rxjs';
import * as i9 from '@angular/common';
import { DatePipe } from '@angular/common';
import { SelectItem } from '@sowatech/shared/@types';
import { I18nService } from '@sowatech/shared/utilities';
import * as i10 from '@angular/forms';
import * as i11 from '@sowatech/shared/global-keyboard-shortcuts';

declare class ISortItem {
    fieldname: string;
    reverse: boolean;
}
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[];
}
declare class IFilterItem {
    fieldnames: string[];
    fieldvalues: string[];
    filterOperator: FilterOperator;
}
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;
}
declare enum FilterOperator {
    StartsWith = 0,
    IsEqual = 1,
    Contains = 2,
    IsGreaterOrEqual = 3,
    IsLessOrEqual = 4
}
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;
}
interface AggregateItem<DTO = any> {
    fieldname: Extract<keyof DTO, string>;
    operator: AggregateFunctionOperator;
    includedData: 'selected' | 'all';
}
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;
}
/**
 * - 'page' - normaler refresh, bei dem 1 Page zurückgegeben wird
 * - 'aggregate-data' - refresh, bei dem nur die aggregate items geladen werden
 * - 'csv-export' - lädt alle datensätze für den csv-export
 */
type ExternalRefreshMode = 'page' | 'aggregate-data' | 'csv-export';
declare class RefreshParams {
    paginationInfo: PaginationInfo;
    sortItems: SortItem[];
    filterItems: FilterItem[];
    aggregateParam: AggregateParam;
    idField?: string;
    mode?: ExternalRefreshMode;
}
interface AggregateResult<T> {
    fieldname: Extract<keyof T, string>;
    operator: AggregateFunctionOperator;
    value: number;
}
declare class RefreshResult<T> {
    refreshParams: RefreshParams;
    data: T[];
    aggregateResults?: AggregateResult<T>[];
}
type AggregateFunctionOperator = 'sum' | 'min' | 'max' | 'count';
type AggregateFunctionFieldConfig<T> = {
    fieldname?: Extract<keyof T, string>;
    aggregateFunctions?: AggregateFunctionConfig[];
    includedAggregateData?: 'selected' | 'all';
    unit?: string;
    digitInfo?: string;
};
type AggregateFunctionDefinition = {
    defaultPrefix: string;
    calc: (values: number[]) => number | undefined;
};
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 */
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
}

/**
 * Helfer für AggregateFunctions.
 * Hier muss über die `init` Methode die datasource gesetzt werden
 * und es muss die `getVisibleColumns` methode von außen gesetzt werden
 */
declare class AggregateFunctionsService<ListItem> {
    private readonly subscriptions;
    readonly values: Partial<Record<keyof ListItem, AggregateFunctionValue[]>>;
    private listDatasource;
    getConfigs?: () => AggregateFunctionFieldConfig<ListItem>[];
    init(listDatasource: DatasourceComponent<ListItem>): void;
    recalc({ refreshIfNotVisible }?: {
        refreshIfNotVisible?: boolean;
    }): void;
    cleanUp(): void;
    getAggregateItems(): AggregateItem<ListItem>[];
    getAggregateItemsForSelectedData(): AggregateItem<ListItem>[];
    setByRefreshResult(result: RefreshResult<ListItem>): void;
    getValue(fieldName: keyof ListItem, operator: AggregateFunctionOperator): number | undefined;
    private getConfigsForSelectedData;
    private tryRecalcWithExternalRefresh;
    private recalcWithExternalRefresh;
    private recalcClientSide;
    private resetValues;
    private getColumnResult;
    private getAggregateValuesOfColumn;
    private getValuesOfSelectedItems;
    private getTypedValue;
    private columnHasAggregateFunctions;
    static ɵfac: i0.ɵɵFactoryDeclaration<AggregateFunctionsService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<AggregateFunctionsService<any>>;
}
declare const aggregateFunctionImplementations: Record<AggregateFunctionOperator, AggregateFunctionDefinition>;
type AggregateFunctionValue = {
    operator: AggregateFunctionOperator;
    value: number | undefined;
};

declare class DatasourceCSVService {
    private datePipe;
    private configService;
    private readonly locale;
    constructor(datePipe: DatePipe, configService: DsDatasourceDefaultConfig, locale: string);
    generateAndDownloadCSV<Model>(csvData: Model[], filename: string, config?: CSVConfig): void;
    private generateCSV;
    private createCSV;
    private removeNewline;
    private removeSeparator;
    private buildHeaderRow;
    private buildRow;
    private getContent;
    private isSelectItemArray;
    private createCell;
    private applyQuotes;
    private formatCSVField;
    private applyConfig;
    private readonly utf8BOM;
    private executeDownload;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceCSVService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DatasourceCSVService>;
}
interface CSVConfig extends IDatasourceDefaultCSVConfig {
    columns?: Array<CSVColumn>;
}
interface CSVColumn<Model = any> {
    fieldname: Extract<keyof Model, string>;
    text?: string;
    digitsInfo?: digitsInfo;
    dateformat?: DateFormat;
    type?: string;
    lookups?: Array<SelectItem> | Array<string>;
    trueValueText?: string;
    falseValueText?: string;
}
type digitsInfo = `${number}.${number}-${number}`;
type DateFormat = string;

declare class FilterHelper {
    private loggerService;
    constructor(loggerService: LoggerService);
    private filterStrategies;
    private items;
    onFilterItems: Subject<FilterItem[]>;
    get filterItems(): Array<FilterItem>;
    private getItemByFieldNames;
    getFirstValueByFieldname(fieldnames: string[], filterOperator: FilterOperator): string | null;
    clear(): void;
    add(filterItems: Array<FilterItem>): any;
    add(filterItem: FilterItem): any;
    set(filterItems: Array<FilterItem>): any;
    set(filterItem: FilterItem): any;
    execute(dataSourceBackup: Array<any>, dataSource: Array<any>): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FilterHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<FilterHelper>;
}

declare class PaginationHelper {
    constructor(config: DsDatasourceDefaultConfig);
    init(dsPaginationChangedEmitter: Subject<PaginationInfo>): void;
    private paginationChangedEmitter;
    get paginationInfo(): PaginationInfo;
    pageSize: number;
    setPageSize(pageSize: number, data: Array<any>): void;
    private _currentPageIndex;
    get currentPageIndex(): number;
    set currentPageIndex(value: number);
    private totalNumOfItems;
    private _maxPageIndex;
    get maxPageIndex(): number;
    private recalcMaxPageIndexAndTotalNum;
    execute(data: any[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PaginationHelper>;
}

declare class RefreshParamsStoreHelper {
    private readonly userProperties;
    private readonly destroyRef;
    init(storeKey: string, onAfterViewInit: Subject<void>, onFilterItems: Subject<Array<FilterItem>>, onSortItems: Subject<Array<SortItem>>, onPaginationChanged: Subject<PaginationInfo>, onSelectionChanged: Subject<Array<any>>, refreshDatasource: (filterItems: FilterItem[], sortItems: SortItem[], pageIndex?: number, selectedIds?: any[], pageSize?: number) => void): void;
    private storeKey;
    clearStorage(): void;
    loadFromStorage(): void;
    private refreshDatasource;
    private get filterItemsStoreKey();
    private onDatasourceFilterChanged;
    private get sortItemsStoreKey();
    private onDatasourceSortChanged;
    private get paginationStoreKey();
    private onDatasourcePaginationChanged;
    private get pageSizeStoreKey();
    private get selectionStoreKey();
    private onDatasourceSelectionChanged;
    static ɵfac: i0.ɵɵFactoryDeclaration<RefreshParamsStoreHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RefreshParamsStoreHelper>;
}

type Id = any;
declare class SelectionListHelper {
    private loggerService;
    constructor(loggerService: LoggerService);
    private selectedIds;
    private onSelectedIdsChanged;
    private onFocusedIdChanged;
    private onFocus;
    init(dsSelectedIdsChangedEmitter: Subject<Array<Id>>, dsFocusedIdChangedEventEmitter: Subject<Id>, dsFocusEventEmitter: Subject<Id>): void;
    private doSelectionAndFocusChanged;
    private doSelectionChanged;
    private doFocusChanged;
    set(ids: Id[]): any;
    set(id: Id): any;
    add(ids: Id[]): any;
    add(id: Id): any;
    remove(id: Id): void;
    clear(): void;
    contains(id: Id): boolean;
    getSelectedIds(): Id[];
    static ɵfac: i0.ɵɵFactoryDeclaration<SelectionListHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SelectionListHelper>;
}

declare class SortHelper {
    private fixedItems;
    private items;
    onSortItems: EventEmitter<SortItem[]>;
    get sortItems(): Array<SortItem>;
    clear(): void;
    add(sortItem: SortItem): void;
    setItem(sortItem: SortItem): void;
    setItems(sortItems: SortItem[]): void;
    /** @returns HasChanges */
    setFixedItems(sortItems: SortItem[]): boolean;
    private fixedItemsChanged;
    execute(dataSource: Array<any>): void;
    private getItemByFieldName;
    private getFixedItemByFieldName;
    private sortByMultiple;
    private compare;
    private emitSortItems;
    static ɵfac: i0.ɵɵFactoryDeclaration<SortHelper, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SortHelper>;
}

type FieldName<T> = Extract<keyof T, string>;
type ModelId = any;
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: i0.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: i0.ModelSignal<RefreshType>;
    /** externalRefreshCallback oder externalRefreshInput */
    isExternalRefresh: i0.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: i0.WritableSignal<RefreshParams>;
    readonly refreshResultRequested: i0.OutputEmitterRef<RefreshParams>;
    readonly externalRefreshResult: i0.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[];
    private readonly dataChange$;
    readonly dataSignal: i0.Signal<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, csvData?: Model[]): Promise<void>;
    private assembleCSVName;
    private getCSVData;
    private externalCSVDataRefresh;
    private getCsvExportRefreshParams;
    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: i0.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>;
}
declare class DataChangeEvent {
    dataItemChanges: {
        [id: string]: KeyValueChanges<any, any>;
    };
}

declare class DatasourceSelectionCheckboxComponent implements OnInit, OnDestroy {
    private subscriptions;
    ngOnInit(): void;
    ngOnDestroy(): void;
    datasource: DatasourceComponent;
    allowMultiSelect: boolean;
    selectId: any;
    /** Html Id Attribute for Input */
    ariaLabel: string;
    disable: boolean;
    checkboxControl: ElementRef<HTMLInputElement>;
    private toogleIsCheckedIfNesseary;
    private _isChecked;
    private multiSelectIsChecked;
    set isChecked(value: boolean);
    get isChecked(): boolean;
    private onSelectedIdsChanges;
    onClick($event: MouseEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceSelectionCheckboxComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatasourceSelectionCheckboxComponent, "ds-selection-checkbox", never, { "datasource": { "alias": "datasource"; "required": false; }; "allowMultiSelect": { "alias": "allowMultiSelect"; "required": false; }; "selectId": { "alias": "ds-select"; "required": false; }; "ariaLabel": { "alias": "aria-label"; "required": false; }; "disable": { "alias": "disable"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DatasourceFilterDirective implements OnInit, OnDestroy {
    private readonly logger;
    protected readonly dataCyFilterSignal: i0.WritableSignal<string>;
    set dsfilter(filter: string | Array<string>);
    filterMinLength: number;
    private get inputWithCheckedProperty();
    private assertInputWithCheckedProperty;
    set setDatasource(value: DatasourceComponent);
    set filterOperatorAsString(value: string);
    filterTrueValue: string;
    defaultFilterValues: string;
    private datasource;
    filterFields: string | string[];
    filterOperator: FilterOperator;
    private filterInput;
    get filterValue(): string;
    private get isInputChecked();
    private subscriptions;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private initDefaultFilter;
    private onFilterChanged;
    private resetFilter;
    onBlur(): void;
    onChange(): void;
    onInput(): void;
    private setOldValueFromDatasource;
    private resetOldValueToEmpty;
    private timeout;
    /** selbstgebauter debounce */
    private timeoutFilter;
    private oldFilter;
    private addFilter;
    private isEmpty;
    private allEmpty;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceFilterDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DatasourceFilterDirective, "[ds-filter]", never, { "dsfilter": { "alias": "ds-filter"; "required": false; }; "filterMinLength": { "alias": "ds-filter-minlength"; "required": false; }; "setDatasource": { "alias": "datasource"; "required": false; }; "filterOperatorAsString": { "alias": "ds-filter-operator"; "required": false; }; "filterTrueValue": { "alias": "ds-filter-true-value"; "required": false; }; "defaultFilterValues": { "alias": "ds-filter-default"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DatasourceFilterdisplayComponent implements OnInit, OnDestroy {
    private subscriptions;
    isFilterSet: boolean;
    ngOnInit(): void;
    ngOnDestroy(): void;
    datasource: DatasourceComponent;
    filterFieldsVisible: boolean;
    filterText: string;
    private onDatasourceFilterChanged;
    private isFilterSetCheck;
    private createFilterText;
    clearFilter(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceFilterdisplayComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatasourceFilterdisplayComponent, "ds-filterdisplay", never, { "datasource": { "alias": "datasource"; "required": false; }; "filterFieldsVisible": { "alias": "filterFieldsVisible"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DatasourceSortDirective implements OnInit, OnDestroy {
    sortField: string;
    datasource: DatasourceComponent;
    setIconLeft: boolean;
    sortIconAlign: 'left' | 'right';
    private nativeElement;
    constructor(el: ElementRef);
    private subscriptions;
    ngOnInit(): void;
    ngOnDestroy(): void;
    private onTableSortingChanged;
    private setClassNone;
    private setClassAsc;
    private setClassDesc;
    private setClassIconLeft;
    private removeClass;
    private addClass;
    protected onClick(event: PointerEvent): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceSortDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<DatasourceSortDirective, "[ds-sort]", never, { "sortField": { "alias": "ds-sort"; "required": false; }; "datasource": { "alias": "datasource"; "required": false; }; "setIconLeft": { "alias": "icon-left"; "required": false; }; "sortIconAlign": { "alias": "ds-sort-icon-align"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DatasourcePaginationInfoComponent implements OnDestroy {
    private loggerService;
    private i18n;
    constructor(loggerService: LoggerService, i18n: I18nService);
    set setDatasource(value: DatasourceComponent);
    variant: 'default' | 'compact';
    private readonly subscriptions;
    ngOnDestroy(): void;
    private datasource;
    itemNumberFrom: number;
    itemNumberTo: number;
    itemNumberTotal: number;
    private paginationChanged;
    getDataFromToDisplayText(from: number, to: number, total: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourcePaginationInfoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatasourcePaginationInfoComponent, "ds-pagination-info", never, { "setDatasource": { "alias": "datasource"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DatasourcePaginationComponent implements OnDestroy {
    private readonly subscriptions;
    ngOnDestroy(): void;
    pageItems: Array<PageItem>;
    pageSize: number;
    totalNumOfItems: number;
    set setDatasource(datasource: DatasourceComponent);
    variant: PaginationInfoVariant;
    /** Da this.datasource.currentPageIndex 0-basiert ist, speichert diese Variable die tatsächliche Seitenzahl (currentPageIndex + 1) */
    selectedPage: number;
    private datasource;
    hasPrevious: boolean;
    hasNext: boolean;
    previousPage(): void;
    nextPage(): void;
    updateSelectedPage(pageNumber: number): void;
    gotoPage(event: MouseEvent, pageIndex: number): void;
    private paginationChanged;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourcePaginationComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatasourcePaginationComponent, "ds-pagination", never, { "setDatasource": { "alias": "datasource"; "required": false; }; "variant": { "alias": "variant"; "required": false; }; }, {}, never, never, false, never>;
}
declare class PageItem {
    text: string;
    pageIndex: number;
    isCurrent: boolean;
}

declare class DatasourcePaginationSizeSelectorComponent implements OnInit, OnDestroy {
    constructor(config: DsDatasourceDefaultConfig);
    private subscriptions;
    ngOnInit(): void;
    ngOnDestroy(): void;
    set _pageSizes(values: Array<number>);
    pageSizes: Array<number>;
    set _pageSize(value: number);
    set setDatasource(datasource: DatasourceComponent);
    private datasource;
    datasourceDataCount: number;
    pageSize: number;
    setPageSize(value?: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourcePaginationSizeSelectorComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatasourcePaginationSizeSelectorComponent, "ds-pagination-size-selector", never, { "_pageSizes": { "alias": "pageSizes"; "required": false; }; "_pageSize": { "alias": "pageSize"; "required": false; }; "setDatasource": { "alias": "datasource"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DatasourceModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<DatasourceModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<DatasourceModule, [typeof DatasourceComponent, typeof DatasourceFilterDirective, typeof DatasourceFilterdisplayComponent, typeof DatasourceSortDirective, typeof DatasourcePaginationInfoComponent, typeof DatasourcePaginationComponent, typeof DatasourceSelectionCheckboxComponent, typeof DatasourcePaginationSizeSelectorComponent], [typeof i9.CommonModule, typeof i10.FormsModule, typeof i11.GlobalKeyboardShortcutsModule], [typeof DatasourceComponent, typeof DatasourceFilterDirective, typeof DatasourceFilterdisplayComponent, typeof DatasourceSortDirective, typeof DatasourcePaginationInfoComponent, typeof DatasourcePaginationComponent, typeof DatasourceSelectionCheckboxComponent, typeof DatasourcePaginationSizeSelectorComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<DatasourceModule>;
}

export { AggregateParam, DatasourceCSVService, DatasourceComponent, DatasourceFilterDirective, DatasourceFilterdisplayComponent, DatasourceModule, DatasourcePaginationComponent, DatasourcePaginationInfoComponent, DatasourcePaginationSizeSelectorComponent, DatasourceSelectionCheckboxComponent, DatasourceSortDirective, FilterItem, FilterOperator, IFilterItem, ISortItem, PageItem, PaginationInfo, RefreshParams, RefreshResult, RefreshType, SortItem, aggregateFunctionImplementations };
export type { AggregateFunctionConfig, AggregateFunctionDefinition, AggregateFunctionFieldConfig, AggregateFunctionOperator, AggregateItem, AggregateResult, CSVColumn, CSVConfig, DateFormat, ExternalRefreshMode, digitsInfo };