nuxeo-development-framework 5.2.2 → 5.2.4

package/lib/components/tables/ndf-table/components/table-columns-toggler/table-columns-toggler.component.d.ts

@@ -0,0 +1,35 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { EventEmitter, OnChanges, OnDestroy, OnInit, SimpleChanges } from '@angular/core';
+import { BaseComponent } from '../../../../../shared/components';
+import { TableColumnConfig, TableSortConfig } from '../../models';
+import { MatCheckboxChange } from '@angular/material/checkbox';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import * as i0 from "@angular/core";
+export declare class TableColumnsTogglerComponent extends BaseComponent implements OnInit, OnChanges, OnDestroy {
+    prefix: string;
+    sortEnabled: boolean;
+    frozenColumnsNames: string[];
+    set sortable(value: TableSortConfig);
+    enableSorting: boolean;
+    frozenColumns: TableColumnConfig[];
+    defaultColumns: TableColumnConfig[];
+    columnsSelection: SelectionModel<TableColumnConfig>;
+    private _cols;
+    private columnsChange$;
+    set columns(cols: TableColumnConfig[]);
+    get columns(): TableColumnConfig[];
+    columnsChanged: EventEmitter<TableColumnConfig[]>;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onCheckAllChange({ checked }: MatCheckboxChange): void;
+    toggleSorting(): void;
+    drop(event: CdkDragDrop<any[]>): void;
+    applySort(): void;
+    private _selectAll;
+    private _deselectAll;
+    private _filterByVisibility;
+    private _updateColumns;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableColumnsTogglerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableColumnsTogglerComponent, "table-columns-toggler", never, { "prefix": "prefix"; "sortable": "sortable"; "columns": "columns"; }, { "columnsChanged": "columnsChanged"; }, never, never>;
+}

package/lib/components/tables/ndf-table/components/table-export/table-export.component.d.ts

@@ -0,0 +1,13 @@
+import { EventEmitter } from '@angular/core';
+import { TableExportConfig, ExportType } from '../../models';
+import * as i0 from "@angular/core";
+export declare class TableExportComponent {
+    private _exportType;
+    private _config;
+    set config(config: TableExportConfig);
+    get config(): TableExportConfig;
+    onExport: EventEmitter<"pdf" | "excel" | "docx">;
+    export(type: ExportType): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableExportComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TableExportComponent, "ndf-table-export", never, { "config": "config"; }, { "onExport": "onExport"; }, never, never>;
+}

package/lib/components/tables/ndf-table/components/text-search/text-search.component.d.ts

@@ -0,0 +1,21 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { DestroySubject } from '../../../../../shared/components';
+import { GlobalSearchConfig } from '../../models';
+import * as i0 from "@angular/core";
+export declare class TextSearchComponent extends DestroySubject implements OnInit {
+    internalValue: FormControl;
+    searchConfig: GlobalSearchConfig;
+    set search(val: string);
+    searchChange: EventEmitter<string>;
+    openModal: EventEmitter<void>;
+    clear: EventEmitter<void>;
+    get dialogConfig(): import("../../filters-panel").HtmlDialogConfig;
+    get sendMode(): "realTime" | "triggered";
+    get showSendButton(): boolean;
+    ngOnInit(): void;
+    onSearch(value?: string): void;
+    onReset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TextSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<TextSearchComponent, "app-text-search", never, { "searchConfig": "searchConfig"; "search": "search"; }, { "searchChange": "searchChange"; "openModal": "openModal"; "clear": "clear"; }, never, never>;
+}

package/lib/components/tables/ndf-table/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './sizes';

package/lib/components/tables/ndf-table/constants/sizes.d.ts

@@ -0,0 +1,4 @@
+export declare const PAGE_SIZE: {
+    label: string;
+    size: number;
+}[];

package/lib/components/tables/ndf-table/containers/index.d.ts

@@ -0,0 +1 @@
+export * from './ndf-table/ndf-table.component';

package/lib/components/tables/ndf-table/containers/ndf-table/ndf-table.component.d.ts

