@hermes-ui/angular 0.1.4

package/types/hermes-ui-angular-data-datagrid.d.ts

@@ -0,0 +1,1938 @@
+import * as i0 from '@angular/core';
+import { TemplateRef, OnDestroy, OnInit, OnChanges, EventEmitter, ElementRef, ViewContainerRef, ChangeDetectorRef, SimpleChanges, DoCheck, IterableDiffers, TrackByFunction, QueryList, AfterContentInit, AfterViewInit, Renderer2, NgZone, EnvironmentInjector, AfterViewChecked, EmbeddedViewRef, Type } from '@angular/core';
+import * as i39 from '@hermes-ui/angular/utils';
+import { HermesCommonStringsService, IfExpandService, HermesLoadingState, HermesExpandableAnimationDirective, DomAdapter, WillyWonka, OompaLoompa } from '@hermes-ui/angular/utils';
+import { Observable, BehaviorSubject, Subject, ReplaySubject } from 'rxjs';
+import { ModalStackService } from '@hermes-ui/angular/modal';
+import * as i1 from '@hermes-ui/angular/popover/common';
+import { HermesPopoverPosition, HermesPopoverService, HermesPopoverType } from '@hermes-ui/angular/popover/common';
+import * as i38 from '@angular/common';
+import { NgForOfContext } from '@angular/common';
+import * as _hermes_ui_angular_data_datagrid from '@hermes-ui/angular/data/datagrid';
+import { HermesSignpost } from '@hermes-ui/angular/popover/signpost';
+import { Directionality } from '@angular/cdk/bidi';
+import { ListRange } from '@angular/cdk/collections';
+import { CdkVirtualForOfContext, ScrollDispatcher, ViewportRuler, CdkVirtualForOf, CdkFixedSizeVirtualScroll } from '@angular/cdk/scrolling';
+import * as _angular_cdk_overlay from '@angular/cdk/overlay';
+import { HermesControlLabel } from '@hermes-ui/angular/forms/common';
+import * as i40 from '@hermes-ui/angular/icon';
+import * as i41 from '@hermes-ui/angular/forms/input';
+import * as i42 from '@hermes-ui/angular/forms/radio';
+import * as i43 from '@hermes-ui/angular/forms/checkbox';
+import * as i44 from '@hermes-ui/angular/forms/number-input';
+import * as i45 from '@hermes-ui/angular/forms/native-select';
+import * as i46 from '@angular/forms';
+import { ControlValueAccessor } from '@angular/forms';
+import * as i47 from '@hermes-ui/angular/progress/spinner';
+
+/**
+ * Enumeration representing the sorting order of a datagrid column. It is a constant Enum,
+ * i.e. each value needs to be treated as a `number`, starting at index 0.
+ *
+ * @export
+ * @enum {number}
+ */
+declare enum HermesDatagridSortOrder {
+    UNSORTED = 0,
+    ASC = 1,
+    DESC = -1
+}
+declare enum HermesDatagridAriaSortOrder {
+    UNSORTED = "none",
+    ASC = "ascending",
+    DESC = "descending"
+}
+
+declare enum DatagridColumnChanges {
+    WIDTH = 0,
+    HIDDEN = 1,
+    INITIALIZE = 2,
+    PINNED = 3
+}
+
+interface ColumnState {
+    columnIndex?: number;
+    changes?: DatagridColumnChanges[];
+    width?: number;
+    strictWidth?: number;
+    hideable?: boolean;
+    hidden?: boolean;
+    pinned?: boolean;
+    titleTemplateRef?: TemplateRef<any>;
+}
+interface ColumnStateDiff extends ColumnState {
+    changes: DatagridColumnChanges[];
+}
+
+interface HermesDatagridComparatorInterface<T> {
+    compare(a: T, b: T): number;
+}
+
+interface HermesDatagridFilterInterface<T, S = any> {
+    readonly state?: S;
+    changes: Observable<any>;
+    isActive(): boolean;
+    accepts(item: T): boolean;
+    equals?(other: HermesDatagridFilterInterface<T, any>): boolean;
+}
+
+declare class ColumnsService {
+    columns: BehaviorSubject<ColumnState>[];
+    columnsStateChange: BehaviorSubject<ColumnState>;
+    private _cache;
+    get columnStates(): ColumnState[];
+    get hasHideableColumns(): boolean;
+    get visibleColumns(): ColumnState[];
+    get hasPinnedColumns(): boolean;
+    /**
+     * Tells whether the column at the given index is pinned (static). Columns and cells are
+     * matched by their declaration index, so this is what the header, the rows and a column aligned
+     * row detail use to decide which views belong in the static container.
+     */
+    isPinned(columnIndex: number): boolean;
+    cache(): void;
+    hasCache(): boolean;
+    resetToLastCache(): void;
+    emitStateChangeAt(columnIndex: number, diff: ColumnStateDiff): void;
+    emitStateChange(column: BehaviorSubject<ColumnState>, diff: ColumnStateDiff): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnsService>;
+}
+
+declare class DetailService {
+    private readonly modalStackService;
+    id: string;
+    detailWidth: number;
+    private preventScroll;
+    private toggleState;
+    private cache;
+    private button;
+    private _enabled;
+    private _state;
+    constructor(modalStackService: ModalStackService);
+    get enabled(): boolean;
+    set enabled(state: boolean);
+    get preventFocusScroll(): boolean;
+    set preventFocusScroll(preventScroll: boolean);
+    get state(): any;
+    get stateChange(): Observable<boolean | null>;
+    get isOpen(): boolean;
+    open(item: any, button?: HTMLButtonElement): void;
+    close(): void;
+    returnFocus(): void;
+    toggle(item: any, button?: HTMLButtonElement): void;
+    isRowOpen(item: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DetailService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DetailService>;
+}
+
+declare class StateDebouncer {
+    private nbChanges;
+    /**
+     * The Observable that lets other classes subscribe to global state changes
+     */
+    private _change;
+    get change(): Observable<void>;
+    changeStart(): void;
+    changeDone(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateDebouncer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StateDebouncer>;
+}
+
+declare class Page {
+    private stateDebouncer;
+    activated: boolean;
+    /**
+     * Page size, a value of 0 means no pagination
+     */
+    private _size;
+    /**
+     * Total items (needed to guess the last page)
+     */
+    private _totalItems?;
+    /**
+     * Last page
+     */
+    private _last;
+    /**
+     * Current page
+     */
+    private _current;
+    /**
+     * The Observable that lets other classes subscribe to page changes
+     */
+    private _change;
+    private preventEmit;
+    private _sizeChange;
+    constructor(stateDebouncer: StateDebouncer);
+    get size(): number;
+    set size(size: number);
+    get totalItems(): number;
+    set totalItems(total: number);
+    get last(): number;
+    set last(page: number);
+    get change(): Observable<number>;
+    get sizeChange(): Observable<number>;
+    get current(): number;
+    set current(page: number);
+    /**
+     * Index of the first item displayed on the current page, starting at 0, -1 if none displayed
+     */
+    get firstItem(): number;
+    /**
+     * Index of the last item displayed on the current page, starting at 0, -1 if none displayed
+     */
+    get lastItem(): number;
+    /**
+     * Moves to the previous page if it exists
+     */
+    previous(): void;
+    /**
+     * Moves to the next page if it exists
+     */
+    next(): void;
+    /**
+     * Resets the page size to 0
+     */
+    resetPageSize(preventEmit?: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Page, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Page>;
+}
+
+declare class FiltersProvider<T = any> {
+    private _page;
+    private stateDebouncer;
+    /**
+     * This subject is the list of filters that changed last, not the whole list.
+     * We emit a list rather than just one filter to allow batch changes to several at once.
+     */
+    private _change;
+    /**
+     * List of all filters, whether they're active or not
+     */
+    private _all;
+    constructor(_page: Page, stateDebouncer: StateDebouncer);
+    get change(): Observable<HermesDatagridFilterInterface<T>[]>;
+    /**
+     * Tests if at least one filter is currently active
+     */
+    hasActiveFilters(): boolean;
+    /**
+     * Returns a list of all currently active filters
+     */
+    getActiveFilters(): HermesDatagridFilterInterface<T>[];
+    /**
+     * Registers a filter, and returns a deregistration function
+     */
+    add<F extends HermesDatagridFilterInterface<T>>(filter: F): RegisteredFilter<T, F>;
+    /**
+     * Accepts an item if it is accepted by all currently active filters
+     */
+    accepts(item: T): boolean;
+    private resetPageAndEmitFilterChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FiltersProvider<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FiltersProvider<any>>;
+}
+declare class RegisteredFilter<T, F extends HermesDatagridFilterInterface<T>> {
+    filter: F;
+    unregister: () => void;
+    constructor(filter: F, unregister: () => void);
+}
+
+declare class Sort<T = any> {
+    private stateDebouncer;
+    /**
+     * Currently active comparator
+     */
+    private _comparator;
+    /**
+     * Ascending order if false, descending if true
+     */
+    private _reverse;
+    /**
+     * The Observable that lets other classes subscribe to sort changes
+     */
+    private _change;
+    constructor(stateDebouncer: StateDebouncer);
+    get comparator(): HermesDatagridComparatorInterface<T>;
+    set comparator(value: HermesDatagridComparatorInterface<T>);
+    get reverse(): boolean;
+    set reverse(value: boolean);
+    get change(): Observable<Sort<T>>;
+    /**
+     * Sets a comparator as the current one, or toggles reverse if the comparator is already used. The
+     * optional forceReverse input parameter allows to override that toggling behavior by sorting in
+     * reverse order if `true`.
+     *
+     * @memberof Sort
+     */
+    toggle(sortBy: HermesDatagridComparatorInterface<T>, forceReverse?: boolean): void;
+    /**
+     * Clears the current sorting order
+     */
+    clear(): void;
+    /**
+     * Compares two objects according to the current comparator
+     */
+    compare(a: T, b: T): number;
+    private emitChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Sort<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Sort<any>>;
+}
+
+declare abstract class DatagridFilterRegistrar<T, F extends HermesDatagridFilterInterface<T>> implements OnDestroy {
+    private filters;
+    /**
+     * @NOTEe Type `any` is set here to be able to pass templateStrictMode
+     */
+    registered: any;
+    protected constructor(filters: FiltersProvider<T>);
+    get filter(): F;
+    ngOnDestroy(): void;
+    setFilter(filter: F | RegisteredFilter<T, F>): void;
+    deleteFilter(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridFilterRegistrar<any, any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatagridFilterRegistrar<any, any>, never, never, {}, {}, never, never, true, never>;
+}
+
+declare class HermesDatagridColumn<T = any> extends DatagridFilterRegistrar<T, HermesDatagridFilterInterface<T>> implements OnDestroy, OnInit, OnChanges {
+    private el;
+    private _sort;
+    private vcr;
+    private detailService;
+    private changeDetectorRef;
+    protected commonStrings: HermesCommonStringsService;
+    private columnsService;
+    private columnState;
+    filterStringPlaceholder: string;
+    filterNumberMaxPlaceholder: string;
+    filterNumberMinPlaceholder: string;
+    disableUnsort: boolean;
+    sortOrderChange: EventEmitter<HermesDatagridSortOrder>;
+    filterValueChange: EventEmitter<any>;
+    titleContainer: ElementRef<HTMLElement>;
+    /**
+     * A custom filter for this column that can be provided in the projected content
+     */
+    customFilter: boolean;
+    private _colType;
+    private _field;
+    /**
+     * HermesDatagridComparatorInterface to use when sorting the column
+     */
+    private _sortBy;
+    /**
+     * Indicates how the column is currently sorted
+     */
+    private _sortOrder;
+    private _sortDirection;
+    private initFilterValue;
+    private wrappedInjector;
+    /**
+     * Subscription to the sort service changes
+     */
+    private subscriptions;
+    private _showSeparator;
+    private _pinned;
+    constructor(el: ElementRef<HTMLElement>, _sort: Sort<T>, filters: FiltersProvider<T>, vcr: ViewContainerRef, detailService: DetailService, changeDetectorRef: ChangeDetectorRef, commonStrings: HermesCommonStringsService, columnsService: ColumnsService, columnState: BehaviorSubject<ColumnState>);
+    get isHidden(): boolean;
+    /**
+     * Whether the column is currently rendered as pinned. This can differ from the `pinned` input
+     * while the detail pane is open, because pinning is suspended for as long as it shows a single
+     * column.
+     */
+    get isPinned(): boolean;
+    get showSeparator(): boolean;
+    set showSeparator(value: boolean);
+    /**
+     * Pins the column to the left of the datagrid, so it stays visible while the remaining
+     * columns are scrolled horizontally. Pinned columns keep their declaration order and are
+     * rendered before the scrollable ones, right after the built-in row controls.
+     */
+    get pinned(): boolean;
+    set pinned(value: boolean);
+    get colType(): "string" | "number";
+    set colType(value: 'string' | 'number');
+    get field(): string;
+    set field(field: string);
+    get sortBy(): HermesDatagridComparatorInterface<T> | string;
+    set sortBy(comparator: HermesDatagridComparatorInterface<T> | string);
+    get sortOrder(): HermesDatagridSortOrder;
+    set sortOrder(value: HermesDatagridSortOrder);
+    set updateFilterValue(newValue: string | [number, number]);
+    set projectedFilter(custom: any);
+    /**
+     * Indicates if the column is sortable
+     */
+    get sortable(): boolean;
+    get ariaSort(): HermesDatagridAriaSortOrder;
+    get sortDirection(): 'up' | 'down' | null;
+    /**
+     * @NOTE type `any` here is to let us pass templateStrictMode, because in our code we try to handle
+     * two types of filters String and Number with the same variable but both of them work with different
+     * format we got an error for casting. We could not cast anything inside the template so to not mess the
+     * casting, the last type is set to `any`
+     *
+     * Orignial types: string | [number, number]
+     */
+    get filterValue(): any;
+    set filterValue(newValue: any);
+    get _view(): any;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    /**
+     * Sorts the datagrid based on this column
+     */
+    sort(reverse?: boolean): void;
+    private listenForDetailPaneChanges;
+    private setFilterToggleAriaLabel;
+    private listenForSortingChanges;
+    private setupDefaultFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridColumn<any>, [null, null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridColumn<any>, "hermes-dg-column", never, { "filterStringPlaceholder": { "alias": "hermesFilterStringPlaceholder"; "required": false; }; "filterNumberMaxPlaceholder": { "alias": "hermesFilterNumberMaxPlaceholder"; "required": false; }; "filterNumberMinPlaceholder": { "alias": "hermesFilterNumberMinPlaceholder"; "required": false; }; "disableUnsort": { "alias": "hermesDgDisableUnsort"; "required": false; }; "pinned": { "alias": "hermesDgPinned"; "required": false; }; "colType": { "alias": "hermesDgColType"; "required": false; }; "field": { "alias": "hermesDgField"; "required": false; }; "sortBy": { "alias": "hermesDgSortBy"; "required": false; }; "sortOrder": { "alias": "hermesDgSortOrder"; "required": false; }; "updateFilterValue": { "alias": "hermesFilterValue"; "required": false; }; }, { "sortOrderChange": "hermesDgSortOrderChange"; "filterValueChange": "hermesFilterValueChange"; }, ["projectedFilter"], ["hermes-dg-filter, hermes-dg-string-filter, hermes-dg-numeric-filter", "*"], false, [{ directive: typeof i1.HermesPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+    static ngAcceptInputType_pinned: unknown;
+}
+
+type HermesDatagridItemsIdentityFunction<T> = (item: T) => any;
+declare class Items<T = any> {
+    private _filters;
+    private _sort;
+    private _page;
+    /**
+     * Indicates if the data is currently loading
+     */
+    loading: boolean;
+    /**
+     * Subscriptions to the other providers changes.
+     */
+    private _filtersSub;
+    private _sortSub;
+    private _pageSub;
+    /**
+     * Whether we should use smart items for this datagrid or let the user handle
+     * everything.
+     */
+    private _smart;
+    /**
+     * List of all items in the datagrid
+     */
+    private _all;
+    /**
+     * Internal temporary step, which we preserve to avoid re-filtering or re-sorting if not necessary
+     */
+    private _filtered;
+    /**
+     * List of items currently displayed
+     */
+    private _displayed;
+    /**
+     * The Observable that lets other classes subscribe to items changes
+     */
+    private _change;
+    private _allChanges;
+    constructor(_filters: FiltersProvider<T>, _sort: Sort<T>, _page: Page);
+    get smart(): boolean;
+    get all(): T[];
+    set all(items: T[]);
+    get displayed(): T[];
+    get change(): Observable<T[]>;
+    get allChanges(): Observable<T[]>;
+    /**
+     * Checks if we don't have data to process yet, to abort early operations
+     */
+    private get uninitialized();
+    /**
+     * Tracking function to identify objects.
+     */
+    identifyBy: HermesDatagridItemsIdentityFunction<T>;
+    /**
+     * Cleans up our subscriptions to other providers
+     */
+    destroy(): void;
+    smartenDown(): void;
+    smartenUp(): void;
+    /**
+     * Manually recompute the list of displayed items
+     */
+    refresh(): void;
+    private emitChange;
+    private emitAllChanges;
+    /**
+     * FiltersProvider items from the raw list
+     */
+    private _filterItems;
+    /**
+     * Sorts items in the filtered list
+     */
+    private _sortItems;
+    /**
+     * Extracts the current page from the sorted list
+     */
+    private _changePage;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Items<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Items<any>>;
+}
+
+declare class HermesDatagridItems<T> implements DoCheck, OnDestroy {
+    template: TemplateRef<NgForOfContext<T>>;
+    private differs;
+    private items;
+    private iterableProxy;
+    private _rawItems;
+    private differ;
+    private subscriptions;
+    constructor(template: TemplateRef<NgForOfContext<T>>, differs: IterableDiffers, items: Items, vcr: ViewContainerRef);
+    set rawItems(items: T[]);
+    set trackBy(value: TrackByFunction<T>);
+    /**
+     * Asserts the correct type of the template context that the directive will render.
+     * See https://angular.io/guide/structural-directives#typing-the-directives-context
+     *
+     * The presence of this method is a signal to the Ivy template type-check compiler that the
+     * structural directive renders its template with a specific context type.
+     */
+    static ngTemplateContextGuard<T>(_dir: HermesDatagridItems<T>, _ctx: unknown): _ctx is NgForOfContext<T>;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridItems<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesDatagridItems<any>, "[hermesDgItems][hermesDgItemsOf]", never, { "rawItems": { "alias": "hermesDgItemsOf"; "required": false; }; "trackBy": { "alias": "hermesDgItemsTrackBy"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class HermesDatagridPlaceholder<T = any> {
+    private items;
+    constructor(items: Items<T>);
+    /**
+     * Tests if the datagrid is empty, meaning it doesn't contain any items
+     */
+    get emptyDatagrid(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridPlaceholder<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridPlaceholder<any>, "hermes-dg-placeholder", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class HermesDatagridCell implements OnInit {
+    private vcr;
+    /*********
+     * @property signpost
+     *
+     * @description
+     * @ContentChild is used to detect the presence of a Signpost in the projected content.
+     * On the host, we set the .datagrid-signpost-trigger class on the cell when signpost.length is greater than 0.
+     *
+     */
+    signpost: QueryList<HermesSignpost>;
+    private wrappedInjector;
+    constructor(vcr: ViewContainerRef);
+    get _view(): any;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridCell, "hermes-dg-cell", never, {}, {}, ["signpost"], ["*"], false, never>;
+}
+
+declare class DatagridIfExpandService extends IfExpandService {
+    expandableId: string;
+    private _replace;
+    private _animate;
+    constructor();
+    get expanded(): boolean;
+    set expanded(value: boolean);
+    get replace(): Observable<boolean>;
+    get animate(): Observable<void>;
+    loadingStateChange(state: HermesLoadingState): void;
+    setReplace(replaceValue: boolean): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridIfExpandService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatagridIfExpandService>;
+}
+
+declare enum SelectionType {
+    /**
+     * User cannot select any row in the Datagrid
+     */
+    None = "none",
+    /**
+     * User can select only one row at a time in the Datagrid.
+     */
+    Single = "single",
+    /**
+     * User can select any number of rows in the Datagrid.
+     */
+    Multi = "multi"
+}
+declare function selectionTypeAttribute(value: SelectionType | string): SelectionType;
+
+declare enum DatagridDisplayMode {
+    DISPLAY = 0,
+    CALCULATE = 1
+}
+
+declare enum DatagridRenderStep {
+    ALIGN_COLUMNS = 0,
+    CALCULATE_MODE_ON = 1,
+    CALCULATE_MODE_OFF = 2,
+    CLEAR_WIDTHS = 3,// Note this is listened to by both cells and columns
+    COMPUTE_COLUMN_WIDTHS = 4
+}
+
+declare class DatagridRenderOrganizer {
+    protected _renderStep: Subject<DatagridRenderStep>;
+    private alreadySized;
+    get renderStep(): Observable<DatagridRenderStep>;
+    filterRenderSteps(step: DatagridRenderStep): Observable<DatagridRenderStep>;
+    resize(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridRenderOrganizer, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatagridRenderOrganizer>;
+}
+
+declare class DisplayModeService implements OnDestroy {
+    protected _view: BehaviorSubject<DatagridDisplayMode>;
+    private subscriptions;
+    constructor(renderOrganizer: DatagridRenderOrganizer);
+    get view(): Observable<DatagridDisplayMode>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DisplayModeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DisplayModeService>;
+}
+
+declare class ExpandableRowsCount {
+    private detailService;
+    private expandableCount;
+    constructor(detailService: DetailService);
+    /**
+     * false means no rows with action
+     * check if details are on, and disable rows entirely
+     */
+    get hasExpandableRow(): boolean;
+    register(): void;
+    unregister(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableRowsCount, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ExpandableRowsCount>;
+}
+
+declare class RowActionService {
+    private actionableCount;
+    /**
+     * false means no rows with action
+     */
+    get hasActionableRow(): boolean;
+    register(): void;
+    unregister(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowActionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RowActionService>;
+}
+
+declare class Selection<T = any> {
+    private _items;
+    id: string;
+    preserveSelection: boolean;
+    /**
+     * Last selection, for use in range selection.
+     */
+    rangeStart: T;
+    /**
+     * Shift key state, for use in range selection.
+     */
+    shiftPressed: boolean;
+    /** @deprecated since 2.0, remove in 3.0 */
+    rowSelectionMode: boolean;
+    private lockedRefs;
+    private _currentSelectionRefs;
+    private valueCollector;
+    private _selectionType;
+    /**
+     * The current selection
+     */
+    private _current;
+    /**
+     * The Observable that lets other classes subscribe to selection changes
+     */
+    private _change;
+    /**
+     * Subscriptions to the other providers changes.
+     */
+    private subscriptions;
+    /**
+     * Differ to track changes of multi selection.
+     */
+    private _differ;
+    private identifyBy;
+    constructor(_items: Items<T>, filters: FiltersProvider<T>, differs: IterableDiffers);
+    get selectionType(): SelectionType;
+    set selectionType(value: SelectionType);
+    get current(): T[];
+    set current(value: T[]);
+    get currentSingle(): T;
+    get change(): Observable<T[]>;
+    get selectable(): boolean;
+    private get currentSelectionRefs();
+    checkForChanges(): void;
+    clearSelection(): void;
+    /**
+     * Cleans up our subscriptions to other providers
+     */
+    destroy(): void;
+    updateCurrent(value: T[], emit: boolean): void;
+    /**
+     * Checks if an item is currently selected
+     */
+    isSelected(item: T): boolean;
+    /**
+     * Selects or deselects an item
+     */
+    setSelected(item: T, selected: boolean): void;
+    /**
+     * Checks if all currently displayed items are selected
+     */
+    isAllSelected(): boolean;
+    /**
+     * Lock and unlock item
+     */
+    lockItem(item: T, lock: boolean): void;
+    /**
+     * Check is item locked or not by searching into lockedRefs for entry
+     */
+    isLocked(item: T): boolean;
+    /**
+     * Selects or deselects all currently displayed items
+     */
+    toggleAll(): void;
+    /**
+     * Selects an item
+     */
+    private selectItem;
+    /**
+     * Deselects an item
+     */
+    private deselectItem;
+    /**
+     * Make sure that it could be locked
+     */
+    private canItBeLocked;
+    private emitChange;
+    private updateCurrentSelectionRefs;
+    static ɵfac: i0.ɵɵFactoryDeclaration<Selection<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<Selection<any>>;
+}
+
+declare class HermesDatagridRow<T = any> implements AfterContentInit, AfterViewInit {
+    selection: Selection<T>;
+    rowActionService: RowActionService;
+    globalExpandable: ExpandableRowsCount;
+    expand: DatagridIfExpandService;
+    detailService: DetailService;
+    private displayMode;
+    private vcr;
+    el: ElementRef<HTMLElement>;
+    commonStrings: HermesCommonStringsService;
+    private items;
+    private columnsService;
+    private document;
+    selectedChanged: EventEmitter<boolean>;
+    expandedChange: EventEmitter<boolean>;
+    detailDisabled: boolean;
+    detailHidden: boolean;
+    skeletonLoading: boolean;
+    id: string;
+    radioId: string;
+    checkboxId: string;
+    expandableId: string;
+    replaced: boolean;
+    displayCells: boolean;
+    expandAnimationTrigger: boolean;
+    SELECTION_TYPE: typeof SelectionType;
+    /**
+     * @internal
+     */
+    itemChanges: ReplaySubject<T>;
+    /*****
+     * property dgCells
+     *
+     * @description
+     * A Query List of the HermesDatagrid cells in this row.
+     *
+     */
+    dgCells: QueryList<HermesDatagridCell>;
+    expandAnimation: HermesExpandableAnimationDirective;
+    detailButton: ElementRef<HTMLButtonElement>;
+    _stickyCells: ViewContainerRef;
+    _pinnedCells: ViewContainerRef;
+    _scrollableCells: ViewContainerRef;
+    _calculatedCells: ViewContainerRef;
+    _fixedCellTemplate: TemplateRef<any>;
+    private _item;
+    private _selected;
+    private _detailOpenLabel;
+    private _detailCloseLabel;
+    private _rowSelectionLabel;
+    private wrappedInjector;
+    private subscriptions;
+    private _selectable;
+    constructor(selection: Selection<T>, rowActionService: RowActionService, globalExpandable: ExpandableRowsCount, expand: DatagridIfExpandService, detailService: DetailService, displayMode: DisplayModeService, vcr: ViewContainerRef, renderer: Renderer2, el: ElementRef<HTMLElement>, commonStrings: HermesCommonStringsService, items: Items, columnsService: ColumnsService, document: any);
+    /**
+     * Model of the row, to use for selection
+     */
+    get item(): T;
+    set item(item: T);
+    get hermesDgSelectable(): boolean | string;
+    set hermesDgSelectable(value: boolean | string);
+    /**
+     * Indicates if the row is selected
+     */
+    get selected(): boolean | string;
+    set selected(value: boolean | string);
+    get expanded(): boolean | string;
+    set expanded(value: boolean | string);
+    get hermesDgDetailOpenLabel(): string;
+    set hermesDgDetailOpenLabel(label: string);
+    get hermesDgDetailCloseLabel(): string;
+    set hermesDgDetailCloseLabel(label: string);
+    get hermesDgRowSelectionLabel(): string;
+    set hermesDgRowSelectionLabel(label: string);
+    get _view(): any;
+    get identifyBy(): _hermes_ui_angular_data_datagrid.HermesDatagridItemsIdentityFunction<any>;
+    openDetails(event: MouseEvent, detailButton: HTMLButtonElement): void;
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    toggle(selected?: boolean): void;
+    toggleExpand(event: MouseEvent): void;
+    /**
+     * The default behavior in Chrome and Firefox for shift-clicking on a label is to perform text-selection.
+     * This prevents our intended range-selection, because this text-selection overrides our shift-click event.
+     * We need to clear the stored selection range when shift-clicking. This will override the mostly unused shift-click
+     * selection browser functionality, which is inconsistently implemented in browsers anyway.
+     */
+    clearRanges(event: MouseEvent): void;
+    /**
+     * @deprecated related to hermesDgRowSelection, which is deprecated
+     */
+    protected selectRow(selected: boolean, $event: any): void;
+    /**
+     * Projects the cells into the display containers. Cells of pinned columns go into their static
+     * container so they stay visible during horizontal scroll; the rest stay scrollable. Cells are
+     * matched with their column by declaration index, and iterating in that order keeps both groups
+     * aligned with the header.
+     */
+    private insertCellViews;
+    private rangeSelect;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridRow<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridRow<any>, "hermes-dg-row", never, { "detailDisabled": { "alias": "hermesDgDetailDisabled"; "required": false; }; "detailHidden": { "alias": "hermesDgDetailHidden"; "required": false; }; "skeletonLoading": { "alias": "hermesDgSkeletonLoading"; "required": false; }; "item": { "alias": "hermesDgItem"; "required": false; }; "hermesDgSelectable": { "alias": "hermesDgSelectable"; "required": false; }; "selected": { "alias": "hermesDgSelected"; "required": false; }; "expanded": { "alias": "hermesDgExpanded"; "required": false; }; "hermesDgDetailOpenLabel": { "alias": "hermesDgDetailOpenLabel"; "required": false; }; "hermesDgDetailCloseLabel": { "alias": "hermesDgDetailCloseLabel"; "required": false; }; "hermesDgRowSelectionLabel": { "alias": "hermesDgRowSelectionLabel"; "required": false; }; }, { "selectedChanged": "hermesDgSelectedChange"; "expandedChange": "hermesDgExpandedChange"; }, ["dgCells"], ["hermes-dg-action-overflow", "hermes-dg-cell", "hermes-dg-row-detail"], false, never>;
+}
+
+interface HermesDatagridVirtualScrollRangeInterface<T> {
+    total: number;
+    skip: number;
+    data: T[];
+}
+
+type CdkVirtualForInputKey = 'cdkVirtualForOf' | 'cdkVirtualForTrackBy' | 'cdkVirtualForTemplate' | 'cdkVirtualForTemplateCacheSize';
+type CdkVirtualForInputs<T> = Partial<Pick<CdkVirtualForOf<T>, CdkVirtualForInputKey>>;
+type CdkFixedSizeVirtualScrollInputs = Pick<CdkFixedSizeVirtualScroll, 'itemSize' | 'minBufferPx' | 'maxBufferPx'>;
+declare class HermesDatagridVirtualScrollDirective<T> implements AfterViewInit, DoCheck, OnDestroy {
+    private readonly changeDetectorRef;
+    private iterableDiffers;
+    private items;
+    private readonly ngZone;
+    private readonly renderer2;
+    private readonly templateRef;
+    private readonly viewContainerRef;
+    private readonly directionality;
+    private readonly scrollDispatcher;
+    private readonly viewportRuler;
+    private readonly datagrid;
+    private readonly injector;
+    renderedRangeChange: EventEmitter<ListRange>;
+    persistItems: boolean;
+    private _isUserProvidedItemSize;
+    private _itemSize;
+    private _minBufferPx;
+    private _maxBufferPx;
+    private shouldUpdateAriaRowIndexes;
+    private readonly datagridElementRef;
+    private gridRoleElement;
+    private readonly virtualScrollStrategy;
+    private virtualScrollViewport;
+    private cdkVirtualFor;
+    private subscriptions;
+    private topIndex;
+    private mutationChanges;
+    private cdkVirtualForInputs;
+    private _totalItems;
+    constructor(changeDetectorRef: ChangeDetectorRef, iterableDiffers: IterableDiffers, items: Items<T>, ngZone: NgZone, renderer2: Renderer2, templateRef: TemplateRef<CdkVirtualForOfContext<T>>, viewContainerRef: ViewContainerRef, directionality: Directionality, scrollDispatcher: ScrollDispatcher, viewportRuler: ViewportRuler, datagrid: HermesDatagrid, injector: EnvironmentInjector);
+    get totalContentHeight(): string;
+    get cdkVirtualForOf(): CdkVirtualForInputs<T>["cdkVirtualForOf"];
+    set cdkVirtualForOf(value: CdkVirtualForInputs<T>['cdkVirtualForOf']);
+    get cdkVirtualForTrackBy(): CdkVirtualForInputs<T>["cdkVirtualForTrackBy"];
+    set cdkVirtualForTrackBy(value: CdkVirtualForInputs<T>['cdkVirtualForTrackBy']);
+    get cdkVirtualForTemplate(): CdkVirtualForInputs<T>["cdkVirtualForTemplate"];
+    set cdkVirtualForTemplate(value: CdkVirtualForInputs<T>['cdkVirtualForTemplate']);
+    get cdkVirtualForTemplateCacheSize(): CdkVirtualForInputs<T>["cdkVirtualForTemplateCacheSize"];
+    set cdkVirtualForTemplateCacheSize(value: CdkVirtualForInputs<T>['cdkVirtualForTemplateCacheSize']);
+    get itemSize(): CdkFixedSizeVirtualScrollInputs["itemSize"];
+    set itemSize(value: CdkFixedSizeVirtualScrollInputs['itemSize']);
+    get minBufferPx(): CdkFixedSizeVirtualScrollInputs["minBufferPx"];
+    set minBufferPx(value: CdkFixedSizeVirtualScrollInputs['minBufferPx']);
+    get maxBufferPx(): CdkFixedSizeVirtualScrollInputs["maxBufferPx"];
+    set maxBufferPx(value: CdkFixedSizeVirtualScrollInputs['maxBufferPx']);
+    set dataRange(range: HermesDatagridVirtualScrollRangeInterface<T>);
+    get totalItems(): number;
+    private set totalItems(value);
+    ngAfterViewInit(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    scrollUp(offset: number, behavior?: ScrollBehavior): void;
+    scrollDown(offset: number, behavior?: ScrollBehavior): void;
+    scrollToIndex(index: number, behavior?: ScrollBehavior): void;
+    private updateDataRange;
+    private updateItemSize;
+    private updateCdkVirtualForInputs;
+    private updateFixedSizeVirtualScrollInputs;
+    private updateAriaRowCount;
+    private updateAriaRowIndexes;
+    private createVirtualScrollViewportForDatagrid;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridVirtualScrollDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesDatagridVirtualScrollDirective<any>, "[hermesVirtualScroll],[HermesVirtualScroll]", never, { "persistItems": { "alias": "hermesVirtualPersistItems"; "required": false; }; "cdkVirtualForOf": { "alias": "hermesVirtualRowsOf"; "required": false; }; "cdkVirtualForTrackBy": { "alias": "hermesVirtualRowsTrackBy"; "required": false; }; "cdkVirtualForTemplate": { "alias": "hermesVirtualRowsTemplate"; "required": false; }; "cdkVirtualForTemplateCacheSize": { "alias": "hermesVirtualRowsTemplateCacheSize"; "required": false; }; "itemSize": { "alias": "hermesVirtualRowsItemSize"; "required": false; }; "minBufferPx": { "alias": "hermesVirtualRowsMinBufferPx"; "required": false; }; "maxBufferPx": { "alias": "hermesVirtualRowsMaxBufferPx"; "required": false; }; "dataRange": { "alias": "hermesVirtualDataRange"; "required": false; }; }, { "renderedRangeChange": "renderedRangeChange"; }, never, never, false, never>;
+}
+
+interface HermesDatagridStateInterface<T = any> {
+    page?: {
+        from?: number;
+        to?: number;
+        size?: number;
+        current?: number;
+    };
+    sort?: {
+        by: string | HermesDatagridComparatorInterface<T>;
+        reverse: boolean;
+    };
+    filters?: any[];
+}
+
+/**
+ * This provider aggregates state changes from the various providers of the Datagrid
+ */
+declare class StateProvider<T> {
+    private filters;
+    private sort;
+    private page;
+    private debouncer;
+    /**
+     * The Observable that lets other classes subscribe to global state changes
+     */
+    change: Observable<HermesDatagridStateInterface<T>>;
+    constructor(filters: FiltersProvider<T>, sort: Sort<T>, page: Page, debouncer: StateDebouncer);
+    get state(): HermesDatagridStateInterface<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateProvider<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StateProvider<any>>;
+}
+
+interface KeyNavigationGridConfig {
+    keyGrid: string;
+    keyGridRows: string;
+    keyGridCells: string;
+}
+interface CellCoordinates {
+    x: number;
+    y: number;
+    ariaRowIndex?: string;
+}
+declare class KeyNavigationGridController implements OnDestroy {
+    private zone;
+    nextCellCoordsEmitter: EventEmitter<CellCoordinates>;
+    skipItemFocus: boolean;
+    preventScrollOnFocus: boolean;
+    config: KeyNavigationGridConfig;
+    private keyNavUtils;
+    private listenersAdded;
+    private destroy$;
+    constructor(zone: NgZone);
+    ngOnDestroy(): void;
+    addListeners(): void;
+    initializeKeyGrid(host: HTMLElement): void;
+    resetKeyGrid(): void;
+    setActiveCell(activeCell: HTMLElement): void;
+    focusElement(activeCell: HTMLElement, options?: FocusOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeyNavigationGridController, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KeyNavigationGridController>;
+}
+
+declare class HermesDatagrid<T = any> implements AfterContentInit, AfterViewInit, OnDestroy, DoCheck {
+    private organizer;
+    items: Items<T>;
+    expandableRows: ExpandableRowsCount;
+    selection: Selection<T>;
+    rowActionService: RowActionService;
+    private stateProvider;
+    private displayMode;
+    private renderer;
+    detailService: DetailService;
+    private document;
+    el: ElementRef<HTMLElement>;
+    private page;
+    commonStrings: HermesCommonStringsService;
+    keyNavigation: KeyNavigationGridController;
+    private zone;
+    private columnsService;
+    loadingMoreItems: boolean;
+    hermesDgSingleSelectionAriaLabel: string;
+    hermesDgSingleActionableAriaLabel: string;
+    hermesDetailExpandableAriaLabel: string;
+    hermesDgDisablePageFocus: boolean;
+    selectedChanged: EventEmitter<T[]>;
+    /**
+     * Output emitted whenever the data needs to be refreshed, based on user action or external ones
+     */
+    refresh: EventEmitter<HermesDatagridStateInterface<T>>;
+    /**
+     * The application can provide custom select all logic.
+     */
+    customSelectAllEnabled: boolean;
+    selectAllDisabled: boolean;
+    customSelectAll: EventEmitter<boolean>;
+    /**
+     * Expose virtual scroll directive for applications to access its public methods
+     */
+    _virtualScroll: QueryList<HermesDatagridVirtualScrollDirective<any>>;
+    /**
+     * We grab the smart iterator from projected content
+     */
+    iterator: HermesDatagridItems<T>;
+    /**
+     * Custom placeholder detection
+     */
+    placeholder: HermesDatagridPlaceholder<T>;
+    /**
+     * Hideable Column data source / detection.
+     */
+    columns: QueryList<HermesDatagridColumn<T>>;
+    /**
+     * When the datagrid is user-managed without the smart iterator, we get the items displayed
+     * by querying the projected content. This is needed to keep track of the models currently
+     * displayed, typically for selection.
+     */
+    rows: QueryList<HermesDatagridRow<T>>;
+    datagrid: ElementRef<HTMLElement>;
+    datagridTable: ElementRef<HTMLElement>;
+    datagridHeader: ElementRef<HTMLElement>;
+    contentWrapper: ElementRef<HTMLElement>;
+    rowsWrapper: ElementRef<HTMLElement>;
+    scrollableColumns: ViewContainerRef;
+    _projectedDisplayColumns: ViewContainerRef;
+    _projectedStickyColumns: ViewContainerRef;
+    _projectedCalculationColumns: ViewContainerRef;
+    _displayedRows: ViewContainerRef;
+    _calculationRows: ViewContainerRef;
+    _fixedColumnTemplate: TemplateRef<any>;
+    stickyHeaders: QueryList<ElementRef>;
+    selectAllId: string;
+    activeCellCoords: CellCoordinates;
+    SELECTION_TYPE: typeof SelectionType;
+    private selectAllCheckbox;
+    private rowControls;
+    /**
+     * Subscriptions to all the services and queries changes
+     */
+    private _subscriptions;
+    private _virtualScrollSubscriptions;
+    private cachedRowsHeight;
+    private cachedContentHeight;
+    private resizeObserver;
+    /**
+     * Watches the row controls for anything that changes their width without going through a render
+     * cycle - a density change, or an application restyling them.
+     */
+    private rowControlsObserver;
+    constructor(organizer: DatagridRenderOrganizer, items: Items<T>, expandableRows: ExpandableRowsCount, selection: Selection<T>, rowActionService: RowActionService, stateProvider: StateProvider<T>, displayMode: DisplayModeService, renderer: Renderer2, detailService: DetailService, document: any, el: ElementRef<HTMLElement>, page: Page, commonStrings: HermesCommonStringsService, keyNavigation: KeyNavigationGridController, zone: NgZone, columnsService: ColumnsService);
+    /**
+     * Freezes the datagrid while data is loading
+     */
+    get loading(): boolean;
+    set loading(value: boolean);
+    /**
+     * Selection type
+     * - `None`: No rows are selectable.
+     * - `Single`: Only one row can be selected at a time.
+     * - `Multi`: Multiple rows can be selected.
+     *
+     * Defaults to `None`.
+     */
+    get selectionType(): SelectionType;
+    set selectionType(value: SelectionType);
+    /**
+     * Array of all selected items
+     */
+    set selected(value: T[]);
+    set hermesDgPreserveSelection(state: boolean);
+    /**
+     * @deprecated since 2.0, remove in 3.0
+     *
+     * Selection/Deselection on row click mode
+     */
+    set rowSelectionMode(value: boolean);
+    set identityFn(value: HermesDatagridItemsIdentityFunction<T>);
+    /**
+     * Indicates if all currently displayed items are selected
+     */
+    get allSelected(): boolean;
+    set allSelected(value: boolean);
+    get virtualScroll(): HermesDatagridVirtualScrollDirective<any>;
+    protected get isDetailOverlay(): boolean;
+    ngAfterContentInit(): void;
+    /**
+     * Our setup happens in the view of some of our components, so we wait for it to be done before starting
+     */
+    ngAfterViewInit(): void;
+    ngDoCheck(): void;
+    ngOnDestroy(): void;
+    toggleAllSelected($event: any): void;
+    resize(): void;
+    /**
+     * Checks the state of detail panel and if it's opened then
+     * find the matching row and trigger the detail panel
+     */
+    updateDetailState(): void;
+    /**
+     * Public method to re-trigger the computation of displayed items manually
+     */
+    dataChanged(): void;
+    private toggleVirtualScrollSubscriptions;
+    /**
+     * Publishes the width of the row controls - the static container holding the select, action and
+     * caret cells - as a custom property, which is where the pinned columns read the offset they
+     * became static at. They are static right after the controls rather than at the edge of the datagrid,
+     * and `position: sticky` always measures its offsets from that edge, so the distance between the
+     * two has to be measured and handed to the stylesheet.
+     *
+     * The header and the rows get their own value: the header renders one caret column for both
+     * kinds of caret where a row renders one cell per caret, so the two containers are not
+     * necessarily the same width.
+     *
+     * Nothing reads this property unless a column is pinned - `.datagrid-pinned-cells` is the only
+     * consumer, and it is `display: none` while empty - so the measurement is skipped entirely
+     * otherwise. It matters on a datagrid with many rows: `getBoundingClientRect()` forces the
+     * browser to resolve any pending layout first, and on a large datagrid that resolution is not
+     * cheap. Both boxes are read before either write for the same reason - writing the custom
+     * property is itself layout-affecting (`.datagrid-pinned-cells` reads it back for its own
+     * position and width), so reading again in between would force that resolution twice.
+     */
+    private updateRowControlsWidth;
+    private setRowControlsWidth;
+    private handleResizeChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagrid<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagrid<any>, "hermes-datagrid", never, { "loadingMoreItems": { "alias": "hermesLoadingMoreItems"; "required": false; }; "hermesDgSingleSelectionAriaLabel": { "alias": "hermesDgSingleSelectionAriaLabel"; "required": false; }; "hermesDgSingleActionableAriaLabel": { "alias": "hermesDgSingleActionableAriaLabel"; "required": false; }; "hermesDetailExpandableAriaLabel": { "alias": "hermesDetailExpandableAriaLabel"; "required": false; }; "hermesDgDisablePageFocus": { "alias": "hermesDgDisablePageFocus"; "required": false; }; "customSelectAllEnabled": { "alias": "hermesDgCustomSelectAllEnabled"; "required": false; }; "selectAllDisabled": { "alias": "hermesDgSelectAllDisabled"; "required": false; }; "loading": { "alias": "hermesDgLoading"; "required": false; }; "selectionType": { "alias": "hermesDgSelectionType"; "required": false; }; "selected": { "alias": "hermesDgSelected"; "required": false; }; "hermesDgPreserveSelection": { "alias": "hermesDgPreserveSelection"; "required": false; }; "rowSelectionMode": { "alias": "hermesDgRowSelection"; "required": false; }; "identityFn": { "alias": "hermesDgItemsIdentityFn"; "required": false; }; }, { "selectedChanged": "hermesDgSelectedChange"; "refresh": "hermesDgRefresh"; "customSelectAll": "hermesDgCustomSelectAll"; }, ["iterator", "placeholder", "_virtualScroll", "columns", "rows"], ["hermes-dg-action-bar", "hermes-dg-placeholder", "hermes-dg-footer", "[hermesIfDetail],hermes-dg-detail"], false, never>;
+    static ngAcceptInputType_selectionType: SelectionType | string;
+}
+
+declare class HermesDatagridActionBar {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridActionBar, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridActionBar, "hermes-dg-action-bar", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class HermesDatagridActionOverflow implements OnDestroy {
+    private rowActionService;
+    commonStrings: HermesCommonStringsService;
+    private platformId;
+    private popoverService;
+    buttonLabel: string;
+    openChange: EventEmitter<boolean>;
+    popoverId: string;
+    smartPosition: HermesPopoverPosition;
+    protected positions: _angular_cdk_overlay.ConnectedPosition[];
+    private readonly keyFocus;
+    private _open;
+    private subscriptions;
+    constructor(rowActionService: RowActionService, commonStrings: HermesCommonStringsService, platformId: any, popoverService: HermesPopoverService);
+    get open(): boolean;
+    set open(open: boolean);
+    ngOnDestroy(): void;
+    closeOverflowContent(event: Event): void;
+    private initializeFocus;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridActionOverflow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridActionOverflow, "hermes-dg-action-overflow", never, { "buttonLabel": { "alias": "hermesDgActionOverflowButtonLabel"; "required": false; }; "open": { "alias": "hermesDgActionOverflowOpen"; "required": false; }; }, { "openChange": "hermesDgActionOverflowOpenChange"; }, never, ["*"], false, [{ directive: typeof i1.HermesPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HermesDatagridColumnToggle implements OnDestroy {
+    commonStrings: HermesCommonStringsService;
+    private columnsService;
+    popoverId: string;
+    openState: boolean;
+    popoverPosition: HermesPopoverPosition;
+    popoverType: HermesPopoverType;
+    readonly trackByFn: i0.TrackByFunction<ColumnState>;
+    private _allColumnsVisible;
+    private subscription;
+    private allSelectedElement;
+    constructor(commonStrings: HermesCommonStringsService, columnsService: ColumnsService, popoverService: HermesPopoverService);
+    get allColumnsVisible(): boolean;
+    set allColumnsVisible(value: boolean);
+    get hideableColumnStates(): ColumnState[];
+    get hasOnlyOneVisibleColumn(): boolean;
+    ngOnDestroy(): void;
+    toggleColumnState(columnState: ColumnState, event: boolean): void;
+    toggleSwitchPanel(): void;
+    allColumnsSelected(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridColumnToggle, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridColumnToggle, "hermes-dg-column-toggle", never, {}, {}, never, never, false, [{ directive: typeof i1.HermesPopoverHostDirective; inputs: {}; outputs: {}; }]>;
+}
+
+declare class HermesDatagridColumnToggleButton {
+    commonStrings: HermesCommonStringsService;
+    private columnsService;
+    private allSelected;
+    constructor(commonStrings: HermesCommonStringsService, columnsService: ColumnsService);
+    get hermesAllSelected(): Observable<boolean>;
+    get allHideablesVisible(): boolean;
+    selectAll(): void;
+    private hideableColumns;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridColumnToggleButton, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridColumnToggleButton, "hermes-dg-column-toggle-button", never, {}, { "hermesAllSelected": "hermesAllSelected"; }, never, never, false, never>;
+}
+
+declare class ColumnResizerService {
+    private el;
+    private domAdapter;
+    private organizer;
+    isWithinMaxResizeRange: boolean;
+    private widthBeforeResize;
+    private _resizedBy;
+    constructor(el: ElementRef<HTMLElement>, domAdapter: DomAdapter, organizer: DatagridRenderOrganizer);
+    get resizedBy(): number;
+    get minColumnWidth(): number;
+    get maxResizeRange(): number;
+    get widthAfterResize(): number;
+    startResize(): void;
+    endResize(): void;
+    calculateResize(resizedBy: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnResizerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnResizerService>;
+}
+
+/**
+ * @description
+ * Internal datagrid service that holds a reference to the hermes-dg-table element and exposes a method to get height.
+ */
+declare class TableSizeService {
+    private platformId;
+    private _tableRef;
+    constructor(platformId: any);
+    get tableRef(): HTMLElement;
+    set tableRef(element: HTMLElement);
+    set table(table: ElementRef<HTMLElement>);
+    getColumnDragHeight(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TableSizeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TableSizeService>;
+}
+
+declare class HermesDatagridColumnSeparator implements AfterViewInit, OnDestroy {
+    private columnResizerService;
+    private renderer;
+    private ngZone;
+    private tableSizeService;
+    commonString: HermesCommonStringsService;
+    private document;
+    columnSeparatorId: string;
+    private resizeStartedOnKeyDown;
+    private isWithinMaxResizeRange;
+    private unlisteners;
+    private resizeTrackerRef;
+    private columnHandleRef;
+    constructor(columnResizerService: ColumnResizerService, renderer: Renderer2, ngZone: NgZone, tableSizeService: TableSizeService, commonString: HermesCommonStringsService, document: any);
+    get descriptionId(): string;
+    private get resizeTrackerEl();
+    private get columnHandleEl();
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    showTracker(): void;
+    moveTracker(movedBy: number): void;
+    hideTracker(): void;
+    private showTrackerOnFirstKeyDown;
+    private moveTrackerOnKeyDown;
+    private hideTrackerOnKeyUp;
+    private redFlagTracker;
+    private isArrowLeftKeyEvent;
+    private isArrowRightKeyEvent;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridColumnSeparator, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridColumnSeparator, "hermes-dg-column-separator", never, {}, {}, never, never, false, never>;
+}
+
+declare class HermesDatagridDetailHeader implements AfterViewInit {
+    detailService: DetailService;
+    commonStrings: HermesCommonStringsService;
+    title: ElementRef<HTMLElement>;
+    constructor(detailService: DetailService, commonStrings: HermesCommonStringsService);
+    get titleId(): string;
+    ngAfterViewInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridDetailHeader, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridDetailHeader, "hermes-dg-detail-header", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class HermesDatagridDetail {
+    detailService: DetailService;
+    commonStrings: HermesCommonStringsService;
+    ariaLabelledBy: string;
+    ariaLabel: string;
+    header: HermesDatagridDetailHeader;
+    constructor(detailService: DetailService, commonStrings: HermesCommonStringsService);
+    get detailWidth(): number;
+    set detailWidth(value: number | null | undefined);
+    get isCustomWidth(): boolean;
+    get width(): number | null;
+    get labelledBy(): string;
+    get label(): string;
+    close(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridDetail, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridDetail, "hermes-dg-detail", never, { "ariaLabelledBy": { "alias": "hermesDetailAriaLabelledBy"; "required": false; }; "ariaLabel": { "alias": "hermesDetailAriaLabel"; "required": false; }; "detailWidth": { "alias": "hermesDetailWidth"; "required": false; }; }, {}, ["header"], ["*"], false, never>;
+}
+
+declare class HermesDatagridDetailBody {
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridDetailBody, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridDetailBody, "hermes-dg-detail-body", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class HermesDatagridHideableColumn implements OnDestroy {
+    private titleTemplateRef;
+    private columnsService;
+    private columnState;
+    hiddenChange: EventEmitter<boolean>;
+    /**
+     *
+     * @description
+     * Used to initialize the column with either hidden or visible state.
+     *
+     */
+    private _hidden;
+    private subscriptions;
+    constructor(titleTemplateRef: TemplateRef<any>, viewContainerRef: ViewContainerRef, columnsService: ColumnsService, columnState: BehaviorSubject<ColumnState>);
+    /**
+     *
+     * @description
+     * Setter fn for the @Input with the same name as this structural directive.
+     * It allows the user to pre-configure the column's hide/show state. { hidden: true }
+     * It's more verbose but has more Clarity.
+     *
+     * @example
+     * *hermesDgHideableColumn
+     * *hermesDgHideableColumn={hidden: false}
+     * *hermesDgHideableColumn={hidden: true}
+     *
+     */
+    set hermesDgHideableColumn(value: {
+        hidden: boolean;
+    } | string);
+    set hermesDgHidden(hidden: boolean);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridHideableColumn, [null, null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesDatagridHideableColumn, "[hermesDgHideableColumn]", never, { "hermesDgHideableColumn": { "alias": "hermesDgHideableColumn"; "required": false; }; "hermesDgHidden": { "alias": "hermesDgHidden"; "required": false; }; }, { "hiddenChange": "hermesDgHiddenChange"; }, never, never, false, never>;
+}
+
+declare abstract class CustomFilter {
+}
+
+/**
+ * Custom filter that can be added in any column to override the default object property string filter.
+ * The reason this is not just an input on DatagridColumn is because we need the filter's template to be projected,
+ * since it can be anything (not just a text input).
+ */
+declare class HermesDatagridFilter<T = any> extends DatagridFilterRegistrar<T, HermesDatagridFilterInterface<T>> implements CustomFilter, OnDestroy {
+    commonStrings: HermesCommonStringsService;
+    private popoverService;
+    private keyNavigation;
+    openChange: EventEmitter<boolean>;
+    ariaExpanded: boolean;
+    popoverId: string;
+    popoverPosition: HermesPopoverPosition;
+    popoverType: HermesPopoverType;
+    anchor: ElementRef<HTMLButtonElement>;
+    private subs;
+    constructor(_filters: FiltersProvider<T>, commonStrings: HermesCommonStringsService, popoverService: HermesPopoverService, keyNavigation: KeyNavigationGridController);
+    get open(): boolean;
+    set open(open: boolean);
+    set customFilter(filter: HermesDatagridFilterInterface<T> | RegisteredFilter<T, HermesDatagridFilterInterface<T>>);
+    /**
+     * Indicates if the filter is currently active
+     */
+    get active(): boolean;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridFilter<any>, [null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridFilter<any>, "hermes-dg-filter", never, { "open": { "alias": "hermesDgFilterOpen"; "required": false; }; "customFilter": { "alias": "hermesDgFilter"; "required": false; }; }, { "openChange": "hermesDgFilterOpenChange"; }, never, ["*"], false, never>;
+    static ngAcceptInputType_open: unknown;
+}
+
+declare class HermesIfDetail implements OnInit, OnDestroy {
+    private templateRef;
+    private viewContainer;
+    private detailService;
+    stateChange: EventEmitter<any>;
+    private subscriptions;
+    private skip;
+    private embeddedViewRef;
+    constructor(templateRef: TemplateRef<any>, viewContainer: ViewContainerRef, detailService: DetailService);
+    set state(model: any);
+    get viewContext(): {
+        $implicit: any;
+    };
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private togglePanel;
+    /**
+     * For a given outlet instance, we create a proxy object that delegates
+     * to the user-specified context. This allows changing, or swapping out
+     * the context object completely without having to destroy/re-create the view.
+     */
+    private _createContextForwardProxy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesIfDetail, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesIfDetail, "[hermesIfDetail]", never, { "state": { "alias": "hermesIfDetail"; "required": false; }; }, { "stateChange": "hermesIfDetailChange"; }, never, never, false, never>;
+}
+
+/**
+ * Generic bland container serving various purposes for Datagrid.
+ * For instance, it can help span a text over multiple rows in detail view.
+ */
+declare class HermesDatagridRowDetail implements AfterContentInit, AfterViewInit, AfterViewChecked, OnDestroy {
+    selection: Selection;
+    rowActionService: RowActionService;
+    expand: DatagridIfExpandService;
+    expandableRows: ExpandableRowsCount;
+    commonStrings: HermesCommonStringsService;
+    private columnsService;
+    private displayMode;
+    _beginningOfExpandableContentAriaText: string;
+    _endOfExpandableContentAriaText: string;
+    replacedRow: boolean;
+    /**
+     * Whether the detail lays its cells out in the same columns as the row, which it does when it
+     * holds one cell per column and at least one of those columns is pinned. The cells of the pinned
+     * columns are then static alongside the ones in the row above.
+     */
+    columnAligned: boolean;
+    SELECTION_TYPE: typeof SelectionType;
+    cells: QueryList<HermesDatagridCell>;
+    private _pinnedCells;
+    private _scrollableCells;
+    private _plainCells;
+    private subscriptions;
+    private cellsMoved;
+    private lastLayout;
+    private hadCells;
+    constructor(selection: Selection, rowActionService: RowActionService, expand: DatagridIfExpandService, expandableRows: ExpandableRowsCount, commonStrings: HermesCommonStringsService, columnsService: ColumnsService, displayMode: DisplayModeService);
+    set replace(value: boolean);
+    get beginningOfExpandableContentAriaText(): string;
+    get endOfExpandableContentAriaText(): string;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    /**
+     * Moves the cells into the containers that lay them out in the same columns as the row, or back
+     * out of them once that stops making sense.
+     */
+    private syncColumnAlignment;
+    private moveCell;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridRowDetail, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridRowDetail, "hermes-dg-row-detail", never, { "_beginningOfExpandableContentAriaText": { "alias": "hermesRowDetailBeginningAriaText"; "required": false; }; "_endOfExpandableContentAriaText": { "alias": "hermesRowDetailEndAriaText"; "required": false; }; "replace": { "alias": "hermesDgReplace"; "required": false; }; }, {}, ["cells"], ["*"], false, never>;
+}
+
+declare class HermesDatagridFooter<T = any> {
+    selection: Selection<T>;
+    detailService: DetailService;
+    private columnsService;
+    commonStrings: HermesCommonStringsService;
+    SELECTION_TYPE: typeof SelectionType;
+    constructor(selection: Selection<T>, detailService: DetailService, columnsService: ColumnsService, commonStrings: HermesCommonStringsService);
+    get hasHideableColumns(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridFooter<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridFooter<any>, "hermes-dg-footer", never, {}, {}, never, ["*", "hermes-dg-pagination"], false, never>;
+}
+
+declare class HermesDatagridPageSize {
+    page: Page;
+    pageSizeOptions: number[];
+    pageSizeOptionsId: string;
+    constructor(page: Page);
+    set label(label: HermesControlLabel);
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridPageSize, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridPageSize, "hermes-dg-page-size", never, { "pageSizeOptions": { "alias": "hermesPageSizeOptions"; "required": false; }; "pageSizeOptionsId": { "alias": "hermesPageSizeOptionsId"; "required": false; }; }, {}, never, ["*"], false, never>;
+}
+
+declare class HermesDatagridPagination implements OnDestroy, OnInit {
+    page: Page;
+    commonStrings: HermesCommonStringsService;
+    detailService: DetailService;
+    disableCurrentPageInput: boolean;
+    currentChanged: EventEmitter<number>;
+    _pageSizeComponent: HermesDatagridPageSize;
+    currentPageInputRef: ElementRef<HTMLInputElement>;
+    /**
+     * Subscription to the page service changes
+     */
+    private _pageSubscription;
+    constructor(page: Page, commonStrings: HermesCommonStringsService, detailService: DetailService);
+    /**
+     * Page size
+     */
+    get pageSize(): number;
+    set pageSize(size: number);
+    /**
+     * Total items (needed to guess the last page)
+     */
+    get totalItems(): number;
+    set totalItems(total: number);
+    /**
+     * Last page
+     */
+    get lastPage(): number;
+    set lastPage(last: number);
+    /**
+     * Current page
+     */
+    get currentPage(): number;
+    set currentPage(page: number);
+    /**
+     * Index of the first item displayed on the current page, starting at 0, -1 if none displayed
+     */
+    get firstItem(): number;
+    /**
+     * Index of the last item displayed on the current page, starting at 0, -1 if none displayed
+     */
+    get lastItem(): number;
+    /**
+     * Conditionally adds page numbers before and after the current page
+     */
+    get middlePages(): number[];
+    /**********
+     * Subscription to the Page service for page changes.
+     * Note: this only emits after the datagrid is initialized/stabalized and the page changes.
+     */
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Moves to the previous page if it exists
+     */
+    previous(): void;
+    /**
+     * Moves to the next page if it exists
+     */
+    next(): void;
+    verifyCurrentPage(event: any): void;
+    /**
+     * We only update the pagination's current page on enter.
+     */
+    updateCurrentPage(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridPagination, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HermesDatagridPagination, "hermes-dg-pagination", never, { "disableCurrentPageInput": { "alias": "hermesDgPageInputDisabled"; "required": false; }; "pageSize": { "alias": "hermesDgPageSize"; "required": false; }; "totalItems": { "alias": "hermesDgTotalItems"; "required": false; }; "lastPage": { "alias": "hermesDgLastPage"; "required": false; }; "currentPage": { "alias": "hermesDgPage"; "required": false; }; }, { "currentChanged": "hermesDgPageChange"; }, ["_pageSizeComponent"], ["hermes-dg-page-size", "*"], false, never>;
+}
+
+interface HermesDatagridStringFilterInterface<T> {
+    accepts(item: T, search: string): boolean;
+}
+
+interface HermesDatagridNumericFilterInterface<T> {
+    accepts(item: T, low: number, high: number): boolean;
+}
+
+declare class DatagridStringFilterImpl<T = any> implements HermesDatagridFilterInterface<T> {
+    filterFn: HermesDatagridStringFilterInterface<T>;
+    /**
+     * The Observable required as part of the Filter interface
+     */
+    private _changes;
+    /**
+     * Input value converted to lowercase
+     */
+    private _lowerCaseValue;
+    /**
+     * Raw input value
+     */
+    private _rawValue;
+    constructor(filterFn: HermesDatagridStringFilterInterface<T>);
+    get changes(): Observable<string>;
+    get lowerCaseValue(): string;
+    get state(): this | {
+        property: string;
+        value: string;
+    };
+    get value(): string;
+    /**
+     * Common setter for the input value
+     */
+    set value(value: string);
+    /**
+     * Indicates if the filter is currently active, meaning the input is not empty
+     */
+    isActive(): boolean;
+    /**
+     * Tests if an item matches a search text
+     */
+    accepts(item: T): boolean;
+    equals(other: HermesDatagridFilterInterface<T, any>): boolean;
+}
+
+declare class DatagridStringFilter<T = any> extends DatagridFilterRegistrar<T, DatagridStringFilterImpl<T>> implements CustomFilter, OnChanges, OnDestroy, AfterViewInit {
+    private domAdapter;
+    commonStrings: HermesCommonStringsService;
+    private popoverService;
+    private elementRef;
+    private cdr;
+    private ngZone;
+    /**
+     * Provide a way to pass external placeholder and aria-label to the filter input
+     */
+    placeholder: string;
+    label: string;
+    filterValueChange: EventEmitter<any>;
+    /**
+     * Indicates if the filter dropdown is open
+     */
+    open: boolean;
+    /**
+     * We need the actual input element to automatically focus on it
+     */
+    input: ElementRef<HTMLInputElement>;
+    /**
+     * We grab the HermesDatagridFilter we wrap to register this StringFilter to it.
+     */
+    filterContainer: HermesDatagridFilter<T>;
+    labelValue: string;
+    private initFilterValue;
+    private subs;
+    constructor(filters: FiltersProvider<T>, domAdapter: DomAdapter, commonStrings: HermesCommonStringsService, popoverService: HermesPopoverService, elementRef: ElementRef<HTMLElement>, cdr: ChangeDetectorRef, ngZone: NgZone);
+    /**
+     * Customizable filter logic based on a search text
+     */
+    set customStringFilter(value: HermesDatagridStringFilterInterface<T> | RegisteredFilter<T, DatagridStringFilterImpl<T>>);
+    /**
+     * Common setter for the input value
+     */
+    get value(): string;
+    set value(value: string);
+    get placeholderValue(): string;
+    ngAfterViewInit(): void;
+    ngOnChanges(): void;
+    ngOnDestroy(): void;
+    /**
+     * This is not in a getter to prevent "expression has changed after it was checked" errors.
+     */
+    private setFilterLabel;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridStringFilter<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatagridStringFilter<any>, "hermes-dg-string-filter", never, { "placeholder": { "alias": "hermesFilterPlaceholder"; "required": false; }; "label": { "alias": "hermesFilterLabel"; "required": false; }; "customStringFilter": { "alias": "hermesDgStringFilter"; "required": false; }; "value": { "alias": "hermesFilterValue"; "required": false; }; }, { "filterValueChange": "hermesFilterValueChange"; }, never, never, false, never>;
+}
+
+declare class DatagridNumericFilterImpl<T = any> implements HermesDatagridFilterInterface<T> {
+    filterFn: HermesDatagridNumericFilterInterface<T>;
+    /**
+     * The Observable required as part of the Filter interface
+     */
+    private _changes;
+    /**
+     * Internal values and accessor
+     */
+    private _low;
+    private _high;
+    constructor(filterFn: HermesDatagridNumericFilterInterface<T>);
+    get changes(): Observable<[number, number]>;
+    get value(): [number, number];
+    set value(vals: [number, number]);
+    get low(): number;
+    set low(low: number);
+    get high(): number;
+    set high(high: number);
+    get state(): this | {
+        property: string;
+        low: number;
+        high: number;
+    };
+    /**
+     * Indicates if the filter is currently active, (at least one input is set)
+     */
+    isActive(): boolean;
+    /**
+     * Tests if an item matches a search text
+     */
+    accepts(item: T): boolean;
+    equals(other: HermesDatagridFilterInterface<T, any>): boolean;
+}
+
+declare class DatagridNumericFilter<T = any> extends DatagridFilterRegistrar<T, DatagridNumericFilterImpl<T>> implements CustomFilter, AfterViewInit {
+    private domAdapter;
+    commonStrings: HermesCommonStringsService;
+    private popoverService;
+    private ngZone;
+    minPlaceholder: string;
+    maxPlaceholder: string;
+    fromLabel: string;
+    toLabel: string;
+    filterValueChange: EventEmitter<any>;
+    /**
+     * Indicates if the filter dropdown is open
+     */
+    open: boolean;
+    /**
+     * We need the actual input element to automatically focus on it
+     */
+    input: ElementRef<HTMLInputElement>;
+    /**
+     * We grab the HermesDatagridFilter we wrap to register this StringFilter to it.
+     */
+    filterContainer: HermesDatagridFilter<T>;
+    private initFilterValues;
+    private subscriptions;
+    constructor(filters: FiltersProvider<T>, domAdapter: DomAdapter, commonStrings: HermesCommonStringsService, popoverService: HermesPopoverService, ngZone: NgZone);
+    /**
+     * Common setter for the input values
+     */
+    get value(): [number, number];
+    set value(values: [number, number]);
+    /**
+     * Customizable filter logic based on high and low values
+     */
+    set customNumericFilter(value: HermesDatagridNumericFilterInterface<T> | RegisteredFilter<T, DatagridNumericFilterImpl<T>>);
+    get maxPlaceholderValue(): string;
+    get minPlaceholderValue(): string;
+    get fromLabelValue(): string;
+    get toLabelValue(): string;
+    get low(): number | string;
+    set low(low: number | string);
+    get high(): number | string;
+    set high(high: number | string);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridNumericFilter<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatagridNumericFilter<any>, "hermes-dg-numeric-filter", never, { "minPlaceholder": { "alias": "hermesFilterMinPlaceholder"; "required": false; }; "maxPlaceholder": { "alias": "hermesFilterMaxPlaceholder"; "required": false; }; "fromLabel": { "alias": "hermesFilterFromLabel"; "required": false; }; "toLabel": { "alias": "hermesFilterToLabel"; "required": false; }; "value": { "alias": "hermesFilterValue"; "required": false; }; "customNumericFilter": { "alias": "hermesDgNumericFilter"; "required": false; }; }, { "filterValueChange": "hermesFilterValueChange"; }, never, never, false, never>;
+}
+
+declare class DatagridPropertyStringFilter<T = any> implements HermesDatagridStringFilterInterface<T> {
+    prop: string;
+    exact: boolean;
+    private nestedProp;
+    constructor(prop: string, exact?: boolean);
+    accepts(item: T, search: string): boolean;
+}
+
+declare class DatagridPropertyNumericFilter<T = any> implements HermesDatagridNumericFilterInterface<T> {
+    prop: string;
+    exact: boolean;
+    private nestedProp;
+    constructor(prop: string, exact?: boolean);
+    accepts(item: T, low: number, high: number): boolean;
+}
+
+declare class DatagridPropertyComparator<T = any> implements HermesDatagridComparatorInterface<T> {
+    prop: string;
+    private nestedProp;
+    constructor(prop: string);
+    compare(a: T, b: T): number;
+}
+
+declare class DatagridWillyWonka extends WillyWonka {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridWillyWonka, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatagridWillyWonka, "hermes-datagrid", never, {}, {}, never, never, false, never>;
+}
+
+declare class ExpandableOompaLoompa extends OompaLoompa {
+    private expandableCount;
+    constructor(cdr: ChangeDetectorRef, willyWonka: DatagridWillyWonka, expandableCount: ExpandableRowsCount);
+    get flavor(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ExpandableOompaLoompa, [null, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ExpandableOompaLoompa, "hermes-datagrid, hermes-dg-row", never, {}, {}, never, never, false, never>;
+}
+
+declare class ActionableOompaLoompa extends OompaLoompa {
+    private rowActions;
+    constructor(cdr: ChangeDetectorRef, willyWonka: DatagridWillyWonka, rowActions: RowActionService);
+    get flavor(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ActionableOompaLoompa, [null, { optional: true; }, null]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ActionableOompaLoompa, "hermes-datagrid, hermes-dg-row", never, {}, {}, never, never, false, never>;
+}
+
+declare class HermesDatagridSelectionCellDirective {
+    private readonly selection;
+    constructor(selection: Selection);
+    private onSelectionCellClick;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridSelectionCellDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesDatagridSelectionCellDirective, ".datagrid-select", never, {}, {}, never, never, false, never>;
+}
+
+declare class DatagridDetailRegisterer {
+    private expandableRowsCount;
+    constructor(expandableRowsCount: ExpandableRowsCount);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridDetailRegisterer, [{ optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatagridDetailRegisterer, "[hermesIfExpanded]", never, {}, {}, never, never, false, never>;
+}
+
+declare class WrappedCell implements AfterViewInit, OnDestroy {
+    templateRef: TemplateRef<void>;
+    cellView: EmbeddedViewRef<void>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrappedCell, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrappedCell, "dg-wrapped-cell", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class WrappedColumn implements AfterViewInit, OnDestroy {
+    templateRef: TemplateRef<void>;
+    columnView: EmbeddedViewRef<void>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrappedColumn, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrappedColumn, "dg-wrapped-column", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class WrappedRow implements AfterViewInit, OnDestroy {
+    templateRef: TemplateRef<void>;
+    rowView: EmbeddedViewRef<void>;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WrappedRow, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WrappedRow, "dg-wrapped-row", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class DatagridCellRenderer implements OnDestroy {
+    private el;
+    private renderer;
+    private stateSubscription;
+    private subscriptions;
+    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2, organizer: DatagridRenderOrganizer);
+    ngOnDestroy(): void;
+    resetState(state: ColumnState): void;
+    setWidth(state: ColumnState): void;
+    setHidden(state: ColumnState): void;
+    setPinned(state: ColumnState): void;
+    private clearWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridCellRenderer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatagridCellRenderer, "hermes-dg-cell", never, {}, {}, never, never, false, never>;
+}
+
+declare class DatagridHeaderRenderer implements OnDestroy {
+    private el;
+    private renderer;
+    private domAdapter;
+    private columnResizerService;
+    private columnsService;
+    private columnState;
+    resizeEmitter: EventEmitter<number>;
+    /**
+     * Indicates if the column has a strict width, so it doesn't shrink or expand based on the content.
+     */
+    private widthSet;
+    private autoSet;
+    private subscriptions;
+    constructor(el: ElementRef<HTMLElement>, renderer: Renderer2, organizer: DatagridRenderOrganizer, domAdapter: DomAdapter, columnResizerService: ColumnResizerService, columnsService: ColumnsService, columnState: BehaviorSubject<ColumnState>);
+    ngOnDestroy(): void;
+    getColumnWidthState(): Partial<ColumnState>;
+    setColumnState(index: number): void;
+    setWidth(state: ColumnState): void;
+    setHidden(state: ColumnState): void;
+    setPinned(state: ColumnState): void;
+    private clearWidth;
+    private detectStrictWidth;
+    private computeWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridHeaderRenderer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatagridHeaderRenderer, "hermes-dg-column", never, {}, { "resizeEmitter": "hermesDgColumnResize"; }, never, never, false, never>;
+}
+
+declare class DatagridMainRenderer implements AfterContentInit, AfterViewInit, AfterViewChecked, OnDestroy {
+    private datagrid;
+    private organizer;
+    private items;
+    private page;
+    private el;
+    private renderer;
+    private tableSizeService;
+    private columnsService;
+    private ngZone;
+    private keyNavigation;
+    private changeDetectorRef;
+    private headers;
+    private rows;
+    private _heightSet;
+    private shouldStabilizeColumns;
+    private subscriptions;
+    private intersectionObserver;
+    /**
+     * Indicates if we want to re-compute columns width. This should only happen:
+     * 1) When headers change, with columns being added or removed
+     * 2) When rows are lazily loaded for the first time
+     */
+    private columnsSizesStable;
+    constructor(datagrid: HermesDatagrid, organizer: DatagridRenderOrganizer, items: Items, page: Page, el: ElementRef<HTMLElement>, renderer: Renderer2, detailService: DetailService, tableSizeService: TableSizeService, columnsService: ColumnsService, ngZone: NgZone, keyNavigation: KeyNavigationGridController, changeDetectorRef: ChangeDetectorRef);
+    ngOnInit(): void;
+    ngAfterContentInit(): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    ngOnDestroy(): void;
+    toggleDetailPane(state: boolean): void;
+    private setupColumns;
+    private shouldComputeHeight;
+    private computeDatagridHeight;
+    private resetDatagridHeight;
+    /**
+     * Makes each header compute its width.
+     */
+    private computeHeadersWidth;
+    private columnStateChanged;
+    /**
+     * Triggers a whole re-rendring cycle to set column sizes, if needed.
+     */
+    private stabilizeColumns;
+    private updateColumnSeparatorsVisibility;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridMainRenderer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatagridMainRenderer, "hermes-datagrid", never, {}, {}, ["headers", "rows"], never, false, never>;
+}
+
+declare class DatagridRowRenderer implements AfterContentInit, OnDestroy {
+    private columnsService;
+    private el;
+    cells: QueryList<DatagridCellRenderer>;
+    expandableRows: DatagridRowDetailRenderer[];
+    private subscriptions;
+    constructor(columnsService: ColumnsService, el: ElementRef<HTMLElement>);
+    ngAfterContentInit(): void;
+    ngOnDestroy(): void;
+    setCellsState(): void;
+    private addDetachedRowsColumnStateChangesListener;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridRowRenderer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatagridRowRenderer, "hermes-dg-row", never, {}, {}, ["cells"], never, false, never>;
+}
+
+declare class DatagridRowDetailRenderer extends DatagridRowRenderer implements OnDestroy {
+    private parentRow;
+    constructor(parentRow: DatagridRowRenderer, columnsService: ColumnsService, el: ElementRef<HTMLElement>);
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatagridRowDetailRenderer, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatagridRowDetailRenderer, "hermes-dg-row-detail", never, {}, {}, never, never, false, never>;
+}
+
+declare class HermesDatagridSingleSelectionValueAccessor implements ControlValueAccessor {
+    private renderer;
+    private elementRef;
+    value: any;
+    hermesDgIdentityFn: (value: any) => unknown;
+    private state;
+    constructor(renderer: Renderer2, elementRef: ElementRef<HTMLInputElement>);
+    onChange: (value: any) => void;
+    onTouched: () => void;
+    registerOnChange(fn: (value: any) => void): void;
+    registerOnTouched(fn: () => void): void;
+    setDisabledState(isDisabled: boolean): void;
+    writeValue(value: any): void;
+    private keyOf;
+    private updateChecked;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridSingleSelectionValueAccessor, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<HermesDatagridSingleSelectionValueAccessor, "input[type=radio][hermesDgSingleSelectionRadio]", never, { "value": { "alias": "value"; "required": false; }; "hermesDgIdentityFn": { "alias": "hermesDgIdentityFn"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare const HERMES_DATAGRID_DIRECTIVES: Type<any>[];
+declare class HermesDatagridModule {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<HermesDatagridModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HermesDatagridModule, [typeof HermesDatagrid, typeof HermesDatagridActionBar, typeof HermesDatagridActionOverflow, typeof HermesDatagridCell, typeof HermesDatagridColumn, typeof HermesDatagridColumnSeparator, typeof HermesDatagridDetail, typeof HermesDatagridDetailBody, typeof HermesDatagridDetailHeader, typeof HermesDatagridFilter, typeof HermesDatagridFooter, typeof HermesDatagridHideableColumn, typeof HermesDatagridItems, typeof HermesDatagridPageSize, typeof HermesDatagridPagination, typeof HermesDatagridPlaceholder, typeof HermesDatagridRow, typeof HermesDatagridRowDetail, typeof HermesDatagridSelectionCellDirective, typeof HermesDatagridVirtualScrollDirective, typeof HermesIfDetail, typeof DatagridDetailRegisterer, typeof WrappedCell, typeof WrappedColumn, typeof WrappedRow, typeof DatagridCellRenderer, typeof DatagridHeaderRenderer, typeof DatagridMainRenderer, typeof DatagridRowDetailRenderer, typeof DatagridRowRenderer, typeof ActionableOompaLoompa, typeof DatagridWillyWonka, typeof ExpandableOompaLoompa, typeof DatagridNumericFilter, typeof DatagridStringFilter, typeof HermesDatagridColumnToggle, typeof HermesDatagridColumnToggleButton], [typeof i38.CommonModule, typeof i39.CdkDragModule, typeof i39.CdkTrapFocusModule, typeof i40.HermesIcon, typeof i41.HermesInputModule, typeof i42.HermesRadioModule, typeof i43.HermesCheckboxModule, typeof i44.HermesNumberInputModule, typeof i45.HermesNativeSelectModule, typeof i46.FormsModule, typeof i39.HermesLoadingModule, typeof i39.HermesConditionalModule, typeof i39.HermesOutsideClickModule, typeof i39.HermesExpandableAnimationModule, typeof i47.HermesSpinnerModule, typeof i1.HermesPopoverModuleNext, typeof i39.HermesKeyFocusModule, typeof HermesDatagridSingleSelectionValueAccessor, typeof i39.HermesIfExpanded], [typeof HermesDatagrid, typeof HermesDatagridActionBar, typeof HermesDatagridActionOverflow, typeof HermesDatagridCell, typeof HermesDatagridColumn, typeof HermesDatagridColumnSeparator, typeof HermesDatagridDetail, typeof HermesDatagridDetailBody, typeof HermesDatagridDetailHeader, typeof HermesDatagridFilter, typeof HermesDatagridFooter, typeof HermesDatagridHideableColumn, typeof HermesDatagridItems, typeof HermesDatagridPageSize, typeof HermesDatagridPagination, typeof HermesDatagridPlaceholder, typeof HermesDatagridRow, typeof HermesDatagridRowDetail, typeof HermesDatagridSelectionCellDirective, typeof HermesDatagridVirtualScrollDirective, typeof HermesIfDetail, typeof DatagridDetailRegisterer, typeof WrappedCell, typeof WrappedColumn, typeof WrappedRow, typeof DatagridCellRenderer, typeof DatagridHeaderRenderer, typeof DatagridMainRenderer, typeof DatagridRowDetailRenderer, typeof DatagridRowRenderer, typeof ActionableOompaLoompa, typeof DatagridWillyWonka, typeof ExpandableOompaLoompa, typeof DatagridNumericFilter, typeof DatagridStringFilter, typeof HermesDatagridSingleSelectionValueAccessor, typeof i39.HermesIfExpanded]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HermesDatagridModule>;
+}
+
+export { ActionableOompaLoompa, DatagridCellRenderer, DatagridDetailRegisterer, DatagridHeaderRenderer, DatagridMainRenderer, DatagridNumericFilter, DatagridPropertyComparator, DatagridPropertyNumericFilter, DatagridPropertyStringFilter, DatagridRowDetailRenderer, DatagridRowRenderer, DatagridStringFilter, DatagridWillyWonka, ExpandableOompaLoompa, HERMES_DATAGRID_DIRECTIVES, HermesDatagrid, HermesDatagridActionBar, HermesDatagridActionOverflow, HermesDatagridAriaSortOrder, HermesDatagridCell, HermesDatagridColumn, HermesDatagridColumnSeparator, HermesDatagridColumnToggle, HermesDatagridColumnToggleButton, HermesDatagridDetail, HermesDatagridDetailBody, HermesDatagridDetailHeader, HermesDatagridFilter, HermesDatagridFooter, HermesDatagridHideableColumn, HermesDatagridItems, HermesDatagridModule, HermesDatagridPageSize, HermesDatagridPagination, HermesDatagridPlaceholder, HermesDatagridRow, HermesDatagridRowDetail, HermesDatagridSelectionCellDirective, HermesDatagridSingleSelectionValueAccessor, HermesDatagridSortOrder, HermesDatagridVirtualScrollDirective, HermesIfDetail, Selection, SelectionType, WrappedCell, WrappedColumn, WrappedRow, selectionTypeAttribute };
+export type { HermesDatagridComparatorInterface, HermesDatagridFilterInterface, HermesDatagridItemsIdentityFunction, HermesDatagridNumericFilterInterface, HermesDatagridStateInterface, HermesDatagridStringFilterInterface, HermesDatagridVirtualScrollRangeInterface };
+//# sourceMappingURL=hermes-ui-angular-data-datagrid.d.ts.map