bways-grid 0.0.5

package/lib/bways-grid.module.d.ts

@@ -0,0 +1,13 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/ultra-grid/ultra-grid.component";
+import * as i2 from "./components/header/header.component";
+import * as i3 from "./components/row/row.component";
+import * as i4 from "./components/cell/cell.component";
+import * as i5 from "./components/pagination/pagination.component";
+import * as i6 from "./directives/column-resize.directive";
+import * as i7 from "./components/side-bar/side-bar.component";
+export declare class BwaysGridModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<BwaysGridModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<BwaysGridModule, never, [typeof i1.UltraGridComponent, typeof i2.HeaderComponent, typeof i3.RowComponent, typeof i4.CellComponent, typeof i5.PaginationComponent, typeof i6.ColumnResizeDirective, typeof i7.SideBarComponent], [typeof i1.UltraGridComponent, typeof i2.HeaderComponent, typeof i3.RowComponent, typeof i4.CellComponent, typeof i5.PaginationComponent, typeof i6.ColumnResizeDirective, typeof i7.SideBarComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<BwaysGridModule>;
+}

package/lib/components/cell/cell.component.d.ts

@@ -0,0 +1,20 @@
+import { EventEmitter } from '@angular/core';
+import { UltraGridColumn } from '../../models/column.model';
+import { UltraGridRow } from '../../models/row.model';
+import * as i0 from "@angular/core";
+export declare class CellComponent {
+    column: UltraGridColumn;
+    row: UltraGridRow;
+    isSelected?: boolean;
+    isFirstColumn: boolean;
+    groupExpanded: boolean;
+    groupToggleClicked: EventEmitter<void>;
+    get isGroup(): boolean;
+    get isGroupFooter(): boolean;
+    get value(): any;
+    get formattedFooterValue(): string;
+    onCheckboxClick(event: MouseEvent): void;
+    onGroupToggleClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<CellComponent, "ug-cell", never, { "column": { "alias": "column"; "required": false; }; "row": { "alias": "row"; "required": false; }; "isSelected": { "alias": "isSelected"; "required": false; }; "isFirstColumn": { "alias": "isFirstColumn"; "required": false; }; "groupExpanded": { "alias": "groupExpanded"; "required": false; }; }, { "groupToggleClicked": "groupToggleClicked"; }, never, never, true, never>;
+}

package/lib/components/choose-columns/choose-columns.component.d.ts

@@ -0,0 +1,17 @@
+import { EventEmitter } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { UltraGridColumn } from '../../models/column.model';
+import * as i0 from "@angular/core";
+export declare class ChooseColumnsComponent {
+    columns: UltraGridColumn[];
+    columnsChanged: EventEmitter<UltraGridColumn[]>;
+    closePanel: EventEmitter<void>;
+    searchQuery: string;
+    onClose(): void;
+    matchesSearch(col: UltraGridColumn): boolean;
+    toggleVisibility(col: UltraGridColumn): void;
+    onDrop(event: CdkDragDrop<UltraGridColumn[]>): void;
+    private emitChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ChooseColumnsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ChooseColumnsComponent, "ug-choose-columns", never, { "columns": { "alias": "columns"; "required": false; }; }, { "columnsChanged": "columnsChanged"; "closePanel": "closePanel"; }, never, never, true, never>;
+}

package/lib/components/column-tool-panel/column-tool-panel.component.d.ts

