angular-slickgrid 9.13.0 → 10.0.0

package/types/angular-slickgrid.d.ts

@@ -0,0 +1,768 @@
+import { SlickDataView, SlickGrid, ExtensionList, BackendService, ExtensionService, FilterService, GridService, GridEventService, GridStateService, HeaderGroupingService, BasePaginationComponent, PaginationService, ResizerService, SortService, TreeDataService, BackendUtilityService, CollectionService, ExtensionUtility, RxJsFacade, SharedService, RowDetailView as RowDetailView$1, Column, GridOption as GridOption$1, ContainerService as ContainerService$1, ContainerInstance, TranslaterService as TranslaterService$1, OnActiveCellChangedEventArgs, OnAddNewRowEventArgs, OnAutosizeColumnsEventArgs, OnBeforeAppendCellEventArgs, OnBeforeCellEditorDestroyEventArgs, OnBeforeColumnsResizeEventArgs, OnBeforeEditCellEventArgs, OnBeforeHeaderCellDestroyEventArgs, OnBeforeHeaderRowCellDestroyEventArgs, OnBeforeFooterRowCellDestroyEventArgs, OnBeforeSetColumnsEventArgs, SingleColumnSort, OnCellChangeEventArgs, OnCellCssStylesChangedEventArgs, OnClickEventArgs, OnColumnsDragEventArgs, OnColumnsReorderedEventArgs, OnColumnsResizedEventArgs, OnColumnsResizeDblClickEventArgs, OnCompositeEditorChangeEventArgs, DragRowMove, OnDragReplaceCellsEventArgs, OnDblClickEventArgs, OnFooterContextMenuEventArgs, OnFooterRowCellRenderedEventArgs, OnHeaderCellRenderedEventArgs, OnFooterClickEventArgs, OnHeaderClickEventArgs, OnHeaderContextMenuEventArgs, OnHeaderMouseEventArgs, OnHeaderRowCellRenderedEventArgs, OnKeyDownEventArgs, OnValidationErrorEventArgs, OnRenderedEventArgs, OnSelectedRowsChangedEventArgs, OnSetOptionsEventArgs, OnScrollEventArgs, PagingInfo, OnGroupExpandedEventArgs, OnGroupCollapsedEventArgs, OnRowCountChangedEventArgs, OnRowsChangedEventArgs, OnRowsOrCountChangedEventArgs, OnSetItemsCalledEventArgs, MenuFromCellCallbackArgs, OnColumnsChangedArgs, MenuCommandItemCallbackArgs, MenuOptionItemCallbackArgs, GridMenuEventWithElementCallbackArgs, SlickRange, ExportTextDownloadOption, CurrentFilter, OnSearchChangeEventArgs, ColumnSort, GridMenuCommandItemCallbackArgs, HeaderButtonOnCommandArgs, HeaderMenuCommandItemCallbackArgs, GridStateChange, PaginationMetadata, GridSize, OnSelectedRowIdsChangedEventArgs, CurrentSorter, TreeToggleStateChange, SlickEventHandler, Pagination, ExternalResource, ExternalResourceConstructor, SlickGroupItemMetadataProvider, BackendServiceApi, Locale, Metrics, EventSubscription, FilterFactory, CustomDataView } from '@slickgrid-universal/common';
+export * from '@slickgrid-universal/common';
+import * as _angular_core from '@angular/core';
+import { ComponentRef, Type, ViewContainerRef, Injector, NgModuleRef, EnvironmentInjector, AfterViewInit, OnDestroy, ApplicationRef, ElementRef, EventEmitter, TemplateRef } from '@angular/core';
+import { EventPubSubService } from '@slickgrid-universal/event-pub-sub';
+import { TranslateService } from '@ngx-translate/core';
+import * as angular_slickgrid from 'angular-slickgrid';
+import { SlickFooterComponent } from '@slickgrid-universal/custom-footer-component';
+import { SlickEmptyWarningComponent } from '@slickgrid-universal/empty-warning-component';
+
+interface AngularComponentOutput {
+    componentRef: ComponentRef<any>;
+    domElement: HTMLElement;
+}
+
+interface AngularGridInstance {
+    /** Slick DataView object */
+    dataView: SlickDataView;
+    /** Slick Grid object */
+    slickGrid: SlickGrid;
+    /** SlickGrid extensions (external controls/plugins) */
+    extensions: ExtensionList<any>;
+    /** Dispose of the grid and optionally empty the DOM element grid container as well */
+    destroy: (emptyDomElementContainer?: boolean) => void;
+    /** Backend Service, when available */
+    backendService?: BackendService;
+    /** EventPubSub Service instance that is used internal by the lib and could be used externally to subscribe to Angular-Slickgrid events */
+    eventPubSubService?: EventPubSubService;
+    /** Extension (Plugins & Controls) Service */
+    extensionService: ExtensionService;
+    /** Filter Service */
+    filterService: FilterService;
+    /** Grid Service (grid extra functionalities) */
+    gridService: GridService;
+    /** Grid Events Service */
+    gridEventService: GridEventService;
+    /** Grid State Service */
+    gridStateService: GridStateService;
+    /** Grouping (and colspan) Service */
+    headerGroupingService: HeaderGroupingService;
+    /** Pagination Component */
+    paginationComponent?: BasePaginationComponent;
+    /** Pagination Service (allows you to programmatically go to first/last page, etc...) */
+    paginationService?: PaginationService;
+    /** Resizer Service (including auto-resize) */
+    resizerService: ResizerService;
+    /** Sort Service */
+    sortService: SortService;
+    /** Tree Data View Service */
+    treeDataService: TreeDataService;
+}
+
+interface ExternalTestingDependencies {
+    backendUtilityService?: BackendUtilityService;
+    collectionService?: CollectionService;
+    eventPubSubService?: EventPubSubService;
+    extensionService?: ExtensionService;
+    extensionUtility?: ExtensionUtility;
+    filterService?: FilterService;
+    gridEventService?: GridEventService;
+    gridService?: GridService;
+    gridStateService?: GridStateService;
+    headerGroupingService?: HeaderGroupingService;
+    paginationService?: PaginationService;
+    resizerService?: ResizerService;
+    rxjs?: RxJsFacade;
+    sharedService?: SharedService;
+    sortService?: SortService;
+    treeDataService?: TreeDataService;
+}
+
+interface RowDetailView extends RowDetailView$1 {
+    /**
+     * Optionally pass your Parent Component reference to your Child Component (row detail component).
+     * note:: If anyone finds a better way of passing the parent to the row detail extension, please reach out and/or create a PR
+     */
+    parentRef?: any;
+    /** View Component of the preload template (typically a spinner) which shows after opening on the row detail but before the row detail is ready */
+    preloadComponent?: Type<object>;
+    /** View Component that will be loaded in the row detail after the async function completed */
+    viewComponent: Type<object>;
+}
+
+interface GridOption<C extends Column = Column> extends GridOption$1<C> {
+    /** External Custom Pagination Component that can be provided by the user */
+    customPaginationComponent?: typeof BasePaginationComponent;
+    /** ngx-translate i18n translation service instance */
+    i18n?: TranslateService;
+    /** Row Detail View Plugin options & events (columnId, cssClass, toolTip, width) */
+    rowDetailView?: RowDetailView;
+}
+
+interface CreateComponentOption {
+    index?: number;
+    injector?: Injector;
+    ngModuleRef?: NgModuleRef<unknown>;
+    environmentInjector?: EnvironmentInjector | NgModuleRef<unknown>;
+    projectableNodes?: Node[][];
+    sanitizer?: (dirtyHtml: string) => string;
+}
+declare class AngularUtilService {
+    private vcr;
+    constructor(vcr: ViewContainerRef);
+    createInteractiveAngularComponent<C>(component: Type<C>, targetElement: Element, data?: any, createCompOptions?: CreateComponentOption): AngularComponentOutput;
+    /**
+     * Dynamically create an Angular component, user could also provide optional arguments for target, data & createComponent options
+     * @param {Component} component
+     * @param {HTMLElement} [targetElement]
+     * @param {*} [data]
+     * @param {CreateComponentOption} [createCompOptions]
+     * @returns
+     */
+    createAngularComponent<C>(component: Type<C>, targetElement?: Element, data?: any, createCompOptions?: CreateComponentOption): AngularComponentOutput;
+    /**
+     * Dynamically create an Angular component and append it to the DOM unless a target element is provided,
+     * user could also provide other optional arguments for data & createComponent options.
+     * @param {Component} component
+     * @param {HTMLElement} [targetElement]
+     * @param {*} [data]
+     * @param {CreateComponentOption} [createCompOptions]
+     * @returns
+     */
+    createAngularComponentAppendToDom<C>(component: Type<C>, targetElement?: Element, data?: any, createCompOptions?: CreateComponentOption): AngularComponentOutput;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AngularUtilService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<AngularUtilService>;
+}
+
+declare class ContainerService implements ContainerService$1 {
+    dependencies: ContainerInstance[];
+    get<T = any>(key: string): T | null;
+    dispose(): void;
+    registerInstance(key: string, instance: any): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ContainerService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<ContainerService>;
+}
+
+/**
+ * This is a Translate Service Wrapper for Slickgrid-Universal monorepo lib to work properly,
+ * it must implement Slickgrid-Universal TranslaterService interface to work properly
+ */
+declare class TranslaterService implements TranslaterService$1 {
+    private readonly translateService;
+    constructor(translateService: TranslateService);
+    /**
+     * Method to return the current language used by the App
+     * @return {string} current language
+     */
+    getCurrentLanguage(): string;
+    /**
+     * Method to set the language to use in the App and Translate Service
+     * @param {string} language
+     * @return {Promise} output
+     */
+    use(newLang: string): Promise<any>;
+    /**
+     * Method which receives a translation key and returns the translated value assigned to that key
+     * @param {string} translation key
+     * @return {string} translated value
+     */
+    translate(translationKey: string): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TranslaterService, [{ optional: true; }]>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TranslaterService>;
+}
+
+/**
+ * Unsubscribe all Observables Subscriptions
+ * It will return an empty array if it all went well
+ * @param subscriptions
+ */
+declare function unsubscribeAllObservables(subscriptions: Array<{
+    unsubscribe: () => void;
+}>): void;
+
+declare class SlickgridConfig {
+    options: Partial<GridOption>;
+    constructor();
+}
+
+/**
+ * Generic type for wrapping event output with detail property
+ * Used for typed Angular output() signals that need both eventData and args
+ * Extends CustomEvent for compatibility with event handlers
+ * @template T - The event function type from AngularSlickgridOutputs interface
+ */
+type SlickEventOutput<T extends (...args: any) => any> = CustomEvent<{
+    eventData: any;
+    args: Parameters<T>[0];
+}>;
+/**
+ * Generic type for wrapping simple event output with detail property
+ * Extends CustomEvent for compatibility with event handlers
+ * @template T - The event function type from AngularSlickgridOutputs interface
+ */
+type RegularEventOutput<T extends (...args: any) => any> = CustomEvent<Parameters<T>[0]>;
+/**
+ * Angular-Slickgrid Output Events Interface
+ * Defines all typed output signals for strict template type checking in Angular 17+
+ * These are automatically managed by the AngularSlickgridComponent and should be used in templates
+ *
+ * @example
+ * ```html
+ * <angular-slickgrid
+ *   (onActiveCellChanged)="handleCellChange($event)"
+ *   (onAngularGridCreated)="handleGridCreated($event)"
+ * ></angular-slickgrid>
+ * ```
+ */
+interface AngularSlickgridOutputs {
+    onActiveCellChanged: (e: OnActiveCellChangedEventArgs) => void;
+    onActiveCellPositionChanged: (e: {
+        grid: SlickGrid;
+    }) => void;
+    onAddNewRow: (e: OnAddNewRowEventArgs) => void;
+    onAutosizeColumns: (e: OnAutosizeColumnsEventArgs) => void;
+    onBeforeAppendCell: (e: OnBeforeAppendCellEventArgs) => void;
+    onBeforeCellEditorDestroy: (e: OnBeforeCellEditorDestroyEventArgs) => void;
+    onBeforeColumnsResize: (e: OnBeforeColumnsResizeEventArgs) => void;
+    onBeforeDestroy: (e: {
+        grid: SlickGrid;
+    }) => void;
+    onBeforeEditCell: (e: OnBeforeEditCellEventArgs) => void;
+    onBeforeHeaderCellDestroy: (e: OnBeforeHeaderCellDestroyEventArgs) => void;
+    onBeforeHeaderRowCellDestroy: (e: OnBeforeHeaderRowCellDestroyEventArgs) => void;
+    onBeforeFooterRowCellDestroy: (e: OnBeforeFooterRowCellDestroyEventArgs) => void;
+    onBeforeSetColumns: (e: OnBeforeSetColumnsEventArgs) => void;
+    onBeforeSort: (e: SingleColumnSort) => boolean | void;
+    onCellChange: (e: OnCellChangeEventArgs) => void;
+    onCellCssStylesChanged: (e: OnCellCssStylesChangedEventArgs) => void;
+    onClick: (e: OnClickEventArgs) => void;
+    onColumnsDrag: (e: OnColumnsDragEventArgs) => void;
+    onColumnsReordered: (e: OnColumnsReorderedEventArgs) => void;
+    onColumnsResized: (e: OnColumnsResizedEventArgs) => void;
+    onColumnsResizeDblClick: (e: OnColumnsResizeDblClickEventArgs) => void;
+    onCompositeEditorChange: (e: OnCompositeEditorChangeEventArgs) => void;
+    onContextMenu: (e: {
+        grid: SlickGrid;
+    }) => void;
+    onDrag: (e: DragRowMove) => void;
+    onDragEnd: (e: DragRowMove) => void;
+    onDragInit: (e: DragRowMove) => void;
+    onDragStart: (e: DragRowMove) => void;
+    onDragReplaceCells: (e: OnDragReplaceCellsEventArgs) => void;
+    onDblClick: (e: OnDblClickEventArgs) => void;
+    onFooterContextMenu: (e: OnFooterContextMenuEventArgs) => void;
+    onFooterRowCellRendered: (e: OnFooterRowCellRenderedEventArgs) => void;
+    onHeaderCellRendered: (e: OnHeaderCellRenderedEventArgs) => void;
+    onFooterClick: (e: OnFooterClickEventArgs) => void;
+    onHeaderClick: (e: OnHeaderClickEventArgs) => void;
+    onHeaderContextMenu: (e: OnHeaderContextMenuEventArgs) => void;
+    onHeaderMouseEnter: (e: OnHeaderMouseEventArgs) => void;
+    onHeaderMouseLeave: (e: OnHeaderMouseEventArgs) => void;
+    onHeaderRowCellRendered: (e: OnHeaderRowCellRenderedEventArgs) => void;
+    onHeaderRowMouseEnter: (e: OnHeaderMouseEventArgs) => void;
+    onHeaderRowMouseLeave: (e: OnHeaderMouseEventArgs) => void;
+    onKeyDown: (e: OnKeyDownEventArgs) => void;
+    onMouseEnter: (e: {
+        grid: SlickGrid;
+    }) => void;
+    onMouseLeave: (e: {
+        grid: SlickGrid;
+    }) => void;
+    onValidationError: (e: OnValidationErrorEventArgs) => void;
+    onViewportChanged: (e: {
+        grid: SlickGrid;
+    }) => void;
+    onRendered: (e: OnRenderedEventArgs) => void;
+    onSelectedRowsChanged: (e: OnSelectedRowsChangedEventArgs) => void;
+    onSetOptions: (e: OnSetOptionsEventArgs) => void;
+    onScroll: (e: OnScrollEventArgs) => void;
+    onSort: (e: SingleColumnSort) => void;
+    onBeforePagingInfoChanged: (e: PagingInfo) => void;
+    onGroupExpanded: (e: OnGroupExpandedEventArgs) => void;
+    onGroupCollapsed: (e: OnGroupCollapsedEventArgs) => void;
+    onPagingInfoChanged: (e: PagingInfo) => void;
+    onRowCountChanged: (e: OnRowCountChangedEventArgs) => void;
+    onRowsChanged: (e: OnRowsChangedEventArgs) => void;
+    onRowsOrCountChanged: (e: OnRowsOrCountChangedEventArgs) => void;
+    onSetItemsCalled: (e: OnSetItemsCalledEventArgs) => void;
+    onAfterMenuShow: (e: MenuFromCellCallbackArgs) => void;
+    onBeforeMenuClose: (e: MenuFromCellCallbackArgs) => void;
+    onBeforeMenuShow: (e: MenuFromCellCallbackArgs) => void;
+    onColumnsChanged: (e: OnColumnsChangedArgs) => void;
+    onCommand: (e: MenuCommandItemCallbackArgs | MenuOptionItemCallbackArgs) => void;
+    onGridMenuColumnsChanged: (e: OnColumnsChangedArgs) => void;
+    onMenuClose: (e: GridMenuEventWithElementCallbackArgs) => void;
+    onCopyCells: (e: {
+        ranges: SlickRange[];
+    }) => void;
+    onCopyCancelled: (e: {
+        ranges: SlickRange[];
+    }) => void;
+    onPasteCells: (e: {
+        ranges: SlickRange[];
+    }) => void;
+    onBeforePasteCell: (e: {
+        cell: number;
+        row: number;
+        item: any;
+        columnDef: Column;
+        value: any;
+    }) => void;
+    onAfterExportToExcel: (e: {
+        filename: string;
+        mimeType: string;
+    } | {
+        error: any;
+    }) => void;
+    onBeforeExportToExcel: (e: boolean) => void;
+    onAfterExportToPdf: (e: {
+        filename: string;
+    } | {
+        error: any;
+    }) => void;
+    onBeforeExportToPdf: (e: boolean) => void;
+    onBeforeExportToTextFile?: (e: boolean) => void;
+    onAfterExportToTextFile?: (e: ExportTextDownloadOption) => void;
+    onBeforeFilterChange: (e: CurrentFilter[]) => void;
+    onBeforeFilterClear: (e: {
+        columnId: string;
+    } | boolean) => void;
+    onBeforeSearchChange: (e: OnSearchChangeEventArgs) => boolean | void;
+    onBeforeSortChange: (e: Array<ColumnSort & {
+        clearSortTriggered?: boolean;
+    }>) => void;
+    onContextMenuClearGrouping: () => void;
+    onContextMenuCollapseAllGroups: () => void;
+    onContextMenuExpandAllGroups: () => void;
+    onOptionSelected: (e: MenuCommandItemCallbackArgs | MenuOptionItemCallbackArgs) => void;
+    onColumnPickerColumnsChanged: (e: OnColumnsChangedArgs) => void;
+    onGridMenuMenuClose: (e: GridMenuEventWithElementCallbackArgs) => void;
+    onGridMenuBeforeMenuShow: (e: GridMenuEventWithElementCallbackArgs) => void;
+    onGridMenuAfterMenuShow: (e: GridMenuEventWithElementCallbackArgs) => void;
+    onGridMenuClearAllPinning: () => void;
+    onGridMenuClearAllFilters: () => void;
+    onGridMenuClearAllSorting: () => void;
+    onGridMenuCommand: (e: GridMenuCommandItemCallbackArgs) => void;
+    onHeaderButtonCommand: (e: HeaderButtonOnCommandArgs) => void;
+    onHeaderMenuCommand: (e: MenuCommandItemCallbackArgs) => void;
+    onHeaderMenuColumnResizeByContent: (e: {
+        columnId: string;
+    }) => void;
+    onHeaderMenuBeforeMenuShow: (e: HeaderMenuCommandItemCallbackArgs) => void;
+    onHeaderMenuAfterMenuShow: (e: HeaderMenuCommandItemCallbackArgs) => void;
+    onHideColumns: (e: {
+        columns: Column[];
+        hiddenColumn: Column[];
+    }) => void;
+    onItemsAdded: (e: any[]) => void;
+    onItemsDeleted: (e: any[]) => void;
+    onItemsUpdated: (e: any[]) => void;
+    onItemsUpserted: (e: any[]) => void;
+    onFullResizeByContentRequested: (e: {
+        caller: string;
+    }) => void;
+    onGridStateChanged: (e: GridStateChange) => void;
+    onBeforePaginationChange: (e: PaginationMetadata) => boolean | void;
+    onPaginationChanged: (e: PaginationMetadata) => void;
+    onPaginationRefreshed: (e: PaginationMetadata) => void;
+    onPaginationVisibilityChanged: (e: {
+        visible: boolean;
+    }) => void;
+    onPaginationSetCursorBased: (e: {
+        isCursorBased: boolean;
+    }) => void;
+    onGridBeforeResize: () => void;
+    onGridAfterResize: (e: GridSize | undefined) => void;
+    onBeforeResizeByContent: () => void;
+    onAfterResizeByContent: (e: {
+        readItemCount: number;
+        calculateColumnWidths: {
+            [x: string]: number | undefined;
+            [x: number]: number | undefined;
+        };
+    }) => void;
+    onSelectedRowIdsChanged: (e: OnSelectedRowIdsChangedEventArgs) => void;
+    onSortCleared: (e: boolean) => void;
+    onFilterChanged: (e: CurrentFilter[]) => void;
+    onFilterCleared: (e: boolean) => void;
+    onSortChanged: (e: CurrentSorter[]) => void;
+    onTreeItemToggled: (e: TreeToggleStateChange) => void;
+    onTreeFullToggleEnd: (e: TreeToggleStateChange) => void;
+    onTreeFullToggleStart: (e: TreeToggleStateChange) => void;
+    onBeforeGridCreate: (e: boolean) => void;
+    onGridCreated: (e: SlickGrid) => void;
+    onDataviewCreated: (e: SlickDataView) => void;
+    onAngularGridCreated: (e: AngularGridInstance) => void;
+    onBeforeGridDestroy: (e: SlickGrid) => void;
+    onAfterGridDestroyed: (e: boolean) => void;
+    onLanguageChange: (lang: string) => void;
+}
+
+interface AngularRowDetailView {
+    create(columns: Column[], gridOptions: GridOption): any;
+    init(grid: SlickGrid, containerService?: ContainerService): void;
+}
+declare class AngularSlickgridComponent<TData = any> implements AfterViewInit, OnDestroy {
+    protected readonly angularUtilService: AngularUtilService;
+    protected readonly appRef: ApplicationRef;
+    protected readonly containerService: ContainerService;
+    protected readonly elm: ElementRef;
+    protected readonly translate: TranslateService;
+    protected readonly translaterService: TranslaterService;
+    protected forRootConfig?: GridOption | undefined;
+    protected _dataset?: TData[] | null;
+    protected _columnDefinitions: Column[];
+    protected _currentDatasetLength: number;
+    protected _darkMode: boolean;
+    protected _eventHandler: SlickEventHandler;
+    protected _eventPubSubService: EventPubSubService;
+    protected _angularGridInstances: AngularGridInstance | undefined;
+    protected _hideHeaderRowAfterPageLoad: boolean;
+    protected _isAutosizeColsCalled: boolean;
+    protected _isGridInitialized: boolean;
+    protected _isDatasetInitialized: boolean;
+    protected _isDatasetHierarchicalInitialized: boolean;
+    protected _isPaginationInitialized: boolean;
+    protected _isLocalGrid: boolean;
+    protected _paginationOptions: Pagination | undefined;
+    protected _registeredResources: Array<ExternalResource | ExternalResourceConstructor>;
+    protected _scrollEndCalled: boolean;
+    dataView: SlickDataView;
+    slickGrid: SlickGrid;
+    groupingDefinition: any;
+    groupItemMetadataProvider?: SlickGroupItemMetadataProvider;
+    backendServiceApi?: BackendServiceApi;
+    locales: Locale;
+    metrics?: Metrics;
+    showPagination: boolean;
+    serviceList: any[];
+    totalItems: number;
+    paginationData?: {
+        gridOptions: GridOption;
+        paginationService: PaginationService;
+    };
+    subscriptions: EventSubscription[];
+    slickEmptyWarning?: SlickEmptyWarningComponent;
+    slickFooter?: SlickFooterComponent;
+    slickPagination?: BasePaginationComponent;
+    paginationComponent: BasePaginationComponent | undefined;
+    slickRowDetailView?: AngularRowDetailView;
+    backendUtilityService: BackendUtilityService;
+    collectionService: CollectionService;
+    extensionService: ExtensionService;
+    extensionUtility: ExtensionUtility;
+    filterFactory: FilterFactory;
+    filterService: FilterService;
+    gridEventService: GridEventService;
+    gridService: GridService;
+    gridStateService: GridStateService;
+    headerGroupingService: HeaderGroupingService;
+    paginationService: PaginationService;
+    resizerService: ResizerService;
+    rxjs?: RxJsFacade;
+    sharedService: SharedService;
+    sortService: SortService;
+    treeDataService: TreeDataService;
+    customDataView: CustomDataView | undefined;
+    gridId: string;
+    options: GridOption;
+    containerClasses?: string[];
+    get paginationOptions(): Pagination | undefined;
+    set paginationOptions(newPaginationOptions: Pagination | undefined);
+    get columns(): Column[];
+    set columns(columns: Column[]);
+    columnsChange: EventEmitter<any>;
+    onActiveCellChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnActiveCellChangedEventArgs) => void>>;
+    onActiveCellPositionChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        grid: SlickGrid;
+    }) => void>>;
+    onAddNewRow: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnAddNewRowEventArgs) => void>>;
+    onAutosizeColumns: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnAutosizeColumnsEventArgs) => void>>;
+    onBeforeAppendCell: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnBeforeAppendCellEventArgs) => void>>;
+    onBeforeCellEditorDestroy: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnBeforeCellEditorDestroyEventArgs) => void>>;
+    onBeforeColumnsResize: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnBeforeColumnsResizeEventArgs) => void>>;
+    onBeforeDestroy: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        grid: SlickGrid;
+    }) => void>>;
+    onBeforeEditCell: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnBeforeEditCellEventArgs) => void>>;
+    onBeforeHeaderCellDestroy: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnBeforeHeaderCellDestroyEventArgs) => void>>;
+    onBeforeHeaderRowCellDestroy: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnBeforeHeaderRowCellDestroyEventArgs) => void>>;
+    onBeforeFooterRowCellDestroy: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnBeforeFooterRowCellDestroyEventArgs) => void>>;
+    onBeforeSetColumns: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnBeforeSetColumnsEventArgs) => void>>;
+    onBeforeSort: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.SingleColumnSort) => boolean | void>>;
+    onCellChange: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnCellChangeEventArgs) => void>>;
+    onCellCssStylesChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnCellCssStylesChangedEventArgs) => void>>;
+    onClick: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnClickEventArgs) => void>>;
+    onColumnsDrag: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnColumnsDragEventArgs) => void>>;
+    onColumnsReordered: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnColumnsReorderedEventArgs) => void>>;
+    onColumnsResized: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnColumnsResizedEventArgs) => void>>;
+    onColumnsResizeDblClick: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnColumnsResizeDblClickEventArgs) => void>>;
+    onCompositeEditorChange: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnCompositeEditorChangeEventArgs) => void>>;
+    onContextMenu: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        grid: SlickGrid;
+    }) => void>>;
+    onDrag: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.DragRowMove) => void>>;
+    onDragEnd: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.DragRowMove) => void>>;
+    onDragInit: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.DragRowMove) => void>>;
+    onDragStart: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.DragRowMove) => void>>;
+    onDragReplaceCells: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnDragReplaceCellsEventArgs) => void>>;
+    onDblClick: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnDblClickEventArgs) => void>>;
+    onFooterContextMenu: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnFooterContextMenuEventArgs) => void>>;
+    onFooterRowCellRendered: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnFooterRowCellRenderedEventArgs) => void>>;
+    onHeaderCellRendered: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnHeaderCellRenderedEventArgs) => void>>;
+    onFooterClick: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnFooterClickEventArgs) => void>>;
+    onHeaderClick: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnHeaderClickEventArgs) => void>>;
+    onHeaderContextMenu: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnHeaderContextMenuEventArgs) => void>>;
+    onHeaderMouseEnter: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnHeaderMouseEventArgs) => void>>;
+    onHeaderMouseLeave: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnHeaderMouseEventArgs) => void>>;
+    onHeaderRowCellRendered: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnHeaderRowCellRenderedEventArgs) => void>>;
+    onHeaderRowMouseEnter: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnHeaderMouseEventArgs) => void>>;
+    onHeaderRowMouseLeave: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnHeaderMouseEventArgs) => void>>;
+    onKeyDown: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnKeyDownEventArgs) => void>>;
+    onMouseEnter: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        grid: SlickGrid;
+    }) => void>>;
+    onMouseLeave: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        grid: SlickGrid;
+    }) => void>>;
+    onValidationError: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnValidationErrorEventArgs) => void>>;
+    onViewportChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        grid: SlickGrid;
+    }) => void>>;
+    onRendered: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnRenderedEventArgs) => void>>;
+    onSelectedRowsChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnSelectedRowsChangedEventArgs) => void>>;
+    onSetOptions: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnSetOptionsEventArgs) => void>>;
+    onScroll: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnScrollEventArgs) => void>>;
+    onSort: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.SingleColumnSort) => void>>;
+    onBeforePagingInfoChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.PagingInfo) => void>>;
+    onGroupExpanded: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnGroupExpandedEventArgs) => void>>;
+    onGroupCollapsed: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnGroupCollapsedEventArgs) => void>>;
+    onPagingInfoChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.PagingInfo) => void>>;
+    onRowCountChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnRowCountChangedEventArgs) => void>>;
+    onRowsChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnRowsChangedEventArgs) => void>>;
+    onRowsOrCountChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnRowsOrCountChangedEventArgs) => void>>;
+    onSelectedRowIdsChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnSelectedRowIdsChangedEventArgs) => void>>;
+    onSetItemsCalled: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnSetItemsCalledEventArgs) => void>>;
+    onAfterMenuShow: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.MenuFromCellCallbackArgs) => void>>;
+    onBeforeMenuClose: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.MenuFromCellCallbackArgs) => void>>;
+    onBeforeMenuShow: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.MenuFromCellCallbackArgs) => void>>;
+    onColumnsChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnColumnsChangedArgs) => void>>;
+    onCommand: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.MenuCommandItemCallbackArgs | angular_slickgrid.MenuOptionItemCallbackArgs) => void>>;
+    onGridMenuColumnsChanged: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.OnColumnsChangedArgs) => void>>;
+    onMenuClose: _angular_core.OutputEmitterRef<SlickEventOutput<(e: angular_slickgrid.GridMenuEventWithElementCallbackArgs) => void>>;
+    onCopyCells: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        ranges: angular_slickgrid.SlickRange[];
+    }) => void>>;
+    onCopyCancelled: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        ranges: angular_slickgrid.SlickRange[];
+    }) => void>>;
+    onPasteCells: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        ranges: angular_slickgrid.SlickRange[];
+    }) => void>>;
+    onBeforePasteCell: _angular_core.OutputEmitterRef<SlickEventOutput<(e: {
+        cell: number;
+        row: number;
+        item: any;
+        columnDef: Column;
+        value: any;
+    }) => void>>;
+    onAfterExportToExcel: _angular_core.OutputEmitterRef<RegularEventOutput<(e: {
+        filename: string;
+        mimeType: string;
+    } | {
+        error: any;
+    }) => void>>;
+    onBeforeExportToExcel: _angular_core.OutputEmitterRef<RegularEventOutput<(e: boolean) => void>>;
+    onBeforeFilterChange: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.CurrentFilter[]) => void>>;
+    onBeforeFilterClear: _angular_core.OutputEmitterRef<RegularEventOutput<(e: {
+        columnId: string;
+    } | boolean) => void>>;
+    onBeforeSearchChange: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.OnSearchChangeEventArgs) => boolean | void>>;
+    onBeforeSortChange: _angular_core.OutputEmitterRef<RegularEventOutput<(e: Array<angular_slickgrid.ColumnSort & {
+        clearSortTriggered?: boolean;
+    }>) => void>>;
+    onContextMenuClearGrouping: _angular_core.OutputEmitterRef<RegularEventOutput<() => void>>;
+    onContextMenuCollapseAllGroups: _angular_core.OutputEmitterRef<RegularEventOutput<() => void>>;
+    onContextMenuExpandAllGroups: _angular_core.OutputEmitterRef<RegularEventOutput<() => void>>;
+    onOptionSelected: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.MenuCommandItemCallbackArgs | angular_slickgrid.MenuOptionItemCallbackArgs) => void>>;
+    onColumnPickerColumnsChanged: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.OnColumnsChangedArgs) => void>>;
+    onGridMenuMenuClose: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.GridMenuEventWithElementCallbackArgs) => void>>;
+    onGridMenuBeforeMenuShow: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.GridMenuEventWithElementCallbackArgs) => void>>;
+    onGridMenuAfterMenuShow: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.GridMenuEventWithElementCallbackArgs) => void>>;
+    onGridMenuClearAllPinning: _angular_core.OutputEmitterRef<RegularEventOutput<() => void>>;
+    onGridMenuClearAllFilters: _angular_core.OutputEmitterRef<RegularEventOutput<() => void>>;
+    onGridMenuClearAllSorting: _angular_core.OutputEmitterRef<RegularEventOutput<() => void>>;
+    onGridMenuCommand: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.GridMenuCommandItemCallbackArgs) => void>>;
+    onHeaderButtonCommand: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.HeaderButtonOnCommandArgs) => void>>;
+    onHeaderMenuCommand: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.MenuCommandItemCallbackArgs) => void>>;
+    onHeaderMenuColumnResizeByContent: _angular_core.OutputEmitterRef<RegularEventOutput<(e: {
+        columnId: string;
+    }) => void>>;
+    onHeaderMenuBeforeMenuShow: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.HeaderMenuCommandItemCallbackArgs) => void>>;
+    onHeaderMenuAfterMenuShow: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.HeaderMenuCommandItemCallbackArgs) => void>>;
+    onHideColumns: _angular_core.OutputEmitterRef<RegularEventOutput<(e: {
+        columns: Column[];
+        hiddenColumn: Column[];
+    }) => void>>;
+    onItemsAdded: _angular_core.OutputEmitterRef<RegularEventOutput<(e: any[]) => void>>;
+    onItemsDeleted: _angular_core.OutputEmitterRef<RegularEventOutput<(e: any[]) => void>>;
+    onItemsUpdated: _angular_core.OutputEmitterRef<RegularEventOutput<(e: any[]) => void>>;
+    onItemsUpserted: _angular_core.OutputEmitterRef<RegularEventOutput<(e: any[]) => void>>;
+    onFullResizeByContentRequested: _angular_core.OutputEmitterRef<RegularEventOutput<(e: {
+        caller: string;
+    }) => void>>;
+    onGridStateChanged: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.GridStateChange) => void>>;
+    onBeforePaginationChange: _angular_core.OutputEmitterRef<RegularEventOutput<(e: PaginationMetadata) => boolean | void>>;
+    onPaginationChanged: _angular_core.OutputEmitterRef<RegularEventOutput<(e: PaginationMetadata) => void>>;
+    onPaginationRefreshed: _angular_core.OutputEmitterRef<RegularEventOutput<(e: PaginationMetadata) => void>>;
+    onPaginationVisibilityChanged: _angular_core.OutputEmitterRef<RegularEventOutput<(e: {
+        visible: boolean;
+    }) => void>>;
+    onPaginationSetCursorBased: _angular_core.OutputEmitterRef<RegularEventOutput<(e: {
+        isCursorBased: boolean;
+    }) => void>>;
+    onGridBeforeResize: _angular_core.OutputEmitterRef<RegularEventOutput<() => void>>;
+    onGridAfterResize: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.GridSize | undefined) => void>>;
+    onBeforeResizeByContent: _angular_core.OutputEmitterRef<RegularEventOutput<() => void>>;
+    onAfterResizeByContent: _angular_core.OutputEmitterRef<RegularEventOutput<(e: {
+        readItemCount: number;
+        calculateColumnWidths: {
+            [x: string]: number | undefined;
+            [x: number]: number | undefined;
+        };
+    }) => void>>;
+    onSortCleared: _angular_core.OutputEmitterRef<RegularEventOutput<(e: boolean) => void>>;
+    onFilterChanged: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.CurrentFilter[]) => void>>;
+    onFilterCleared: _angular_core.OutputEmitterRef<RegularEventOutput<(e: boolean) => void>>;
+    onSortChanged: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.CurrentSorter[]) => void>>;
+    onTreeItemToggled: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.TreeToggleStateChange) => void>>;
+    onTreeFullToggleEnd: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.TreeToggleStateChange) => void>>;
+    onTreeFullToggleStart: _angular_core.OutputEmitterRef<RegularEventOutput<(e: angular_slickgrid.TreeToggleStateChange) => void>>;
+    onBeforeGridCreate: _angular_core.OutputEmitterRef<RegularEventOutput<(e: boolean) => void>>;
+    onGridCreated: _angular_core.OutputEmitterRef<RegularEventOutput<(e: SlickGrid) => void>>;
+    onDataviewCreated: _angular_core.OutputEmitterRef<RegularEventOutput<(e: SlickDataView) => void>>;
+    onAngularGridCreated: _angular_core.OutputEmitterRef<RegularEventOutput<(e: AngularGridInstance) => void>>;
+    onBeforeGridDestroy: _angular_core.OutputEmitterRef<RegularEventOutput<(e: SlickGrid) => void>>;
+    onAfterGridDestroyed: _angular_core.OutputEmitterRef<RegularEventOutput<(e: boolean) => void>>;
+    onLanguageChange: _angular_core.OutputEmitterRef<RegularEventOutput<(lang: string) => void>>;
+    get dataset(): any[];
+    set dataset(newDataset: any[]);
+    get datasetHierarchical(): any[] | undefined;
+    set datasetHierarchical(newHierarchicalDataset: any[] | undefined);
+    get elementRef(): ElementRef;
+    get backendService(): BackendService | undefined;
+    get eventHandler(): SlickEventHandler;
+    get gridContainerElement(): HTMLElement | null;
+    /** GETTER to know if dataset was initialized or not */
+    get isDatasetInitialized(): boolean;
+    /** SETTER to change if dataset was initialized or not (stringly used for unit testing purposes) */
+    set isDatasetInitialized(isInitialized: boolean);
+    set isDatasetHierarchicalInitialized(isInitialized: boolean);
+    get registeredResources(): Array<ExternalResource | ExternalResourceConstructor>;
+    slickgridHeader: TemplateRef<any> | null;
+    slickgridFooter: TemplateRef<any> | null;
+    constructor(angularUtilService: AngularUtilService, appRef: ApplicationRef, containerService: ContainerService, elm: ElementRef, translate: TranslateService, translaterService: TranslaterService, forRootConfig?: GridOption | undefined, externalServices?: ExternalTestingDependencies);
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    destroy(shouldEmptyDomElementContainer?: boolean): void;
+    disposeExternalResources(): void;
+    emptyGridContainerElm(): void;
+    /**
+     * Define our internal Post Process callback, it will execute internally after we get back result from the Process backend call
+     * Currently ONLY available with the GraphQL Backend Service.
+     * The behavior is to refresh the Dataset & Pagination without requiring the user to create his own PostProcess every time
+     */
+    createBackendApiInternalPostProcessCallback(gridOptions: GridOption): void;
+    initialization(eventHandler: SlickEventHandler): void;
+    /**
+     * On a Pagination changed, we will trigger a Grid State changed with the new pagination info
+     * Also if we use Row Selection or the Checkbox Selector with a Backend Service (Odata, GraphQL), we need to reset any selection
+     */
+    paginationChanged(pagination: PaginationMetadata): void;
+    /**
+     * When dataset changes, we need to refresh the entire grid UI & possibly resize it as well
+     * @param dataset
+     */
+    refreshGridData(dataset: any[], totalCount?: number): void;
+    setData(data: TData[], shouldAutosizeColumns?: boolean): void;
+    /**
+     * Check if there's any Pagination Presets defined in the Grid Options,
+     * if there are then load them in the paginationOptions object
+     */
+    protected setPaginationOptionsWhenPresetDefined(gridOptions: GridOption, paginationOptions: Pagination): Pagination;
+    setDarkMode(dark?: boolean): void;
+    /**
+     * Dynamically change or update the column definitions list.
+     * We will re-render the grid so that the new header and data shows up correctly.
+     * If using i18n, we also need to trigger a re-translate of the column headers
+     */
+    updateColumnDefinitionsList(newColumns: Column[]): void;
+    /**
+     * Show the filter row displayed on first row, we can optionally pass false to hide it.
+     * @param showing
+     */
+    showHeaderRow(showing?: boolean): boolean;
+    /**
+     * Toggle the empty data warning message visibility.
+     * @param showWarning
+     */
+    displayEmptyDataWarning(showWarning?: boolean): void;
+    /**
+     * Loop through all column definitions and copy the original optional `width` properties optionally provided by the user.
+     * We will use this when doing a resize by cell content, if user provided a `width` it won't override it.
+     */
+    protected copyColumnWidthsReference(columns: Column[]): void;
+    protected bindDifferentHooks(grid: SlickGrid, gridOptions: GridOption, dataView: SlickDataView): void;
+    protected bindBackendCallbackFunctions(gridOptions: GridOption): void;
+    protected addBackendInfiniteScrollCallback(): void;
+    protected bindResizeHook(grid: SlickGrid, options: GridOption): void;
+    protected executeAfterDataviewCreated(_grid: SlickGrid, gridOptions: GridOption): void;
+    /** When data changes in the DataView, we'll refresh the metrics and/or display a warning if the dataset is empty */
+    protected handleOnItemCountChanged(currentPageRowItemCount: number, totalItemCount: number): void;
+    protected initializePaginationService(paginationOptions: Pagination): void;
+    /** Load the Editor Collection asynchronously and replace the "collection" property when Observable resolves */
+    protected loadEditorCollectionAsync(column: Column): void;
+    /** Load any possible Columns Grid Presets */
+    protected loadColumnPresetsWhenDatasetInitialized(): void;
+    /** Load any possible Filters Grid Presets */
+    protected loadFilterPresetsWhenDatasetInitialized(): void;
+    /**
+     * local grid, check if we need to show the Pagination
+     * if so then also check if there's any presets and finally initialize the PaginationService
+     * a local grid with Pagination presets will potentially have a different total of items, we'll need to get it from the DataView and update our total
+     */
+    protected loadLocalGridPagination(dataset?: any[]): void;
+    /** Load any Row Selections into the DataView that were presets by the user */
+    protected loadRowSelectionPresetWhenExists(): void;
+    hasBackendInfiniteScroll(gridOptions?: GridOption): boolean;
+    protected mergeGridOptions(gridOptions: GridOption): GridOption;
+    /** Add a register of a new external resource, user could also optional dispose all previous resources before pushing any new resources to the resources array list. */
+    registerExternalResources(resources: Array<ExternalResource | ExternalResourceConstructor>, disposePreviousResources?: boolean): void;
+    resetExternalResources(): void;
+    /** Pre-Register any Resource that don't require SlickGrid to be instantiated (for example RxJS Resource & RowDetail) */
+    protected preRegisterResources(): void;
+    /** initialized & auto-enable external registered resources, e.g. if user registers `ExcelExportService` then let's auto-enable `enableExcelExport:true` */
+    protected autoEnableInitializedResources(resource: ExternalResource | ExternalResourceConstructor): void;
+    protected initializeExternalResources(resources: Array<ExternalResource | ExternalResourceConstructor>): void;
+    protected registerResources(): void;
+    /** Register the RxJS Resource in all necessary services which uses */
+    protected registerRxJsResource(resource: RxJsFacade): void;
+    /**
+     * Render (or dispose) the Pagination Component, user can optionally provide False (to not show it) which will in term dispose of the Pagination,
+     * also while disposing we can choose to omit the disposable of the Pagination Service (if we are simply toggling the Pagination, we want to keep the Service alive)
+     * @param {Boolean} showPagination - show (new render) or not (dispose) the Pagination
+     * @param {Boolean} shouldDisposePaginationService - when disposing the Pagination, do we also want to dispose of the Pagination Service? (defaults to True)
+     */
+    protected renderPagination(showPagination?: boolean): void;
+    /**
+     * Takes a flat dataset with parent/child relationship, sort it (via its tree structure) and return the sorted flat array
+     * @param {Array<Object>} flatDatasetInput - flat dataset input
+     * @param {Boolean} forceGridRefresh - optionally force a full grid refresh
+     * @returns {Array<Object>} sort flat parent/child dataset
+     */
+    protected sortTreeDataset<T>(flatDatasetInput: T[], forceGridRefresh?: boolean): T[];
+    /** Prepare and load all SlickGrid editors, if an async editor is found then we'll also execute it. */
+    protected loadSlickGridEditors(columns: Column<TData>[]): Column<TData>[];
+    protected suggestDateParsingWhenHelpful(): void;
+    /**
+     * When the Editor(s) has a "editor.collection" property, we'll load the async collection.
+     * Since this is called after the async call resolves, the pointer will not be the same as the "column" argument passed.
+     */
+    protected updateEditorCollection<T = any>(column: Column<T>, newCollection: T[]): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AngularSlickgridComponent<any>, [null, null, null, null, { optional: true; }, { optional: true; }, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AngularSlickgridComponent<any>, "angular-slickgrid", never, { "customDataView": { "alias": "customDataView"; "required": false; }; "gridId": { "alias": "gridId"; "required": false; }; "options": { "alias": "options"; "required": false; }; "containerClasses": { "alias": "containerClasses"; "required": false; }; "paginationOptions": { "alias": "paginationOptions"; "required": false; }; "columns": { "alias": "columns"; "required": false; }; "dataset": { "alias": "dataset"; "required": false; }; "datasetHierarchical": { "alias": "datasetHierarchical"; "required": false; }; }, { "columnsChange": "columnsChange"; "onActiveCellChanged": "onActiveCellChanged"; "onActiveCellPositionChanged": "onActiveCellPositionChanged"; "onAddNewRow": "onAddNewRow"; "onAutosizeColumns": "onAutosizeColumns"; "onBeforeAppendCell": "onBeforeAppendCell"; "onBeforeCellEditorDestroy": "onBeforeCellEditorDestroy"; "onBeforeColumnsResize": "onBeforeColumnsResize"; "onBeforeDestroy": "onBeforeDestroy"; "onBeforeEditCell": "onBeforeEditCell"; "onBeforeHeaderCellDestroy": "onBeforeHeaderCellDestroy"; "onBeforeHeaderRowCellDestroy": "onBeforeHeaderRowCellDestroy"; "onBeforeFooterRowCellDestroy": "onBeforeFooterRowCellDestroy"; "onBeforeSetColumns": "onBeforeSetColumns"; "onBeforeSort": "onBeforeSort"; "onCellChange": "onCellChange"; "onCellCssStylesChanged": "onCellCssStylesChanged"; "onClick": "onClick"; "onColumnsDrag": "onColumnsDrag"; "onColumnsReordered": "onColumnsReordered"; "onColumnsResized": "onColumnsResized"; "onColumnsResizeDblClick": "onColumnsResizeDblClick"; "onCompositeEditorChange": "onCompositeEditorChange"; "onContextMenu": "onContextMenu"; "onDrag": "onDrag"; "onDragEnd": "onDragEnd"; "onDragInit": "onDragInit"; "onDragStart": "onDragStart"; "onDragReplaceCells": "onDragReplaceCells"; "onDblClick": "onDblClick"; "onFooterContextMenu": "onFooterContextMenu"; "onFooterRowCellRendered": "onFooterRowCellRendered"; "onHeaderCellRendered": "onHeaderCellRendered"; "onFooterClick": "onFooterClick"; "onHeaderClick": "onHeaderClick"; "onHeaderContextMenu": "onHeaderContextMenu"; "onHeaderMouseEnter": "onHeaderMouseEnter"; "onHeaderMouseLeave": "onHeaderMouseLeave"; "onHeaderRowCellRendered": "onHeaderRowCellRendered"; "onHeaderRowMouseEnter": "onHeaderRowMouseEnter"; "onHeaderRowMouseLeave": "onHeaderRowMouseLeave"; "onKeyDown": "onKeyDown"; "onMouseEnter": "onMouseEnter"; "onMouseLeave": "onMouseLeave"; "onValidationError": "onValidationError"; "onViewportChanged": "onViewportChanged"; "onRendered": "onRendered"; "onSelectedRowsChanged": "onSelectedRowsChanged"; "onSetOptions": "onSetOptions"; "onScroll": "onScroll"; "onSort": "onSort"; "onBeforePagingInfoChanged": "onBeforePagingInfoChanged"; "onGroupExpanded": "onGroupExpanded"; "onGroupCollapsed": "onGroupCollapsed"; "onPagingInfoChanged": "onPagingInfoChanged"; "onRowCountChanged": "onRowCountChanged"; "onRowsChanged": "onRowsChanged"; "onRowsOrCountChanged": "onRowsOrCountChanged"; "onSelectedRowIdsChanged": "onSelectedRowIdsChanged"; "onSetItemsCalled": "onSetItemsCalled"; "onAfterMenuShow": "onAfterMenuShow"; "onBeforeMenuClose": "onBeforeMenuClose"; "onBeforeMenuShow": "onBeforeMenuShow"; "onColumnsChanged": "onColumnsChanged"; "onCommand": "onCommand"; "onGridMenuColumnsChanged": "onGridMenuColumnsChanged"; "onMenuClose": "onMenuClose"; "onCopyCells": "onCopyCells"; "onCopyCancelled": "onCopyCancelled"; "onPasteCells": "onPasteCells"; "onBeforePasteCell": "onBeforePasteCell"; "onAfterExportToExcel": "onAfterExportToExcel"; "onBeforeExportToExcel": "onBeforeExportToExcel"; "onBeforeFilterChange": "onBeforeFilterChange"; "onBeforeFilterClear": "onBeforeFilterClear"; "onBeforeSearchChange": "onBeforeSearchChange"; "onBeforeSortChange": "onBeforeSortChange"; "onContextMenuClearGrouping": "onContextMenuClearGrouping"; "onContextMenuCollapseAllGroups": "onContextMenuCollapseAllGroups"; "onContextMenuExpandAllGroups": "onContextMenuExpandAllGroups"; "onOptionSelected": "onOptionSelected"; "onColumnPickerColumnsChanged": "onColumnPickerColumnsChanged"; "onGridMenuMenuClose": "onGridMenuMenuClose"; "onGridMenuBeforeMenuShow": "onGridMenuBeforeMenuShow"; "onGridMenuAfterMenuShow": "onGridMenuAfterMenuShow"; "onGridMenuClearAllPinning": "onGridMenuClearAllPinning"; "onGridMenuClearAllFilters": "onGridMenuClearAllFilters"; "onGridMenuClearAllSorting": "onGridMenuClearAllSorting"; "onGridMenuCommand": "onGridMenuCommand"; "onHeaderButtonCommand": "onHeaderButtonCommand"; "onHeaderMenuCommand": "onHeaderMenuCommand"; "onHeaderMenuColumnResizeByContent": "onHeaderMenuColumnResizeByContent"; "onHeaderMenuBeforeMenuShow": "onHeaderMenuBeforeMenuShow"; "onHeaderMenuAfterMenuShow": "onHeaderMenuAfterMenuShow"; "onHideColumns": "onHideColumns"; "onItemsAdded": "onItemsAdded"; "onItemsDeleted": "onItemsDeleted"; "onItemsUpdated": "onItemsUpdated"; "onItemsUpserted": "onItemsUpserted"; "onFullResizeByContentRequested": "onFullResizeByContentRequested"; "onGridStateChanged": "onGridStateChanged"; "onBeforePaginationChange": "onBeforePaginationChange"; "onPaginationChanged": "onPaginationChanged"; "onPaginationRefreshed": "onPaginationRefreshed"; "onPaginationVisibilityChanged": "onPaginationVisibilityChanged"; "onPaginationSetCursorBased": "onPaginationSetCursorBased"; "onGridBeforeResize": "onGridBeforeResize"; "onGridAfterResize": "onGridAfterResize"; "onBeforeResizeByContent": "onBeforeResizeByContent"; "onAfterResizeByContent": "onAfterResizeByContent"; "onSortCleared": "onSortCleared"; "onFilterChanged": "onFilterChanged"; "onFilterCleared": "onFilterCleared"; "onSortChanged": "onSortChanged"; "onTreeItemToggled": "onTreeItemToggled"; "onTreeFullToggleEnd": "onTreeFullToggleEnd"; "onTreeFullToggleStart": "onTreeFullToggleStart"; "onBeforeGridCreate": "onBeforeGridCreate"; "onGridCreated": "onGridCreated"; "onDataviewCreated": "onDataviewCreated"; "onAngularGridCreated": "onAngularGridCreated"; "onBeforeGridDestroy": "onBeforeGridDestroy"; "onAfterGridDestroyed": "onAfterGridDestroyed"; "onLanguageChange": "onLanguageChange"; }, ["slickgridHeader", "slickgridFooter"], never, true, never>;
+}
+
+export { AngularSlickgridComponent, AngularUtilService, SlickgridConfig, unsubscribeAllObservables };
+export type { AngularComponentOutput, AngularGridInstance, AngularSlickgridOutputs, GridOption, RowDetailView };