@@ -0,0 +1,119 @@
+import { Direction } from '@angular/cdk/bidi';
+import { EventEmitter, TemplateRef } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { TranslateService } from '@ngx-translate/core';
+import { AggregationResponse, FormQueryModel } from '../../filters-panel';
+import { CustomCriteriaModel, ExportType, NdfTableConfig, SortTableItem, TableColumnConfig, TableSortOptions, TableViewMode } from '../../models';
+import { FiltersMapperService, NdfTableService } from '../../services';
+import { PageEvent } from '@angular/material/paginator/paginator';
+import { DestroySubject } from '../../../../../shared/components';
+import { NuxeoPagination } from '../../../../../shared/models';
+import { DynamicTableService } from '../../../dynamic-table';
+import { CustomToastrService } from '../../../../custom-toastr/services/custom-toastr.service';
+import * as i0 from "@angular/core";
+export declare class NdfTableComponent extends DestroySubject {
+    private _filtersMapper;
+    private _dynamicTableService;
+    private _translateService;
+    private _ngTableService;
+    private _toastrService;
+    private _dialog;
+    private readonly _aggregationsSub;
+    private readonly _displayedColumnsSub;
+    private readonly _sortOptionSub;
+    private readonly _viewModeSub;
+    private readonly _textSearchSub;
+    private readonly _activatedCriteriaSub;
+    private readonly _customCriteriaSub;
+    readonly aggregations$: import("rxjs").Observable<Record<string, AggregationResponse>>;
+    readonly displayedColumns$: import("rxjs").Observable<TableColumnConfig[]>;
+    readonly sortOption$: import("rxjs").Observable<TableSortOptions>;
+    readonly viewMode$: import("rxjs").Observable<TableViewMode>;
+    readonly customFilters$: import("rxjs").Observable<{
+        params?: Record<string, any>;
+        payload?: {
+            predicateList: any[];
+        } & Record<string, any>;
+    }>;
+    readonly textSearch$: import("rxjs").Observable<string>;
+    readonly searchAndFilters$: import("rxjs").Observable<any>;
+    rows: Array<unknown>;
+    totalRecords: number;
+    autoCalculateHeight: boolean;
+    emptyMessage: string;
+    activeQuery: FormQueryModel;
+    set customCriteria(criteria: CustomCriteriaModel);
+    set searchTerm(value: string);
+    onRowSelected: EventEmitter<any>;
+    onRowIndexSelected: EventEmitter<any>;
+    actionOnRow: EventEmitter<any>;
+    onGettingData: EventEmitter<any>;
+    onMultiRowSelected: EventEmitter<any>;
+    onLoading: EventEmitter<any>;
+    onPage: EventEmitter<PageEvent>;
+    onInitialized: EventEmitter<NuxeoPagination<any>>;
+    onLoaded: EventEmitter<NuxeoPagination<any>>;
+    onQueryChange: EventEmitter<any>;
+    onSort: EventEmitter<TableSortOptions>;
+    actionsTableTemplate: TemplateRef<any>;
+    searchTableTemplate: TemplateRef<any>;
+    filterCustomTemplate: TemplateRef<any>;
+    private _tableConfigSub;
+    set config(config: NdfTableConfig);
+    get config(): NdfTableConfig;
+    get options(): import("../../models").NdfTableOptions;
+    get filtersConfig(): import("../../models").FiltersConfig;
+    get sortList(): SortTableItem[];
+    get columnsOptions(): {
+        toggle?: boolean;
+        sortable?: import("../../models").TableSortConfig;
+    };
+    get columnToggle(): boolean;
+    get tableMode(): import("../../models").TableModeConfig;
+    get panelConfig(): {
+        visible?: boolean;
+        toggleButton?: boolean;
+    };
+    get isPanelToggleAvailable(): boolean;
+    get textSearchConfig(): import("../../models").GlobalSearchConfig;
+    get filterReloadConfig(): import("../../models").FilterReloadConfig;
+    get exportTableConfig(): import("../../models").TableExportConfig;
+    readonly defaultSort: {
+        prop: string;
+        dir: string;
+    }[];
+    direction: Direction;
+    isPanelOpened: boolean;
+    readonly defaultPageSizes: {
+        label: string;
+        size: number;
+    }[];
+    private _isConfigChanged;
+    private _tableInitialized;
+    private _pageChanged;
+    private _activePage;
+    private _sortValue;
+    /**
+     *
+     */
+    constructor(_filtersMapper: FiltersMapperService, _dynamicTableService: DynamicTableService, _translateService: TranslateService, _ngTableService: NdfTableService, _toastrService: CustomToastrService, _dialog: MatDialog);
+    togglePanel(): void;
+    onLoad(data: NuxeoPagination<any>): void;
+    onInitialize(data: NuxeoPagination<any>): void;
+    columnsChanged(columns: TableColumnConfig[]): void;
+    sortChanged(sort: SortTableItem): void;
+    modeChanged(mode: TableViewMode): void;
+    onSortChanged(sort: TableSortOptions): void;
+    exportTable(type: ExportType): void;
+    filterChanged(criteria: Record<string, any>): void;
+    onTextSearch(text: string): void;
+    onClearSearch(): void;
+    openSearchModal(): void;
+    onPageChanged(page: PageEvent): void;
+    private _filterByVisibility;
+    private _prepareSearch;
+    private _stringifyValues;
+    private _triggerCriteriaChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NdfTableComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NdfTableComponent, "app-ndf-table", never, { "rows": "rows"; "totalRecords": "totalRecords"; "autoCalculateHeight": "autoCalculateHeight"; "emptyMessage": "emptyMessage"; "activeQuery": "activeQuery"; "customCriteria": "customCriteria"; "searchTerm": "searchTerm"; "config": "config"; }, { "onRowSelected": "onRowSelected"; "onRowIndexSelected": "onRowIndexSelected"; "actionOnRow": "actionOnRow"; "onGettingData": "onGettingData"; "onMultiRowSelected": "onMultiRowSelected"; "onLoading": "onLoading"; "onPage": "onPage"; "onInitialized": "onInitialized"; "onLoaded": "onLoaded"; "onQueryChange": "onQueryChange"; "onSort": "onSort"; }, ["actionsTableTemplate", "searchTableTemplate", "filterCustomTemplate"], never>;
+}