@@ -0,0 +1,36 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { UltraGridColumn, ValueColumnModel } from '../../models/column.model';
+import * as i0 from "@angular/core";
+export declare class ColumnToolPanelComponent implements OnChanges {
+    columns: UltraGridColumn[];
+    groupModel: string[];
+    valuesModel: ValueColumnModel[];
+    columnsUpdated: EventEmitter<UltraGridColumn[]>;
+    groupModelChanged: EventEmitter<string[]>;
+    valuesModelChanged: EventEmitter<ValueColumnModel[]>;
+    exportCsvClicked: EventEmitter<void>;
+    displayColumns: UltraGridColumn[];
+    groupColumns: UltraGridColumn[];
+    valueColumns: ValueColumnModel[];
+    searchQuery: string;
+    pivotMode: boolean;
+    openDropdownField: string | null;
+    ngOnChanges(changes: SimpleChanges): void;
+    private rebuildGroupColumns;
+    getColumnHeader(field: string): string;
+    applySearch(): void;
+    toggleVisibility(col: UltraGridColumn): void;
+    onDrop(event: CdkDragDrop<UltraGridColumn[]>): void;
+    onGroupDrop(event: CdkDragDrop<UltraGridColumn[]>): void;
+    removeGroup(col: UltraGridColumn): void;
+    private emitGroupChange;
+    private rebuildValueColumns;
+    onValueDrop(event: CdkDragDrop<any[]>): void;
+    removeValue(field: string): void;
+    toggleAggDropdown(field: string): void;
+    setAggFunc(vCol: ValueColumnModel, func: 'sum' | 'min' | 'max' | 'count' | 'avg'): void;
+    private emitValuesChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnToolPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<ColumnToolPanelComponent, "ug-column-tool-panel", never, { "columns": { "alias": "columns"; "required": false; }; "groupModel": { "alias": "groupModel"; "required": false; }; "valuesModel": { "alias": "valuesModel"; "required": false; }; }, { "columnsUpdated": "columnsUpdated"; "groupModelChanged": "groupModelChanged"; "valuesModelChanged": "valuesModelChanged"; "exportCsvClicked": "exportCsvClicked"; }, never, never, true, never>;
+}

package/lib/components/filter-tool-panel/filter-tool-panel.component.d.ts

