@theseam/ui-common 0.4.30 → 1.0.0-beta.0

package/datatable/index.d.ts

@@ -1,5 +1,1339 @@
-/**
- * Generated bundle index. Do not edit.
- */
-/// <amd-module name="@theseam/ui-common/datatable" />
-export * from './public-api';
+import * as _fortawesome_fontawesome_common_types from '@fortawesome/fontawesome-common-types';
+import { BooleanInput, NumberInput } from '@angular/cdk/coercion';
+import { CollectionViewer, DataSource, ListRange } from '@angular/cdk/collections';
+import * as i0 from '@angular/core';
+import { EventEmitter, QueryList, TemplateRef, OnChanges, PipeTransform, SimpleChanges, InjectionToken, KeyValueDiffers, OnInit, OnDestroy, ChangeDetectorRef, ElementRef, ViewContainerRef, NgZone } from '@angular/core';
+import * as rxjs from 'rxjs';
+import { Observable } from 'rxjs';
+import * as i30 from '@marklb/ngx-datatable';
+import { TableColumnProp, TableColumn, SortType, SelectionType, DataTableColumnDirective, DataTableColumnHeaderDirective, DataTableColumnCellTreeToggle, TreeStatus, ColumnMode, ContextmenuType, DatatableComponent as DatatableComponent$1, DatatableRowDetailDirective } from '@marklb/ngx-datatable';
+import * as _theseam_ui_common_data_filters from '@theseam/ui-common/data-filters';
+import { IDataFilter, DataFilterContainer, DataFilter, DataFilterState } from '@theseam/ui-common/data-filters';
+import * as i34 from '@theseam/ui-common/shared';
+import { TheSeamElementResizedEvent } from '@theseam/ui-common/shared';
+import * as i32 from '@angular/cdk/overlay';
+import { ConnectionPositionPair, Overlay } from '@angular/cdk/overlay';
+import * as i35 from '@angular/router';
+import { Router } from '@angular/router';
+import * as i42 from '@theseam/ui-common/confirm-dialog';
+import { SeamConfirmDialogService } from '@theseam/ui-common/confirm-dialog';
+import * as i36 from '@theseam/ui-common/menu';
+import { MenuComponent } from '@theseam/ui-common/menu';
+import { ThemeTypes } from '@theseam/ui-common/models';
+import * as i47 from '@theseam/ui-common/table-cell-type';
+import { TableCellTypeName, TableCellTypeConfig, TableCellTypeColumn, TableCellTypeExportProps } from '@theseam/ui-common/table-cell-type';
+import * as i46 from '@angular/forms';
+import { FormGroup, FormControl, UntypedFormControl } from '@angular/forms';
+import { TheSeamPreferencesBase, TheSeamPreferencesManagerService, TheSeamPreferencesAccessor } from '@theseam/ui-common/services';
+import { AlterationDisplayItem } from '@theseam/ui-common/datatable-alterations-display';
+import * as i38 from '@theseam/ui-common/icon';
+import { SeamIcon } from '@theseam/ui-common/icon';
+import * as i39 from 'ngx-toastr';
+import { ToastrService } from 'ngx-toastr';
+import { IDataExporter } from '@theseam/ui-common/data-exporter';
+import { DynamicValueHelperService } from '@theseam/ui-common/dynamic';
+import * as i40 from '@theseam/ui-common/loading';
+import { TheSeamLoadingOverlayService } from '@theseam/ui-common/loading';
+import { HttpClient } from '@angular/common/http';
+import { TheSeamDynamicComponentLoader } from '@theseam/ui-common/dynamic-component-loader';
+import { Modal } from '@theseam/ui-common/modal';
+import { TheSeamOverlayScrollbarsService } from '@theseam/ui-common/scrollbar';
+import * as i29 from '@angular/common';
+import * as i31 from '@fortawesome/angular-fontawesome';
+import * as i33 from '@angular/cdk/a11y';
+import * as i37 from '@theseam/ui-common/buttons';
+import * as i41 from '@angular/cdk/portal';
+import * as i43 from '@theseam/ui-common/popover';
+import * as i44 from '@theseam/ui-common/checkbox';
+import * as i45 from '@theseam/ui-common/form-field';
+import * as i49 from '@ng-select/ng-select';
+import * as i50 from '@theseam/ui-common/toggle-group';
+
+declare class DatatableActionMenuItemComponent {
+    label: string | undefined | null;
+    href: string | undefined | null;
+    target: string | undefined | null;
+    queryParams: {
+        [k: string]: any;
+    } | undefined | null;
+    fragment: string | undefined | null;
+    queryParamsHandling: any;
+    preserveFragment: boolean | undefined | null;
+    skipLocationChange: boolean | undefined | null;
+    replaceUrl: boolean | undefined | null;
+    state: {
+        [k: string]: any;
+    } | undefined | null;
+    routerLink: string | any[] | undefined | null;
+    confirmDialog: {
+        message?: string;
+        alert?: string | {
+            message: string;
+            type: ThemeTypes;
+        };
+    } | undefined | null;
+    disabled: boolean | undefined | null;
+    subMenu: DatatableActionMenuComponent | undefined | null;
+    readonly click: EventEmitter<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableActionMenuItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableActionMenuItemComponent, "seam-datatable-action-menu-item", never, { "label": { "alias": "label"; "required": false; }; "href": { "alias": "attr.href"; "required": false; }; "target": { "alias": "target"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "fragment": { "alias": "fragment"; "required": false; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; }; "preserveFragment": { "alias": "preserveFragment"; "required": false; }; "skipLocationChange": { "alias": "skipLocationChange"; "required": false; }; "replaceUrl": { "alias": "replaceUrl"; "required": false; }; "state": { "alias": "state"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "confirmDialog": { "alias": "confirmDialog"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "subMenu": { "alias": "subMenu"; "required": false; }; }, { "click": "click"; }, never, never, false, never>;
+}
+
+declare class DatatableActionMenuComponent {
+    private _confirmDialog;
+    private _router;
+    static ngAcceptInputType_isSubMenu: BooleanInput;
+    readonly faEllipsisH: _fortawesome_fontawesome_common_types.IconDefinition;
+    menu?: MenuComponent;
+    items?: QueryList<DatatableActionMenuItemComponent>;
+    /** @ignore */
+    _actionMenuPositions: ConnectionPositionPair[];
+    isSubMenu: boolean;
+    constructor(_confirmDialog: SeamConfirmDialogService, _router: Router);
+    activateItem(event: any, item: DatatableActionMenuItemComponent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableActionMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableActionMenuComponent, "seam-datatable-action-menu", ["seamDatatableActionMenu"], { "isSubMenu": { "alias": "isSubMenu"; "required": false; }; }, {}, ["items"], never, false, never>;
+}
+
+declare class DatatableCellTplDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableCellTplDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatatableCellTplDirective, "[seamDatatableCellTpl]", never, {}, {}, never, never, false, never>;
+}
+
+declare class DatatableColumnChangesService {
+    private columnInputChanges;
+    get columnInputChanges$(): Observable<undefined>;
+    onInputChange(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableColumnChangesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatatableColumnChangesService>;
+}
+
+type _PipeTransform = PipeTransform | PipeTransform;
+declare class DatatableColumnComponent implements OnChanges {
+    private _columnChangesService;
+    name?: string | null;
+    prop?: TableColumnProp | null;
+    flexGrow?: number | null;
+    minWidth?: number | null;
+    maxWidth?: number | null;
+    width?: number | null;
+    resizeable?: boolean | null;
+    sortable?: boolean | null;
+    draggable?: boolean | null;
+    canAutoResize?: boolean | null;
+    comparator?: ((valueA: any, valueB: any, rowA?: any, rowB?: any, sortDirection?: 'asc' | 'desc') => -1 | 0 | 1) | null;
+    headerTemplate?: TemplateRef<any> | null;
+    checkboxable?: boolean | null;
+    headerCheckboxable?: boolean | null;
+    headerClass?: string | ((data: any) => string | any) | null;
+    cellClass?: string | ((data: any) => string | any) | null;
+    frozenLeft?: boolean | null;
+    frozenRight?: boolean | null;
+    pipe?: _PipeTransform | null;
+    isTreeColumn?: boolean | null;
+    treeLevelIndent?: number | null;
+    summaryFunc?: ((cells: any[]) => any) | null;
+    summaryTemplate?: TemplateRef<any> | null;
+    hidden?: boolean | null;
+    private _isFirstChange;
+    cellTplDirective?: DatatableCellTplDirective;
+    _cellTemplateInput?: TemplateRef<any> | null;
+    _cellTemplateQuery?: TemplateRef<any>;
+    get cellTemplate(): TemplateRef<any> | undefined | null;
+    constructor(_columnChangesService: DatatableColumnChangesService);
+    ngOnChanges(changes: SimpleChanges): void;
+    getCellDirective(): DatatableCellTplDirective | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableColumnComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableColumnComponent, "seam-datatable-column", never, { "name": { "alias": "name"; "required": false; }; "prop": { "alias": "prop"; "required": false; }; "flexGrow": { "alias": "flexGrow"; "required": false; }; "minWidth": { "alias": "minWidth"; "required": false; }; "maxWidth": { "alias": "maxWidth"; "required": false; }; "width": { "alias": "width"; "required": false; }; "resizeable": { "alias": "resizeable"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "draggable": { "alias": "draggable"; "required": false; }; "canAutoResize": { "alias": "canAutoResize"; "required": false; }; "comparator": { "alias": "comparator"; "required": false; }; "headerTemplate": { "alias": "headerTemplate"; "required": false; }; "checkboxable": { "alias": "checkboxable"; "required": false; }; "headerCheckboxable": { "alias": "headerCheckboxable"; "required": false; }; "headerClass": { "alias": "headerClass"; "required": false; }; "cellClass": { "alias": "cellClass"; "required": false; }; "frozenLeft": { "alias": "frozenLeft"; "required": false; }; "frozenRight": { "alias": "frozenRight"; "required": false; }; "pipe": { "alias": "pipe"; "required": false; }; "isTreeColumn": { "alias": "isTreeColumn"; "required": false; }; "treeLevelIndent": { "alias": "treeLevelIndent"; "required": false; }; "summaryFunc": { "alias": "summaryFunc"; "required": false; }; "summaryTemplate": { "alias": "summaryTemplate"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "_cellTemplateInput": { "alias": "cellTemplate"; "required": false; }; }, {}, ["cellTplDirective", "_cellTemplateQuery"], never, false, never>;
+}
+
+declare class TheSeamDatatableFooterDirective {
+    _templateInput: TemplateRef<any> | undefined | null;
+    _templateQuery: TemplateRef<any> | undefined | null;
+    get template(): TemplateRef<any> | undefined | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamDatatableFooterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamDatatableFooterDirective, "seam-datatable-footer", never, { "_templateInput": { "alias": "template"; "required": false; }; }, {}, ["_templateQuery"], never, false, never>;
+}
+
+declare class DatatableFilterDirective {
+    private _filter?;
+    constructor(dataFilters: IDataFilter[]);
+    get filter(): _theseam_ui_common_data_filters.DataFilter | undefined;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableFilterDirective, [{ self: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatatableFilterDirective, "[seamDatatableFilter]", never, {}, {}, never, never, false, never>;
+}
+
+declare const _THESEAM_DATA_FILTER_CONTAINER: any;
+declare class DatatableMenuBarComponent implements DataFilterContainer {
+    get filterDirectives(): QueryList<DatatableFilterDirective> | undefined;
+    set filterDirectives(value: QueryList<DatatableFilterDirective> | undefined);
+    private _filterDirectives;
+    private _filtersArr;
+    readonly filtersChanged: EventEmitter<_theseam_ui_common_data_filters.DataFilter[]>;
+    filters(): IDataFilter[];
+    addFilter(dataFilter: IDataFilter): void;
+    removeFilter(dataFilter: IDataFilter): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableMenuBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableMenuBarComponent, "seam-datatable-menu-bar", never, {}, {}, ["filterDirectives"], ["*"], false, never>;
+}
+
+declare class TheSeamDatatableRowDetailDirective {
+    /**
+     * The detail row height is required especially
+     * when virtual scroll is enabled.
+     */
+    rowHeight: number | ((row?: any, index?: number) => number) | undefined | null;
+    _templateInput: TemplateRef<any> | undefined | null;
+    _templateQuery: TemplateRef<any> | undefined | null;
+    get template(): TemplateRef<any> | undefined | null;
+    /**
+     * Row detail row visbility was toggled.
+     */
+    toggle: EventEmitter<any>;
+    /**
+     * Internal use for wrapper only.
+     *
+     * To avoid confusion with this directives output and the ngx-datatable
+     * directive being wrapped, this directive emits `_toggle` stream to the
+     * `ngx-datatable-row-detail` directive and emits it's `toggle` stream out to
+     * this directives `toggle` stream.
+     * @ignore
+     */
+    _toggle: EventEmitter<any>;
+    /**
+     * Toggle the expansion of the row
+     */
+    toggleExpandRow(row: any): void;
+    /**
+     * API method to expand all the rows.
+     */
+    expandAllRows(): void;
+    /**
+     * API method to collapse all the rows.
+     */
+    collapseAllRows(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamDatatableRowDetailDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamDatatableRowDetailDirective, "seam-datatable-row-detail", never, { "rowHeight": { "alias": "rowHeight"; "required": false; }; "_templateInput": { "alias": "template"; "required": false; }; }, { "toggle": "toggle"; }, ["_templateQuery"], never, false, never>;
+}
+
+declare class DatatableRowActionItemDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableRowActionItemDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatatableRowActionItemDirective, "[seamDatatableRowActionItem]", never, {}, {}, never, never, false, never>;
+}
+
+interface TheSeamPageInfo {
+    /**
+     * Index of page.
+     */
+    offset: number;
+    /**
+     * Size of a page.
+     */
+    pageSize: number;
+    /**
+     * Max page size.
+     */
+    limit?: number;
+    /**
+     * Number of rows.
+     */
+    count: number;
+}
+
+interface SortItem {
+    prop: TableColumnProp;
+    dir: 'asc' | 'desc';
+}
+
+interface SortEvent {
+    sorts: SortItem[];
+}
+
+interface TheSeamDatatableColumnHidable {
+    /**
+     * Hide a column, but let the datatable still know about it. Useful for
+     * hidding a columns that can be unhidden through a setting.
+     *
+     * NOTE: If you filter out the column before passing it to the datatable it
+     * will not be able to provide that column as an option in the column toggle
+     * list.
+     */
+    hidden?: boolean;
+}
+interface TheSeamDatatableColumnFilterable<T extends TheSeamDatatableColumnFilterableConfig = any> {
+    filterable?: boolean;
+    /**
+     * Additional options for a specific filter type.
+     */
+    filterOptions?: T;
+}
+interface TheSeamDatatableColumnFilterableConfig {
+    /**
+     * The object name on which to run the filter.
+     *
+     * Defaults to column prop.
+     */
+    filterProp?: string;
+    /**
+     * The type of filter(s) to show in the filter menu.
+     *
+     * If not provided, will look to cellType to determine default filter(s).
+     */
+    filterType?: string;
+}
+type TheSeamDatatableColumn<T extends TableCellTypeName = any, C extends TableCellTypeConfig<T> = any, F extends TheSeamDatatableColumnFilterableConfig = any> = TableColumn & TableCellTypeColumn<T, C> & TableCellTypeExportProps & TheSeamDatatableColumnHidable & TheSeamDatatableColumnFilterable<F>;
+
+interface TheSeamDatatableAccessor {
+    columns: TheSeamDatatableColumn[];
+    readonly columns$: Observable<TheSeamDatatableColumn[]>;
+    rows: any[];
+    readonly rows$: Observable<any[]>;
+    filters: DataFilter[];
+    readonly filters$: Observable<DataFilter[]>;
+    sortType: SortType;
+    sorts: SortItem[];
+    sort: Observable<SortEvent>;
+    readonly filterStates: Observable<DataFilterState[]>;
+    readonly page: Observable<TheSeamPageInfo>;
+    pageInfo: TheSeamPageInfo;
+}
+
+interface ColumnsDataFilterStateState<T = any, O = any> {
+    prop?: string;
+    formValue?: Partial<T>;
+    options?: O;
+    [key: string]: any;
+}
+interface ColumnsDataFilterState<T = any, O = any> extends DataFilterState {
+    state: ColumnsDataFilterStateState<T, O>;
+}
+declare abstract class ColumnsDataFilter<TInitial = any, TForm = FormGroup, TOptions = any, TConfig extends TheSeamDatatableColumnFilterableConfig = any> implements DataFilter {
+    readonly prop: string;
+    readonly initialValue: TInitial;
+    readonly column: TheSeamDatatableColumn<any, any, TConfig>;
+    /**
+     * Name used when referencing filter by string.
+     */
+    abstract readonly name: string;
+    /**
+     * Unique value to prevent a filter being used more than once if it ends up
+     * being registered more than once.
+     */
+    abstract readonly uid: string;
+    abstract readonly form: TForm;
+    /**
+     * Listens for changes in the filter value and emits the current state of the filter.
+     */
+    abstract readonly filterStateChanges: Observable<DataFilterState>;
+    abstract readonly options: TOptions;
+    constructor(prop: string, initialValue: TInitial, column: TheSeamDatatableColumn<any, any, TConfig>);
+    /**
+     * Takes rows, filter form value, and an optional config object, and returns filtered rows.
+     */
+    abstract dataFilter(data: any[], filterValue: TInitial, options: any): any[];
+    /**
+     * Listens for changes in the filter value and filters the data based on the conditions set.
+     */
+    abstract filter<T>(data: T[]): Observable<T[]>;
+    /**
+     * Returns the current state of the filter.
+     */
+    abstract filterState(): ColumnsDataFilterState<TInitial, TOptions>;
+    /**
+     * Returns the form value back to the default.
+     */
+    abstract applyFilter(): void;
+    /**
+     * Returns the form value back to the default.
+     */
+    abstract clearFilter(): void;
+    abstract isDefault(): boolean;
+}
+declare const THESEAM_COLUMNS_DATA_FILTER: InjectionToken<ColumnsDataFilter<any, any, any, any>>;
+
+declare class TheSeamDatatableColumnFilterDirective {
+    filterName: string | undefined | null;
+    _templateInput: TemplateRef<any> | undefined | null;
+    _templateQuery: TemplateRef<any> | undefined | null;
+    get template(): TemplateRef<any> | undefined | null;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamDatatableColumnFilterDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<TheSeamDatatableColumnFilterDirective, "seam-datatable-column-filter", never, { "filterName": { "alias": "filterName"; "required": false; }; "_templateInput": { "alias": "template"; "required": false; }; }, {}, ["_templateQuery"], never, false, never>;
+}
+
+declare class ColumnsFiltersService {
+    private readonly _customColumnsDataFilters?;
+    private readonly _columnFilterTemplates;
+    readonly columnFilterTemplates$: rxjs.Observable<TheSeamDatatableColumnFilterDirective[]>;
+    private readonly _columns;
+    readonly columnsFilters$: rxjs.Observable<any[]>;
+    readonly columnActiveFilterProps$: rxjs.Observable<any[]>;
+    constructor(_customColumnsDataFilters?: {
+        name: string;
+        class: any;
+    }[] | undefined);
+    setFilterTemplates(tpls: TheSeamDatatableColumnFilterDirective[]): void;
+    createColumnDataFilter(column: TheSeamDatatableColumn, initialValue: any): ColumnsDataFilter | null;
+    private _getColumnsDataFilter;
+    private _getColumnsDataFilterType;
+    getColumnFilterProp(column: TheSeamDatatableColumn | null | undefined): string | null;
+    setColumns(columns: TheSeamDatatableColumn[]): void;
+    getColumnFilter(prop: string | null): ColumnsDataFilter | undefined;
+    filters(): ColumnsDataFilter[];
+    addFilter(filter: ColumnsDataFilter): void;
+    removeFilter(filter: ColumnsDataFilter): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsFiltersService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnsFiltersService>;
+}
+
+declare const ActionItemColumnPosition: readonly ["frozenLeft", "frozenRight", "staticLeft", "staticRight"];
+/**
+ * If `frozenLeft`, action item column will be fixed to the left side of the table.
+ *
+ * If `frozenRight`, action item column will be fixed to the right side of the table.
+ *
+ * If `staticLeft`, action item column will be the first static column on the left side of the table.
+ *
+ * If `staticRight`, action item column will be the last static column on the right side of the table.
+ */
+type ActionItemColumnPosition = typeof ActionItemColumnPosition[number];
+
+type InternalColumnsGetter = () => TableColumn[];
+declare class ColumnsManagerService {
+    private readonly _differs;
+    private readonly _columnChangesService;
+    private readonly _columnsFilters;
+    private readonly _updateColumns;
+    private readonly _inputColumns;
+    private readonly _templateColumns;
+    private readonly _inpColDiffersMap;
+    private readonly _tplColDiffersMap;
+    private readonly _resultColDiffersMap;
+    private _colPropsDiffer?;
+    private _internalColumnsGetter?;
+    private _selectionType;
+    private _rowActionItem;
+    private _actionMenuCellTpl;
+    private _actionItemColumnPosition;
+    private _blankHeaderTpl;
+    private _treeToggleTpl;
+    private _headerTpl;
+    private _cellTypeSelectorTpl;
+    readonly columns$: Observable<TheSeamDatatableColumn[]>;
+    constructor(_differs: KeyValueDiffers, _columnChangesService: DatatableColumnChangesService, _columnsFilters: ColumnsFiltersService);
+    setInputColumns(columns: TheSeamDatatableColumn[]): void;
+    setTemplateColumns(columns: DatatableColumnComponent[]): void;
+    setInternalColumnsGetter(getter: InternalColumnsGetter | null): void;
+    setSelectionType(selectionType: SelectionType | undefined): void;
+    getSelectionType(): SelectionType | undefined;
+    setRowActionItem(rowActionItem: DatatableRowActionItemDirective | undefined): void;
+    setActionItemColumnPosition(actionItemColumnPosition: ActionItemColumnPosition | undefined): void;
+    setActionMenuCellTpl(actionMenuCellTpl: TemplateRef<DataTableColumnDirective<any>> | undefined): void;
+    setBlankHeaderTpl(blankHeaderTpl: TemplateRef<DataTableColumnHeaderDirective> | undefined): void;
+    setTreeToggleTpl(treeToggleTpl: TemplateRef<DataTableColumnCellTreeToggle> | undefined): void;
+    setHeaderTpl(headerTpl: TemplateRef<DataTableColumnHeaderDirective> | undefined): void;
+    setCellTypeSelectorTpl(cellTypeSelectorTpl: TemplateRef<DataTableColumnDirective<any>> | undefined): void;
+    private _mergeColumns;
+    private _getInternalColumns;
+    private _getInternalColumn;
+    private _findColumnByProp;
+    private _getDifMapForColumnsType;
+    private _getColumnDiffer;
+    private _getColDif;
+    private _updateColDif;
+    private _hasAddedOrRemovedColumns;
+    private _hasColumnsChanged;
+    private _shouldAddCheckboxColumn;
+    private _shouldAddRowActionColumn;
+    private _rowActionColumnIsFrozenLeft;
+    private _rowActionColumnIsFrozenRight;
+    private _rowActionColumnIsStaticLeft;
+    private _rowActionColumnIsStaticRight;
+    private _shouldAddTreeToggleColumn;
+    private _shouldAddHeaderTemplate;
+    private _shouldAddCellTypeSelectorTpl;
+    private _getExistingFilter;
+    private _createColumnFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnsManagerService>;
+}
+
+interface ColumnsAlterationState<TState = any> {
+    readonly id: string;
+    readonly type: string;
+    readonly state: TState;
+}
+/**
+ * Alteration applied to a column or columns that can be persisted.
+ *
+ * Tracking if a column was altered by user or library code can be confusing.
+ * This allows us to store a list of replayable alterations on columns. By
+ * having a defined way to implement alterations, the datatable should be easier
+ * to support external features that want to provide an alteration.
+ *
+ * NOTE: Current, to unapply an alteration you can create an alteration with
+ * `persistent` set to false and the alteration will be removed after `apply()`
+ * is called.
+ */
+declare abstract class ColumnsAlteration<TState = any> {
+    /**
+     * Persistable state.
+     *
+     * Returned value should be JSON stringifyable.
+     */
+    state: TState;
+    /**
+     * If false, the state will not be persisted to a persistent storage and
+     * will be removed after applied.
+     */
+    readonly persistent: boolean;
+    /**
+     * This should be unique to the alteration, but determinable. When an app is
+     * reloaded and alterations are restored from a persistable storage this
+     * should still be recognizable.
+     */
+    abstract readonly id: string;
+    /**
+     * The alteration type.
+     *
+     * This can be used to group alteraction from a common feature.
+     */
+    abstract readonly type: string;
+    constructor(
+    /**
+     * Persistable state.
+     *
+     * Returned value should be JSON stringifyable.
+     */
+    state: TState, 
+    /**
+     * If false, the state will not be persisted to a persistent storage and
+     * will be removed after applied.
+     */
+    persistent: boolean);
+    /**
+     * Apply alteration to column.
+     */
+    abstract apply(columns: TheSeamDatatableColumn[], datatable: TheSeamDatatableAccessor): void;
+    /**
+     * Convert alteration to display format for UI rendering.
+     */
+    abstract toDisplayItem(): AlterationDisplayItem;
+    /**
+     * Get sort order for grouping alterations of the same type.
+     * Lower numbers appear first.
+     */
+    abstract getDisplaySortOrder(): number;
+    toJSON(): ColumnsAlterationState<TState>;
+}
+
+interface TheSeamDatatablePreferencesColumn {
+    prop: string;
+    width?: number;
+    canAutoResize?: boolean;
+    hidden?: boolean;
+}
+interface TheSeamDatatablePreferences_v1 {
+    columns?: TheSeamDatatablePreferencesColumn[];
+}
+interface TheSeamDatatablePreferences_v2 extends TheSeamPreferencesBase {
+    version: 2;
+    alterations: ColumnsAlterationState[];
+}
+type TheSeamDatatablePreferences = TheSeamDatatablePreferences_v2;
+declare const CURRENT_DATATABLE_PREFERENCES_VERSION = 2;
+declare const EMPTY_DATATABLE_PREFERENCES: TheSeamDatatablePreferences;
+
+declare class DatatablePreferencesService {
+    private readonly _preferencesManager;
+    private _prefsAccessor?;
+    /**
+     * Used to prevent multiple updates from happening at the same time, but it is not per key.
+     */
+    private _pending;
+    constructor(_preferencesManager: TheSeamPreferencesManagerService, _prefsAccessor?: TheSeamPreferencesAccessor | undefined);
+    isPending(preferenceKey: string): boolean;
+    isLoaded(preferenceKey: string): boolean;
+    preferences(preferenceKey: string): Observable<TheSeamDatatablePreferences>;
+    refresh(preferenceKey: string): void;
+    setAlterations(preferenceKey: string, alterations: ColumnsAlterationState[]): void;
+    private _isValidDatatablePreferences;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatablePreferencesService, [null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatatablePreferencesService>;
+}
+
+interface ColumnsAlterationsChangedRecord {
+    type: 'added' | 'removed';
+    alteration: ColumnsAlteration;
+}
+interface ColumnsAlterationsChangedEvent {
+    changes: ColumnsAlterationsChangedRecord[];
+}
+declare class ColumnsAlterationsManagerService {
+    private readonly _changesSubject;
+    private _alterations;
+    readonly changes: Observable<ColumnsAlterationsChangedEvent>;
+    constructor();
+    get(): ColumnsAlteration[];
+    /**
+     * Adds alterations to be applied to columns.
+     *
+     * If an alteration with the same `id` already exists then the existing
+     * alteration will be removed and the new one added.
+     *
+     * NOTE: When there is a duplicate alteration the old alteration is removed,
+     * instead of updated, to maintain the order alterations are applied.
+     */
+    add(alterations: ColumnsAlteration[], options?: {
+        emitEvent?: boolean;
+    }): ColumnsAlterationsChangedRecord[];
+    remove(alterations: ColumnsAlteration[], options?: {
+        emitEvent?: boolean;
+    }): ColumnsAlterationsChangedRecord[];
+    apply(columns: TheSeamDatatableColumn[], datatable: TheSeamDatatableAccessor): void;
+    clear(options?: {
+        emitEvent?: boolean;
+    }): ColumnsAlterationsChangedRecord[];
+    private _removeNonPersistant;
+    private _emitChanges;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnsAlterationsManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ColumnsAlterationsManagerService>;
+}
+
+interface TheSeamDatatableMessages {
+    /**
+     * Message to show when array is presented, but contains no values.
+     *
+     * @default 'No records found'
+     */
+    emptyMessage: string;
+    /**
+     * Footer total message.
+     *
+     * @default 'total'
+     */
+    totalMessage: string;
+    /**
+     * Footer selected message.
+     *
+     * @default 'selected'
+     */
+    selectedMessage: string;
+}
+type TheSeamDatatableColumnFilterUpdateMethod = 'valueChanges' | 'submit';
+/**
+ * A config object that can be injected at the top level of a project
+ * to apply specific TheSeamDatatable settings site-wide.
+ */
+interface TheSeamDatatableConfig {
+    /**
+     * See `TheSeamDatatableMessages`.
+     */
+    messages?: Partial<TheSeamDatatableMessages> | undefined | null;
+    /**
+     * Minimum header height in pixels.
+     *
+     * @default 50
+     */
+    headerHeight?: number | undefined | null;
+    /**
+     * Row height in pixels, necessary for calculating scroll height.
+     *
+     * @default 50
+     */
+    rowHeight?: number | undefined | null;
+    /**
+     * Minimum footer height in pixels.
+     *
+     * @default 40
+     */
+    footerHeight?: number | undefined | null;
+    /**
+     * CSS classes for various icon buttons.
+     *
+     * @default
+     *   sortAscending: 'datatable-icon-up',
+     *   sortDescending: 'datatable-icon-down',
+     *   pagerLeftArrow: 'datatable-icon-left',
+     *   pagerRightArrow: 'datatable-icon-right',
+     *   pagerPrevious: 'datatable-icon-prev',
+     *   pagerNext: 'datatable-icon-skip'
+     */
+    cssClasses?: {
+        [key: string]: string;
+    };
+    /**
+     * Icon to display to the left of the column header
+     * when a column is marked "filterable".
+     *
+     * @default faFilter
+     */
+    columnFilterIcon?: SeamIcon;
+    /**
+     * Determines what kind of action causes a filter column to be applied.
+     *
+     * `valueChanges`: Filter is applied on form `valueChanges` event, with an optional debounce set on `columnFilterUpdateDebounce`.
+     *
+     * `submit`: Filter is applied on form submit. No debounce is applied.
+     *
+     * @default "valueChanges"
+     */
+    columnFilterUpdateMethod?: TheSeamDatatableColumnFilterUpdateMethod;
+    /**
+     * Number of milliseconds to debounce a filter form input before applying the filter change.
+     * Only applicable when `columnFilterUpdateMethod` is `valueChanges`.
+     *
+     * @default 400
+     */
+    columnFilterUpdateDebounce?: number;
+    /**
+     * Sets position behavior for optional Action Menu Button column.
+     *
+     * @default frozenRight
+     */
+    actionItemColumnPosition?: ActionItemColumnPosition;
+}
+declare const THESEAM_DATATABLE_CONFIG: InjectionToken<TheSeamDatatableConfig>;
+
+/**
+ * NOTE: This is still being worked on. I am trying to figure out this model
+ * because `ngx-datatable` just uses an untyped object and sets properties in
+ * multiple places.
+ */
+interface ICellContext {
+    allRowsSelected: false;
+    selectFn: () => any;
+    sortDir?: 'asc' | 'desc';
+    sortFn: () => any;
+    expanded?: boolean;
+    onCheckboxChangeFn?: any;
+    activateFn?: any;
+    row?: any;
+    group?: any;
+    value?: any;
+    column?: TheSeamDatatableColumn;
+    rowHeight?: number;
+    isSelected?: boolean;
+    rowIndex?: number;
+    treeStatus?: TreeStatus;
+    onTreeAction?: any;
+}
+/**
+ * Intended for internal classes declared by the `TheSeamDatatableModule`.
+ */
+declare const THESEAM_DATATABLE: InjectionToken<DataFilter>;
+declare const _THESEAM_DATATABLE: any;
+declare const _THESEAM_DATATABLE_ACCESSOR: any;
+declare class DatatableComponent<TRow = any> implements OnInit, OnDestroy, TheSeamDatatableAccessor, CollectionViewer {
+    private readonly _preferences;
+    private readonly _columnsManager;
+    private readonly _columnsAlterationsManager;
+    private readonly _columnsFilters;
+    private readonly _config?;
+    static ngAcceptInputType_externalPaging: BooleanInput;
+    static ngAcceptInputType_externalSorting: BooleanInput;
+    static ngAcceptInputType_externalFiltering: BooleanInput;
+    static ngAcceptInputType_loadingIndicator: BooleanInput;
+    static ngAcceptInputType_reorderable: BooleanInput;
+    static ngAcceptInputType_swapColumns: BooleanInput;
+    static ngAcceptInputType_groupExpansionDefault: BooleanInput;
+    static ngAcceptInputType_selectAllRowsOnPage: BooleanInput;
+    static ngAcceptInputType_summaryRow: BooleanInput;
+    static ngAcceptInputType_virtualization: BooleanInput;
+    static ngAcceptInputType_scrollbarV: BooleanInput;
+    static ngAcceptInputType_scrollbarH: BooleanInput;
+    static ngAcceptInputType_limit: NumberInput;
+    static ngAcceptInputType_count: NumberInput;
+    static ngAcceptInputType_offset: NumberInput;
+    static ngAcceptInputType_headerHeight: NumberInput;
+    static ngAcceptInputType_rowHeight: NumberInput;
+    static ngAcceptInputType_footerHeight: NumberInput;
+    static ngAcceptInputType_summaryHeight: NumberInput;
+    static ngAcceptInputType_columns: TheSeamDatatableColumn[] | undefined | null;
+    static ngAcceptInputType_sorts: SortItem[] | undefined | null;
+    readonly _faChevronDown: _fortawesome_fontawesome_common_types.IconDefinition;
+    readonly _faChevronRight: _fortawesome_fontawesome_common_types.IconDefinition;
+    readonly _faSpinner: _fortawesome_fontawesome_common_types.IconDefinition;
+    _cdr: ChangeDetectorRef;
+    private readonly _ngUnsubscribe;
+    private readonly _menuBarsFiltersSubject;
+    private readonly _dataSourceSubject;
+    private _resizing;
+    readonly filterStates: Observable<DataFilterState[]>;
+    get filters(): DataFilter[];
+    readonly filters$: Observable<DataFilter[]>;
+    get preferencesKey(): string | undefined | null;
+    set preferencesKey(value: string | undefined | null);
+    private _preferencesKey;
+    targetMarkerTemplate: any;
+    set columns(value: TheSeamDatatableColumn[]);
+    get rows(): any[];
+    set rows(value: any[]);
+    private _rows;
+    rows$: Observable<any[]>;
+    columnMode: ColumnMode | undefined | null;
+    groupRowsBy: string | undefined | null;
+    groupedRows: any[] | undefined | null;
+    selected: any[] | undefined | null;
+    externalPaging: boolean;
+    externalSorting: boolean;
+    externalFiltering: boolean;
+    limit: number | undefined;
+    count: number;
+    offset: number;
+    loadingIndicator: boolean;
+    get selectionType(): SelectionType | undefined | null;
+    set selectionType(value: SelectionType | undefined | null);
+    reorderable: boolean;
+    swapColumns: boolean;
+    get sortType(): SortType;
+    set sortType(value: SortType);
+    _sortType: SortType;
+    get sorts(): SortItem[];
+    set sorts(value: SortItem[]);
+    _sorts: SortItem[];
+    get cssClasses(): {
+        [key: string]: string;
+    } | undefined | null;
+    set cssClasses(value: {
+        [key: string]: string;
+    } | undefined | null);
+    private _cssClassesDefault;
+    _cssClasses: {
+        [key: string]: string;
+    } | undefined | null;
+    get messages(): TheSeamDatatableMessages | undefined | null;
+    set messages(value: TheSeamDatatableMessages | undefined | null);
+    private _messagesDefault;
+    _messages: TheSeamDatatableMessages | undefined | null;
+    rowIdentity: ((x: any) => any) | undefined | null;
+    rowClass: any | undefined | null;
+    selectCheck: any | undefined | null;
+    displayCheck: ((row: any, column?: any, value?: any) => boolean) | undefined | null;
+    groupExpansionDefault: boolean;
+    trackByProp: string | undefined | null;
+    selectAllRowsOnPage: boolean;
+    treeFromRelation: string | undefined | null;
+    treeToRelation: string | undefined | null;
+    summaryRow: boolean;
+    summaryHeight: number;
+    summaryPosition: string | undefined | null;
+    virtualization: boolean;
+    get headerHeight(): number | undefined | null;
+    set headerHeight(value: number | undefined | null);
+    private readonly _headerHeightDefault;
+    _headerHeight: number | undefined | null;
+    get rowHeight(): number | undefined | null;
+    set rowHeight(value: number | undefined | null);
+    private readonly _rowHeightDefault;
+    _rowHeight: number | undefined | null;
+    get footerHeight(): number | undefined | null;
+    set footerHeight(value: number | undefined | null);
+    private readonly _footerHeightDefault;
+    _footerHeight: number | undefined | null;
+    scrollbarV: boolean;
+    scrollbarH: boolean;
+    set dataSource(value: DataSource<any> | any[] | undefined | null);
+    /**
+     * Sets position behavior for optional Action Menu Button column.
+     *
+     * Defaults to `frozenRight`.
+     */
+    get actionItemColumnPosition(): ActionItemColumnPosition | undefined;
+    set actionItemColumnPosition(value: ActionItemColumnPosition | undefined);
+    private readonly _actionItemColumnPositionDefault;
+    _actionItemColumnPosition: ActionItemColumnPosition | undefined;
+    get columnFilterIcon(): SeamIcon | undefined | null;
+    set columnFilterIcon(value: SeamIcon | undefined | null);
+    private readonly _columnFilterIconDefault;
+    _columnFilterIcon: SeamIcon | undefined | null;
+    get columnFilterUpdateMethod(): TheSeamDatatableColumnFilterUpdateMethod | undefined | null;
+    set columnFilterUpdateMethod(value: TheSeamDatatableColumnFilterUpdateMethod | undefined | null);
+    private readonly _columnFilterUpdateMethodDefault;
+    _columnFilterUpdateMethod: TheSeamDatatableColumnFilterUpdateMethod | undefined | null;
+    get columnFilterUpdateDebounce(): number | undefined | null;
+    set columnFilterUpdateDebounce(value: number | undefined | null);
+    private readonly _columnFilterUpdateDebounceDefault;
+    _columnFilterUpdateDebounce: number | undefined | null;
+    readonly scroll: EventEmitter<any>;
+    readonly activate: EventEmitter<any>;
+    readonly select: EventEmitter<any>;
+    readonly sort: EventEmitter<SortEvent>;
+    readonly page: EventEmitter<TheSeamPageInfo>;
+    readonly reorder: EventEmitter<any>;
+    readonly resize: EventEmitter<any>;
+    readonly tableContextmenu: EventEmitter<{
+        event: MouseEvent;
+        type: ContextmenuType;
+        content: any;
+    }>;
+    readonly treeAction: EventEmitter<any>;
+    readonly actionRefreshRequest: EventEmitter<void>;
+    readonly hiddenColumnsChange: EventEmitter<string[]>;
+    set columnComponents(value: QueryList<DatatableColumnComponent> | undefined);
+    actionMenu?: DatatableActionMenuComponent;
+    get rowActionItem(): DatatableRowActionItemDirective | undefined;
+    set rowActionItem(value: DatatableRowActionItemDirective | undefined);
+    private _rowActionItem;
+    rowDetail?: TheSeamDatatableRowDetailDirective;
+    footer?: TheSeamDatatableFooterDirective;
+    get menuBarComponent(): DatatableMenuBarComponent | undefined;
+    set menuBarComponent(value: DatatableMenuBarComponent | undefined);
+    private _menuBarComponent;
+    private _menuBarSub;
+    set columnFilterTemplates(value: QueryList<TheSeamDatatableColumnFilterDirective> | undefined);
+    ngxDatatable?: DatatableComponent$1;
+    ngxDatatableElement?: ElementRef;
+    ngxRowDetail?: DatatableRowDetailDirective;
+    get actionMenuCellTpl(): TemplateRef<DataTableColumnDirective<any>> | undefined;
+    set actionMenuCellTpl(value: TemplateRef<DataTableColumnDirective<any>> | undefined);
+    private _actionMenuCellTpl;
+    get treeToggleTpl(): TemplateRef<DataTableColumnCellTreeToggle> | undefined;
+    set treeToggleTpl(value: TemplateRef<DataTableColumnCellTreeToggle> | undefined);
+    private _treeToggleTpl;
+    get headerTpl(): TemplateRef<DataTableColumnHeaderDirective> | undefined;
+    set headerTpl(value: TemplateRef<DataTableColumnHeaderDirective> | undefined);
+    private _headerTpl;
+    get blankHeaderTpl(): TemplateRef<DataTableColumnHeaderDirective> | undefined;
+    set blankHeaderTpl(value: TemplateRef<DataTableColumnHeaderDirective> | undefined);
+    private _blankHeaderTpl;
+    get cellTypeSelectorTpl(): TemplateRef<DataTableColumnDirective<any>> | undefined;
+    set cellTypeSelectorTpl(value: TemplateRef<DataTableColumnDirective<any>> | undefined);
+    private _cellTypeSelectorTpl;
+    columnComponents$?: Observable<DatatableColumnComponent[]>;
+    private _colDiffersInp;
+    private _colDiffersTpl;
+    readonly columns$: Observable<TheSeamDatatableColumn[]>;
+    readonly displayColumns$: Observable<TheSeamDatatableColumn[]>;
+    viewChange: Observable<ListRange>;
+    private _rowDetailToggleSubscription;
+    _dblClick(event: any): void;
+    constructor(_preferences: DatatablePreferencesService, _columnsManager: ColumnsManagerService, _columnsAlterationsManager: ColumnsAlterationsManagerService, _columnsFilters: ColumnsFiltersService, _config?: TheSeamDatatableConfig | undefined);
+    ngOnInit(): void;
+    /** Sets missing inputs from config */
+    private _setDatatableConfigOrDefault;
+    ngOnDestroy(): void;
+    private _setMenuBarFilters;
+    getColumnComponent(propName: string): DatatableColumnComponent | null;
+    _columnData(col: any): {
+        col: any;
+        comp: DatatableColumnComponent | null;
+    };
+    _getRowExpanded(row: any): boolean;
+    trackByFnColumn(index: number, item: any): any;
+    onDatatableResize(event: TheSeamElementResizedEvent): void;
+    _onResize(event: any): void;
+    _onReorder(event: any): void;
+    _onSort(event: any): void;
+    _onTreeAction(event: any): void;
+    triggerActionRefreshRequest(): void;
+    /**
+     * Returns the page info from the wrapped NgxDatatable instance or defaults.
+     */
+    get pageInfo(): TheSeamPageInfo;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableComponent<any>, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableComponent<any>, "seam-datatable", never, { "preferencesKey": { "alias": "preferencesKey"; "required": false; }; "targetMarkerTemplate": { "alias": "targetMarkerTemplate"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "rows": { "alias": "rows"; "required": false; }; "columnMode": { "alias": "columnMode"; "required": false; }; "groupRowsBy": { "alias": "groupRowsBy"; "required": false; }; "groupedRows": { "alias": "groupedRows"; "required": false; }; "selected": { "alias": "selected"; "required": false; }; "externalPaging": { "alias": "externalPaging"; "required": false; }; "externalSorting": { "alias": "externalSorting"; "required": false; }; "externalFiltering": { "alias": "externalFiltering"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "count": { "alias": "count"; "required": false; }; "offset": { "alias": "offset"; "required": false; }; "loadingIndicator": { "alias": "loadingIndicator"; "required": false; }; "selectionType": { "alias": "selectionType"; "required": false; }; "reorderable": { "alias": "reorderable"; "required": false; }; "swapColumns": { "alias": "swapColumns"; "required": false; }; "sortType": { "alias": "sortType"; "required": false; }; "sorts": { "alias": "sorts"; "required": false; }; "cssClasses": { "alias": "cssClasses"; "required": false; }; "messages": { "alias": "messages"; "required": false; }; "rowIdentity": { "alias": "rowIdentity"; "required": false; }; "rowClass": { "alias": "rowClass"; "required": false; }; "selectCheck": { "alias": "selectCheck"; "required": false; }; "displayCheck": { "alias": "displayCheck"; "required": false; }; "groupExpansionDefault": { "alias": "groupExpansionDefault"; "required": false; }; "trackByProp": { "alias": "trackByProp"; "required": false; }; "selectAllRowsOnPage": { "alias": "selectAllRowsOnPage"; "required": false; }; "treeFromRelation": { "alias": "treeFromRelation"; "required": false; }; "treeToRelation": { "alias": "treeToRelation"; "required": false; }; "summaryRow": { "alias": "summaryRow"; "required": false; }; "summaryHeight": { "alias": "summaryHeight"; "required": false; }; "summaryPosition": { "alias": "summaryPosition"; "required": false; }; "virtualization": { "alias": "virtualization"; "required": false; }; "headerHeight": { "alias": "headerHeight"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "footerHeight": { "alias": "footerHeight"; "required": false; }; "scrollbarV": { "alias": "scrollbarV"; "required": false; }; "scrollbarH": { "alias": "scrollbarH"; "required": false; }; "dataSource": { "alias": "dataSource"; "required": false; }; "actionItemColumnPosition": { "alias": "actionItemColumnPosition"; "required": false; }; "columnFilterIcon": { "alias": "columnFilterIcon"; "required": false; }; "columnFilterUpdateMethod": { "alias": "columnFilterUpdateMethod"; "required": false; }; "columnFilterUpdateDebounce": { "alias": "columnFilterUpdateDebounce"; "required": false; }; }, { "scroll": "scroll"; "activate": "activate"; "select": "select"; "sort": "sort"; "page": "page"; "reorder": "reorder"; "resize": "resize"; "tableContextmenu": "tableContextmenu"; "treeAction": "treeAction"; "actionRefreshRequest": "actionRefreshRequest"; "hiddenColumnsChange": "hiddenColumnsChange"; }, ["actionMenu", "rowActionItem", "rowDetail", "footer", "menuBarComponent", "columnComponents", "columnFilterTemplates"], ["seam-datatable-menu-bar"], false, never>;
+}
+
+declare class DatatableColumnFilterMenuComponent implements OnInit {
+    private readonly _columnsFilters;
+    _filterForm: FormGroup<any> | undefined;
+    column: TheSeamDatatableColumn | null | undefined;
+    updateMethod: TheSeamDatatableColumnFilterUpdateMethod | null | undefined;
+    debounce: number | null | undefined;
+    columnFilterProp: string | null | null | undefined;
+    columnFilter: ColumnsDataFilter<any, any> | null | undefined;
+    customFilterTemplate$: Observable<any> | null | undefined;
+    closePopover: EventEmitter<any>;
+    constructor(_columnsFilters: ColumnsFiltersService);
+    ngOnInit(): void;
+    submit(): void;
+    clearFilter(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableColumnFilterMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableColumnFilterMenuComponent, "seam-datatable-column-filter-menu", never, { "column": { "alias": "column"; "required": false; }; "updateMethod": { "alias": "updateMethod"; "required": false; }; "debounce": { "alias": "debounce"; "required": false; }; }, { "closePopover": "closePopover"; }, never, never, false, never>;
+}
+
+declare const THESEAM_COLUMNS_DATA_FILTER_DATE_SEARCH_NAME: "search-date";
+declare const THESEAM_COLUMNS_DATA_FILTER_DATE_SEARCH_TYPES: readonly ["lt", "lte", "gt", "gte", "eq", "blank", "not-blank", "between", "not-between"];
+declare const THESEAM_COLUMNS_DATA_FILTER_DATE_TEXT_SEARCH_TYPES: string[];
+declare const THESEAM_COLUMNS_DATA_FILTER_DATE_RANGE_SEARCH_TYPES: string[];
+declare const THESEAM_COLUMNS_DATA_FILTER_DATE_SELECT_SEARCH_TYPES: string[];
+type TheSeamColumnsDataFilterDateSearchType = typeof THESEAM_COLUMNS_DATA_FILTER_DATE_SEARCH_TYPES[number];
+type TheSeamColumnsDataFilterDateSearchForm = FormGroup<{
+    searchType: FormControl<TheSeamColumnsDataFilterDateSearchType | null>;
+    searchText: FormControl<string | null>;
+    fromText: FormControl<string | null>;
+    toText: FormControl<string | null>;
+}>;
+interface TheSeamColumnsDataFilterDateSearchFormState {
+    searchType: TheSeamColumnsDataFilterDateSearchType | null;
+    searchText: string | null;
+    fromText: string | null;
+    toText: string | null;
+}
+type TheSeamColumnsDataFilterDateSearchDateType = 'date' | 'datetime-local';
+interface TheSeamDatatableDateColumnFilterableConfig extends TheSeamDatatableColumnFilterableConfig {
+    /**
+     * The input type to use for the date filter form.
+     */
+    dateType?: TheSeamColumnsDataFilterDateSearchDateType;
+    /**
+     * When set to true, assumes provided date is in local time.
+     */
+    useLocalTime?: boolean;
+}
+interface TheSeamColumnsDataFilterDateSearchOptions {
+    dateType: TheSeamColumnsDataFilterDateSearchDateType;
+}
+declare const THESEAM_COLUMNS_DATA_FILTER_NUMERIC_SEARCH_NAME: "search-numeric";
+declare const THESEAM_COLUMNS_DATA_FILTER_NUMERIC_SEARCH_TYPES: readonly ["gt", "lt", "eq", "gte", "lte", "blank", "not-blank", "between", "not-between"];
+declare const THESEAM_COLUMNS_DATA_FILTER_NUMERIC_TEXT_SEARCH_TYPES: string[];
+declare const THESEAM_COLUMNS_DATA_FILTER_NUMERIC_RANGE_SEARCH_TYPES: string[];
+declare const THESEAM_COLUMNS_DATA_FILTER_NUMERIC_SELECT_SEARCH_TYPES: string[];
+type TheSeamColumnsDataFilterNumericSearchType = typeof THESEAM_COLUMNS_DATA_FILTER_NUMERIC_SEARCH_TYPES[number];
+type TheSeamColumnsDataFilterNumericSearchForm = FormGroup<{
+    searchType: FormControl<TheSeamColumnsDataFilterNumericSearchType | null>;
+    searchText: FormControl<string | null>;
+    fromText: FormControl<string | null>;
+    toText: FormControl<string | null>;
+}>;
+type TheSeamColumnsDataFilterNumericSearchFormState = {
+    searchType: TheSeamColumnsDataFilterNumericSearchType | null;
+    searchText: string | null;
+    fromText: string | null;
+    toText: string | null;
+};
+declare const THESEAM_COLUMNS_DATA_FILTER_TEXT_SEARCH_NAME: "search-text";
+declare const THESEAM_COLUMNS_DATA_FILTER_TEXT_SEARCH_TYPES: readonly ["contains", "ncontains", "eq", "neq", "blank", "not-blank"];
+declare const THESEAM_COLUMNS_DATA_FILTER_TEXT_TEXT_SEARCH_TYPES: string[];
+declare const THESEAM_COLUMNS_DATA_FILTER_TEXT_SELECT_SEARCH_TYPES: string[];
+type TheSeamColumnsDataFilterTextSearchType = typeof THESEAM_COLUMNS_DATA_FILTER_TEXT_SEARCH_TYPES[number];
+type TheSeamColumnsDataFilterTextSearchForm = FormGroup<{
+    searchType: FormControl<TheSeamColumnsDataFilterTextSearchType | null>;
+    searchText: FormControl<string | null>;
+}>;
+type TheSeamColumnsDataFilterTextSearchFormState = {
+    searchType: TheSeamColumnsDataFilterTextSearchType | null;
+    searchText: string | null;
+};
+
+declare class DatatableColumnFilterSearchDateComponent implements OnInit {
+    searchTypes: {
+        label: string;
+        value: TheSeamColumnsDataFilterDateSearchType;
+    }[];
+    options: TheSeamColumnsDataFilterDateSearchOptions | undefined;
+    filterForm: TheSeamColumnsDataFilterDateSearchForm | undefined;
+    dateFormat: TheSeamColumnsDataFilterDateSearchDateType | undefined;
+    showSearchInput$: Observable<boolean> | undefined;
+    showRangeInputs$: Observable<boolean> | undefined;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableColumnFilterSearchDateComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableColumnFilterSearchDateComponent, "seam-datatable-column-filter-search-date", never, { "options": { "alias": "options"; "required": false; }; "filterForm": { "alias": "filterForm"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DatatableColumnFilterSearchNumericComponent implements OnInit {
+    searchTypes: {
+        label: string;
+        value: TheSeamColumnsDataFilterNumericSearchType;
+    }[];
+    filterForm: TheSeamColumnsDataFilterNumericSearchForm | undefined;
+    showSearchInput$: Observable<boolean> | undefined;
+    showRangeInputs$: Observable<boolean> | undefined;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableColumnFilterSearchNumericComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableColumnFilterSearchNumericComponent, "seam-datatable-column-filter-search-numeric", never, { "filterForm": { "alias": "filterForm"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DatatableColumnFilterSearchTextComponent implements OnInit {
+    searchTypes: {
+        label: string;
+        value: TheSeamColumnsDataFilterTextSearchType;
+    }[];
+    filterForm: TheSeamColumnsDataFilterTextSearchForm | undefined;
+    showTextbox$: Observable<boolean> | undefined;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableColumnFilterSearchTextComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableColumnFilterSearchTextComponent, "seam-datatable-column-filter-search-text", never, { "filterForm": { "alias": "filterForm"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DatatableColumnPreferencesComponent {
+    private _datatable;
+    private readonly _columnsAlterationsManager;
+    _columns$: Observable<TheSeamDatatableColumn[]>;
+    _filterControl: UntypedFormControl;
+    constructor(_datatable: DatatableComponent, _columnsAlterationsManager: ColumnsAlterationsManagerService);
+    private _canToggleColumn;
+    private _columnMatchesFilter;
+    _onChange(event: any, col: TheSeamDatatableColumn): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableColumnPreferencesComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableColumnPreferencesComponent, "seam-datatable-column-preferences", never, {}, {}, never, never, false, never>;
+}
+
+declare class DatatableColumnPreferencesButtonComponent {
+    private readonly _columnsAlterationsManager;
+    icon: _fortawesome_fontawesome_common_types.IconDefinition;
+    /** @ignore */
+    _actionMenuPositions: ConnectionPositionPair[];
+    constructor(_columnsAlterationsManager: ColumnsAlterationsManagerService);
+    _resetColumns(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableColumnPreferencesButtonComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableColumnPreferencesButtonComponent, "seam-datatable-column-preferences-button", never, {}, {}, never, never, false, never>;
+}
+
+interface IDatatableExportButtonData {
+    exporters: IDataExporter[];
+}
+declare class DatatableExportButtonComponent {
+    private readonly _datatable;
+    private readonly _toastr;
+    private readonly _loading;
+    private readonly _valueHelper;
+    private readonly _data?;
+    icon: _fortawesome_fontawesome_common_types.IconDefinition;
+    exporters: IDataExporter[] | undefined | null;
+    get disabled(): boolean;
+    constructor(_datatable: DatatableComponent, _toastr: ToastrService, _loading: TheSeamLoadingOverlayService, _valueHelper: DynamicValueHelperService, _data?: IDatatableExportButtonData | undefined);
+    _onExporterClicked(exporter: IDataExporter): void;
+    private _mapExportData;
+    private _rowValue;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableExportButtonComponent, [null, null, null, null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableExportButtonComponent, "seam-datatable-export-button", never, { "exporters": { "alias": "exporters"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DatatableFooterTplDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableFooterTplDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatatableFooterTplDirective, "[seamDatatableFooterTpl]", never, {}, {}, never, never, false, never>;
+}
+
+declare class DatatableMenuBarColumnCenterComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableMenuBarColumnCenterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableMenuBarColumnCenterComponent, "seam-datatable-menu-bar-column-center", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class DatatableMenuBarColumnLeftComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableMenuBarColumnLeftComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableMenuBarColumnLeftComponent, "seam-datatable-menu-bar-column-left", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class DatatableMenuBarColumnRightComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableMenuBarColumnRightComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableMenuBarColumnRightComponent, "seam-datatable-menu-bar-column-right", never, {}, {}, never, ["*"], false, never>;
+}
+
+declare class DatatableMenuBarRowComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableMenuBarRowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableMenuBarRowComponent, "seam-datatable-menu-bar-row", never, {}, {}, never, ["*"], false, never>;
+}
+
+interface MenubarItemData {
+    value: any;
+}
+
+declare class DatatableMenuBarTextComponent {
+    private _menuBar;
+    private _data;
+    value: string | undefined | null;
+    constructor(_menuBar: DatatableMenuBarComponent, _data: MenubarItemData | null);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableMenuBarTextComponent, [null, { optional: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DatatableMenuBarTextComponent, "seam-datatable-menu-bar-text", never, { "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DatatableRowDetailTplDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableRowDetailTplDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatatableRowDetailTplDirective, "[seamDatatableRowDetailTpl]", never, {}, {}, never, never, false, never>;
+}
+
+interface TheSeamDatatableRow {
+    [prop: string]: any;
+}
+declare class DatatableActionMenuItemDirective {
+    private readonly _modal;
+    private readonly _dynamicComponentLoader;
+    private readonly _http;
+    _listGroupItem: boolean;
+    _listGroupItemAction: boolean;
+    label: string | undefined | null;
+    href: string | undefined | null;
+    target: string | undefined | null;
+    queryParams: {
+        [k: string]: any;
+    } | undefined | null;
+    fragment: string | undefined | null;
+    queryParamsHandling: any | undefined | null;
+    preserveFragment: boolean | undefined | null;
+    skipLocationChange: boolean | undefined | null;
+    replaceUrl: boolean | undefined | null;
+    state: {
+        [k: string]: any;
+    } | undefined | null;
+    routerLink: string | any[] | undefined | null;
+    confirmDialog: any;
+    row: TheSeamDatatableRow | undefined | null;
+    click: EventEmitter<any>;
+    constructor(_modal: Modal, _dynamicComponentLoader: TheSeamDynamicComponentLoader, _http: HttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableActionMenuItemDirective, [null, null, { optional: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatatableActionMenuItemDirective, "[seamDatatableActionMenuItem]", never, { "label": { "alias": "label"; "required": false; }; "href": { "alias": "attr.href"; "required": false; }; "target": { "alias": "target"; "required": false; }; "queryParams": { "alias": "queryParams"; "required": false; }; "fragment": { "alias": "fragment"; "required": false; }; "queryParamsHandling": { "alias": "queryParamsHandling"; "required": false; }; "preserveFragment": { "alias": "preserveFragment"; "required": false; }; "skipLocationChange": { "alias": "skipLocationChange"; "required": false; }; "replaceUrl": { "alias": "replaceUrl"; "required": false; }; "state": { "alias": "state"; "required": false; }; "routerLink": { "alias": "routerLink"; "required": false; }; "confirmDialog": { "alias": "confirmDialog"; "required": false; }; "row": { "alias": "row"; "required": false; }; }, { "click": "click"; }, never, never, false, never>;
+}
+
+declare class DatatableActionMenuToggleDirective {
+    private _elementRef;
+    private _viewContainerRef;
+    private _overlay;
+    seamDatatableActionMenuToggle: TemplateRef<HTMLElement> | undefined | null;
+    private _active;
+    private _overlayRef?;
+    private _actionDown;
+    _onKeydown(event: any): void;
+    _onClick(event: any): void;
+    _mouseDown(event: any): void;
+    _pointerDown(event: any): void;
+    _mouseUp(event: any): void;
+    _pointerUp(event: any): void;
+    constructor(_elementRef: ElementRef<HTMLElement>, _viewContainerRef: ViewContainerRef, _overlay: Overlay);
+    get active(): boolean;
+    toggle(): void;
+    enable(): void;
+    disable(): void;
+    private getOverlayPosition;
+    private getPositions;
+    onFocusChangeOverlay(event: any): void;
+    onInputDown(event: any): void;
+    onInputUp(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableActionMenuToggleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatatableActionMenuToggleDirective, "[seamDatatableActionMenuToggle]", ["seamDatatableActionMenuToggle"], { "seamDatatableActionMenuToggle": { "alias": "seamDatatableActionMenuToggle"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DatatableColumnFilterTplDirective {
+    template: TemplateRef<any>;
+    constructor(template: TemplateRef<any>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatatableColumnFilterTplDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DatatableColumnFilterTplDirective, "[seamDatatableColumnFilterTpl]", never, {}, {}, never, never, false, never>;
+}
+
+declare class SearchDateColumnsDataFilter extends ColumnsDataFilter<TheSeamColumnsDataFilterDateSearchFormState, TheSeamColumnsDataFilterDateSearchForm, TheSeamColumnsDataFilterDateSearchOptions, TheSeamDatatableDateColumnFilterableConfig> {
+    readonly name: "search-date";
+    readonly uid: string;
+    form: TheSeamColumnsDataFilterDateSearchForm;
+    filterStateChanges: Observable<DataFilterState>;
+    options: TheSeamColumnsDataFilterDateSearchOptions;
+    private _updateFilterValue;
+    constructor(prop: string, initialValue: TheSeamColumnsDataFilterDateSearchFormState, column: TheSeamDatatableColumn<any, any, TheSeamDatatableDateColumnFilterableConfig>);
+    dataFilter(data: any[], filterValue: Partial<TheSeamColumnsDataFilterDateSearchFormState>, options: any): any[];
+    private _isInvalidDate;
+    private _isInvalidSearchTerm;
+    private _dateSearchDataFilter;
+    filter(data: any[]): Observable<any[]>;
+    filterState(): ColumnsDataFilterState<TheSeamColumnsDataFilterDateSearchFormState, TheSeamColumnsDataFilterDateSearchOptions>;
+    applyFilter(): void;
+    clearFilter(): void;
+    isDefault(): boolean;
+}
+
+declare class SearchNumericColumnsDataFilter extends ColumnsDataFilter<TheSeamColumnsDataFilterNumericSearchFormState, TheSeamColumnsDataFilterNumericSearchForm, undefined> {
+    readonly name: "search-numeric";
+    readonly uid: string;
+    form: TheSeamColumnsDataFilterNumericSearchForm;
+    filterStateChanges: Observable<DataFilterState>;
+    options: any;
+    private _updateFilterValue;
+    constructor(prop: string, initialValue: TheSeamColumnsDataFilterNumericSearchFormState, column: TheSeamDatatableColumn);
+    dataFilter(data: any[], filterValue: Partial<TheSeamColumnsDataFilterNumericSearchFormState>, options: any): any[];
+    private _isInvalidSearchTerm;
+    private numberSearchDataFilter;
+    filter(data: any[]): Observable<any[]>;
+    filterState(): ColumnsDataFilterState<TheSeamColumnsDataFilterNumericSearchFormState>;
+    applyFilter(): void;
+    clearFilter(): void;
+    isDefault(): boolean;
+}
+
+declare class SearchTextColumnsDataFilter extends ColumnsDataFilter<TheSeamColumnsDataFilterTextSearchFormState, TheSeamColumnsDataFilterTextSearchForm> {
+    readonly name: "search-text";
+    readonly uid: string;
+    form: TheSeamColumnsDataFilterTextSearchForm;
+    filterStateChanges: Observable<DataFilterState>;
+    options: any;
+    private _updateFilterValue;
+    constructor(prop: string, initialValue: TheSeamColumnsDataFilterTextSearchFormState, column: TheSeamDatatableColumn);
+    dataFilter(data: any[], filterValue: Partial<TheSeamColumnsDataFilterTextSearchFormState>, options: any): any[];
+    private _textSearchDataFilter;
+    filter(data: any[]): Observable<any[]>;
+    filterState(): ColumnsDataFilterState<TheSeamColumnsDataFilterTextSearchFormState>;
+    applyFilter(): void;
+    clearFilter(): void;
+    isDefault(): boolean;
+}
+
+declare const THESEAM_COLUMNS_DATA_FILTERS_DEFAULT: readonly [{
+    readonly name: "search-text";
+    readonly class: typeof SearchTextColumnsDataFilter;
+}, {
+    readonly name: "search-numeric";
+    readonly class: typeof SearchNumericColumnsDataFilter;
+}, {
+    readonly name: "search-date";
+    readonly class: typeof SearchDateColumnsDataFilter;
+}];
+declare const getFormattedDateForComparison: (date: string | number | Date | null | undefined, dateType: TheSeamColumnsDataFilterDateSearchDateType, setToLocalTime?: boolean) => Date;
+
+declare abstract class DatatableDataSource<TRow> extends DataSource<TRow> {
+    private readonly _datatableSubject;
+    readonly sorts$: Observable<SortItem[]>;
+    readonly filterStates$: Observable<DataFilterState[]>;
+    readonly page$: Observable<TheSeamPageInfo>;
+    constructor();
+    setDatatableAccessor(accessor: TheSeamDatatableAccessor): void;
+}
+
+declare class DatatableGqlDataSource<TRow> extends DatatableDataSource<TRow> {
+    connect(collectionViewer: CollectionViewer): Observable<readonly TRow[]>;
+    disconnect(collectionViewer: CollectionViewer): void;
+}
+
+/** @deprecated Use `TheSeamPreferencesAccessor` instead. */
+type TheSeamDatatablePreferencesAccessor = TheSeamPreferencesAccessor;
+
+declare class TheSeamDatatableScrollbarHelperService {
+    private _ngZone;
+    private _scrollbars;
+    width: number;
+    /**
+     * Animates programmatic scrolling, such as switching pages.
+     *
+     * NOTE: Animating the scrolling works, but the datatable may need changes
+     * before this is enabled, because it seems a little stuttery when it moves.
+     */
+    animatedScrolling: boolean;
+    animatedScrollingTime: number;
+    constructor(_ngZone: NgZone, _scrollbars: TheSeamOverlayScrollbarsService);
+    onInitScroller(scroller: any): void;
+    onDestroyScroller(scroller: any): void;
+    setOffset(scroller: any, offsetY: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamDatatableScrollbarHelperService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TheSeamDatatableScrollbarHelperService>;
+}
+
+declare const THESEAM_DATATABLE_PREFERENCES_ACCESSOR: InjectionToken<TheSeamPreferencesAccessor>;
+
+declare const THESEAM_MENUBAR_ITEM_DATA: InjectionToken<MenubarItemData>;
+
+declare function withStoredColumnInfo(columns: TheSeamDatatableColumn[], preferenceColumns: TheSeamDatatablePreferencesColumn[]): TheSeamDatatableColumn[];
+
+declare function mapColumnsAlterationsStates(states: ColumnsAlterationState[]): ColumnsAlteration[];
+
+declare class TheSeamDatatableModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<TheSeamDatatableModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<TheSeamDatatableModule, [typeof DatatableComponent, typeof DatatableCellTplDirective, typeof DatatableColumnComponent, typeof DatatableActionMenuComponent, typeof DatatableActionMenuToggleDirective, typeof DatatableActionMenuItemComponent, typeof DatatableMenuBarComponent, typeof DatatableFilterDirective, typeof DatatableRowActionItemDirective, typeof DatatableExportButtonComponent, typeof TheSeamDatatableRowDetailDirective, typeof DatatableRowDetailTplDirective, typeof TheSeamDatatableFooterDirective, typeof DatatableFooterTplDirective, typeof DatatableColumnPreferencesComponent, typeof DatatableColumnPreferencesButtonComponent, typeof DatatableActionMenuItemDirective, typeof DatatableMenuBarRowComponent, typeof DatatableMenuBarColumnLeftComponent, typeof DatatableMenuBarColumnCenterComponent, typeof DatatableMenuBarColumnRightComponent, typeof DatatableMenuBarTextComponent, typeof DatatableColumnFilterMenuComponent, typeof DatatableColumnFilterSearchTextComponent, typeof DatatableColumnFilterSearchNumericComponent, typeof DatatableColumnFilterSearchDateComponent, typeof DatatableColumnFilterTplDirective, typeof TheSeamDatatableColumnFilterDirective], [typeof i29.CommonModule, typeof i30.NgxDatatableModule, typeof i31.FontAwesomeModule, typeof i32.OverlayModule, typeof i33.A11yModule, typeof i34.TheSeamSharedModule, typeof i35.RouterModule, typeof i36.TheSeamMenuModule, typeof i37.TheSeamButtonsModule, typeof i38.TheSeamIconModule, typeof i39.ToastrModule, typeof i40.TheSeamLoadingModule, typeof i41.PortalModule, typeof i42.TheSeamConfirmDialogModule, typeof i43.TheSeamPopoverModule, typeof i44.TheSeamCheckboxComponent, typeof i45.TheSeamFormFieldModule, typeof i46.ReactiveFormsModule, typeof i47.TheSeamTableCellTypeModule, typeof _theseam_ui_common_data_filters.TheSeamDataFiltersModule, typeof i49.NgSelectModule, typeof i50.TheSeamToggleGroupModule], [typeof DatatableComponent, typeof DatatableCellTplDirective, typeof DatatableColumnComponent, typeof DatatableActionMenuComponent, typeof DatatableActionMenuItemComponent, typeof DatatableMenuBarComponent, typeof DatatableFilterDirective, typeof DatatableRowActionItemDirective, typeof DatatableExportButtonComponent, typeof TheSeamDatatableRowDetailDirective, typeof DatatableRowDetailTplDirective, typeof TheSeamDatatableFooterDirective, typeof DatatableFooterTplDirective, typeof DatatableColumnPreferencesComponent, typeof DatatableColumnPreferencesButtonComponent, typeof DatatableActionMenuItemDirective, typeof DatatableMenuBarRowComponent, typeof DatatableMenuBarColumnLeftComponent, typeof DatatableMenuBarColumnCenterComponent, typeof DatatableMenuBarColumnRightComponent, typeof DatatableMenuBarTextComponent, typeof DatatableColumnFilterMenuComponent, typeof DatatableColumnFilterSearchTextComponent, typeof DatatableColumnFilterSearchNumericComponent, typeof DatatableColumnFilterSearchDateComponent, typeof DatatableColumnFilterTplDirective, typeof TheSeamDatatableColumnFilterDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<TheSeamDatatableModule>;
+}
+
+export { CURRENT_DATATABLE_PREFERENCES_VERSION, ColumnsAlteration, ColumnsDataFilter, ColumnsFiltersService, DatatableActionMenuComponent, DatatableActionMenuItemComponent, DatatableActionMenuItemDirective, DatatableActionMenuToggleDirective, DatatableCellTplDirective, DatatableColumnChangesService, DatatableColumnComponent, DatatableColumnFilterMenuComponent, DatatableColumnFilterSearchDateComponent, DatatableColumnFilterSearchNumericComponent, DatatableColumnFilterSearchTextComponent, DatatableColumnFilterTplDirective, DatatableColumnPreferencesButtonComponent, DatatableColumnPreferencesComponent, DatatableComponent, DatatableDataSource, DatatableExportButtonComponent, DatatableFilterDirective, DatatableFooterTplDirective, DatatableGqlDataSource, DatatableMenuBarColumnCenterComponent, DatatableMenuBarColumnLeftComponent, DatatableMenuBarColumnRightComponent, DatatableMenuBarComponent, DatatableMenuBarRowComponent, DatatableMenuBarTextComponent, DatatablePreferencesService, DatatableRowActionItemDirective, DatatableRowDetailTplDirective, EMPTY_DATATABLE_PREFERENCES, SearchDateColumnsDataFilter, SearchNumericColumnsDataFilter, SearchTextColumnsDataFilter, THESEAM_COLUMNS_DATA_FILTER, THESEAM_COLUMNS_DATA_FILTERS_DEFAULT, THESEAM_COLUMNS_DATA_FILTER_DATE_RANGE_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_DATE_SEARCH_NAME, THESEAM_COLUMNS_DATA_FILTER_DATE_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_DATE_SELECT_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_DATE_TEXT_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_NUMERIC_RANGE_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_NUMERIC_SEARCH_NAME, THESEAM_COLUMNS_DATA_FILTER_NUMERIC_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_NUMERIC_SELECT_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_NUMERIC_TEXT_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_TEXT_SEARCH_NAME, THESEAM_COLUMNS_DATA_FILTER_TEXT_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_TEXT_SELECT_SEARCH_TYPES, THESEAM_COLUMNS_DATA_FILTER_TEXT_TEXT_SEARCH_TYPES, THESEAM_DATATABLE, THESEAM_DATATABLE_CONFIG, THESEAM_DATATABLE_PREFERENCES_ACCESSOR, THESEAM_MENUBAR_ITEM_DATA, TheSeamDatatableColumnFilterDirective, TheSeamDatatableFooterDirective, TheSeamDatatableModule, TheSeamDatatableRowDetailDirective, TheSeamDatatableScrollbarHelperService, _THESEAM_DATATABLE, _THESEAM_DATATABLE_ACCESSOR, _THESEAM_DATA_FILTER_CONTAINER, getFormattedDateForComparison, mapColumnsAlterationsStates, withStoredColumnInfo };
+export type { ColumnsAlterationState, ColumnsDataFilterState, ColumnsDataFilterStateState, ICellContext, IDatatableExportButtonData, MenubarItemData, SortEvent, SortItem, TheSeamColumnsDataFilterDateSearchDateType, TheSeamColumnsDataFilterDateSearchForm, TheSeamColumnsDataFilterDateSearchFormState, TheSeamColumnsDataFilterDateSearchOptions, TheSeamColumnsDataFilterDateSearchType, TheSeamColumnsDataFilterNumericSearchForm, TheSeamColumnsDataFilterNumericSearchFormState, TheSeamColumnsDataFilterNumericSearchType, TheSeamColumnsDataFilterTextSearchForm, TheSeamColumnsDataFilterTextSearchFormState, TheSeamColumnsDataFilterTextSearchType, TheSeamDatatableAccessor, TheSeamDatatableColumn, TheSeamDatatableColumnFilterUpdateMethod, TheSeamDatatableColumnFilterable, TheSeamDatatableColumnFilterableConfig, TheSeamDatatableColumnHidable, TheSeamDatatableConfig, TheSeamDatatableDateColumnFilterableConfig, TheSeamDatatableMessages, TheSeamDatatablePreferences, TheSeamDatatablePreferencesAccessor, TheSeamDatatablePreferencesColumn, TheSeamDatatablePreferences_v1, TheSeamDatatablePreferences_v2, TheSeamDatatableRow, TheSeamPageInfo };