package/lib/components/tables/ndf-table/directives/actions.directive.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const ACTIONS_TABLE_TEMPLATE: InjectionToken<ActionsTableTemplateDirective>;
+export declare class ActionsTableTemplateDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionsTableTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ActionsTableTemplateDirective, "[headerTableTemplate]", never, {}, {}, never>;
+}

package/lib/components/tables/ndf-table/directives/filter-custom.directive.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const FILTER_CUSTOM_TEMPLATE: InjectionToken<FilterCustomTemplateDirective>;
+export declare class FilterCustomTemplateDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterCustomTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FilterCustomTemplateDirective, "[filterCustomTemplate]", never, {}, {}, never>;
+}

package/lib/components/tables/ndf-table/directives/fluid-height.directive.d.ts

@@ -0,0 +1,36 @@
+import { AfterViewInit, ElementRef, NgZone, OnDestroy, Renderer2 } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export declare class FluidHeightDirective implements AfterViewInit, OnDestroy {
+    private renderer;
+    private elementRef;
+    private ngZone;
+    minHeight: number;
+    topOffset: number;
+    subtractItems: string[];
+    decrease: number;
+    delay: number;
+    calculate: boolean;
+    private _inlineStyle;
+    get inlineStyle(): boolean;
+    set inlineStyle(value: boolean);
+    private _domElement;
+    private _animationId?;
+    private _resizeListener;
+    constructor(renderer: Renderer2, elementRef: ElementRef, ngZone: NgZone);
+    ngAfterViewInit(): void;
+    scheduleSetHeight(delay?: number): void;
+    private onResize;
+    private setHeight;
+    private _getSelectorHeight;
+    private _calcTopOffset;
+    static ngAcceptInputType_inlineStyle: BooleanInput;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FluidHeightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FluidHeightDirective, "[ndfFluidHeight]", ["ndfFluidHeight"], { "minHeight": "minHeight"; "topOffset": "ndfFluidHeight"; "subtractItems": "subtractItems"; "decrease": "decrease"; "delay": "delay"; "calculate": "calculate"; "inlineStyle": "inlineStyle"; }, {}, never>;
+}
+export declare class FluidHeightModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FluidHeightModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FluidHeightModule, [typeof FluidHeightDirective], never, [typeof FluidHeightDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FluidHeightModule>;
+}

