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, OnContextMenuArgs, DragRowMove, OnDragReplaceCellsEventArgs, OnDblClickEventArgs, OnFooterContextMenuEventArgs, OnFooterRowCellRenderedEventArgs, OnHeaderCellRenderedEventArgs, OnFooterClickEventArgs, OnHeaderClickEventArgs, OnHeaderContextMenuEventArgs, OnHeaderMouseEventArgs, OnHeaderRowCellRenderedEventArgs, OnKeyDownEventArgs, OnValidationErrorEventArgs, OnRenderedEventArgs, OnSelectedRowsChangedEventArgs, OnSetOptionsEventArgs, OnScrollEventArgs, PagingInfo, OnFormattedDataCacheProgressEventArgs, OnFormattedDataCacheCompletedEventArgs, OnGroupExpandedEventArgs, OnGroupCollapsedEventArgs, OnRowCountChangedEventArgs, OnRowsChangedEventArgs, OnRowsOrCountChangedEventArgs, OnSetItemsCalledEventArgs, MenuFromCellCallbackArgs, OnColumnsChangedArgs, MenuCommandItemCallbackArgs, MenuOptionItemCallbackArgs, GridMenuEventWithElementCallbackArgs, SlickRange, ExportTextDownloadOption, CurrentFilter, OnSearchChangeEventArgs, OnLocalSortChangedArgs, 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: OnContextMenuArgs) => 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;
    onFormattedDataCacheProgress: (e: OnFormattedDataCacheProgressEventArgs) => void;
    onFormattedDataCacheCompleted: (e: OnFormattedDataCacheCompletedEventArgs) => 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: OnLocalSortChangedArgs) => 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;
    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 _columns: 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: angular_slickgrid.OnContextMenuArgs) => 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: angular_slickgrid.OnLocalSortChangedArgs) => 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>>;
    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 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[];
    protected suggestDateParsingWhenHelpful(): 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"; "onLanguageChange": "onLanguageChange"; }, ["slickgridHeader", "slickgridFooter"], never, true, never>;
}

export { AngularSlickgridComponent, AngularUtilService, SlickgridConfig, unsubscribeAllObservables };
export type { AngularComponentOutput, AngularGridInstance, AngularSlickgridOutputs, GridOption, RowDetailView };