@recursyve/nice-data-filter-kit 18.0.2 → 20.0.0

package/index.d.ts

@@ -1,5 +1,1681 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@recursyve/nice-data-filter-kit" />
-export * from './public-api';
+import { HttpHeaders, HttpContext, HttpParams, HttpClient } from '@angular/common/http';
+import * as i0 from '@angular/core';
+import { Type, TemplateRef, ApplicationRef, OnInit, OnDestroy, OnChanges, EventEmitter, SimpleChanges, ElementRef, PipeTransform, ModuleWithProviders, Provider, ChangeDetectorRef, Injector, DoCheck, QueryList, AfterContentInit, ViewContainerRef } from '@angular/core';
+import * as i2 from '@recursyve/nice-ui-kit.v2';
+import { HttpOptions, NiceHttpExceptionFactory, Constructor, AbstractConstructor, ExportStrategy, NiceMediaWatcherService, NiceAsyncTypeaheadProvider, NiceAsyncTypeaheadSearchResult } from '@recursyve/nice-ui-kit.v2';
+import * as rxjs from 'rxjs';
+import { Observable, Subject } from 'rxjs';
+import { Store, Query, EntityState, HashMap, EntityStore, QueryEntity, ActiveState } from '@datorama/akita';
+import * as i6 from '@angular/router';
+import { ActivatedRoute, Router } from '@angular/router';
+import { AddEntitiesOptions } from '@datorama/akita/src/lib/addEntities';
+import * as _recursyve_nice_data_filter_kit from '@recursyve/nice-data-filter-kit';
+import * as i16$1 from '@angular/material/bottom-sheet';
+import { MatBottomSheet } from '@angular/material/bottom-sheet';
+import * as i11 from '@angular/material/paginator';
+import { PageEvent, MatPaginator } from '@angular/material/paginator';
+import * as i14$2 from '@angular/material/sort';
+import { Sort, MatSort } from '@angular/material/sort';
+import * as i15 from '@angular/common';
+import * as i14 from '@angular/forms';
+import { ControlValueAccessor, FormGroupName } from '@angular/forms';
+import * as i7 from '@angular/material/button';
+import * as i8 from '@angular/material/icon';
+import * as i9 from '@angular/material/tooltip';
+import * as i10 from '@angular/material/card';
+import * as i12 from '@ngx-translate/core';
+import { TranslateService } from '@ngx-translate/core';
+import * as i13 from '@angular/material/table';
+import { MatTable } from '@angular/material/table';
+import * as i15$1 from '@angular/material/core';
+import { NativeDateAdapter } from '@angular/material/core';
+import { GeneratedFormGroup, GeneratedFormArray } from '@recursyve/ngx-form-generator';
+import * as i14$1 from '@angular/cdk/overlay';
+import { OverlayPositionBuilder, Overlay } from '@angular/cdk/overlay';
+import { Platform } from '@angular/cdk/platform';
+import * as i16 from '@angular/material/list';
+import * as i20 from '@angular/material/select';
+import * as i21 from '@angular/material/input';
+import * as i22 from '@angular/material/datepicker';
+import { MatDatepicker } from '@angular/material/datepicker';
+import * as i23 from '@angular/material/radio';
+import * as i25 from 'ngx-mask';
+import * as i18 from '@angular/material/badge';
+import { StoreConfigOptions } from '@datorama/akita/src/lib/storeConfig';
+import * as i22$1 from '@angular/material/form-field';
+import * as i25$1 from '@angular/material/button-toggle';
+import { MatCheckbox } from '@angular/material/checkbox';
+
+type Condition = "and" | "or";
+declare enum FilterOperatorTypes {
+    Equal = "equal",
+    NotEqual = "not_equal",
+    In = "in",
+    NotIn = "not_in",
+    Less = "less",
+    LessOrEqual = "less_or_equal",
+    Greater = "greater",
+    GreaterOrEqual = "greater_or_equal",
+    Between = "between",
+    NotBetween = "not_between",
+    IsNull = "is_null",
+    IsNotNull = "is_not_null",
+    BeginsWith = "begins_with",
+    NotBeginsWith = "not_begins_with",
+    EndsWith = "ends_with",
+    NotEndsWith = "not_ends_with",
+    Contains = "contains",
+    NotContains = "not_contains",
+    IsEmpty = "is_empty",
+    IsNotEmpty = "is_not_empty",
+    None = "none"
+}
+interface CustomOperator {
+    name: string;
+    where?: any;
+    having?: any;
+}
+type FilterOperators = FilterOperatorTypes | CustomOperator;
+interface RuleModel {
+    operation: FilterOperators;
+    value: unknown | unknown[];
+}
+interface QueryRuleModel extends RuleModel {
+    id: string;
+}
+interface QueryModel {
+    condition: Condition;
+    rules: (QueryRuleModel | QueryModel)[];
+}
+
+interface FilterParametersModel {
+    start?: number | null;
+    length?: number | null;
+    order?: OrderModel | null;
+    fallbackOrder?: OrderModel | OrderModel[] | null;
+    search?: string | null;
+    rules?: QueryModel[] | null;
+    draw?: number | null;
+    data?: object | null;
+    groupBy?: string | null;
+}
+interface FilterPageMode {
+    number: number;
+    size: number;
+}
+interface FilterSearchModel {
+    value: string;
+}
+interface OrderModel {
+    column?: string | null;
+    direction?: "asc" | "desc" | null;
+    nullLast?: boolean | null;
+}
+interface FilterQueryModel {
+    page?: FilterPageMode;
+    search?: FilterSearchModel;
+    query?: QueryModel;
+    order?: OrderModel | OrderModel[];
+    data?: object | undefined;
+    groupBy?: string;
+}
+interface FilterResultModel<T = any> {
+    values: T[];
+    total: number;
+    page?: {
+        number: number;
+        size: number;
+    };
+}
+declare enum FilterType {
+    Text = "text",
+    Number = "number",
+    Date = "date",
+    Select = "select",
+    Radio = "radio",
+    Options = "options"
+}
+type OptionsFilterSelectionMode = "radio" | "select";
+interface RadioFilterOptionConfiguration {
+    key: string;
+    name: string;
+}
+interface FilterOperatorsConfiguration {
+    id: string;
+    name: string;
+}
+interface FilterGroupConfiguration {
+    key: string;
+    name: string;
+}
+interface FilterBaseConfigurationModel {
+    type: FilterType;
+    operators: FilterOperatorsConfiguration[];
+    group?: FilterGroupConfiguration;
+    values?: unknown[];
+    lazyLoading?: boolean;
+    selectionMode?: OptionsFilterSelectionMode;
+    options?: RadioFilterOptionConfiguration[];
+    mask?: string;
+}
+interface FilterConfigurationModel extends FilterBaseConfigurationModel {
+    id: string;
+    name: string;
+}
+interface SelectFilterValue {
+    id: number;
+    name: string;
+}
+
+interface NiceHttpOptions {
+    headers?: HttpHeaders | {
+        [header: string]: string | string[];
+    };
+    context?: HttpContext;
+    params?: HttpParams | {
+        [param: string]: string | number | boolean | ReadonlyArray<string | number | boolean>;
+    };
+    reportProgress?: boolean;
+    withCredentials?: boolean;
+}
+interface QueryParams {
+    [param: string]: any;
+}
+interface NiceFilterApiDefinition {
+    filter(queryModel: FilterQueryModel, option?: HttpOptions): Observable<FilterResultModel>;
+    filterCount(queryModel: FilterQueryModel): Observable<number>;
+    downloadData(type: string, queryModel: FilterQueryModel): Observable<Blob>;
+    getPrintableHtml(queryModel: FilterQueryModel): Observable<string>;
+    getFilterConfig(option?: HttpOptions): Observable<FilterConfigurationModel[]>;
+    searchFilterValue(id: string, value: string, options?: HttpOptions): Observable<SelectFilterValue[]>;
+    searchFilterResourceValue(id: string, resourceId: number, options?: HttpOptions): Observable<SelectFilterValue>;
+}
+declare class NiceFilterApi<T> implements NiceFilterApiDefinition {
+    private filterApiUrl;
+    private path;
+    protected http: HttpClient;
+    constructor(filterApiUrl: string, path: string, http: HttpClient);
+    filter(queryModel: FilterQueryModel, option?: NiceHttpOptions): Observable<FilterResultModel<T>>;
+    filterCount(queryModel: FilterQueryModel): Observable<number>;
+    downloadData(type: string, queryModel: FilterQueryModel): Observable<Blob>;
+    getPrintableHtml(queryModel: FilterQueryModel): Observable<string>;
+    getFilterConfig(option?: NiceHttpOptions): Observable<FilterConfigurationModel[]>;
+    searchFilterValue(id: string, value: string, options?: HttpOptions): Observable<SelectFilterValue[]>;
+    searchFilterResourceValue(id: string, resourceId: number, options?: HttpOptions): Observable<SelectFilterValue>;
+    protected url(route?: string, queryParams?: object): string;
+    protected url(queryParams: object): string;
+    private transformUrlArgs;
+}
+interface HasNiceFilterApiDefinition {
+    exceptionFactory: NiceHttpExceptionFactory;
+    httpClient: HttpClient;
+    apiUrl: string;
+    path: string;
+    url(route?: string): string;
+    delete<T>(route?: string, options?: HttpOptions): Observable<T>;
+    get<T>(route?: string, options?: HttpOptions): Observable<T>;
+    patch<T>(route?: string, body?: any, options?: HttpOptions): Observable<T>;
+    post<T>(route?: string, body?: any, options?: HttpOptions): Observable<T>;
+    put<T>(route?: string, body?: any, options?: HttpOptions): Observable<T>;
+}
+type NiceFilterApiDefinitionCtor = Constructor<NiceFilterApiDefinition> & AbstractConstructor<NiceFilterApiDefinition>;
+declare const mixinNiceFilterApi: <T>(model?: Type<T>) => <C extends Constructor<HasNiceFilterApiDefinition>>(base: C) => NiceFilterApiDefinitionCtor & C;
+
+declare class NiceBaseListButtonsDirective {
+    template: TemplateRef<any>;
+    position: "prefix" | "suffix" | "search";
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListButtonsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceBaseListButtonsDirective, "[niceListButton]", never, { "position": { "alias": "position"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceBaseListTitleDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListTitleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceBaseListTitleDirective, "[niceListTitle]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceBaseListTableDirective {
+    template: TemplateRef<any>;
+    stickyHeader: boolean;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListTableDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceBaseListTableDirective, "[niceListTable]", never, { "stickyHeader": { "alias": "stickyHeader"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceBaseListCardsDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListCardsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceBaseListCardsDirective, "[niceListCards]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceBaseListCustomContentDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListCustomContentDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceBaseListCustomContentDirective, "[niceListContent]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceBaseListEmptyStateDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListEmptyStateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceBaseListEmptyStateDirective, "[niceListEmptyState]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceBaseListFiltersDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListFiltersDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceBaseListFiltersDirective, "[niceListFilters]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceBaseListEmptySearchResultStateDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListEmptySearchResultStateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceBaseListEmptySearchResultStateDirective, "[niceListEmptySearchResultState]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceBaseListDirectiveModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListDirectiveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceBaseListDirectiveModule, [typeof NiceBaseListButtonsDirective, typeof NiceBaseListTitleDirective, typeof NiceBaseListTableDirective, typeof NiceBaseListCardsDirective, typeof NiceBaseListCustomContentDirective, typeof NiceBaseListEmptyStateDirective, typeof NiceBaseListFiltersDirective, typeof NiceBaseListEmptySearchResultStateDirective], never, [typeof NiceBaseListButtonsDirective, typeof NiceBaseListTitleDirective, typeof NiceBaseListTableDirective, typeof NiceBaseListCardsDirective, typeof NiceBaseListCustomContentDirective, typeof NiceBaseListEmptyStateDirective, typeof NiceBaseListFiltersDirective, typeof NiceBaseListEmptySearchResultStateDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceBaseListDirectiveModule>;
+}
+
+interface TableColumnsModel {
+    id: string;
+    sortable?: boolean;
+}
+declare class TableColumns implements TableColumnsModel {
+    id: string;
+    sortable: boolean;
+    nullLast: boolean;
+    constructor(id: string, sortable?: boolean, nullLast?: boolean);
+}
+
+interface ExportSettings {
+    xlsx: boolean;
+    csv: boolean;
+    pdf: boolean;
+}
+
+type NiceBaseListIcons = {
+    matIcon: string;
+    svgIcon?: string;
+} | {
+    matIcon?: string;
+    svgIcon: string;
+} | {
+    class: string;
+    matIcon?: string;
+    svgIcon?: string;
+};
+interface NiceBaseIconOptions {
+    search?: NiceBaseListIcons;
+    queryBuilder?: NiceBaseListIcons;
+    close?: NiceBaseListIcons;
+    print?: NiceBaseListIcons;
+    download?: NiceBaseListIcons;
+}
+declare const defaultIcons: NiceBaseIconOptions;
+
+type AvailableLayoutItem = "title" | "search" | "prefixButtons" | "suffixButtons" | "exportButtons" | "content" | "pagination" | "queryBuilder" | "filters";
+declare enum LayoutContent {
+    Table = "table",
+    Cards = "cards",
+    Custom = "custom"
+}
+interface LayoutItem {
+    name: AvailableLayoutItem;
+    flex?: string;
+    align?: string;
+    classes?: string[];
+}
+interface Layout {
+    classes?: string[];
+    items: (LayoutItem | Layout)[];
+}
+type BaseListPageLayout = (LayoutItem | Layout);
+interface BaseListLayout {
+    default: Layout | BaseListPageLayout[];
+    xs?: Layout | BaseListPageLayout[];
+    sm?: Layout | BaseListPageLayout[];
+    md?: Layout | BaseListPageLayout[];
+    lg?: Layout | BaseListPageLayout[];
+    xl?: Layout | BaseListPageLayout[];
+}
+declare const defaultLayout: BaseListLayout;
+
+interface INiceFilterService<T> {
+    getFilterConfig(option: NiceHttpOptions): Observable<FilterConfigurationModel[]>;
+    filter(params: FilterParametersModel, option: NiceHttpOptions): Observable<FilterResultModel<T>>;
+    getFile(type: string, parameters: FilterParametersModel): Observable<Blob>;
+    getPrintableHtml(parameters: FilterParametersModel): Observable<string>;
+}
+declare class NiceFilterService<T> implements INiceFilterService<T> {
+    protected api?: NiceFilterApiDefinition;
+    constructor(api?: NiceFilterApiDefinition);
+    filter(params: FilterParametersModel, option?: NiceHttpOptions): Observable<FilterResultModel<T>>;
+    getFile(type: string, parameters: FilterParametersModel): Observable<Blob>;
+    getPrintableHtml(parameters: FilterParametersModel): Observable<string>;
+    getFilterConfig(option?: NiceHttpOptions): Observable<FilterConfigurationModel[]>;
+    searchFilterValue(filterConfig: FilterConfigurationModel, value: string, options?: HttpOptions): Observable<SelectFilterValue[]>;
+    searchFilterResourceValue(filterConfig: FilterConfigurationModel, resourceId: number, options?: HttpOptions): Observable<SelectFilterValue>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceFilterService<any>>;
+}
+
+interface NiceSavedReportDto {
+    name: string;
+    table: string;
+    content: string;
+    scope: string;
+}
+
+interface NiceSavedReports {
+    table: string;
+    name: string;
+    content: string;
+}
+
+declare class NiceSavedReportsApi {
+    private filterApiUrl;
+    private path;
+    protected http: HttpClient;
+    constructor(filterApiUrl: string, path: string, http: HttpClient);
+    create(dto: NiceSavedReportDto): Observable<NiceSavedReports>;
+    getAll(): Observable<NiceSavedReports[]>;
+    getByTable(table: string): Observable<NiceSavedReports[]>;
+    getTopByTable(table: string | undefined): Observable<NiceSavedReports[]>;
+    hit(id: number): Observable<void>;
+    update(id: number, dto: NiceSavedReportDto): Observable<NiceSavedReports>;
+    delete(id: number): Observable<void>;
+    protected url(route?: string, queryParams?: object): string;
+    protected url(queryParams: object): string;
+    private transformUrlArgs;
+}
+
+declare class NiceSavedReportService {
+    private api;
+    constructor(api: NiceSavedReportsApi);
+    create(report: NiceSavedReportDto): Observable<NiceSavedReports>;
+    update(id: number, report: NiceSavedReportDto): Observable<NiceSavedReports>;
+    remove(id: number): Observable<void>;
+    getByTableName(table: string): Observable<NiceSavedReports[]>;
+    getTopByTableName(table: string): Observable<NiceSavedReports[]>;
+    hit(id: number): Observable<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSavedReportService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceSavedReportService>;
+}
+
+interface NiceBaseListState {
+    loading?: boolean;
+    disabled: boolean;
+    mergePageResults: boolean;
+    resetPaging: boolean;
+    filterConfigLoading: boolean;
+    filterResult: FilterResultModel | null;
+    filterParameters: FilterParametersModel;
+    filterConfig: FilterConfigurationModel[];
+    showQueryBuilder: boolean;
+    defaultRules: (QueryRuleModel | QueryModel)[];
+    queryParams: any;
+}
+declare const initialBaseListState: NiceBaseListState;
+declare class NiceBaseListStore<T extends NiceBaseListState = NiceBaseListState> extends Store<T> {
+    constructor(parameters: FilterParametersModel, defaultRules: QueryModel[]);
+    setFilterConfigLoading(loading: boolean): void;
+    setResult(filterResult: FilterResultModel, reset?: boolean): void;
+    setParameters(filterParameters: FilterParametersModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListStore<any>, [{ optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceBaseListStore<any>>;
+}
+
+declare class NiceBaseListQuery<T extends NiceBaseListState = NiceBaseListState> extends Query<T> {
+    protected store: NiceBaseListStore<T>;
+    constructor(store: NiceBaseListStore<T>);
+    selectEmpty(): Observable<boolean>;
+    selectSearchResultEmpty(): Observable<boolean>;
+    selectData(): Observable<any[]>;
+    selectFilterParameters(): Observable<FilterParametersModel>;
+    selectFilterResult(): Observable<FilterResultModel | null>;
+    selectFilterConfig(): Observable<FilterConfigurationModel[]>;
+    selectFilterConfigLoading(): Observable<boolean>;
+    selectShowQueryBuilder(): Observable<boolean>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListQuery<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceBaseListQuery<any>>;
+}
+
+declare class NiceBaseListService<Filter extends NiceFilterService<any> = NiceFilterService<any>> {
+    protected store: NiceBaseListStore;
+    protected filterService: Filter;
+    protected disableQueryParams: boolean;
+    protected activatedRoute: ActivatedRoute;
+    protected router: Router;
+    protected appRef: ApplicationRef;
+    queryParamsLoaded$: Subject<unknown>;
+    protected downloadFileName: string;
+    protected unsubscribeAll$: Subject<void>;
+    protected loadingData: boolean;
+    constructor(store: NiceBaseListStore, filterService: Filter, disableQueryParams: boolean, activatedRoute: ActivatedRoute, router: Router, appRef: ApplicationRef);
+    get filter(): Filter;
+    init(configQueryParams?: QueryParams): Promise<void>;
+    resetStore(): void;
+    resetData(): void;
+    closeSubscriptions(): void;
+    disableList(): void;
+    enableList(): void;
+    setLoading(loading: boolean): void;
+    setMode(mode: "normal" | "infinite-scroll"): void;
+    setQueryParams(queryParams: any): void;
+    loadQueryParams(autoLoad: boolean): void;
+    resetAndLoadData(parameters?: FilterParametersModel, updateQueryParams?: boolean): Promise<void>;
+    loadData(parameters?: FilterParametersModel, updateQueryParams?: boolean, reset?: boolean): Promise<void>;
+    searchData(search: string): Promise<void>;
+    loadNewPage(start: number, length: number): Promise<void>;
+    loadNextPage(): Promise<void>;
+    resetPaging(): void;
+    downloadData(type: string, parameters?: FilterParametersModel, updateQueryParams?: boolean): Promise<void>;
+    printData(parameters?: FilterParametersModel, updateQueryParams?: boolean): Promise<void>;
+    updateRule(id: string, newRule: QueryRuleModel): void;
+    updateDefaultRules(rule: (QueryRuleModel | QueryModel)[]): void;
+    updateGlobalRules(rules: QueryModel[], updateQueryParams?: boolean, reset?: boolean): Promise<void>;
+    addRuleFromConfig(config: FilterConfigurationModel): void;
+    updateRules(rules: QueryRuleModel[]): void;
+    toggleQueryBuilder(): void;
+    addListValue(value: any, opts?: AddEntitiesOptions): void;
+    updateListValue(value: any, key?: string): void;
+    removeListValue(value: any, key?: string): void;
+    getParameters(filterParameters?: FilterParametersModel): FilterParametersModel;
+    protected updateQueryParams(queryParams: any): Promise<void>;
+    private mergeParameters;
+    private setParameters;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceBaseListService<any>>;
+}
+
+declare class NiceBaseListComponent<Filter extends NiceFilterService<any> = NiceFilterService<any>> implements OnInit, OnDestroy, OnChanges {
+    enableQueryBuilder: boolean;
+    icons: NiceBaseIconOptions;
+    listLayout: BaseListLayout;
+    columns: TableColumns[];
+    private readonly exportsSettings;
+    readonly query: NiceBaseListQuery;
+    readonly service: NiceBaseListService<Filter>;
+    private readonly activatedRoute;
+    private readonly bottomSheet;
+    private readonly router;
+    private readonly mediaWatcher;
+    title: TemplateRef<any>;
+    buttons: NiceBaseListButtonsDirective[];
+    table: NiceBaseListTableDirective;
+    cards: TemplateRef<any>;
+    customContent: TemplateRef<any>;
+    filters: TemplateRef<any>;
+    emptyState: TemplateRef<any>;
+    emptySearchResultState: TemplateRef<any>;
+    mode: "normal" | "infinite-scroll";
+    layout: "page" | "component";
+    layoutContent: LayoutContent;
+    autoChangeLayout: boolean;
+    baseRoute: string;
+    routeFn: (item: any) => string | string[];
+    navigateFn: (baseRoute: string, item: any) => string;
+    autoLoad: boolean;
+    pageTitle: string;
+    canExport: boolean;
+    disableRouting: boolean;
+    customExport: ExportStrategy[];
+    queryParams: QueryParams;
+    configQueryParams: QueryParams;
+    newPage: EventEmitter<PageEvent>;
+    defaultPageSizeOptions: number[];
+    columnNames: string[];
+    loading$: Observable<boolean>;
+    filterResult$: Observable<_recursyve_nice_data_filter_kit.FilterResultModel<any>>;
+    data$: Observable<any[]>;
+    recordsFiltered$: Observable<number>;
+    isEmpty$: Observable<boolean>;
+    isSearchResultEmpty$: Observable<boolean>;
+    showQueryBuilder$: Observable<boolean>;
+    filterParameters$: Observable<_recursyve_nice_data_filter_kit.FilterParametersModel>;
+    index$: Observable<number>;
+    length$: Observable<number>;
+    searchQuery$: Observable<string>;
+    filterConfig$: Observable<FilterConfigurationModel[]>;
+    sortColumn$: Observable<string>;
+    sortDirection$: Observable<"" | "asc" | "desc">;
+    filterConfigLoading$: Observable<boolean>;
+    rules$: Observable<QueryModel[]>;
+    rulesCount$: Observable<number>;
+    xsActive$: Observable<boolean>;
+    smActive$: Observable<boolean>;
+    mdActive$: Observable<boolean>;
+    lgActive$: Observable<boolean>;
+    xlActive$: Observable<boolean>;
+    defaultActive$: Observable<boolean>;
+    private searchText$;
+    constructor(enableQueryBuilder: boolean, icons: NiceBaseIconOptions, listLayout: BaseListLayout, columns: TableColumns[], exportsSettings: ExportSettings, query: NiceBaseListQuery, service: NiceBaseListService<Filter>, activatedRoute: ActivatedRoute, bottomSheet: MatBottomSheet, router: Router, mediaWatcher: NiceMediaWatcherService);
+    get prefixButtons(): TemplateRef<any> | undefined;
+    get suffixButtons(): TemplateRef<any> | undefined;
+    get searchButtons(): TemplateRef<any> | undefined;
+    ngOnInit(): Promise<void>;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    setLoading(loading: boolean): void;
+    clickToggleShowQueryBuilder(): void;
+    onUpdateRules(rules: QueryModel[]): void;
+    onQueryBuilderFilterSelected(filterConfigurationModel: FilterConfigurationModel): void;
+    onUpdatePage(pageEvent: PageEvent): void;
+    onUpdateSearch(search: string): void;
+    getFilterRule$(id: string): Observable<QueryRuleModel | undefined>;
+    onUpdateSort(sort: Sort): void;
+    updateRule(id: string, newRule: QueryRuleModel): void;
+    updateRules(rules: QueryRuleModel[]): void;
+    clickExport(): void;
+    navigate(item: any): void;
+    clickXlsx(): void;
+    clickCsv(): void;
+    clickPrint(): void;
+    clickPdf(): void;
+    setColumns(columns: TableColumns[]): void;
+    addColumns(columns: TableColumns[], prepend?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListComponent<any>, [{ optional: true; }, null, null, null, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceBaseListComponent<any>, "nice-base-list", never, { "mode": { "alias": "mode"; "required": false; }; "layout": { "alias": "layout"; "required": false; }; "layoutContent": { "alias": "layoutContent"; "required": false; }; "autoChangeLayout": { "alias": "autoChangeLayout"; "required": false; }; "baseRoute": { "alias": "baseRoute"; "required": false; }; "routeFn": { "alias": "routeFn"; "required": false; }; "navigateFn": { "alias": "navigateFn"; "required": false; }; "autoLoad": { "alias": "autoLoad"; "required": false; }; "pageTitle": { "alias": "pageTitle"; "required": false; }; "canExport": { "alias": "canExport"; "required": false; }; "disableRouting": { "alias": "disableRouting"; "required": false; }; "customExport": { "alias": "customExport"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "configQueryParams": { "alias": "configQueryParams"; "required": false; }; }, { "newPage": "newPage"; }, ["title", "table", "cards", "customContent", "filters", "emptyState", "emptySearchResultState", "buttons"], never, false, never>;
+}
+
+declare abstract class NiceFilterGroupService<T> {
+    abstract getFilterGroupIconClass(group: T): string | NiceBaseListIcons;
+}
+
+interface NiceQueryBuilderIconOptions {
+    add?: NiceBaseListIcons;
+    refresh?: NiceBaseListIcons;
+    delete?: NiceBaseListIcons;
+    arrowDown?: NiceBaseListIcons;
+    datePicker?: NiceBaseListIcons;
+}
+
+declare class QueryRuleForm {
+    id: string;
+    operation: string;
+    value: any;
+    secondValue: any;
+    constructor(rule: QueryRuleModel);
+    transform(): QueryRuleModel;
+}
+declare class QueryForm {
+    condition: string;
+    rules: QueryRuleForm[];
+}
+declare class QueryBuilderForm {
+    rules: QueryForm[];
+    constructor(rules: QueryModel[]);
+    transform(): QueryModel[];
+}
+
+declare class NiceQueryBuilderComponent implements ControlValueAccessor {
+    icons: NiceQueryBuilderIconOptions;
+    formGroup: GeneratedFormGroup<QueryBuilderForm>;
+    filterConfigs: FilterConfigurationModel[] | null;
+    currentSavedReport: NiceSavedReports | null;
+    loading: boolean;
+    close: EventEmitter<any>;
+    createReport: EventEmitter<any>;
+    updateReport: EventEmitter<any>;
+    rules: GeneratedFormArray<QueryForm>;
+    get canSave(): boolean;
+    private propagateChanges;
+    constructor(icons: NiceQueryBuilderIconOptions, formGroup: GeneratedFormGroup<QueryBuilderForm>);
+    registerOnChange(fn: (rules: QueryModel[]) => void): void;
+    registerOnTouched(fn: any): void;
+    writeValue(rules: QueryModel[]): void;
+    onClickAddRule(filterConfigurationModel: FilterConfigurationModel): void;
+    onClickDeleteRule(id: number): void;
+    onClickApply(): void;
+    onClickSaveReport(): void;
+    onClickUpdateReport(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceQueryBuilderComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceQueryBuilderComponent, "nice-query-builder", never, { "filterConfigs": { "alias": "filterConfigs"; "required": false; }; "currentSavedReport": { "alias": "currentSavedReport"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "close": "close"; "createReport": "createReport"; "updateReport": "updateReport"; }, never, never, false, never>;
+}
+
+declare class QueryBuilderTriggerDirective {
+    private overlayPositionBuilder;
+    private elementRef;
+    private overlay;
+    private platform;
+    private overlayRef;
+    private filterSelectionRef;
+    private _queryBuilderFilters;
+    private _queryBuilderFiltersLoading;
+    set queryBuilderFilters(queryBuilderFilters: FilterConfigurationModel[] | null);
+    set queryBuilderFiltersLoading(queryBuilderFiltersLoading: boolean);
+    queryBuilderFilterSelected: EventEmitter<FilterConfigurationModel>;
+    constructor(overlayPositionBuilder: OverlayPositionBuilder, elementRef: ElementRef, overlay: Overlay, platform: Platform);
+    click(): void;
+    private close;
+    private updateFilterSelectionComponent;
+    private isMobile;
+    static ɵfac: i0.ɵɵFactoryDeclaration<QueryBuilderTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QueryBuilderTriggerDirective, "[niceQueryBuilderTrigger]", never, { "queryBuilderFilters": { "alias": "queryBuilderFilters"; "required": false; }; "queryBuilderFiltersLoading": { "alias": "queryBuilderFiltersLoading"; "required": false; }; }, { "queryBuilderFilterSelected": "queryBuilderFilterSelected"; }, never, never, false, never>;
+}
+
+declare class FilterSelectionComponent {
+    filterConfigs: FilterConfigurationModel[];
+    loading: boolean;
+    filterSelected: EventEmitter<FilterConfigurationModel>;
+    get filterGroups(): [FilterGroupConfiguration, FilterConfigurationModel[]][];
+    selectFilter(filterConfigurationModel: FilterConfigurationModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSelectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSelectionComponent, "nice-filter-selection", never, { "filterConfigs": { "alias": "filterConfigs"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; }, { "filterSelected": "filterSelected"; }, never, never, false, never>;
+}
+
+declare class RuleComponent implements OnInit {
+    icons: NiceQueryBuilderIconOptions;
+    private formGroupName;
+    filterConfigs: FilterConfigurationModel[] | null;
+    remove: EventEmitter<any>;
+    formGroup: GeneratedFormGroup<QueryForm>;
+    rules: GeneratedFormArray<QueryRuleForm>;
+    filterOperator: FilterOperators;
+    get filterConfig(): FilterConfigurationModel;
+    get isSingleInput(): boolean;
+    get isDoubleInput(): boolean;
+    get isNoInput(): boolean;
+    constructor(icons: NiceQueryBuilderIconOptions, formGroupName: FormGroupName);
+    ngOnInit(): void;
+    onUpdateFilterConfig(config: FilterConfigurationModel): void;
+    onClickOr(): void;
+    onUpdateFilterOperator(operator: string): void;
+    onClickDelete(index: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RuleComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RuleComponent, "nice-rule", never, { "filterConfigs": { "alias": "filterConfigs"; "required": false; }; }, { "remove": "remove"; }, never, never, false, never>;
+}
+
+declare class FilterComponent$1<T> implements ControlValueAccessor {
+    private _value;
+    get value(): T | undefined;
+    protected propagateChanges: (_: T) => void;
+    registerOnTouched(fn: any): void;
+    registerOnChange(fn: (_: T) => void): void;
+    writeValue(value: T): void;
+    onValueChange(value: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent$1<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent$1<any>, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class SelectFilterComponent extends FilterComponent$1<unknown> implements OnInit, OnDestroy, OnChanges {
+    protected filterService: NiceFilterService<any>;
+    filterConfig: FilterConfigurationModel;
+    values: SelectFilterValue[];
+    search$: Subject<string>;
+    private searchSub$;
+    constructor(filterService: NiceFilterService<any>);
+    ngOnInit(): Promise<void>;
+    ngOnChanges(changes: SimpleChanges): void;
+    private searchValue;
+    onValueChange(value: unknown): void;
+    ngOnDestroy(): void;
+    writeValue(value: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SelectFilterComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SelectFilterComponent, "nice-select-filter", never, { "filterConfig": { "alias": "filterConfig"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class TextFilterComponent extends FilterComponent$1<string> {
+    filterConfig: FilterConfigurationModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextFilterComponent, "nice-text-filter", never, { "filterConfig": { "alias": "filterConfig"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NumberFilterComponent extends FilterComponent$1<number> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NumberFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NumberFilterComponent, "nice-number-filter", never, {}, {}, never, never, false, never>;
+}
+
+declare class RadioFilterComponent extends FilterComponent$1<string> {
+    filterConfig: FilterConfigurationModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RadioFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RadioFilterComponent, "nice-radio-filter", never, { "filterConfig": { "alias": "filterConfig"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DateFilterComponent extends FilterComponent$1<string> {
+    icons: NiceQueryBuilderIconOptions;
+    constructor(icons: NiceQueryBuilderIconOptions);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DateFilterComponent, [{ optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DateFilterComponent, "nice-date-filter", never, {}, {}, never, never, false, never>;
+}
+
+declare class FilterGroupIconPipe implements PipeTransform {
+    private service?;
+    constructor(service?: NiceFilterGroupService<any>);
+    transform(value: string): NiceBaseListIcons;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterGroupIconPipe, [{ optional: true; }]>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FilterGroupIconPipe, "filterGroupIcon", false>;
+}
+
+interface QueryBuilderGlobalOptions {
+    icons?: NiceQueryBuilderIconOptions;
+}
+declare class NiceQueryBuilderModule {
+    static forRoot(options?: QueryBuilderGlobalOptions): ModuleWithProviders<NiceQueryBuilderModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceQueryBuilderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceQueryBuilderModule, [typeof NiceQueryBuilderComponent, typeof QueryBuilderTriggerDirective, typeof FilterSelectionComponent, typeof RuleComponent, typeof SelectFilterComponent, typeof TextFilterComponent, typeof NumberFilterComponent, typeof RadioFilterComponent, typeof DateFilterComponent, typeof FilterGroupIconPipe], [typeof i15.CommonModule, typeof i14.FormsModule, typeof i12.TranslateModule, typeof i14$1.OverlayModule, typeof i10.MatCardModule, typeof i16.MatListModule, typeof i7.MatButtonModule, typeof i15$1.MatRippleModule, typeof i8.MatIconModule, typeof i20.MatSelectModule, typeof i21.MatInputModule, typeof i22.MatDatepickerModule, typeof i23.MatRadioModule, typeof i2.NiceLoadingSpinnerModule, typeof i2.NiceTypeaheadModule, typeof i14.ReactiveFormsModule, typeof i25.NgxMaskDirective], [typeof NiceQueryBuilderComponent, typeof QueryBuilderTriggerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceQueryBuilderModule>;
+}
+
+interface BaseListOptions<T> {
+    table: string;
+    columns: TableColumns[];
+    filterService: Type<NiceFilterService<T>>;
+    defaultRules?: QueryModel[];
+    defaultParameters?: FilterParametersModel;
+    layout?: BaseListLayout;
+    exports?: ExportSettings;
+    disableQueryBuilder?: boolean;
+    disableQueryParams?: boolean;
+    queryBuilder?: {
+        filterGroupService: Type<NiceFilterGroupService<any>>;
+        savedReportService?: Type<NiceSavedReportService>;
+    };
+}
+interface BaseListGlobalOptions {
+    layout?: BaseListLayout;
+    icons?: NiceBaseIconOptions;
+    queryBuilder?: {
+        filterGroupService: Type<NiceFilterGroupService<any>>;
+        savedReportService?: Type<NiceSavedReportService>;
+    };
+}
+declare class NiceBaseListModule {
+    static forRoot(options?: BaseListGlobalOptions): ModuleWithProviders<NiceBaseListModule>;
+    static providerFactory<T>(options: BaseListOptions<T>): Provider[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceBaseListModule, [typeof NiceBaseListComponent], [typeof i2.NiceExportBottomSheetModule, typeof NiceBaseListDirectiveModule, typeof i15.CommonModule, typeof i14.FormsModule, typeof i6.RouterModule, typeof i7.MatButtonModule, typeof i8.MatIconModule, typeof i9.MatTooltipModule, typeof i10.MatCardModule, typeof i11.MatPaginatorModule, typeof i12.TranslateModule, typeof i2.NiceLoadingSpinnerModule, typeof i13.MatTableModule, typeof i14$2.MatSortModule, typeof i15$1.MatRippleModule, typeof i16$1.MatBottomSheetModule, typeof NiceQueryBuilderModule, typeof i18.MatBadgeModule], [typeof NiceBaseListComponent, typeof NiceBaseListDirectiveModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceBaseListModule>;
+}
+
+declare class NiceListState {
+    table: string;
+    columns: TableColumns[];
+    defaultParameters?: FilterParametersModel;
+}
+interface ListStates {
+    [state: string]: NiceListState;
+}
+
+declare class NiceMultiStateFilterService extends NiceFilterService<any> {
+    protected filters: {
+        [state: string]: NiceFilterApiDefinition;
+    };
+    protected constructor(filters: {
+        [state: string]: NiceFilterApiDefinition;
+    });
+    switchState(state: string): void;
+}
+
+interface NiceMultiStateListState extends NiceBaseListState {
+}
+declare const initialValue: NiceMultiStateListState;
+declare class NiceMultiStateListStore extends NiceBaseListStore<NiceMultiStateListState> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceMultiStateListStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceMultiStateListStore>;
+}
+
+declare class NiceMultiStateListQuery extends NiceBaseListQuery<NiceMultiStateListState> {
+    protected store: NiceMultiStateListStore;
+    constructor(store: NiceMultiStateListStore);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceMultiStateListQuery, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceMultiStateListQuery>;
+}
+
+declare class NiceMultiStateListService extends NiceBaseListService {
+    private states;
+    private multiFilterService;
+    constructor(states: ListStates, disableQueryParams: boolean, store: NiceMultiStateListStore, activatedRoute: ActivatedRoute, router: Router, appRef: ApplicationRef, multiFilterService: NiceMultiStateFilterService);
+    reset(): void;
+    setStateDefaultFilter(state: string, parameters: FilterParametersModel): void;
+    switchState(state: string): TableColumns[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceMultiStateListService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceMultiStateListService>;
+}
+
+declare class NiceMultiStateListComponent extends NiceBaseListComponent {
+    private multiStateListService;
+    set state(state: string);
+    constructor(enableQueryBuilder: boolean, icons: NiceBaseIconOptions, listLayout: BaseListLayout, exportsSetting: ExportSettings, query: NiceMultiStateListQuery, activatedRoute: ActivatedRoute, bottomSheet: MatBottomSheet, router: Router, mediaWatcher: NiceMediaWatcherService, multiStateListService: NiceMultiStateListService);
+    private switchState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceMultiStateListComponent, [{ optional: true; }, null, null, null, null, null, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceMultiStateListComponent, "nice-multi-state-list", never, { "state": { "alias": "state"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface MultiStateListOptions {
+    filterService: Type<NiceMultiStateFilterService>;
+    states: ListStates;
+    layout?: BaseListLayout;
+    exports?: ExportSettings;
+    disableQueryBuilder?: boolean;
+    disableQueryParams?: boolean;
+    queryBuilder?: {
+        filterGroupService: Type<NiceFilterGroupService<any>>;
+        savedReportService?: Type<NiceSavedReportService>;
+    };
+}
+declare class NiceMultiStateListModule {
+    static providerFactory<T>(options: MultiStateListOptions): Provider[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceMultiStateListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceMultiStateListModule, [typeof NiceMultiStateListComponent], [typeof i2.NiceExportBottomSheetModule, typeof NiceBaseListDirectiveModule, typeof i15.CommonModule, typeof i14.FormsModule, typeof i6.RouterModule, typeof i7.MatButtonModule, typeof i8.MatIconModule, typeof i9.MatTooltipModule, typeof i10.MatCardModule, typeof i11.MatPaginatorModule, typeof i12.TranslateModule, typeof i2.NiceLoadingSpinnerModule, typeof i13.MatTableModule, typeof i14$2.MatSortModule, typeof i15$1.MatRippleModule, typeof i16$1.MatBottomSheetModule, typeof NiceQueryBuilderModule, typeof i18.MatBadgeModule], [typeof NiceMultiStateListComponent, typeof NiceBaseListDirectiveModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceMultiStateListModule>;
+}
+
+interface OrderColumnOptions {
+    column?: string;
+    nullLast?: boolean;
+}
+interface OrderOptions {
+    [order: string]: OrderColumnOptions;
+}
+
+interface NiceFilterViewState extends EntityState {
+    subStates: HashMap<any>;
+    mode: "paginated" | "accumulated";
+    autoLoad: boolean;
+    disabled: boolean;
+    initialLoadCompleted: boolean;
+    filterConfigLoading: boolean;
+    filterConfig: FilterConfigurationModel[];
+    filterResult: FilterResultModel | null;
+    filterParameters: FilterParametersModel;
+    baseRules: (QueryRuleModel | QueryModel)[];
+    queryParams: QueryParams | null;
+    orderColumns: OrderOptions | null;
+    resetResult: boolean;
+}
+declare class NiceFilterViewStore extends EntityStore<NiceFilterViewState> {
+    constructor(state: Partial<NiceFilterViewState>, store: StoreConfigOptions);
+    setFilterConfigLoading(loading: boolean): void;
+    setParameters(filterParameters: FilterParametersModel): void;
+    patchParameters(filterParameters: FilterParametersModel): void;
+    setResult(filterResult: FilterResultModel): void;
+    addValue(value: any, opts?: AddEntitiesOptions): void;
+    addValues(values: any[], opts?: AddEntitiesOptions): void;
+    upsertValue(value: any, key?: string): void;
+    upsertValues(values: any[], key?: string): void;
+    removeValue(value: any, key?: string): void;
+    removeValues(values: any[], key?: string): void;
+    getParameters(filterParameters?: FilterParametersModel): FilterParametersModel;
+    getSubState<T>(name: string): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterViewStore, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceFilterViewStore>;
+}
+
+declare class NiceFilterViewQuery extends QueryEntity<NiceFilterViewState> {
+    protected store: NiceFilterViewStore;
+    constructor(store: NiceFilterViewStore);
+    selectSubState<T>(name: string): Observable<T>;
+    selectFilterConfigLoading(): Observable<boolean>;
+    selectFilterConfig(): Observable<FilterConfigurationModel[]>;
+    selectFilterParameters(): Observable<FilterParametersModel>;
+    selectFilterResult(): Observable<FilterResultModel | null>;
+    selectQueryParams(): Observable<QueryParams>;
+    getParameters(): FilterParametersModel;
+    getSubState<T>(name: string): T;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterViewQuery, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceFilterViewQuery>;
+}
+
+declare class NiceFilterViewService<Filter extends NiceFilterService<any> = NiceFilterService<any>> {
+    private store;
+    readonly filterService: Filter;
+    constructor(store: NiceFilterViewStore, filterService: Filter);
+    reset(): void;
+    disable(): void;
+    updateSubState<T>(name: string, value: T): void;
+    enable(): void;
+    setAutoLoad(autoLoad: boolean): void;
+    setLoading(loading: boolean): void;
+    setMode(mode: "paginated" | "accumulated"): void;
+    loadConfig(configQueryParams?: QueryParams): Promise<void>;
+    filter(): Promise<void>;
+    downloadData(type: string, downloadFileName: string, ids?: number[]): Promise<void>;
+    printData(): Promise<void>;
+    /**
+     * @deprecated reload show not be passed, and the caller should instead call `filter()` after calling this function.
+     */
+    setParameters(filterParameters: FilterParametersModel, reload: boolean): void;
+    setParameters(filterParameters: FilterParametersModel): void;
+    patchParameters(filterParameters: FilterParametersModel): void;
+    resetPaging(): void;
+    setQueryParams(queryParams: QueryParams): void;
+    setBaseRules(rule: (QueryRuleModel | QueryModel)[], reload: boolean): void;
+    addBaseRule(rule: QueryRuleModel, reload: boolean): void;
+    upsertBaseRules(rule: QueryRuleModel, reload: boolean): void;
+    removeBaseRules(key: string, reload: boolean): void;
+    setRules(rules: QueryModel | QueryModel[]): void;
+    upsertRule(id: string, newRule: RuleModel): void;
+    removeRule(id: string): void;
+    addValue(value: any, opts?: AddEntitiesOptions): void;
+    addValues(value: any[], opts?: AddEntitiesOptions): void;
+    upsertValue(value: any, key?: string): void;
+    upsertValues(values: any[], key?: string): void;
+    removeValue(value: any, key?: string): void;
+    removeValues(values: any[], key?: string): void;
+    resetResult(waitForNextFilter: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterViewService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceFilterViewService<any>>;
+}
+
+interface NiceAdvancedFilterIconOptions {
+    add?: NiceBaseListIcons;
+    close?: NiceBaseListIcons;
+    refresh?: NiceBaseListIcons;
+    delete?: NiceBaseListIcons;
+    arrowDown?: NiceBaseListIcons;
+    datePicker?: NiceBaseListIcons;
+    queryBuilder?: NiceBaseListIcons;
+}
+
+declare class NiceAdvancedFiltersButtonComponent {
+    icons: NiceAdvancedFilterIconOptions;
+    private query;
+    private service;
+    shouldShowAdvancedFilters$: rxjs.Observable<boolean>;
+    hasParameters$: rxjs.Observable<boolean>;
+    constructor(icons: NiceAdvancedFilterIconOptions, query: NiceFilterViewQuery, service: NiceFilterViewService);
+    clickToggleShowAdvancedFilters(): void;
+    onSelectedFilter(filter: FilterConfigurationModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedFiltersButtonComponent, [{ optional: true; }, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedFiltersButtonComponent, "nice-advanced-filters-button", never, {}, {}, never, never, false, never>;
+}
+
+declare class FilterFormValues {
+    value: any;
+    secondValue: any;
+}
+declare class FilterForm {
+    id: string;
+    operation: string;
+    condition: Condition;
+    values: FilterFormValues[];
+    constructor(value: QueryModel | QueryRuleModel);
+    transform(): QueryModel | QueryRuleModel;
+}
+declare class AdvancedFiltersForm {
+    rules: FilterForm[];
+    condition: Condition;
+    constructor(query: QueryModel);
+    transform(): QueryModel;
+}
+
+declare class NiceAdvancedFiltersComponent implements OnInit, OnDestroy {
+    icons: NiceAdvancedFilterIconOptions;
+    formGroup: GeneratedFormGroup<AdvancedFiltersForm>;
+    private query;
+    private service;
+    private changeDetectorRef;
+    config$: Observable<FilterConfigurationModel[]>;
+    rules$: Observable<FilterForm[]>;
+    rulesFormArray: GeneratedFormArray<FilterForm>;
+    constructor(icons: NiceAdvancedFilterIconOptions, formGroup: GeneratedFormGroup<AdvancedFiltersForm>, query: NiceFilterViewQuery, service: NiceFilterViewService, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onClickAddRule(filterConfigurationModel: FilterConfigurationModel): void;
+    onClickDeleteRule(index: number): void;
+    onClose(): void;
+    onRefresh(): void;
+    removeEmptyRules({ reload }?: {
+        reload: boolean;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedFiltersComponent, [{ optional: true; }, null, null, null, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedFiltersComponent, "nice-advanced-filters", never, {}, {}, never, never, false, never>;
+}
+
+interface AdvancedDateFilterOptions {
+    openDatePickerOnClick?: boolean;
+}
+
+declare class NiceAdvancedFilterSelectionComponent {
+    private query;
+    filterSelected: EventEmitter<FilterConfigurationModel>;
+    loading$: rxjs.Observable<boolean>;
+    filterGroups$: rxjs.Observable<[FilterGroupConfiguration, FilterConfigurationModel[]][]>;
+    constructor(query: NiceFilterViewQuery);
+    selectFilter(filterConfigurationModel: FilterConfigurationModel): void;
+    trackGroups(index: number, value: [FilterGroupConfiguration, FilterConfigurationModel[]]): any;
+    trackFilter(index: number, value: FilterConfigurationModel): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedFilterSelectionComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedFilterSelectionComponent, "nice-advanced-filter-selection", never, {}, { "filterSelected": "filterSelected"; }, never, never, false, never>;
+}
+
+declare class NiceAdvancedRuleComponent implements OnInit {
+    icons: NiceAdvancedFilterIconOptions;
+    private formGroupName;
+    filterConfigs: FilterConfigurationModel[] | null;
+    remove: EventEmitter<any>;
+    formGroup: GeneratedFormGroup<FilterForm>;
+    valuesFormArray: GeneratedFormArray<FilterFormValues>;
+    isSingleInput$: Observable<boolean>;
+    isDoubleInput$: Observable<boolean>;
+    get filterConfig(): FilterConfigurationModel;
+    constructor(icons: NiceAdvancedFilterIconOptions, formGroupName: FormGroupName);
+    ngOnInit(): void;
+    onUpdateFilterConfig(config: FilterConfigurationModel): void;
+    addValue(index: number): void;
+    removeValue(i: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedRuleComponent, [{ optional: true; }, null]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedRuleComponent, "nice-advanced-rule", never, { "filterConfigs": { "alias": "filterConfigs"; "required": false; }; }, { "remove": "remove"; }, never, never, false, never>;
+}
+
+declare class FilterComponent<T> implements ControlValueAccessor {
+    private _value;
+    get value(): T | undefined;
+    protected propagateChanges: (_: T) => void;
+    registerOnTouched(fn: any): void;
+    registerOnChange(fn: (_: T) => void): void;
+    writeValue(value: T): void;
+    onValueChange(value: T): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterComponent<any>, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceAdvancedDateFilterComponent extends FilterComponent<string> {
+    icons: NiceAdvancedFilterIconOptions;
+    advancedDateFilterOptions: AdvancedDateFilterOptions;
+    constructor(icons: NiceAdvancedFilterIconOptions, advancedDateFilterOptions: AdvancedDateFilterOptions);
+    onInputClick(picker: MatDatepicker<any>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedDateFilterComponent, [{ optional: true; }, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedDateFilterComponent, "nice-advanced-date-filter", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceAdvancedNumberFilterComponent extends FilterComponent<number> {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedNumberFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedNumberFilterComponent, "nice-advanced-number-filter", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceAdvancedOptionsFilterComponent extends FilterComponent<string> {
+    filterConfig: FilterConfigurationModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedOptionsFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedOptionsFilterComponent, "nice-advanced-options-filter", never, { "filterConfig": { "alias": "filterConfig"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceAdvancedRadioFilterComponent extends FilterComponent<string> {
+    filterConfig: FilterConfigurationModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedRadioFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedRadioFilterComponent, "nice-advanced-radio-filter", never, { "filterConfig": { "alias": "filterConfig"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceAdvancedSelectFilterComponent extends FilterComponent<unknown> implements OnInit, OnChanges {
+    private filterViewQuery;
+    filterConfig: FilterConfigurationModel;
+    values: SelectFilterValue[];
+    protected queryParams$: rxjs.Observable<_recursyve_nice_data_filter_kit.QueryParams>;
+    constructor(filterViewQuery: NiceFilterViewQuery);
+    ngOnInit(): Promise<void>;
+    ngOnChanges(changes: SimpleChanges): void;
+    onValueChange(value: unknown): void;
+    writeValue(value: unknown): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedSelectFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedSelectFilterComponent, "nice-advanced-select-filter", never, { "filterConfig": { "alias": "filterConfig"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceAdvancedTextFilterComponent extends FilterComponent<string> {
+    filterConfig: FilterConfigurationModel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedTextFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceAdvancedTextFilterComponent, "nice-advanced-text-filter", never, { "filterConfig": { "alias": "filterConfig"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class AdvancedFiltersTriggerDirective {
+    private query;
+    private service;
+    private overlayPositionBuilder;
+    private elementRef;
+    private overlay;
+    private platform;
+    private injector;
+    private overlayRef;
+    private filterSelectionRef;
+    position: "topRight" | "bottomCenter";
+    advancedFilterSelected: EventEmitter<FilterConfigurationModel>;
+    private get connectedPosition();
+    constructor(query: NiceFilterViewQuery, service: NiceFilterViewService, overlayPositionBuilder: OverlayPositionBuilder, elementRef: ElementRef, overlay: Overlay, platform: Platform, injector: Injector);
+    click(): void;
+    private close;
+    private updateFilterSelectionComponent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdvancedFiltersTriggerDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AdvancedFiltersTriggerDirective, "[niceAdvancedFiltersTrigger]", ["niceAdvancedFiltersTrigger"], { "position": { "alias": "position"; "required": false; }; }, { "advancedFilterSelected": "advancedFilterSelected"; }, never, never, false, never>;
+}
+
+declare class NiceFilterGroupIconPipe implements PipeTransform {
+    private service?;
+    constructor(service?: NiceFilterGroupService<any>);
+    transform(value: string): NiceBaseListIcons;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterGroupIconPipe, [{ optional: true; }]>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<NiceFilterGroupIconPipe, "niceFilterGroupIcon", false>;
+}
+
+interface NiceAdvancedFiltersOptions {
+    icons?: NiceAdvancedFilterIconOptions;
+    filterGroupService?: Type<NiceFilterGroupService<any>>;
+    advancedDateFilter?: AdvancedDateFilterOptions;
+}
+declare class NiceAdvancedFiltersModule {
+    static forRoot(options?: NiceAdvancedFiltersOptions): ModuleWithProviders<NiceAdvancedFiltersModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceAdvancedFiltersModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceAdvancedFiltersModule, [typeof NiceAdvancedFiltersComponent, typeof NiceAdvancedFiltersButtonComponent, typeof NiceAdvancedFilterSelectionComponent, typeof NiceAdvancedRuleComponent, typeof NiceAdvancedDateFilterComponent, typeof NiceAdvancedNumberFilterComponent, typeof NiceAdvancedOptionsFilterComponent, typeof NiceAdvancedRadioFilterComponent, typeof NiceAdvancedSelectFilterComponent, typeof NiceAdvancedTextFilterComponent, typeof AdvancedFiltersTriggerDirective, typeof NiceFilterGroupIconPipe], [typeof i15.CommonModule, typeof i14.ReactiveFormsModule, typeof i23.MatRadioModule, typeof i10.MatCardModule, typeof i16.MatListModule, typeof i2.NiceLoadingSpinnerModule, typeof i8.MatIconModule, typeof i15$1.MatRippleModule, typeof i7.MatButtonModule, typeof i22$1.MatFormFieldModule, typeof i15$1.MatOptionModule, typeof i20.MatSelectModule, typeof i14.FormsModule, typeof i21.MatInputModule, typeof i25$1.MatButtonToggleModule, typeof i12.TranslateModule, typeof i22.MatDatepickerModule, typeof i2.NiceTypeaheadModule, typeof i2.NiceAsyncTypeaheadModule, typeof i25.NgxMaskDirective], [typeof NiceAdvancedFiltersComponent, typeof NiceAdvancedRuleComponent, typeof NiceAdvancedFiltersButtonComponent, typeof AdvancedFiltersTriggerDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceAdvancedFiltersModule>;
+}
+
+declare class AdvancedFiltersUtils {
+    static noInputOperators: FilterOperators[];
+    static singleInputOperators: FilterOperators[];
+    static doubleInputOperators: FilterOperators[];
+    static isSingleInput(filterOperator?: FilterOperators): boolean;
+    static isDoubleInput(filterOperator?: FilterOperators): boolean;
+    static isNoInput(filterOperator?: FilterOperators): boolean;
+    static createRule(config: FilterConfigurationModel, operator?: FilterOperators): QueryRuleModel;
+}
+
+interface AdvancedFiltersAsyncTypeaheadOptions {
+    filterConfig: FilterConfigurationModel;
+    queryParams?: Record<string, any>;
+}
+declare class AdvancedFiltersAsyncTypeaheadProvider extends NiceAsyncTypeaheadProvider<SelectFilterValue> {
+    private filterService;
+    resource: string;
+    private pageSize;
+    constructor(filterService: NiceFilterService<any>);
+    getById(id: number, options: AdvancedFiltersAsyncTypeaheadOptions): Promise<SelectFilterValue>;
+    search(searchQuery: string, page: number, options: AdvancedFiltersAsyncTypeaheadOptions): Promise<NiceAsyncTypeaheadSearchResult<SelectFilterValue>>;
+    format(item: SelectFilterValue): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AdvancedFiltersAsyncTypeaheadProvider, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AdvancedFiltersAsyncTypeaheadProvider>;
+}
+
+declare class NiceFilterDataDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterDataDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceFilterDataDirective, "[niceFilterData]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceFilterCustomDataViewComponent {
+    private query;
+    content: TemplateRef<any>;
+    data$: rxjs.Observable<any[]>;
+    constructor(query: NiceFilterViewQuery);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterCustomDataViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceFilterCustomDataViewComponent, "nice-filter-custom-data-view, div[nice-filter-custom-data-view]", never, {}, {}, ["content"], never, false, never>;
+}
+
+type NiceSelectableListEntity<T> = T & {
+    id?: number;
+    loaded?: boolean;
+};
+type SelectAllBehaviour = "lock" | "allow_unselect";
+interface NiceSelectableListState<T, ID = number> extends EntityState<NiceSelectableListEntity<T>, ID>, ActiveState<ID> {
+    allSelected: boolean;
+    unselectedEntity: any[];
+}
+
+interface NiceSelectableListOptions {
+    idKey?: string;
+    preloadWindow?: number;
+    disableQueryParams?: boolean;
+    selectAllBehaviour?: SelectAllBehaviour;
+}
+
+interface NiceSelectableListLoadAllEntitiesOptions {
+    query?: FilterQueryModel;
+}
+
+declare abstract class NicePreloadSelectedEntitiesProvider<T, ID = number> {
+    abstract state: string;
+    abstract reloadEntity(entity: T): Promise<T>;
+    abstract reloadEntities(entities: T[]): Promise<T[]>;
+    abstract loadEntityById(id: ID): Promise<T>;
+    abstract loadEntitiesById(ids: ID[]): Promise<T[]>;
+    abstract loadAllEntities(options?: NiceSelectableListLoadAllEntitiesOptions): Promise<ID[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NicePreloadSelectedEntitiesProvider<any, any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NicePreloadSelectedEntitiesProvider<any, any>>;
+}
+
+declare class NiceSelectableListStateQuery<T> extends QueryEntity<NiceSelectableListState<T>> {
+    constructor(store: EntityStore<NiceSelectableListState<T>>);
+    selectAllSelected(): Observable<boolean>;
+    selectActiveViewIndex(): Observable<number>;
+    selectFirstActive(): Observable<boolean>;
+    selectLastActive(): Observable<boolean>;
+}
+
+declare class NiceSelectableListStateService<T, ID = any> {
+    private store;
+    private router;
+    private preloadService?;
+    private _options?;
+    get idKey(): string;
+    get preloadedWindow(): number;
+    get queryParamsDisabled(): boolean;
+    get selectAllBehaviour(): SelectAllBehaviour | null;
+    constructor(store: EntityStore<NiceSelectableListState<any>>, router: Router, preloadService?: NicePreloadSelectedEntitiesProvider<T>, options?: NiceSelectableListOptions);
+    setOptions(options?: NiceSelectableListOptions): void;
+    setActive(entity: T): void;
+    getIndex(identifier: number): number;
+    selectAll(options?: NiceSelectableListLoadAllEntitiesOptions): Promise<void>;
+    select(id: ID): Promise<void>;
+    selectMany(ids: ID[], active: ID): Promise<void>;
+    selectEntity(entity: T): Promise<void>;
+    selectManyEntities(entities: T[]): Promise<void>;
+    unselectAll(): void;
+    unselect(id: ID): void;
+    unselectEntity(entity: T): void;
+    unselectManyEntities(entities: T[]): void;
+    updateEntity(entity: T): void;
+    setEntities(ids: ID[], activeId: ID): Promise<void>;
+    next(): Promise<void>;
+    previous(): Promise<void>;
+    first(): Promise<void>;
+    last(): Promise<void>;
+    removeActive(): Promise<void>;
+    loadActiveEntity(id: number, direction: number): Promise<void>;
+    loadEntities(loadExtremity: boolean): Promise<void>;
+    getListIdToLoad(loadExtremity: boolean): number[];
+    generateQueryParams(): {
+        selection: number[] | null;
+        selected: number | null;
+    };
+    setQueryParams(): void;
+}
+
+declare class NiceSelectableListService {
+    private providers;
+    private router;
+    private stores;
+    private services;
+    constructor(providers: NicePreloadSelectedEntitiesProvider<any>[], router: Router);
+    createState(name: string, options?: NiceSelectableListOptions): {
+        store: EntityStore<NiceSelectableListState<any, number>, any, number>;
+        query: NiceSelectableListStateQuery<any>;
+    };
+    getState(name: string): {
+        store: EntityStore<NiceSelectableListState<any>>;
+        query: NiceSelectableListStateQuery<any>;
+    };
+    withState<T, ID = any>(stateName: string, options?: NiceSelectableListOptions): NiceSelectableListStateService<T, ID>;
+    query<T>(stateName: string): NiceSelectableListStateQuery<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListService, [{ optional: true; }, null]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceSelectableListService>;
+}
+
+declare class NiceFilterExportButtonsComponent {
+    icons: NiceBaseIconOptions;
+    private readonly exportsSettings;
+    private niceFilterViewQuery;
+    private selectableListService;
+    private query;
+    private service;
+    private readonly bottomSheet;
+    customExport: ExportStrategy[];
+    downloadFileName: string;
+    canPrint: boolean;
+    loading$: rxjs.Observable<boolean>;
+    constructor(icons: NiceBaseIconOptions, exportsSettings: ExportSettings, niceFilterViewQuery: NiceFilterViewQuery, selectableListService: NiceSelectableListService, query: NiceFilterViewQuery, service: NiceFilterViewService, bottomSheet: MatBottomSheet);
+    clickExport(): void;
+    clickXlsx(ids?: number[]): void;
+    clickCsv(ids?: number[]): void;
+    clickPrint(): void;
+    clickPdf(ids?: number[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterExportButtonsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceFilterExportButtonsComponent, "nice-filter-export-buttons, div[nice-filter-export-buttons]", never, { "customExport": { "alias": "customExport"; "required": false; }; "downloadFileName": { "alias": "downloadFileName"; "required": false; }; "canPrint": { "alias": "canPrint"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceFilterExportDirective {
+    private service;
+    type: string;
+    downloadFileName: string;
+    constructor(service: NiceFilterViewService);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterExportDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceFilterExportDirective, "[niceFilterExport]", never, { "type": { "alias": "type"; "required": false; }; "downloadFileName": { "alias": "downloadFileName"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceFilterInfiniteScrollDataViewComponent implements OnInit {
+    private query;
+    private service;
+    content: TemplateRef<any>;
+    data$: rxjs.Observable<any[]>;
+    constructor(query: NiceFilterViewQuery, service: NiceFilterViewService);
+    ngOnInit(): void;
+    loadNextPage(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterInfiniteScrollDataViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceFilterInfiniteScrollDataViewComponent, "nice-filter-infinite-scroll-data-view, div[nice-filter-infinite-scroll-data-view]", never, {}, {}, ["content"], never, false, never>;
+}
+
+declare class NiceFilterSearchComponent implements OnInit, OnDestroy {
+    icons: NiceBaseIconOptions;
+    private query;
+    private service;
+    appearance: "default" | "outlined" | "legacy" | "custom";
+    searchQuery$: rxjs.Observable<string>;
+    private unsubscribeAll$;
+    private searchText$;
+    constructor(icons: NiceBaseIconOptions, query: NiceFilterViewQuery, service: NiceFilterViewService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onUpdateSearch(search: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceFilterSearchComponent, "nice-filter-search", never, { "appearance": { "alias": "appearance"; "required": false; }; }, {}, never, ["[niceFilterSearchButtons]"], false, never>;
+}
+
+declare class NiceFilterQueryParamsDirective implements OnInit, OnDestroy {
+    private query;
+    private service;
+    private route;
+    private router;
+    replaceUrlOnNavigation: boolean;
+    init: EventEmitter<any>;
+    private unsubscribeAll$;
+    private _initialized;
+    get initialized(): boolean;
+    constructor(query: NiceFilterViewQuery, service: NiceFilterViewService, route: ActivatedRoute, router: Router);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private updateQueryParams;
+    private loadQueryParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterQueryParamsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceFilterQueryParamsDirective, "nice-filter-view[niceFilterQueryParams]", never, { "replaceUrlOnNavigation": { "alias": "replaceUrlOnNavigation"; "required": false; }; }, { "init": "init"; }, never, never, false, never>;
+}
+
+type AfterQueryParamLoadedCallback = () => void;
+declare abstract class NiceNestedFilterView<Filter extends NiceFilterService<any> = NiceFilterService<any>> implements OnInit, OnDestroy {
+    private readonly _afterQueryParamHooks;
+    protected unsubscribeAll$: Subject<void>;
+    protected filterViewService: NiceFilterViewService<Filter>;
+    protected filterViewQuery: NiceFilterViewQuery;
+    protected queryParams: NiceFilterQueryParamsDirective | null;
+    filterViewLoading$: Observable<boolean>;
+    filterViewCount$: Observable<number>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    protected afterInit(fn: AfterQueryParamLoadedCallback): void;
+    private onInit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceNestedFilterView<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceNestedFilterView<any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class NiceFilterMatPaginatorPaginationDirective extends NiceNestedFilterView implements OnInit {
+    private paginator;
+    defaultPageSizeOptions: number[];
+    constructor(paginator: MatPaginator);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterMatPaginatorPaginationDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceFilterMatPaginatorPaginationDirective, "mat-paginator[niceFilterPagination]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceFilterMatSortSortingDirective extends NiceNestedFilterView implements OnInit {
+    private sort;
+    constructor(sort: MatSort);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterMatSortSortingDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceFilterMatSortSortingDirective, "mat-table[matSort][niceFilterSorting]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceFilterMatTableViewDirective implements OnInit {
+    private query;
+    private table;
+    constructor(query: NiceFilterViewQuery, table: MatTable<any>);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterMatTableViewDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceFilterMatTableViewDirective, "mat-table[niceFilterDataView]", never, {}, {}, never, never, false, never>;
+}
+
+interface NiceBaseFilterViewInitOptions {
+    mode?: "paginated" | "accumulated";
+    loadConfig?: boolean;
+    configQueryParams?: QueryParams;
+}
+declare abstract class NiceBaseFilterViewComponent<Filter extends NiceFilterService<any> = NiceFilterService<any>> implements OnInit {
+    protected filterViewService: NiceFilterViewService<Filter>;
+    protected filterViewQuery: NiceFilterViewQuery;
+    protected queryParams: NiceFilterQueryParamsDirective;
+    protected advancedFiltersButton: NiceAdvancedFiltersButtonComponent;
+    private advancedFilters;
+    private selectableListDirective;
+    private readonly _afterQueryParamHooks;
+    filterViewLoading$: Observable<boolean>;
+    filterViewCount$: Observable<number>;
+    ngOnInit(autoLoad?: boolean, { mode, loadConfig, configQueryParams }?: NiceBaseFilterViewInitOptions): void;
+    /**
+     * Call the filter endpoint with the current filter parameters.
+     */
+    loadData(): void;
+    /**
+     * Disable the filter view. This will stop calling any api routes.
+     */
+    disable(): void;
+    /**
+     * Enable the filter view. This will resume calling any api routes.
+     */
+    enable(): void;
+    /**
+     * Update the loading state
+     */
+    setLoading(loading: boolean): void;
+    /**
+     * Set a set of rules that won't be saved in the current filterParameters config.
+     * NOTE: These rules will be injected in each filter request.
+     */
+    setBaseRules(rule: (QueryRuleModel | QueryModel)[], reload?: boolean): void;
+    /**
+     * Add a rule to the set of rules that won't be saved in the current filterParameters config.
+     * NOTE: These rules will be injected in each filter request.
+     */
+    addBaseRule(rule: QueryRuleModel, reload?: boolean): void;
+    /**
+     * Add a rule to the set of rules that won't be saved in the current filterParameters config.
+     * NOTE: These rules will be injected in each filter request.
+     */
+    upsertBaseRule(rule: QueryRuleModel, reload?: boolean): void;
+    /**
+     * Remove a rule to the set of rules that won't be saved in the current filterParameters config.
+     * NOTE: These rules will be injected in each filter request.
+     */
+    removeBaseRule(id: string, reload?: boolean): void;
+    /**
+     * Reset all rules with a new set of rules.
+     */
+    setRules(rules: QueryModel | QueryModel[], reload?: boolean): void;
+    /**
+     * Add or update a rule.
+     * NOTE: This will only check for rules in the first element of the rules array in the current filterParameters.
+     */
+    upsertRule(id: string, newRule: RuleModel, reload?: boolean): void;
+    /**
+     * Remove a rule.
+     * NOTE: This will only check for rules in the first element of the rules array in the current filterParameters.
+     */
+    removeRule(id: string, reload?: boolean): void;
+    protected afterInit(fn: AfterQueryParamLoadedCallback): void;
+    private autoLoad;
+    private loadConfig;
+    private onInit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceBaseFilterViewComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceBaseFilterViewComponent<any>, "ng-component", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceFilterViewComponent implements OnChanges {
+    private service;
+    queryParams: QueryParams;
+    constructor(service: NiceFilterViewService);
+    ngOnChanges(changes: SimpleChanges): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterViewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NiceFilterViewComponent, "nice-filter-view", never, { "queryParams": { "alias": "queryParams"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+interface NiceFilterViewOptions<T> {
+    filterService: Type<NiceFilterService<T>>;
+    exports?: ExportSettings;
+    state?: Partial<NiceFilterViewState>;
+    store?: StoreConfigOptions;
+}
+interface NiceFilterViewGlobalOptions {
+    icons?: NiceBaseIconOptions;
+}
+declare class NiceFilterViewModule {
+    static forRoot(options?: NiceFilterViewGlobalOptions): ModuleWithProviders<NiceFilterViewModule>;
+    static providerFactory<T>(options: NiceFilterViewOptions<T>): Provider[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceFilterViewModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceFilterViewModule, [typeof NiceFilterViewComponent, typeof NiceFilterCustomDataViewComponent, typeof NiceFilterExportButtonsComponent, typeof NiceFilterInfiniteScrollDataViewComponent, typeof NiceFilterSearchComponent, typeof NiceFilterDataDirective, typeof NiceFilterExportDirective, typeof NiceFilterMatTableViewDirective, typeof NiceFilterMatSortSortingDirective, typeof NiceFilterMatPaginatorPaginationDirective, typeof NiceFilterQueryParamsDirective], [typeof i12.TranslateModule, typeof i8.MatIconModule, typeof i14.FormsModule, typeof i15.AsyncPipe, typeof i15.NgIf, typeof i15.NgTemplateOutlet, typeof i9.MatTooltipModule, typeof i7.MatButtonModule, typeof i16$1.MatBottomSheetModule, typeof i2.NiceExportBottomSheetModule], [typeof NiceFilterViewComponent, typeof NiceFilterCustomDataViewComponent, typeof NiceFilterExportButtonsComponent, typeof NiceFilterInfiniteScrollDataViewComponent, typeof NiceFilterSearchComponent, typeof NiceFilterDataDirective, typeof NiceFilterExportDirective, typeof NiceFilterMatTableViewDirective, typeof NiceFilterMatSortSortingDirective, typeof NiceFilterMatPaginatorPaginationDirective, typeof NiceFilterQueryParamsDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceFilterViewModule>;
+}
+
+declare class QBFilterUtils {
+    static noInputOperators: FilterOperators[];
+    static singleInputOperators: FilterOperators[];
+    static doubleInputOperators: FilterOperators[];
+    static isSingleInput(filterOperator?: FilterOperators): boolean;
+    static isDoubleInput(filterOperator?: FilterOperators): boolean;
+    static isNoInput(filterOperator?: FilterOperators): boolean;
+    static createRule(config: FilterConfigurationModel, operator?: FilterOperators): QueryRuleModel;
+    static createQueryModel(config: FilterConfigurationModel): QueryModel;
+}
+
+declare class NiceSelectableListCheckboxDirective implements OnInit, OnDestroy, DoCheck {
+    readonly checkbox: MatCheckbox;
+    private service;
+    private selectableListService;
+    selectableEntity?: any;
+    selectPage?: boolean;
+    private selectableListStateService;
+    private selectableListStateQuery;
+    private unsubscribeAll$;
+    private initialized;
+    private get currentId();
+    constructor(checkbox: MatCheckbox, service: NiceSelectableListContentService, selectableListService: NiceSelectableListService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngDoCheck(): void;
+    private handleSelectableEntity;
+    private handleSelectPage;
+    private updateCheckboxState;
+    private propageCheckedValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListCheckboxDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceSelectableListCheckboxDirective, "mat-checkbox[niceSelectableListCheckbox]", never, { "selectableEntity": { "alias": "selectableEntity"; "required": false; }; "selectPage": { "alias": "selectPage"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceSelectableListContentService {
+    private _options;
+    private _state;
+    private _checkboxes;
+    private defaultOptions;
+    get options(): NiceSelectableListOptions;
+    get state(): string | null;
+    get checkboxes(): QueryList<NiceSelectableListCheckboxDirective>;
+    setOptions(options: NiceSelectableListOptions): void;
+    setState(state: string): void;
+    setCheckboxes(checkboxes: QueryList<NiceSelectableListCheckboxDirective>): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListContentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceSelectableListContentService>;
+}
+
+declare class NiceSelectableListDirective implements OnInit, OnDestroy, OnChanges, AfterContentInit {
+    private service;
+    private selectableListService;
+    private route;
+    state: string;
+    options: NiceSelectableListOptions;
+    readonly checkboxes: QueryList<NiceSelectableListCheckboxDirective>;
+    private unsubscribeAll$;
+    private unsubscribeQuerySub$;
+    private stateService;
+    private stateQuery;
+    constructor(service: NiceSelectableListContentService, selectableListService: NiceSelectableListService, route: ActivatedRoute);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterContentInit(): void;
+    private listenOnStateChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceSelectableListDirective, "[niceSelectableList]", never, { "state": { "alias": "state"; "required": false; }; "options": { "alias": "options"; "required": false; }; }, {}, ["checkboxes"], never, false, never>;
+}
+
+declare class NiceSelectableListSelectAllDirective implements OnInit {
+    private niceFilterViewQuery;
+    private service;
+    private selectableListService;
+    action: "select" | "unselect";
+    private selectableListStateService;
+    private selectableListStateQuery;
+    constructor(niceFilterViewQuery: NiceFilterViewQuery | null, service: NiceSelectableListContentService, selectableListService: NiceSelectableListService);
+    ngOnInit(): void;
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListSelectAllDirective, [{ optional: true; }, null, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceSelectableListSelectAllDirective, "button[niceSelectableListSelectAll]", never, { "action": { "alias": "action"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class NiceSelectableListIsEmptyDirectiveContext {
+    $implicit: boolean;
+    isEmpty: boolean;
+}
+declare class NiceSelectableListIsEmptyDirective implements OnInit, OnDestroy {
+    private templateRef;
+    private viewContainerRef;
+    private contentService;
+    private selectableListService;
+    private context;
+    private embeddedViewRef;
+    private unsubscribeAll$;
+    constructor(templateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef, contentService: NiceSelectableListContentService, selectableListService: NiceSelectableListService);
+    static ngTemplateContextGuard(directive: NiceSelectableListIsEmptyDirective, ctx: any): ctx is NiceSelectableListIsEmptyDirectiveContext;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListIsEmptyDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NiceSelectableListIsEmptyDirective, "[niceSelectableListIsEmpty]", never, {}, {}, never, never, false, never>;
+}
+
+declare class NiceSelectableListModule {
+    static register(...providers: Type<NicePreloadSelectedEntitiesProvider<any, any>>[]): ModuleWithProviders<NiceSelectableListModule>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceSelectableListModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NiceSelectableListModule, [typeof NiceSelectableListDirective, typeof NiceSelectableListCheckboxDirective, typeof NiceSelectableListSelectAllDirective, typeof NiceSelectableListIsEmptyDirective], never, [typeof NiceSelectableListDirective, typeof NiceSelectableListCheckboxDirective, typeof NiceSelectableListSelectAllDirective, typeof NiceSelectableListIsEmptyDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NiceSelectableListModule>;
+}
+
+declare class NiceCustomDateAdapter extends NativeDateAdapter {
+    private translateService;
+    constructor(translateService: TranslateService);
+    format(date: Date, displayFormat: any): string;
+    getDate(date: Date): number;
+    getMonth(date: Date): number;
+    getYear(date: Date): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NiceCustomDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NiceCustomDateAdapter>;
+}
+
+declare class FilterUtils {
+    static parametersToRequest(filterParameters: FilterParametersModel): FilterQueryModel;
+    static filterChangeNeedsRefresh(currentFilters: FilterParametersModel, newFilters: FilterParametersModel): boolean;
+}
+
+declare class StringUtils {
+}
+declare global {
+    interface String {
+        toTableColumn(sortable?: boolean, nullLast?: boolean): TableColumns;
+        toTableColumn({ sortable, nullLast }: {
+            sortable?: boolean;
+            nullLast?: boolean;
+        }): TableColumns;
+    }
+}
+
+declare class OrderUtils {
+    static mergeOrder(oldOrder?: OrderModel, newOrder?: OrderModel): OrderModel | undefined;
+    static combineOrders(firstOrder?: OrderModel | OrderModel[], secondOrder?: OrderModel | OrderModel[], opts?: {
+        uniqueFromBack: any;
+    }): OrderModel[];
+}
+
+export { AdvancedFiltersAsyncTypeaheadProvider, AdvancedFiltersForm, AdvancedFiltersTriggerDirective, AdvancedFiltersUtils, DateFilterComponent, FilterComponent$1 as FilterComponent, FilterForm, FilterFormValues, FilterGroupIconPipe, FilterOperatorTypes, FilterSelectionComponent, FilterType, FilterUtils, LayoutContent, NiceAdvancedDateFilterComponent, NiceAdvancedFiltersButtonComponent, NiceAdvancedFiltersComponent, NiceAdvancedFiltersModule, NiceAdvancedRuleComponent, NiceBaseFilterViewComponent, NiceBaseListButtonsDirective, NiceBaseListCardsDirective, NiceBaseListComponent, NiceBaseListCustomContentDirective, NiceBaseListDirectiveModule, NiceBaseListEmptySearchResultStateDirective, NiceBaseListEmptyStateDirective, NiceBaseListFiltersDirective, NiceBaseListModule, NiceBaseListQuery, NiceBaseListService, NiceBaseListStore, NiceBaseListTableDirective, NiceBaseListTitleDirective, NiceCustomDateAdapter, NiceFilterApi, NiceFilterCustomDataViewComponent, NiceFilterDataDirective, NiceFilterExportButtonsComponent, NiceFilterExportDirective, NiceFilterGroupService, NiceFilterInfiniteScrollDataViewComponent, NiceFilterMatPaginatorPaginationDirective, NiceFilterMatSortSortingDirective, NiceFilterMatTableViewDirective, NiceFilterQueryParamsDirective, NiceFilterSearchComponent, NiceFilterService, NiceFilterViewComponent, NiceFilterViewModule, NiceFilterViewQuery, NiceFilterViewService, NiceListState, NiceMultiStateFilterService, NiceMultiStateListComponent, NiceMultiStateListModule, NiceMultiStateListQuery, NiceMultiStateListService, NiceMultiStateListStore, NiceNestedFilterView, NicePreloadSelectedEntitiesProvider, NiceQueryBuilderComponent, NiceQueryBuilderModule, NiceSavedReportService, NiceSelectableListCheckboxDirective, NiceSelectableListDirective, NiceSelectableListIsEmptyDirective, NiceSelectableListModule, NiceSelectableListSelectAllDirective, NiceSelectableListService, NiceSelectableListStateQuery, NiceSelectableListStateService, NumberFilterComponent, OrderUtils, QBFilterUtils, QueryBuilderTriggerDirective, RadioFilterComponent, RuleComponent, SelectFilterComponent, StringUtils, TableColumns, TextFilterComponent, defaultIcons, defaultLayout, initialBaseListState, initialValue, mixinNiceFilterApi };
+export type { AfterQueryParamLoadedCallback, AvailableLayoutItem, BaseListGlobalOptions, BaseListLayout, BaseListOptions, BaseListPageLayout, Condition, CustomOperator, ExportSettings, FilterBaseConfigurationModel, FilterConfigurationModel, FilterGroupConfiguration, FilterOperators, FilterOperatorsConfiguration, FilterPageMode, FilterParametersModel, FilterQueryModel, FilterResultModel, FilterSearchModel, HasNiceFilterApiDefinition, INiceFilterService, Layout, LayoutItem, ListStates, MultiStateListOptions, NiceAdvancedFiltersOptions, NiceBaseFilterViewInitOptions, NiceBaseIconOptions, NiceBaseListIcons, NiceBaseListState, NiceFilterApiDefinition, NiceFilterApiDefinitionCtor, NiceFilterViewGlobalOptions, NiceFilterViewOptions, NiceHttpOptions, NiceMultiStateListState, NiceSelectableListEntity, NiceSelectableListLoadAllEntitiesOptions, NiceSelectableListOptions, NiceSelectableListState, OptionsFilterSelectionMode, OrderModel, QueryBuilderGlobalOptions, QueryModel, QueryParams, QueryRuleModel, RadioFilterOptionConfiguration, RuleModel, SelectAllBehaviour, SelectFilterValue, TableColumnsModel };