package/lib/components/tables/ndf-table/directives/index.d.ts

@@ -0,0 +1,4 @@
+export * from './actions.directive';
+export * from './search.directive';
+export * from './fluid-height.directive';
+export * from './filter-custom.directive';

package/lib/components/tables/ndf-table/directives/search.directive.d.ts

@@ -0,0 +1,9 @@
+import { InjectionToken, TemplateRef } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare const SEARCH_TABLE_TEMPLATE: InjectionToken<SearchTableTemplateDirective>;
+export declare class SearchTableTemplateDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<SearchTableTemplateDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SearchTableTemplateDirective, "[searchTableTemplate]", never, {}, {}, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/base/base-aggregation-field.component.d.ts

@@ -0,0 +1,35 @@
+import { Injector, TemplateRef } from '@angular/core';
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+import { BaseSelector } from '../../../../../shared/components';
+import { BehaviorSubject } from 'rxjs';
+import { AggregationFieldConfig, AggregationFieldType, AggregationResponse, FieldOptionsType, FieldValueObject, FilterOption, OptionsType } from '../models';
+import * as i0 from "@angular/core";
+export declare abstract class BaseAggregationField<TType extends AggregationFieldType, TValue = any> extends BaseSelector<FilterOption[], TValue> {
+    protected injector: Injector;
+    private readonly _aggregationService;
+    searchText: string;
+    contentTemplate: TemplateRef<any> | undefined;
+    protected _isFieldDirty: boolean;
+    protected _sourceState: BehaviorSubject<FieldOptionsType>;
+    sourceState$: import("rxjs").Observable<FieldOptionsType>;
+    renderOptions$: import("rxjs").Observable<OptionsType<TType>>;
+    protected _optionsSub: BehaviorSubject<FilterOption[]>;
+    prefix: string;
+    set fieldConfig(val: AggregationFieldConfig);
+    get fieldConfig(): AggregationFieldConfig;
+    set aggregation(val: AggregationResponse);
+    get aggregation(): AggregationResponse;
+    get renderOptions(): OptionsType<TType>;
+    get language(): string;
+    /**
+     *
+     */
+    constructor(injector: Injector);
+    validate(control: AbstractControl): ValidationErrors;
+    protected _isValueObject(): boolean;
+    protected _isSendAsQueryParams(): boolean;
+    protected _prepareValueObject(value: TValue, operator?: import("../models").ComparisonOperator, prefix?: string): FieldValueObject<TValue>;
+    private _updateOption;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseAggregationField<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseAggregationField<any, any>, never, never, { "contentTemplate": "contentTemplate"; "prefix": "prefix"; "fieldConfig": "fieldConfig"; "aggregation": "aggregation"; }, {}, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/base/base-checkbox-radio.component.d.ts

@@ -0,0 +1,22 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { Injector } from '@angular/core';
+import { BaseAggregationField } from '.';
+import { FieldValueObject, SortModel } from '../models';
+import * as i0 from "@angular/core";
+export declare abstract class AggregationBaseSelectionComponent<OptType extends 'checkbox' | 'radio' | 'switch'> extends BaseAggregationField<OptType> {
+    internalValue: any;
+    abstract selectionModel: SelectionModel<unknown>;
+    visibleItemsCount: number;
+    expandedCount: number;
+    sort: SortModel;
+    /**
+     *
+     */
+    constructor(injector: Injector);
+    writeValue(values: any[] | FieldValueObject): void;
+    updateValue(): void;
+    emitValue(value: string[]): void;
+    sortChange(event: SortModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregationBaseSelectionComponent<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AggregationBaseSelectionComponent<any>, never, never, {}, {}, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/base/base-custom-field.component.d.ts

@@ -0,0 +1,19 @@
+import { Injector } from '@angular/core';
+import { BaseCustomValueAccessor } from './base-value-accessor.component';
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+import { AggregationResponse, CustomFieldConfig, CustomFieldType, FieldValueObject, OptionsType } from '../models';
+import * as i0 from "@angular/core";
+export declare abstract class BaseCustomField<FType extends CustomFieldType, T = any, R = any> extends BaseCustomValueAccessor<T, R> {
+    injector: Injector;
+    aggregations: Record<string, AggregationResponse>;
+    field: CustomFieldConfig;
+    protected _isFieldDirty: boolean;
+    get renderOptions(): OptionsType<FType>;
+    constructor(injector: Injector);
+    validate(control: AbstractControl): ValidationErrors;
+    protected _isValueObject(): boolean;
+    protected _isSendAsQueryParams(): boolean;
+    protected _prepareValueObject(value: R, operator?: import("../models").ComparisonOperator, prefix?: string): FieldValueObject<R>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseCustomField<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseCustomField<any, any, any>, never, never, { "aggregations": "aggregations"; "field": "field"; }, {}, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/base/base-predicate-field.component.d.ts

@@ -0,0 +1,15 @@
+import { AbstractControl, ValidationErrors } from '@angular/forms';
+import { FieldValueObject, OptionsType, PredicateFieldConfig, PredicateFieldType } from '../models';
+import { BaseCustomValueAccessor } from './base-value-accessor.component';
+import * as i0 from "@angular/core";
+export declare abstract class BasePredicateField<FType extends PredicateFieldType, T = any, R = any> extends BaseCustomValueAccessor<T, R> {
+    field: PredicateFieldConfig;
+    protected _isFieldDirty: boolean;
+    get renderOptions(): OptionsType<FType>;
+    validate(control: AbstractControl): ValidationErrors;
+    protected _isValueObject(): boolean;
+    protected _isSendAsQueryParams(): boolean;
+    protected _prepareValueObject(value: R, operator?: import("../models").ComparisonOperator, prefix?: string): FieldValueObject<R>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BasePredicateField<any, any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BasePredicateField<any, any, any>, never, never, { "field": "field"; }, {}, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/base/base-value-accessor.component.d.ts

@@ -0,0 +1,20 @@
+import { Injector } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, ValidationErrors, Validator } from '@angular/forms';
+import { BaseComponent } from '../../../../../shared/components';
+import * as i0 from "@angular/core";
+export declare abstract class BaseCustomValueAccessor<T, R> extends BaseComponent implements ControlValueAccessor, Validator {
+    injector: Injector;
+    abstract writeValue(obj: T): void;
+    abstract validate(control: AbstractControl): ValidationErrors;
+    constructor(injector: Injector);
+    onChange: (value: R) => void;
+    onTouched: () => void;
+    onValidationChange: any;
+    disabled: boolean;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    registerOnValidatorChange?(fn: () => void): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseCustomValueAccessor<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<BaseCustomValueAccessor<any, any>, never, never, { "disabled": "disabled"; }, {}, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/base/index.d.ts

@@ -0,0 +1,5 @@
+export * from './base-aggregation-field.component';
+export * from './base-checkbox-radio.component';
+export * from './base-predicate-field.component';
+export * from './base-value-accessor.component';
+export * from './base-custom-field.component';

package/lib/components/tables/ndf-table/filters-panel/components/__parts/field-header.component.d.ts

@@ -0,0 +1,5 @@
+import * as i0 from "@angular/core";
+export declare class FieldHeaderComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FieldHeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FieldHeaderComponent, "field-header", never, {}, {}, never, ["*"]>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/filter-autocomplete-input/filter-autocomplete-input.component.d.ts

@@ -0,0 +1,35 @@
+import { Direction } from '@angular/cdk/bidi';
+import { ChangeDetectorRef, EventEmitter, OnInit } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { MatAutocompleteSelectedEvent } from '@angular/material/autocomplete';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { AggregationFieldConfig, FilterOption, SearchConfig } from '../../../models';
+import { FilterAutocompleteService } from './filter-autocomplete.service';
+import { DestroySubject } from '../../../../../../../shared/components';
+import * as i0 from "@angular/core";
+export declare class FilterAutocompleteInputComponent extends DestroySubject implements OnInit {
+    private _filterService;
+    private cdr;
+    private _translate;
+    searchChange: EventEmitter<any>;
+    direction: Direction;
+    language: string;
+    private _selectionMade;
+    private _fieldConfig;
+    set fieldConfig(config: AggregationFieldConfig);
+    get fieldConfig(): AggregationFieldConfig;
+    searchConfig: SearchConfig['search'];
+    searchCtrl: FormControl;
+    options$: Observable<any>;
+    selectedOption: FilterOption;
+    private _isLoadingResultSub;
+    isLoadingResult$: Observable<boolean>;
+    constructor(_filterService: FilterAutocompleteService, cdr: ChangeDetectorRef, _translate: TranslateService);
+    displayFn: (option: FilterOption) => any;
+    ngOnInit(): void;
+    onOptionSelected({ option: { value } }: MatAutocompleteSelectedEvent): void;
+    reset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterAutocompleteInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterAutocompleteInputComponent, "filter-autocomplete-input", never, { "direction": "direction"; "language": "language"; "fieldConfig": "fieldConfig"; }, { "searchChange": "searchChange"; }, never, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/filter-autocomplete-input/filter-autocomplete.service.d.ts

@@ -0,0 +1,13 @@
+import { Injector } from '@angular/core';
+import { BaseService } from '../../../../../../../shared/services/base';
+import { AggregationFieldConfig, EvaluatedString, SearchConfig } from '../../../models';
+import * as i0 from "@angular/core";
+export declare class FilterAutocompleteService extends BaseService {
+    private injector;
+    private readonly _aggregationService;
+    constructor(injector: Injector);
+    customSearch(searchText: string, query: SearchConfig['search']['query'], fieldConfig: AggregationFieldConfig): import("rxjs").Observable<import("../../../models").FilterOption[]>;
+    replacePlaceholder(template: EvaluatedString, searchText: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterAutocompleteService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FilterAutocompleteService>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/filter-collapse-control/filter-collapse-control.component.d.ts

@@ -0,0 +1,12 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FilterCollapseControlComponent {
+    minCount: number;
+    totalItems: number;
+    visibleCount: number;
+    visibleCountChange: EventEmitter<number>;
+    more(): void;
+    less(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterCollapseControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterCollapseControlComponent, "filter-collapse-control", never, { "minCount": "minCount"; "totalItems": "totalItems"; "visibleCount": "visibleCount"; }, { "visibleCountChange": "visibleCountChange"; }, never, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/filter-date-range/filter-date-range.component.d.ts

@@ -0,0 +1,16 @@
+import { OnInit } from '@angular/core';
+import { AbstractControl, FormControl, ValidationErrors } from '@angular/forms';
+import { BaseSelector } from '../../../../../../../shared/components';
+import * as i0 from "@angular/core";
+export declare class FilterDateRangeComponent extends BaseSelector implements OnInit {
+    formControl: FormControl;
+    writeValue(obj: {
+        min: string;
+        max: string;
+    }): void;
+    validate(control: AbstractControl): ValidationErrors;
+    ngOnInit(): void;
+    private _prepareDateToEmit;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterDateRangeComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterDateRangeComponent, "filter-date-range", never, {}, {}, never, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/filter-empty-message.component.d.ts

@@ -0,0 +1,6 @@
+import * as i0 from "@angular/core";
+export declare class FilterEmptyMessageComponent {
+    message: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterEmptyMessageComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterEmptyMessageComponent, "filter-empty-message", never, { "message": "message"; }, {}, never, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/filter-option-text/filter-option-text.component.d.ts

@@ -0,0 +1,9 @@
+import { FilterOption } from '../../../models';
+import * as i0 from "@angular/core";
+export declare class FilterOptionTextComponent {
+    option: FilterOption;
+    showCount: boolean;
+    language: 'ar' | 'en' | string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterOptionTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterOptionTextComponent, "filter-option-text", never, { "option": "option"; "showCount": "showCount"; "language": "language"; }, {}, never, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/filter-options-sort/filter-options-sort.component.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from '@angular/core';
+import { SortModel } from '../../../models';
+import * as i0 from "@angular/core";
+export declare class FilterOptionsSortComponent {
+    options: SortModel[];
+    sort: SortModel;
+    sortChange: EventEmitter<SortModel>;
+    onSortChange(sort: SortModel): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterOptionsSortComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterOptionsSortComponent, "filter-options-sort", never, { "options": "options"; "sort": "sort"; }, { "sortChange": "sortChange"; }, never, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/filter-search-input/filter-search-input.component.d.ts

@@ -0,0 +1,10 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class FilterSearchInputComponent {
+    searchText: string;
+    searchTextChange: EventEmitter<string>;
+    constructor();
+    onChange(value: string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterSearchInputComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterSearchInputComponent, "filter-search-input", never, { "searchText": "searchText"; }, { "searchTextChange": "searchTextChange"; }, never, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/html-dialog/html-dialog.component.d.ts

@@ -0,0 +1,10 @@
+import { MatDialogRef } from '@angular/material/dialog';
+import { HtmlDialogConfig, StrictOmit } from '../../../models';
+import * as i0 from "@angular/core";
+export declare class HtmlDialogComponent {
+    data: StrictOmit<HtmlDialogConfig, 'options'>;
+    dialogRef: MatDialogRef<HtmlDialogComponent>;
+    constructor(data: StrictOmit<HtmlDialogConfig, 'options'>, dialogRef: MatDialogRef<HtmlDialogComponent>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<HtmlDialogComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HtmlDialogComponent, "html-dialog", never, {}, {}, never, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/__parts/index.d.ts

@@ -0,0 +1,9 @@
+export * from './field-header.component';
+export * from './filter-autocomplete-input/filter-autocomplete-input.component';
+export * from './filter-collapse-control/filter-collapse-control.component';
+export * from './filter-date-range/filter-date-range.component';
+export * from './filter-empty-message.component';
+export * from './filter-option-text/filter-option-text.component';
+export * from './filter-search-input/filter-search-input.component';
+export * from './html-dialog/html-dialog.component';
+export * from './filter-options-sort/filter-options-sort.component';

package/lib/components/tables/ndf-table/filters-panel/components/aggregation-autocomplete/aggregation-autocomplete.component.d.ts

@@ -0,0 +1,20 @@
+import { OnInit, TemplateRef } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { Subject } from 'rxjs';
+import { BaseAggregationField } from '../../base';
+import { FilterOption } from '../../models';
+import * as i0 from "@angular/core";
+export declare class AggregationAutocompleteComponent extends BaseAggregationField<'autocomplete'> implements OnInit {
+    autocompleteTemplate: TemplateRef<any> | undefined;
+    internalValue: FormControl;
+    selectedValueSub: Subject<unknown>;
+    private _valueSub;
+    displayFn: (value: FilterOption | string) => any;
+    writeValue(obj: string): void;
+    ngOnInit(): void;
+    private _initValue;
+    private _changeValueListener;
+    private _updateValueListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregationAutocompleteComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AggregationAutocompleteComponent, "app-aggregation-autocomplete", never, {}, {}, ["autocompleteTemplate"], never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/aggregation-checkbox/aggregation-checkbox.component.d.ts

@@ -0,0 +1,10 @@
+import { SelectionModel } from '@angular/cdk/collections';
+import { OnInit } from '@angular/core';
+import { AggregationBaseSelectionComponent } from '../../base';
+import * as i0 from "@angular/core";
+export declare class AggregationCheckboxComponent extends AggregationBaseSelectionComponent<'checkbox'> implements OnInit {
+    selectionModel: SelectionModel<any>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregationCheckboxComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AggregationCheckboxComponent, "app-aggregation-checkbox", never, {}, {}, never, never>;
+}

package/lib/components/tables/ndf-table/filters-panel/components/aggregation-custom/aggregation-custom.component.d.ts

@@ -0,0 +1,9 @@
+import { BaseAggregationField } from '../../base';
+import * as i0 from "@angular/core";
+export declare class AggregationCustomComponent extends BaseAggregationField<'custom'> {
+    internalValue: any;
+    updateValue: (value: any) => void;
+    writeValue(obj: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AggregationCustomComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<AggregationCustomComponent, "app-aggregation-custom", never, {}, {}, never, never>;
+}