@@ -0,0 +1,63 @@
+import { EventEmitter, OnChanges, SimpleChanges, ChangeDetectorRef } from '@angular/core';
+import { UltraGridColumn } from '../../models/column.model';
+import { FilterConditionType, JoinOperator, ColumnConditionFilter } from '../../models/filter.model';
+import * as i0 from "@angular/core";
+interface FilterSection {
+    column: UltraGridColumn;
+    expanded: boolean;
+    searchQuery: string;
+    uniqueValues: any[];
+    displayValues: any[];
+    selectedValues: Set<any>;
+    hasActiveFilter: boolean;
+    filterOptions: {
+        value: FilterConditionType;
+        label: string;
+    }[];
+    cond1Type: FilterConditionType;
+    cond1Value: string;
+    condOperator: JoinOperator;
+    cond2Type: FilterConditionType;
+    cond2Value: string;
+    cond2ValueTo: string;
+    hasConditionFilter: boolean;
+}
+export declare class FilterToolPanelComponent implements OnChanges {
+    private cdr;
+    columns: UltraGridColumn[];
+    rowData: any[];
+    activeFilters: Map<string, Set<any>>;
+    filterApplied: EventEmitter<{
+        field: string;
+        selected: Set<any>;
+    }>;
+    conditionFilterChanged: EventEmitter<{
+        field: string;
+        filter: ColumnConditionFilter | null;
+    }>;
+    clearAllFilters: EventEmitter<void>;
+    sections: FilterSection[];
+    private _loadedFields;
+    constructor(cdr: ChangeDetectorRef);
+    get hasAnyActiveFilter(): boolean;
+    ngOnChanges(changes: SimpleChanges): void;
+    private buildSections;
+    private detectNumericColumn;
+    private ensureSectionLoaded;
+    private syncActiveFilters;
+    onConditionChanged(section: FilterSection): void;
+    toggleSection(section: FilterSection): void;
+    expandAll(): void;
+    collapseAll(): void;
+    onSectionSearch(section: FilterSection): void;
+    private applySearchOnSection;
+    isSectionAllSelected(section: FilterSection): boolean;
+    toggleSectionAll(section: FilterSection): void;
+    toggleValue(section: FilterSection, val: any): void;
+    private emitFilter;
+    onClearAll(): void;
+    trackByField(index: number, section: FilterSection): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FilterToolPanelComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FilterToolPanelComponent, "ug-filter-tool-panel", never, { "columns": { "alias": "columns"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; "activeFilters": { "alias": "activeFilters"; "required": false; }; }, { "filterApplied": "filterApplied"; "conditionFilterChanged": "conditionFilterChanged"; "clearAllFilters": "clearAllFilters"; }, never, never, true, never>;
+}
+export {};

package/lib/components/header/header.component.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from '@angular/core';
+import { CdkDragDrop } from '@angular/cdk/drag-drop';
+import { UltraGridColumn } from '../../models/column.model';
+import * as i0 from "@angular/core";
+export declare class HeaderComponent {
+    columns: UltraGridColumn[];
+    sortModel: {
+        field: string;
+        direction: 'asc' | 'desc';
+    }[];
+    isAllSelected: boolean;
+    sortChanged: EventEmitter<{
+        field: string;
+        direction: "asc" | "desc" | null;
+    }>;
+    columnsReordered: EventEmitter<UltraGridColumn[]>;
+    columnResized: EventEmitter<{
+        field: string;
+        width: number;
+    }>;
+    headerCheckboxClicked: EventEmitter<boolean>;
+    menuClicked: EventEmitter<{
+        column: UltraGridColumn;
+        event: MouseEvent;
+    }>;
+    filterClicked: EventEmitter<{
+        column: UltraGridColumn;
+        event: MouseEvent;
+    }>;
+    getSortDirection(field: string): 'asc' | 'desc' | null;
+    onSort(col: UltraGridColumn): void;
+    onColumnDrop(event: CdkDragDrop<string[]>): void;
+    onResize(event: {
+        field: string;
+        width: number;
+    }): void;
+    onHeaderCheckboxClick(event: MouseEvent): void;
+    onMenuClick(column: UltraGridColumn, event: MouseEvent): void;
+    onFilterClick(column: UltraGridColumn, event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderComponent, "ug-header", never, { "columns": { "alias": "columns"; "required": false; }; "sortModel": { "alias": "sortModel"; "required": false; }; "isAllSelected": { "alias": "isAllSelected"; "required": false; }; }, { "sortChanged": "sortChanged"; "columnsReordered": "columnsReordered"; "columnResized": "columnResized"; "headerCheckboxClicked": "headerCheckboxClicked"; "menuClicked": "menuClicked"; "filterClicked": "filterClicked"; }, never, never, true, never>;
+}

package/lib/components/header-filter/header-filter.component.d.ts

@@ -0,0 +1,31 @@
+import { EventEmitter, OnChanges, SimpleChanges } from '@angular/core';
+import { UltraGridColumn } from '../../models/column.model';
+import * as i0 from "@angular/core";
+export declare class HeaderFilterComponent implements OnChanges {
+    column?: UltraGridColumn;
+    isOpen: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    uniqueValues: any[];
+    activeFilterSet: Set<any>;
+    closeFilter: EventEmitter<void>;
+    filterApplied: EventEmitter<{
+        field: string;
+        selected: Set<any>;
+    }>;
+    searchQuery: string;
+    displayValues: any[];
+    selectedValues: Set<any>;
+    ngOnChanges(changes: SimpleChanges): void;
+    onClose(): void;
+    onSearchChanged(): void;
+    private applySearch;
+    get isAllSelected(): boolean;
+    toggleAll(): void;
+    toggleValue(val: any): void;
+    private emitFilter;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderFilterComponent, "ug-header-filter", never, { "column": { "alias": "column"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "position": { "alias": "position"; "required": false; }; "uniqueValues": { "alias": "uniqueValues"; "required": false; }; "activeFilterSet": { "alias": "activeFilterSet"; "required": false; }; }, { "closeFilter": "closeFilter"; "filterApplied": "filterApplied"; }, never, never, true, never>;
+}

package/lib/components/header-menu/header-menu.component.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter, ElementRef } from '@angular/core';
+import { UltraGridColumn } from '../../models/column.model';
+import * as i0 from "@angular/core";
+export declare class HeaderMenuComponent {
+    private el;
+    column?: UltraGridColumn;
+    isOpen: boolean;
+    position: {
+        x: number;
+        y: number;
+    };
+    groupModel: string[];
+    closeMenu: EventEmitter<void>;
+    sort: EventEmitter<{
+        field: string;
+        direction: "asc" | "desc";
+    }>;
+    pin: EventEmitter<{
+        field: string;
+        pinned: "left" | "right" | null;
+    }>;
+    autosize: EventEmitter<{
+        field: string;
+        all: boolean;
+    }>;
+    group: EventEmitter<{
+        field: string;
+    }>;
+    chooseColumns: EventEmitter<void>;
+    showPinSubmenu: boolean;
+    get isGrouped(): boolean;
+    constructor(el: ElementRef);
+    onClose(): void;
+    onSort(direction: 'asc' | 'desc'): void;
+    onPin(pinned: 'left' | 'right' | null): void;
+    onAutosize(all: boolean): void;
+    onGroup(): void;
+    onChooseColumns(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeaderMenuComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HeaderMenuComponent, "ug-header-menu", never, { "column": { "alias": "column"; "required": false; }; "isOpen": { "alias": "isOpen"; "required": false; }; "position": { "alias": "position"; "required": false; }; "groupModel": { "alias": "groupModel"; "required": false; }; }, { "closeMenu": "closeMenu"; "sort": "sort"; "pin": "pin"; "autosize": "autosize"; "group": "group"; "chooseColumns": "chooseColumns"; }, never, never, true, never>;
+}

package/lib/components/pagination/pagination.component.d.ts

@@ -0,0 +1,22 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class PaginationComponent {
+    totalCount: number;
+    pageSize: number;
+    currentPage: number;
+    pageChanged: EventEmitter<number>;
+    pageSizeChanged: EventEmitter<number>;
+    get showControls(): boolean;
+    get totalPages(): number;
+    get isFirstPage(): boolean;
+    get isLastPage(): boolean;
+    get startRow(): number;
+    get endRow(): number;
+    onPrev(): void;
+    onNext(): void;
+    onPage(page: number): void;
+    get isAllSelectedSize(): boolean;
+    onPageSizeChange(size: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<PaginationComponent, "ug-pagination", never, { "totalCount": { "alias": "totalCount"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "currentPage": { "alias": "currentPage"; "required": false; }; }, { "pageChanged": "pageChanged"; "pageSizeChanged": "pageSizeChanged"; }, never, never, true, never>;
+}

package/lib/components/row/row.component.d.ts

@@ -0,0 +1,19 @@
+import { EventEmitter } from '@angular/core';
+import { UltraGridColumn } from '../../models/column.model';
+import { UltraGridRow } from '../../models/row.model';
+import * as i0 from "@angular/core";
+export declare class RowComponent {
+    columns: UltraGridColumn[];
+    row: UltraGridRow;
+    rowHeight: number;
+    isExpanded: boolean;
+    selectionVersion: number;
+    groupToggled: EventEmitter<void>;
+    get isSelected(): boolean | undefined;
+    get isGroupFooter(): boolean;
+    get height(): number;
+    trackByField(index: number, col: UltraGridColumn): string;
+    onGroupToggle(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RowComponent, "ug-row", never, { "columns": { "alias": "columns"; "required": false; }; "row": { "alias": "row"; "required": false; }; "rowHeight": { "alias": "rowHeight"; "required": false; }; "isExpanded": { "alias": "isExpanded"; "required": false; }; "selectionVersion": { "alias": "selectionVersion"; "required": false; }; }, { "groupToggled": "groupToggled"; }, never, never, true, never>;
+}

package/lib/components/side-bar/side-bar.component.d.ts

@@ -0,0 +1,42 @@
+import { EventEmitter } from '@angular/core';
+import { UltraGridColumn, ValueColumnModel } from '../../models/column.model';
+import { ColumnConditionFilter } from '../../models/filter.model';
+import * as i0 from "@angular/core";
+export declare class SideBarComponent {
+    columns: UltraGridColumn[];
+    rowData: any[];
+    activeFilters: Map<string, Set<any>>;
+    groupModel: string[];
+    valuesModel: ValueColumnModel[];
+    columnsUpdated: EventEmitter<UltraGridColumn[]>;
+    groupModelUpdated: EventEmitter<string[]>;
+    valuesModelUpdated: EventEmitter<ValueColumnModel[]>;
+    exportCsvClicked: EventEmitter<void>;
+    filterApplied: EventEmitter<{
+        field: string;
+        selected: Set<any>;
+    }>;
+    conditionFilterChanged: EventEmitter<{
+        field: string;
+        filter: ColumnConditionFilter | null;
+    }>;
+    clearAllFilters: EventEmitter<void>;
+    activeTab: 'columns' | 'filters' | null;
+    toggleTab(tab: 'columns' | 'filters'): void;
+    closePanel(): void;
+    onColumnsChanged(updatedCols: UltraGridColumn[]): void;
+    onGroupModelChanged(model: string[]): void;
+    onExportCsvClicked(): void;
+    onFilterApplied(event: {
+        field: string;
+        selected: Set<any>;
+    }): void;
+    onClearAllFilters(): void;
+    onConditionFilterChanged(event: {
+        field: string;
+        filter: ColumnConditionFilter | null;
+    }): void;
+    onValuesModelChanged(model: ValueColumnModel[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SideBarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SideBarComponent, "ug-side-bar", never, { "columns": { "alias": "columns"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; "activeFilters": { "alias": "activeFilters"; "required": false; }; "groupModel": { "alias": "groupModel"; "required": false; }; "valuesModel": { "alias": "valuesModel"; "required": false; }; }, { "columnsUpdated": "columnsUpdated"; "groupModelUpdated": "groupModelUpdated"; "valuesModelUpdated": "valuesModelUpdated"; "exportCsvClicked": "exportCsvClicked"; "filterApplied": "filterApplied"; "conditionFilterChanged": "conditionFilterChanged"; "clearAllFilters": "clearAllFilters"; }, never, never, true, never>;
+}

package/lib/components/ultra-grid/ultra-grid.component.d.ts

@@ -0,0 +1,155 @@
+import { EventEmitter, OnInit, OnDestroy, OnChanges, SimpleChanges, ChangeDetectorRef, NgZone } from '@angular/core';
+import { ColumnConditionFilter } from '../../models/filter.model';
+import { UltraGridColumn, ValueColumnModel } from '../../models/column.model';
+import { UltraGridRow, UltraGridNode } from '../../models/row.model';
+import { UltraGridConfig } from '../../models/grid-config.model';
+import { ServerDataSource } from '../../datasources/server-datasource.interface';
+import { InfiniteScrollDataSource } from '../../datasources/infinite-scroll.datasource';
+import { GridFlattenerService } from '../../core/grid-flattener.service';
+import { CsvExportService } from '../../services/csv-export.service';
+import { CsvExportOptions } from '../../models/csv-export.model';
+import * as i0 from "@angular/core";
+export declare class UltraGridComponent implements OnInit, OnDestroy, OnChanges {
+    private cdr;
+    private ngZone;
+    private flattener;
+    private csvExportService;
+    private _workerInitialized;
+    columns: UltraGridColumn[];
+    rowData: any[];
+    serverDataSource?: ServerDataSource;
+    config: UltraGridConfig;
+    pagination: boolean;
+    pageSize: number;
+    rowClicked: EventEmitter<UltraGridRow>;
+    sortChanged: EventEmitter<{
+        field: string;
+        direction: "asc" | "desc" | null;
+    }[]>;
+    isBrowser: boolean;
+    visibleColumns: UltraGridColumn[];
+    sortModel: {
+        field: string;
+        direction: 'asc' | 'desc';
+    }[];
+    groupModel: string[];
+    valuesModel: ValueColumnModel[];
+    groupStateMap: Map<string, boolean>;
+    _internalDataSource?: InfiniteScrollDataSource<UltraGridRow>;
+    _localTreeData: UltraGridNode[];
+    _unpaginatedLocalData: UltraGridRow[];
+    _mappedRowData: UltraGridRow[];
+    renderedLocalData: UltraGridRow[];
+    ssrData: UltraGridRow[];
+    totalCount: number;
+    currentPage: number;
+    selectionVersion: number;
+    isMenuOpen: boolean;
+    activeMenuColumn?: UltraGridColumn;
+    menuPosition: {
+        x: number;
+        y: number;
+    };
+    isFilterOpen: boolean;
+    activeFilterColumn?: UltraGridColumn;
+    filterPosition: {
+        x: number;
+        y: number;
+    };
+    activeFilterUniqueValues: any[];
+    activeFilters: Map<string, Set<any>>;
+    conditionFilters: Map<string, ColumnConditionFilter>;
+    isChooseColumnsOpen: boolean;
+    chooseColumnsPosition: {
+        x: number;
+        y: number;
+    };
+    private destroy$;
+    private sortingWorker?;
+    private sortingWorkerUrl?;
+    private _unflattenedTreeData;
+    private hasCheckboxSelection;
+    private hasHeaderCheckboxSelection;
+    get rowHeight(): number;
+    get showPagination(): boolean;
+    constructor(platformId: Object, cdr: ChangeDetectorRef, ngZone: NgZone, flattener: GridFlattenerService, csvExportService: CsvExportService);
+    ngOnInit(): void;
+    get selectedRowsCount(): number;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    private initSortingWorker;
+    private updateVisibleColumns;
+    private wrapServerDataSource;
+    applyLocalData(): void;
+    refreshFlattener(): void;
+    private isNumericColumn;
+    toggleGroup(groupId: string): void;
+    isGroupExpanded(row: UltraGridRow): boolean;
+    private sortLocal;
+    private updatePaginationForLocalData;
+    fetchServerPage(page: number): void;
+    /**
+     * Triggers a Web-Worker powered CSV export of the grid data.
+     * @param options Configures whether to export all records or just visible records, as well as CSV formatting.
+     */
+    exportCsv(options?: CsvExportOptions): Promise<void>;
+    onPageChanged(page: number): void;
+    onSortChanged(event: {
+        field: string;
+        direction: 'asc' | 'desc' | null;
+    }): void;
+    onColumnsReordered(cols: UltraGridColumn[]): void;
+    onSideBarColumnsUpdated(cols: UltraGridColumn[]): void;
+    onSideBarGroupModelUpdated(model: string[]): void;
+    onValuesModelUpdated(model: ValueColumnModel[]): void;
+    onColumnResized(event: {
+        field: string;
+        width: number;
+    }): void;
+    get isAllSelected(): boolean;
+    onHeaderCheckboxClicked(selected: boolean): void;
+    onPageSizeChanged(size: number): void;
+    private selectNodeAndChildren;
+    onRowClicked(row: UltraGridRow | undefined): void;
+    getPlaceholderRow(index: number): UltraGridRow;
+    trackByRowId(index: number, item: UltraGridRow | undefined): string | number;
+    onHeaderMenuClicked(event: {
+        column: UltraGridColumn;
+        event: MouseEvent;
+    }): void;
+    onMenuClosed(): void;
+    onMenuSort(event: {
+        field: string;
+        direction: 'asc' | 'desc';
+    }): void;
+    onMenuPin(event: {
+        field: string;
+        pinned: 'left' | 'right' | null;
+    }): void;
+    onMenuAutosize(event: {
+        field: string;
+        all: boolean;
+    }): void;
+    onMenuGroup(event: {
+        field: string;
+    }): void;
+    onMenuChooseColumns(): void;
+    onChooseColumnsUpdated(columns: UltraGridColumn[]): void;
+    getFilterSetForColumn(field?: string): Set<any>;
+    onHeaderFilterClicked(event: {
+        column: UltraGridColumn;
+        event: MouseEvent;
+    }): void;
+    onFilterClosed(): void;
+    onFilterApplied(event: {
+        field: string;
+        selected: Set<any>;
+    }): void;
+    onClearAllFilters(): void;
+    onConditionFilterChanged(event: {
+        field: string;
+        filter: ColumnConditionFilter | null;
+    }): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UltraGridComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UltraGridComponent, "bways-grid", never, { "columns": { "alias": "columns"; "required": false; }; "rowData": { "alias": "rowData"; "required": false; }; "serverDataSource": { "alias": "serverDataSource"; "required": false; }; "config": { "alias": "config"; "required": false; }; "pagination": { "alias": "pagination"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, { "rowClicked": "rowClicked"; "sortChanged": "sortChanged"; }, never, never, true, never>;
+}

package/lib/core/grid-engine.service.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export type GridEventName = 'rowClicked' | 'columnResized' | 'sortChanged' | 'filterChanged' | 'selectionChanged';
+export interface GridEvent {
+    name: GridEventName;
+    payload: any;
+}
+export declare class GridEngineService {
+    private _eventBus;
+    get events$(): Observable<GridEvent>;
+    dispatch(name: GridEventName, payload: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridEngineService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridEngineService>;
+}

package/lib/core/grid-flattener.service.d.ts

@@ -0,0 +1,8 @@
+import { UltraGridNode } from '../models/row.model';
+import * as i0 from "@angular/core";
+export declare class GridFlattenerService {
+    flatten(nodes: UltraGridNode[], groupStateMap: Map<string, boolean>, groupIncludeFooter?: boolean): UltraGridNode[];
+    private traverse;
+    static ɵfac: i0.ɵɵFactoryDeclaration<GridFlattenerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<GridFlattenerService>;
+}

package/lib/core/row-cache.d.ts

@@ -0,0 +1,10 @@
+import { UltraGridRow } from '../models/row.model';
+import * as i0 from "@angular/core";
+export declare class RowCache {
+    private _cache;
+    getRow(data: any): UltraGridRow | undefined;
+    setRow(data: any, row: UltraGridRow): void;
+    clear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RowCache, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RowCache>;
+}

package/lib/core/viewport-manager.d.ts

@@ -0,0 +1,21 @@
+import * as i0 from "@angular/core";
+export declare class ViewportManager {
+    private _scrollTop;
+    private _viewportHeight;
+    private _rowHeight;
+    private _bufferSize;
+    get scrollTop(): number;
+    set scrollTop(val: number);
+    get viewportHeight(): number;
+    set viewportHeight(val: number);
+    get rowHeight(): number;
+    set rowHeight(val: number);
+    get bufferSize(): number;
+    set bufferSize(val: number);
+    getVisibleRange(): {
+        start: number;
+        end: number;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<ViewportManager, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ViewportManager>;
+}

package/lib/datasources/infinite-scroll.datasource.d.ts

@@ -0,0 +1,17 @@
+import { CollectionViewer, DataSource } from '@angular/cdk/collections';
+import { Observable } from 'rxjs';
+import { ServerDataSource } from './server-datasource.interface';
+export declare class InfiniteScrollDataSource<T> extends DataSource<T | undefined> {
+    private _serverDataSource;
+    private _bufferSize;
+    private _cachedData;
+    private _dataStream;
+    private _subscription;
+    private _fetchedPages;
+    private _pageSize;
+    constructor(_serverDataSource: ServerDataSource<T>, _bufferSize?: number);
+    connect(collectionViewer: CollectionViewer): Observable<(T | undefined)[]>;
+    disconnect(): void;
+    private _getPageForIndex;
+    private _fetchPage;
+}

package/lib/datasources/server-datasource.interface.d.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+export interface ServerResponse<T = any> {
+    rows: T[];
+    totalCount: number;
+}
+export interface GetRowsParams {
+    startRow: number;
+    endRow: number;
+    sortModel?: any;
+    filterModel?: any;
+}
+export interface ServerDataSource<T = any> {
+    getRows(params: GetRowsParams): Observable<ServerResponse<T>>;
+}

package/lib/directives/column-resize.directive.d.ts

@@ -0,0 +1,18 @@
+import { ElementRef, EventEmitter, Renderer2 } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class ColumnResizeDirective {
+    private el;
+    private renderer;
+    columnField: string;
+    resizeEnd: EventEmitter<{
+        field: string;
+        width: number;
+    }>;
+    private startX;
+    private startWidth;
+    private minWidth;
+    constructor(el: ElementRef, renderer: Renderer2);
+    onMouseDown(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ColumnResizeDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ColumnResizeDirective, "[ugColumnResize]", never, { "columnField": { "alias": "ugColumnResize"; "required": false; }; }, { "resizeEnd": "resizeEnd"; }, never, never, true, never>;
+}

package/lib/models/column.model.d.ts

@@ -0,0 +1,21 @@
+export interface UltraGridColumn {
+    field: string;
+    headerName?: string;
+    width?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    sortable?: boolean;
+    resizable?: boolean;
+    hide?: boolean;
+    pinned?: 'left' | 'right';
+    cellTemplate?: any;
+    headerCheckboxSelection?: boolean;
+    checkboxSelection?: boolean;
+    aggFunc?: 'sum' | 'min' | 'max' | 'count' | 'avg';
+    _leftOffset?: number;
+    _rightOffset?: number;
+}
+export interface ValueColumnModel {
+    field: string;
+    aggFunc: 'sum' | 'min' | 'max' | 'count' | 'avg';
+}