@angular-bootstrap/ngbootstrap 0.0.13 → 2.0.0

package/types/angular-bootstrap-ngbootstrap.d.ts

@@ -1,7 +1,55 @@
 import * as i0 from '@angular/core';
-import { TemplateRef, AfterContentInit, OnChanges, ElementRef, EventEmitter, SimpleChanges, InjectionToken, QueryList, AfterViewInit, OnDestroy, ChangeDetectorRef } from '@angular/core';
+import { EventEmitter, AfterViewInit, OnDestroy, ElementRef, ChangeDetectorRef, TemplateRef, AfterContentInit, OnChanges, SimpleChanges, InjectionToken, OnInit, AfterViewChecked, QueryList } from '@angular/core';
 import { AbstractControl, FormGroup, FormControl, ControlValueAccessor } from '@angular/forms';
 import { Observable } from 'rxjs';
+import * as _angular_bootstrap_ngbootstrap from '@angular-bootstrap/ngbootstrap';
+import { ChartConfiguration } from 'chart.js';
+
+type NgbFilterMode = 'row' | 'menu' | 'multi' | 'none';
+type NgbFilterable = boolean | 'row' | 'menu' | 'multi' | 'none';
+type NgbFilterOperator = 'contains' | 'doesnotcontain' | 'eq' | 'neq' | 'startswith' | 'endswith' | 'gt' | 'gte' | 'lt' | 'lte' | 'isnull' | 'isnotnull' | 'isempty' | 'isnotempty';
+interface NgbFilterDescriptor {
+    field: string;
+    operator: NgbFilterOperator;
+    value?: any;
+    ignoreCase?: boolean;
+}
+/** Single condition in a column filter menu or layout-toolbar filter tool. */
+interface NgbMenuFilterConditionDraft {
+    operator: NgbFilterOperator;
+    value: any;
+}
+interface NgbCompositeFilterDescriptor {
+    logic: 'and' | 'or';
+    filters: Array<NgbFilterDescriptor | NgbCompositeFilterDescriptor>;
+}
+interface NgbFilterState {
+    global?: string;
+    root: NgbCompositeFilterDescriptor;
+}
+type NgbColumnFilterType = 'text' | 'numeric' | 'boolean' | 'date' | 'select';
+declare const NGB_TEXT_FILTER_OPERATORS: NgbFilterOperator[];
+declare const NGB_NUMERIC_FILTER_OPERATORS: NgbFilterOperator[];
+declare const NGB_BOOLEAN_FILTER_OPERATORS: NgbFilterOperator[];
+declare const NGB_DATE_FILTER_OPERATORS: NgbFilterOperator[];
+declare const NGB_SELECT_FILTER_OPERATORS: NgbFilterOperator[];
+declare function ngbColumnTypeToFilterType(type?: ColumnType): NgbColumnFilterType;
+declare function ngbDefaultFilterOperator(type: NgbColumnFilterType): NgbFilterOperator;
+declare function ngbAllowedFilterOperators(type: NgbColumnFilterType): NgbFilterOperator[];
+declare function ngbFilterOperatorLabel(operator: NgbFilterOperator, type?: NgbColumnFilterType): string;
+declare function ngbIsCompositeFilter(filter: NgbFilterDescriptor | NgbCompositeFilterDescriptor): filter is NgbCompositeFilterDescriptor;
+/** Recursively collects leaf filter descriptors from a composite filter tree. */
+declare function ngbFlattenFilterDescriptors(composite: NgbCompositeFilterDescriptor | null | undefined): NgbFilterDescriptor[];
+/** Returns the first leaf descriptor for `field`, searching nested composite nodes. */
+declare function ngbFindFieldFilterDescriptor(composite: NgbCompositeFilterDescriptor | null | undefined, field: string): NgbFilterDescriptor | null;
+declare function ngbOperatorRequiresFilterValue(operator: NgbFilterOperator): boolean;
+/**
+ * Returns a new composite filter with the field set (or removed when value is empty).
+ * Supports manual `filterChange(root)` updates from custom filter templates.
+ */
+declare function ngbSetFieldFilter(composite: NgbCompositeFilterDescriptor, field: string, operator: NgbFilterOperator, value?: any, options?: {
+    requiresValue?: (operator: NgbFilterOperator) => boolean;
+}): NgbCompositeFilterDescriptor;
 
 type ColumnType = 'text' | 'number' | 'email' | 'boolean' | 'date' | 'select';
 interface ColumnDef<T = any> {
@@ -17,16 +65,173 @@ interface ColumnDef<T = any> {
     sortable?: boolean;
     /** enable filtering on this column */
     filterable?: boolean;
-    editable?: boolean;
+    filterType?: NgbColumnFilterType;
+    /** When `''`, the first entry from {@link allowedFilterOperators} or the type list is used. */
+    defaultFilterOperator?: NgbFilterOperator | '';
+    allowedFilterOperators?: NgbFilterOperator[];
+    showFilterMenu?: boolean;
+    showFilterRow?: boolean;
+    /** When `false`, hides the operator-list trigger in row filter mode. */
+    showFilterOperator?: boolean;
+    /** Placeholder for the row filter input; defaults to a type-specific label. */
+    filterPlaceholder?: string;
+    editable?: boolean | ((row: T, isNew: boolean) => boolean);
     type?: ColumnType;
     options?: Array<{
         label: string;
         value: any;
     }>;
     width?: number;
+    /** Groups cells in stacked card layout (`tableOptions.stackedLayout = 'cards'`). */
+    stackedGroup?: 'start' | 'center' | 'end';
+    hidden?: boolean;
+    sticky?: boolean | 'start' | 'end';
+    locked?: boolean;
+    reorderable?: boolean;
+    /** When grid `[resizable]` is true, set to `false` to disable resizing for this column. */
+    resizable?: boolean;
+    /** Minimum width (px) while resizing; defaults to 50 when resizing is enabled. */
+    minResizableWidth?: number;
+    /** Maximum width (px) while resizing. */
+    maxResizableWidth?: number;
+    headerClass?: string | string[] | Record<string, boolean>;
+    headerStyle?: Record<string, string | number>;
+    cellClass?: string | string[] | Record<string, boolean> | ((row: T, rowIndex: number) => string | string[] | Record<string, boolean>);
+    cellStyle?: Record<string, string | number> | ((row: T, rowIndex: number) => Record<string, string | number> | null | undefined);
     required?: boolean;
 }
 
+declare class NgbPaginationComponent {
+    page: number;
+    pageSize: number;
+    collectionSize: number;
+    /** @deprecated Use `buttonCount`. Kept for compatibility. */
+    maxSize: number;
+    buttonCount?: number;
+    previousNext: boolean;
+    pagerType: 'numeric' | 'input';
+    responsive: boolean;
+    pageChange: EventEmitter<number>;
+    get effectiveButtonCount(): number;
+    get totalPages(): number;
+    get pages(): Array<number | '…'>;
+    go(p: number | string): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbPaginationComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbPaginationComponent, "ngb-pagination", never, { "page": { "alias": "page"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "collectionSize": { "alias": "collectionSize"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; "buttonCount": { "alias": "buttonCount"; "required": false; }; "previousNext": { "alias": "previousNext"; "required": false; }; "pagerType": { "alias": "pagerType"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
+}
+
+type NgbPagerType = 'numeric' | 'input';
+/**
+ * Responsive pager density based on container width.
+ * - `full`: info, pagination, and page-size controls
+ * - `compact`: hides range info
+ * - `minimal`: hides range info and page-size controls (pagination remains)
+ */
+type NgbPagerDensity = 'full' | 'compact' | 'minimal';
+/** Width breakpoints (px) for {@link ngbResolvePagerDensity}. */
+declare const NGB_PAGER_BREAKPOINTS: {
+    readonly fullMinWidth: 520;
+    readonly compactMinWidth: 360;
+};
+/** Configuration for {@link NgbPagerComponent}. */
+interface NgbPagerSettings {
+    /** Maximum numeric page buttons before ellipsis collapse. Default `10`. */
+    buttonCount?: number;
+    /** Shows the current range and total record count. Default `true`. */
+    info?: boolean;
+    /**
+     * Page-size presets. `false` hides the control (set `pageSize` yourself).
+     * The active `pageSize` is included when it is not already in the list.
+     */
+    pageSizes?: false | number[];
+    /** Shows previous/next pager buttons. Default `true`. */
+    previousNext?: boolean;
+    /** `numeric` (page buttons) or `input` (type a page number). Default `numeric`. */
+    type?: NgbPagerType;
+    /**
+     * When `true` (default), hides info and page-size controls as the container narrows.
+     * When `false`, all controls stay visible and wrap onto new rows.
+     */
+    responsive?: boolean;
+}
+declare const NGB_PAGER_DEFAULT_SETTINGS: Required<Omit<NgbPagerSettings, 'pageSizes'>> & {
+    pageSizes: false | number[];
+};
+declare function ngbResolvePagerSettings(settings: boolean | NgbPagerSettings | null | undefined): NgbPagerSettings | null;
+declare function ngbResolvePagerDensity(width: number): NgbPagerDensity;
+declare function ngbResolvePagerPageSizeOptions(pageSizes: false | number[] | undefined, pageSize: number): number[];
+declare function ngbPagerButtonCountForDensity(base: number, density: NgbPagerDensity, responsive: boolean): number;
+declare function ngbFormatPagerRangeLabel(start: number, end: number, total: number, template?: string): string;
+
+declare class NgbPagerComponent implements AfterViewInit, OnDestroy {
+    private readonly cdr;
+    private static nextId;
+    private readonly uid;
+    readonly pageSizeSelectId: string;
+    pagerDensity: NgbPagerDensity;
+    private resizeObserver?;
+    pagerRoot?: ElementRef<HTMLElement>;
+    page: number;
+    pageSize: number;
+    collectionSize: number;
+    settings: boolean | NgbPagerSettings | null;
+    /** Overrides the default range label when `info` is enabled. */
+    infoLabel?: string;
+    rangeLabelTemplate: string;
+    rowsPerPageLabel: string;
+    /** When set, overrides `settings.responsive`. */
+    responsive?: boolean;
+    pageChange: EventEmitter<number>;
+    pageSizeChange: EventEmitter<number>;
+    constructor(cdr: ChangeDetectorRef);
+    get resolved(): NgbPagerSettings;
+    get responsiveEnabled(): boolean;
+    get showInfoSetting(): boolean;
+    get showPageSizesSetting(): boolean;
+    get showInfo(): boolean;
+    get showPageSizes(): boolean;
+    get previousNextEnabled(): boolean;
+    get pagerType(): 'numeric' | 'input';
+    get effectiveButtonCount(): number;
+    get resolvedPageSizeOptions(): number[];
+    get displayInfoLabel(): string;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onPageChange(page: number): void;
+    onPageSizeChange(size: number): void;
+    private observeWidth;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbPagerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbPagerComponent, "ngb-pager", never, { "page": { "alias": "page"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "collectionSize": { "alias": "collectionSize"; "required": false; }; "settings": { "alias": "settings"; "required": false; }; "infoLabel": { "alias": "infoLabel"; "required": false; }; "rangeLabelTemplate": { "alias": "rangeLabelTemplate"; "required": false; }; "rowsPerPageLabel": { "alias": "rowsPerPageLabel"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; }, { "pageChange": "pageChange"; "pageSizeChange": "pageSizeChange"; }, never, never, true, never>;
+}
+
+type NgbDatagridPagerType = NgbPagerType;
+type NgbDatagridPagerPosition = 'top' | 'bottom' | 'both';
+type NgbDatagridPagerDensity = NgbPagerDensity;
+/** @deprecated Use {@link NGB_PAGER_BREAKPOINTS}. */
+declare const NGB_DATAGRID_PAGER_BREAKPOINTS: {
+    readonly fullMinWidth: 520;
+    readonly compactMinWidth: 360;
+};
+/** Pager configuration for {@link Datagrid} via `[pageable]`. */
+interface NgbDatagridPageableSettings extends NgbPagerSettings {
+    /** Pager placement relative to the table. Default `bottom`. */
+    position?: NgbDatagridPagerPosition;
+}
+declare const NGB_DATAGRID_DEFAULT_PAGEABLE: Required<Omit<NgbDatagridPageableSettings, 'pageSizes'>> & {
+    pageSizes: false | number[];
+};
+
+declare function ngbResolvePageableSettings(pageable: boolean | NgbDatagridPageableSettings | null | undefined, legacy?: {
+    enablePagination?: boolean;
+    pageSizeOptions?: number[];
+}): NgbDatagridPageableSettings | null;
+/** Settings for {@link NgbPagerComponent} (excludes grid-only `position`). */
+declare function ngbDatagridPagerSettings(pageable: NgbDatagridPageableSettings): NgbPagerSettings;
+declare function ngbResolveDatagridPagerSettings(pageable: boolean | NgbDatagridPageableSettings | null | undefined, legacy?: {
+    enablePagination?: boolean;
+    pageSizeOptions?: number[];
+}): NgbPagerSettings | null;
+
 interface CellCtx<T = any> {
     $implicit: any;
     row: T;
@@ -46,10 +251,30 @@ interface FilterCtx<T = any> {
     $implicit: AbstractControl | null;
     control: AbstractControl | null;
     col: ColumnDef<T>;
+    /** Column field name (same as `col.field`). */
+    field: string;
+    descriptor: NgbFilterDescriptor | null;
+    /** Current composite filter root (clone). Use with `filterChange` for custom filter templates. */
+    filter: NgbCompositeFilterDescriptor;
+    operators: NgbFilterOperator[];
+    setOperator: (operator: NgbFilterOperator) => void;
+    setValue: (value: any) => void;
+    clear: () => void;
+    /** Replaces the grid filter state and emits `filterChange` when enabled. */
+    filterChange: (filter: NgbCompositeFilterDescriptor) => void;
+    /** Sets this column's field filter in the current descriptor and commits. */
+    setFieldFilter: (operator: NgbFilterOperator, value?: any) => void;
 }
 interface GlobalFilterCtx {
     $implicit: AbstractControl;
 }
+interface PagerCtx<T = any> {
+    grid: T;
+    page: number;
+    pageSize: number;
+    total: number;
+    pageCount: number;
+}
 declare class NgbCellTemplate<T = any> {
     readonly template: TemplateRef<CellCtx<T>>;
     field: string;
@@ -71,6 +296,13 @@ declare class NgbFilterTemplate<T = any> {
     static ɵfac: i0.ɵɵFactoryDeclaration<NgbFilterTemplate<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgbFilterTemplate<any>, "ng-template[ngbFilter]", never, { "field": { "alias": "ngbFilter"; "required": false; }; }, {}, never, never, true, never>;
 }
+declare class NgbFilterMenuTemplate<T = any> {
+    readonly template: TemplateRef<FilterCtx<T>>;
+    field: string;
+    constructor(template: TemplateRef<FilterCtx<T>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbFilterMenuTemplate<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbFilterMenuTemplate<any>, "ng-template[ngbFilterMenu]", never, { "field": { "alias": "ngbFilterMenu"; "required": false; }; }, {}, never, never, true, never>;
+}
 declare class NgbGlobalFilterTemplate {
     readonly template: TemplateRef<GlobalFilterCtx>;
     constructor(template: TemplateRef<GlobalFilterCtx>);
@@ -89,12 +321,69 @@ declare class NgbRowDetailTemplate<T = any> {
     static ɵfac: i0.ɵɵFactoryDeclaration<NgbRowDetailTemplate<any>, never>;
     static ɵdir: i0.ɵɵDirectiveDeclaration<NgbRowDetailTemplate<any>, "ng-template[ngbRowDetail]", never, {}, {}, never, never, true, never>;
 }
+declare class NgbPagerTemplate<T = any> {
+    readonly template: TemplateRef<PagerCtx<T>>;
+    constructor(template: TemplateRef<PagerCtx<T>>);
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbPagerTemplate<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbPagerTemplate<any>, "ng-template[ngbPager]", never, {}, {}, never, never, true, never>;
+}
 /** Handy constant to import in consumer apps */
-declare const DATAGRID_TEMPLATE_DIRECTIVES: (typeof NgbCellTemplate | typeof NgbGlobalFilterTemplate)[];
+declare const DATAGRID_TEMPLATE_DIRECTIVES: (typeof NgbCellTemplate | typeof NgbFilterTemplate | typeof NgbGlobalFilterTemplate | typeof NgbPagerTemplate)[];
 
+type NgbDataGridSortDirection = 'asc' | 'desc';
+interface NgbDataGridSortDescriptor {
+    field: string;
+    direction: NgbDataGridSortDirection;
+}
+interface NgbDataGridState {
+    /** 1-based page number used by the DataGrid pager. */
+    page?: number;
+    /** 0-based page index for API integrations that use page indexes. */
+    pageIndex?: number;
+    /** Number of records skipped before the current page. */
+    skip?: number;
+    pageSize?: number;
+    sort?: NgbDataGridSortDescriptor[];
+    filter?: NgbCompositeFilterDescriptor;
+    globalFilter?: string;
+}
+type NgbDataGridAggregateFunction = 'count' | 'sum' | 'average' | 'min' | 'max';
+interface NgbDataGridAggregateDescriptor {
+    field: string;
+    aggregate: NgbDataGridAggregateFunction;
+}
+type NgbDataGridAggregateResults = Record<string, Partial<Record<NgbDataGridAggregateFunction, number | string | Date | null>>>;
+interface NgbDataGridProcessOptions<T = unknown> {
+    state?: NgbDataGridState | null;
+    aggregates?: NgbDataGridAggregateDescriptor[];
+    globalFilterFields?: string[];
+    columns?: Array<{
+        field: Extract<keyof T, string> | string;
+        type?: string;
+        filterType?: string;
+    }>;
+    /**
+     * When false, returns the filtered/sorted full result without page slicing.
+     * Aggregates are always calculated before page slicing.
+     */
+    page?: boolean;
+}
+interface NgbDataGridDataResult<T = unknown> {
+    data: T[];
+    total: number;
+    aggregates?: NgbDataGridAggregateResults;
+}
 type NgbDataGridExportType = 'pdf' | 'excel' | 'both';
 type NgbDataGridExportPages = 'all' | 'current' | 'selection';
-type NgbDataGridTheme = 'material' | 'tailwind' | 'bootstrap';
+type NgbDataGridTheme = 'bootstrap' | 'bootstrap-main' | 'bootstrap-main-dark' | 'bootstrap-nordic' | 'bootstrap-urban' | 'bootstrap-vintage' | 'material' | 'material-main' | 'material-indigo' | 'material-deep-purple' | 'tailwind' | 'tailwind-main' | 'tailwind-slate' | 'tailwind-emerald';
+interface NgbDataGridThemeOption {
+    value: NgbDataGridTheme;
+    label: string;
+    group: 'Bootstrap' | 'Material' | 'Tailwind';
+    swatches: [string, string, string];
+    dark?: boolean;
+}
+declare const NGB_DATAGRID_THEME_OPTIONS: NgbDataGridThemeOption[];
 interface NgbDataGridExportOptions {
     enabled: boolean;
     type: NgbDataGridExportType;
@@ -117,6 +406,40 @@ interface NgbDataGridResponsiveOptions {
         desktop?: number;
     };
 }
+/** Built-in row editing interaction mode. */
+type NgbEditMode = 'inline' | 'incell' | 'external' | 'toolbar';
+/** Labels and visibility for the built-in multi-checkbox filter menu footer. */
+/** Segment returned by {@link Datagrid.getSearchHighlightSegments} for match highlighting. */
+interface NgbSearchHighlightSegment {
+    text: string;
+    match: boolean;
+}
+/** Placement when calling {@link Datagrid.reorderColumn}. */
+interface NgbColumnReorderOptions {
+    /** When true (default), inserts before the column at the destination index. When false, inserts after it. */
+    before?: boolean;
+}
+interface NgbColumnReorderEvent<T = any> {
+    /** Visible columns in their new order. */
+    columns: Array<{
+        field: string;
+        header: string;
+    } & Record<string, unknown>>;
+    /** Column that was moved. */
+    column: T;
+    fromIndex: number;
+    toIndex: number;
+    /** Ordered field names after the move. */
+    fields: string[];
+}
+interface NgbMultiCheckboxFilterOptions {
+    /** Primary action label. Default: `OK` */
+    applyLabel?: string;
+    /** Secondary action label. Default: `Cancel` */
+    cancelLabel?: string;
+    /** Whether the secondary action is shown. Default: `true` */
+    showCancel?: boolean;
+}
 
 type NgbDatagridTrackByFn<T> = (index: number, row: T) => any;
 interface NgbDatagridEditService<T> {
@@ -185,8 +508,142 @@ interface HighlightItem {
     columnKey?: any;
 }
 
+interface NgbDndDropEvent<T> {
+    item: T;
+    fromIndex: number;
+    toIndex: number;
+    fromList: T[];
+    toList: T[];
+    sameList: boolean;
+}
+interface DndCanDropPayload<T = any> {
+    dragItem: T;
+    srcList: T[];
+    srcIndex: number;
+    dstList: T[];
+    dstIndex: number;
+    isExternal: boolean;
+}
+/** Guard function; return true to allow, false to block */
+type DndCanDropFn<T = any> = (payload: DndCanDropPayload<T>) => boolean;
+declare class NgbDndListDirective<T = unknown> {
+    private el;
+    private state;
+    dndChildrenKey: string | null;
+    /** Bind your array here: <div [ngbDndList]="items"> */
+    list: T[];
+    /** Optional: group barrier across lists */
+    dndGroup?: string;
+    /** Disable this list */
+    dndDisabled: boolean;
+    /** NEW: clone if source wasn't a list (e.g. palette) */
+    dndCloneOnDrop: boolean;
+    /** NEW: custom clone function */
+    dndCloneFn?: (item: T) => T;
+    dndIsPalette: boolean;
+    dndCanDrop: boolean | DndCanDropFn<any>;
+    private _denied;
+    get denied(): boolean;
+    dndAriaLabel?: string;
+    get ariaLabel(): string | null;
+    /** Fires after item is inserted */
+    dndDropped: EventEmitter<NgbDndDropEvent<T>>;
+    role: string;
+    hostClass: boolean;
+    private hover;
+    get isOver(): boolean;
+    private canDrop;
+    get dataDropValid(): "true" | "false" | null;
+    private placeholder?;
+    private lastIndex;
+    onDragEnter(ev: DragEvent): void;
+    onDragOver(ev: DragEvent): void;
+    onDragLeave(ev: DragEvent): void;
+    onDocumentDrop(ev: DragEvent): void;
+    onDrop(ev: DragEvent): void;
+    onDocumentDragFinished(): void;
+    private getSession;
+    private ensurePlaceholder;
+    private removePlaceholder;
+    private resetVisualState;
+    private positionPlaceholderAt;
+    private indexFromPointer;
+    private draggableChildren;
+    private cloneItem;
+    private isDroppingIntoOwnDescendant;
+    /**
+     * Build a guard payload using whatever drag context you already store.
+     * If some fields don’t exist in your code, the fallbacks keep it working.
+     */
+    private _buildGuardPayload;
+    /**
+     * Compute destination index from the event position (no placeholder var needed).
+     * Uses vertical list heuristics; adjust for horizontal if your list is horizontal.
+     */
+    private _computeDropIndex;
+    private _allowDrop;
+    private performDrop;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDndListDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDndListDirective<any>, "[ngbDndList]", never, { "dndChildrenKey": { "alias": "dndChildrenKey"; "required": false; }; "list": { "alias": "ngbDndList"; "required": false; }; "dndGroup": { "alias": "dndGroup"; "required": false; }; "dndDisabled": { "alias": "dndDisabled"; "required": false; }; "dndCloneOnDrop": { "alias": "dndCloneOnDrop"; "required": false; }; "dndCloneFn": { "alias": "dndCloneFn"; "required": false; }; "dndIsPalette": { "alias": "dndIsPalette"; "required": false; }; "dndCanDrop": { "alias": "dndCanDrop"; "required": false; }; "dndAriaLabel": { "alias": "dndAriaLabel"; "required": false; }; }, { "dndDropped": "dndDropped"; }, never, never, true, never>;
+}
+
+/** Localizable strings for built-in datagrid UI (pagination, filters, actions, a11y). */
+interface NgbDatagridLabels {
+    paginationRange?: string;
+    rowsPerPage?: string;
+    emptyState?: string;
+    booleanYes?: string;
+    booleanNo?: string;
+    selectAll?: string;
+    unselectAll?: string;
+    selectRow?: string;
+    unselectRow?: string;
+    globalFilter?: string;
+    expandRow?: string;
+    collapseRow?: string;
+    exportPdf?: string;
+    exportExcel?: string;
+    stickyRowToggle?: string;
+    editRow?: string;
+    deleteRow?: string;
+    reorderColumn?: string;
+    resizeColumn?: string;
+    openFilterMenu?: string;
+    clearFilter?: string;
+    filterOperator?: string;
+    columnFilter?: string;
+    sortBy?: string;
+    stickyBadge?: string;
+    addRow?: string;
+    addRowButton?: string;
+    save?: string;
+    cancel?: string;
+    edit?: string;
+    delete?: string;
+    multiCheckboxApply?: string;
+    multiCheckboxCancel?: string;
+    combineConditions?: string;
+    searchFilterValues?: string;
+}
+declare const NGB_DATAGRID_DEFAULT_LABELS: Required<NgbDatagridLabels>;
+/** Documented keyboard shortcuts when [keyboardNavigation] is enabled. */
+declare const NGB_DATAGRID_KEYBOARD_SHORTCUTS: {
+    readonly moveCell: "Arrow keys — move focus between data cells";
+    readonly firstLastColumn: "Home / End — first or last column in the row";
+    readonly firstLastRow: "Ctrl+Home / Ctrl+End — first or last row on the page";
+    readonly sortColumn: "Enter on focused sortable header — cycle sort";
+    readonly toggleSelection: "Space on a focused row — toggle row selection (when enabled)";
+    readonly pagePrevNext: "Alt+Page Up / Alt+Page Down — previous or next page (when paginated)";
+    readonly openFilter: "F3 on a focused column — open row filter operator menu (row filter mode)";
+    readonly cancelOverlay: "Escape — close filter menus and cancel in-cell edit";
+    readonly commitIncell: "Enter — commit in-cell edit; Arrow keys move between editable cells while editing";
+};
+type NgbDatagridTextDirection = 'ltr' | 'rtl' | 'auto';
+declare function ngbFormatDatagridLabel(template: string, tokens: Record<string, string | number>): string;
+
 type SortDir = 'asc' | 'desc' | '';
 type KeyOf<T> = Extract<keyof T, string>;
+type UtilityColumnKind = 'selection' | 'detail' | 'sticky-toggle' | 'actions';
 type NgbTableResponsive = true | false | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
 interface NgbTableOptions {
     stripedRows?: boolean;
@@ -204,7 +661,15 @@ interface NgbTableOptions {
     stickyHeader?: boolean;
     stickyFooter?: boolean;
     stickyRows?: boolean;
+    density?: 'comfortable' | 'compact';
+    stacked?: boolean;
+    /** `list` = single-column cards; `cards` = multi-column card rows (use `stackedGroup` on columns). */
+    stackedLayout?: 'list' | 'cards';
+    /** Alternating row backgrounds in the table body (Figma patient grid). */
+    zebraStripes?: boolean;
 }
+/** Tabular columns vs adaptive stacked cards (`stacked` in {@link NgbTableOptions}). */
+type NgbDataLayoutMode = 'tabular' | 'stacked';
 type NgbSelectionMode = 'none' | 'single' | 'multiple';
 type NgbSelectionBehavior = 'row' | 'checkbox' | 'both';
 type NgbSelectionKeyMode = 'desktop' | 'mobile';
@@ -218,17 +683,77 @@ interface NgbSelectionLabels {
 }
 declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     /** Column definitions to render */
-    columns: ColumnDef<T>[];
+    private _columns;
+    get columns(): ColumnDef<T>[];
+    set columns(value: ColumnDef<T>[] | null | undefined);
     /** Row data to display */
-    data: T[];
-    enableSorting: boolean;
-    enableFiltering: boolean;
-    enableGlobalFilter: boolean;
-    enablePagination: boolean;
+    private _data;
+    get data(): T[];
+    set data(value: T[] | null | undefined);
+    /**
+     * When `true`, shows a loading overlay and sets `aria-busy` on the grid root.
+     * Use while fetching remote data before assigning `[data]`.
+     */
+    loading: boolean;
+    /**
+     * Total record count for paging and range labels when using server-side data binding.
+     * When set and greater than `data.length`, the grid treats `[data]` as the current page only
+     * (no client-side page slicing). Omit for local in-memory arrays.
+     */
+    private _total;
+    get total(): number | null;
+    set total(value: number | null | undefined);
+    private _enableSorting;
+    get enableSorting(): boolean;
+    set enableSorting(value: boolean);
+    private _enableFiltering;
+    get enableFiltering(): boolean;
+    set enableFiltering(value: boolean);
+    private _filterable;
+    get filterable(): NgbFilterable;
+    set filterable(value: NgbFilterable | null | undefined);
+    private _enableGlobalFilter;
+    get enableGlobalFilter(): boolean;
+    set enableGlobalFilter(value: boolean);
+    private _filterMode;
+    get filterMode(): NgbFilterMode;
+    set filterMode(value: NgbFilterMode | null | undefined);
+    private _filter;
+    get filter(): NgbCompositeFilterDescriptor | null;
+    set filter(value: NgbCompositeFilterDescriptor | null | undefined);
+    filterOperators?: Partial<Record<ColumnType, NgbFilterOperator[]>>;
+    filterManual: boolean;
+    externalFiltering: boolean;
+    /** Opts local arrays into the reusable DataGrid operation helper for filter/sort/page processing. */
+    private _dataOperations;
+    get dataOperations(): boolean | NgbDataGridProcessOptions<T>;
+    set dataOperations(value: boolean | NgbDataGridProcessOptions<T> | null | undefined);
+    /**
+     * Optional controlled data-operation state. When provided, the grid syncs page, pageSize,
+     * sort, filter, and global filter from this object.
+     */
+    private _state;
+    get state(): NgbDataGridState | null;
+    set state(value: NgbDataGridState | null | undefined);
+    /** Footer actions for the built-in multi-checkbox filter menu. */
+    multiCheckboxFilterOptions: NgbMultiCheckboxFilterOptions;
+    private _enablePagination;
+    get enablePagination(): boolean;
+    set enablePagination(value: boolean);
+    /**
+     * Pager configuration. `true` enables the pager with defaults; pass an object to customize.
+     * When set, pagination is active even if `[enablePagination]` is false.
+     */
+    private _pageable;
+    get pageable(): boolean | NgbDatagridPageableSettings;
+    set pageable(value: boolean | NgbDatagridPageableSettings | null | undefined);
     enableEdit: boolean;
     enableDelete: boolean;
+    /** @deprecated Prefer `pageable.pageSizes`. Kept for `[enablePagination]` compatibility. */
     pageSizeOptions: number[];
-    enableAdd: boolean;
+    private _enableAdd;
+    get enableAdd(): boolean;
+    set enableAdd(value: boolean);
     /** Accessible label (aria-label) applied to the add-row button. */
     addButtonAriaLabel: string | null;
     /** Visible text rendered inside the add-row button. */
@@ -248,7 +773,14 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     /** Footer height (px) used to offset scrollable area. */
     stickyFooterHeight: number;
     /** Bootstrap-like table styling options. */
-    tableOptions: NgbTableOptions;
+    private _tableOptions;
+    get tableOptions(): NgbTableOptions;
+    set tableOptions(value: NgbTableOptions | null | undefined);
+    /**
+     * When set, overrides `tableOptions.stacked` for layout mode.
+     * Use `'stacked'` for card/label-value rows or `'tabular'` for the standard column grid.
+     */
+    dataLayoutMode: NgbDataLayoutMode | null;
     /** Selection mode for rows. */
     selectionMode: NgbSelectionMode;
     /** Selection activation: row click, checkbox only, or both. */
@@ -262,13 +794,21 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     /** Disable selection for specific rows. */
     selectionDisabledFn?: (row: T, index: number) => boolean;
     /** Highlight items (row/cell). */
-    highlightedIndex: HighlightItem[];
+    private _highlightedIndex;
+    get highlightedIndex(): HighlightItem[];
+    set highlightedIndex(value: HighlightItem[] | null | undefined);
     /** Row key for highlighting. */
     highlightRowKey: NgbRowKey | null;
     /** Column key for highlighting. */
     highlightColKey: NgbColKey | null;
     /** Accessible label for the global filter input. */
     globalFilterAriaLabel: string;
+    /** Placeholder for the built-in global search input. */
+    globalFilterPlaceholder: string;
+    /** When set, matching substrings in visible cells are wrapped with `.grid-search-highlight`. */
+    searchHighlightTerm: string;
+    /** Column fields included in search highlighting; all visible columns when empty. */
+    searchHighlightFields: string[] | null;
     /** Accessible label announced when expanding a row. */
     expandRowAriaLabel: string;
     /** Accessible label announced when collapsing a row. */
@@ -281,18 +821,54 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     newRowDefaults: Partial<Record<KeyOf<T>, any>> | (() => Partial<Record<KeyOf<T>, any>>) | null;
     strictEmail: boolean;
     editOnRowClick: boolean;
+    /** Row editing interaction: inline actions, in-cell, external dialog, or toolbar selection. */
+    editMode: NgbEditMode;
+    /** Hint shown in toolbar editing mode when a row is selected. */
+    toolbarEditHint: string;
     singleExpand: boolean;
-    exportOptions: NgbDataGridExportOptions;
+    private _exportOptions;
+    get exportOptions(): NgbDataGridExportOptions;
+    set exportOptions(value: NgbDataGridExportOptions | null | undefined);
     theme: NgbDataGridTheme;
     responsive: NgbDataGridResponsiveOptions | boolean;
     trackBy?: NgbDatagridTrackByFn<T>;
+    rowClass?: string | string[] | Record<string, boolean> | ((row: T, rowIndex: number) => string | string[] | Record<string, boolean>);
+    rowStyle?: Record<string, string | number> | ((row: T, rowIndex: number) => Record<string, string | number> | null | undefined);
+    rowReorderable: boolean;
+    private _columnReorderable;
+    get columnReorderable(): boolean;
+    set columnReorderable(value: boolean);
+    /** Enables drag-to-resize on column headers (requires explicit column widths). */
+    private _resizable;
+    get resizable(): boolean;
+    set resizable(value: boolean);
+    /** Render row actions as icon-only square buttons (Figma editing screen). */
+    actionDisplay: 'text' | 'icons';
+    /** Show a STICKY badge on the configured column when a row is pinned. */
+    showStickyRowBadge: boolean;
+    stickyRowBadgeField: string | null;
+    stickyRowBadgeLabel: string;
+    /** Localized strings for built-in UI; individual aria/text inputs override matching keys. */
+    labels: NgbDatagridLabels;
+    /** BCP 47 locale for pagination range and number formatting (e.g. `en-US`, `ar-SA`). */
+    locale: string | null;
+    /** Text direction on the grid root; `auto` inherits from document or parent `dir`. */
+    dir: NgbDatagridTextDirection;
+    /** Enables arrow-key cell focus, Space selection, Alt+Page paging, and F3 filter shortcuts. */
+    keyboardNavigation: boolean;
     editService?: NgbDatagridEditService<T>;
     dataProviderAll?: () => Observable<any[]> | Promise<any[]> | any[];
     dataProviderSelection?: () => any[];
     exportButtonDir?: ExportButtonDirective;
     bodyScroller?: ElementRef<HTMLElement>;
     headerScroller?: ElementRef<HTMLElement>;
+    private hostEl;
     colgroupSyncId: string;
+    private columnWidthOverrides;
+    private resizeSession;
+    private columnOrder;
+    columnDragField: string | null;
+    columnDragOverIndex: number | null;
     exporting: boolean;
     rowAdd: EventEmitter<{
         newRow: T;
@@ -318,6 +894,7 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
         active: string | null;
         direction: "asc" | "desc" | "";
     }>;
+    filterChange: EventEmitter<NgbCompositeFilterDescriptor>;
     filtersChange: EventEmitter<{
         global: string;
         columns: Record<string, string>;
@@ -326,6 +903,7 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
         page: number;
         pageSize: number;
     }>;
+    dataStateChange: EventEmitter<NgbDataGridState>;
     selectionChange: EventEmitter<{
         selected: T[];
         lastAction: {
@@ -334,7 +912,15 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
             selected: boolean;
         } | null;
     }>;
+    rowReorder: EventEmitter<{
+        row: T;
+        fromIndex: number;
+        toIndex: number;
+        data: T[];
+    }>;
+    columnReorder: EventEmitter<NgbColumnReorderEvent<ColumnDef<T>>>;
     rowDetailTpl?: NgbRowDetailTemplate<T>;
+    pagerTpl?: NgbPagerTemplate<T>;
     private exporter;
     expanded: Set<number>;
     private fb;
@@ -343,27 +929,85 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     addingNew: boolean;
     draftNew: Partial<Record<KeyOf<T>, any>> | null;
     errorsNew: Partial<Record<KeyOf<T>, string>>;
-    sort: {
+    private _sort;
+    get sort(): {
         active: Extract<keyof T, string> | null;
         direction: SortDir;
     };
+    set sort(value: {
+        active: Extract<keyof T, string> | null;
+        direction: SortDir;
+    } | null | undefined);
     stickyRowIds: Set<any>;
     selectedRowIds: Set<any>;
     private selectionAnchor;
     private highlightRowMap;
-    globalFilter: string;
-    filters: Record<string, string>;
-    page: number;
-    pageSize: number;
-    /** Inline editing state */
+    private _globalFilter;
+    get globalFilter(): string;
+    set globalFilter(value: string | null | undefined);
+    private _filters;
+    get filters(): Record<string, string>;
+    set filters(value: Record<string, string> | null | undefined);
+    private _localFilter;
+    get localFilter(): NgbCompositeFilterDescriptor;
+    set localFilter(value: NgbCompositeFilterDescriptor | null | undefined);
+    openFilterMenuField: string | null;
+    openFilterMenuAnchor: HTMLElement | null;
+    openRowFilterField: string | null;
+    openRowFilterOperatorAnchor: HTMLElement | null;
+    openMenuOperatorField: string | null;
+    menuDrafts: Record<string, NgbMenuFilterConditionDraft[]>;
+    /** Join logic between conditions in a column filter menu (And / Or). */
+    menuDraftJoinLogic: Record<string, 'and' | 'or'>;
+    multiCheckboxDrafts: Record<string, any[]>;
+    multiCheckboxSearch: Record<string, string>;
+    private syncingFilterForm;
+    private _page;
+    get page(): number;
+    set page(value: number | null | undefined);
+    private _pageSize;
+    get pageSize(): number;
+    set pageSize(value: number | null | undefined);
+    /** Inline / in-cell editing state */
     editingIndex: number | null;
+    editingCell: {
+        rowIndex: number;
+        field: string;
+    } | null;
+    /** Roving keyboard focus within the current page (data cells). */
+    focusedCell: {
+        rowIndex: number;
+        colIndex: number;
+    } | null;
+    /** Screen-reader status updates (sort, page, selection). */
+    statusMessage: string;
     editForm: FormGroup;
     saveAttemptedEdit: boolean;
+    /** External dialog editing state */
+    externalEditOpen: boolean;
+    externalEditIsNew: boolean;
+    externalEditPagedIndex: number | null;
+    externalForm: FormGroup;
+    saveAttemptedExternal: boolean;
+    private externalDialogOpener;
+    private externalDialogFocusedOnce;
     addForm: FormGroup;
     saveAttemptedNew: boolean;
     private addDraftRowId;
     private readonly defaultEditService;
     private cdr;
+    private resolvedColumnsCache;
+    private visibleColumnsCache;
+    private filteredCache;
+    private sortedCache;
+    private pagedCache;
+    private resolvedColumnsDirty;
+    private visibleColumnsDirty;
+    private filteredDirty;
+    private sortedDirty;
+    private pagedDirty;
+    private rowIndexMap;
+    private rowIndexMapSource;
     private norm;
     private keyOf;
     private getDefaults;
@@ -373,24 +1017,275 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     private buildFormFromRow;
     private strictEmailValidator;
     get exportButtonTpl(): TemplateRef<ExportButtonContext> | null;
+    get gridHost(): this;
+    get declarativeColumns(): ColumnDef<T>[];
+    get resolvedColumns(): ColumnDef<T>[];
+    get visibleColumns(): ColumnDef<T>[];
+    private invalidateColumnCaches;
+    private invalidateFilteredCaches;
+    private invalidateSortedCaches;
+    private invalidatePagedCache;
+    private invalidateDataCaches;
+    private markGridForCheck;
+    private ensureRowIndexMap;
+    private dataIndexOf;
+    private syncColumnOrder;
+    isColumnReorderEnabled(): boolean;
+    isColumnReorderable(col: ColumnDef<T>): boolean;
+    onColumnDragStart(event: DragEvent, col: ColumnDef<T>, fromIndex: number): void;
+    onColumnDragOver(event: DragEvent, toIndex: number): void;
+    onColumnDragLeave(event: DragEvent, index: number): void;
+    onColumnDrop(event: DragEvent, toIndex: number): void;
+    onColumnDragEnd(): void;
+    /**
+     * Reorders a visible column relative to another visible column index.
+     * Only columns that pass {@link isColumnReorderable} can be moved.
+     */
+    reorderColumn(column: ColumnDef<T> | Extract<keyof T, string>, destinationIndex: number, options?: NgbColumnReorderOptions, emit?: boolean): void;
+    moveColumn(fromIndex: number, toIndex: number, emit?: boolean): void;
+    private validateColumnConfig;
+    isFilteringEnabled(): boolean;
+    resolvedFilterMode(): NgbFilterMode;
     get filtered(): T[];
+    private effectiveFilterDescriptor;
+    private legacyFilterDescriptor;
+    private currentGlobalFilter;
+    private matchesComposite;
+    private matchesDescriptor;
+    private normalizeFilterValue;
+    getColumnFilterType(col?: ColumnDef<T>): 'text' | 'numeric' | 'boolean' | 'date' | 'select';
+    isMultiCheckboxMode(col: ColumnDef<T>): boolean;
+    getAllowedOperators(col: ColumnDef<T>): NgbFilterOperator[];
+    defaultFilterOperator(col: ColumnDef<T>): NgbFilterOperator;
+    rowFilterOperator(col: ColumnDef<T>): NgbFilterOperator;
+    operatorLabel(operator: NgbFilterOperator): string;
+    rowFilterOperatorLabel(col: ColumnDef<T>, operator: NgbFilterOperator): string;
+    rowFilterMenuTitle(col: ColumnDef<T>): string;
+    rowFilterPlaceholder(col: ColumnDef<T>): string;
+    isSearchHighlightEnabled(): boolean;
+    shouldHighlightSearchInColumn(field: string): boolean;
+    formatCellDisplayValue(value: unknown): string;
+    getSearchHighlightSegments(value: unknown, field: string): Array<{
+        text: string;
+        match: boolean;
+    }>;
+    rowFilterEmptyOptionLabel(col: ColumnDef<T>): string;
+    booleanFilterOptionLabel(value: boolean): string;
+    isRowFilterMenuOpen(field: string): boolean;
+    get openRowFilterColumn(): ColumnDef<T> | null;
+    toggleRowFilterMenu(field: string, anchor?: HTMLElement | null): void;
+    setRowFilterOperator(col: ColumnDef<T>, operator: NgbFilterOperator): void;
+    operatorRequiresValue(operator: NgbFilterOperator): boolean;
+    isRowFilterVisible(col: ColumnDef<T>): boolean;
+    isRowFilterOperatorVisible(col: ColumnDef<T>): boolean;
+    isMenuFilterVisible(col: ColumnDef<T>): boolean;
+    getColumnFilter(field: string): NgbFilterDescriptor | null;
+    hasActiveColumnFilter(field: string): boolean;
+    private findFieldFilter;
+    private withoutFieldFilters;
+    private upsertColumnFilter;
+    clearColumnFilter(field: string, emit?: boolean): void;
+    clearAllFilters(emit?: boolean): void;
+    private commitFilter;
+    private cloneComposite;
+    private syncLegacyFilters;
+    currentGlobalFilterValue(): string;
+    operatorControlName(field: string): string;
+    valueControlName(field: string): string;
+    getFilterControl(field: string): AbstractControl | null;
+    applyRowFilter(col: ColumnDef<T>): void;
+    private setFilterFormField;
+    private syncFilterFormFromState;
+    private static readonly MENU_FILTER_CONDITION_COUNT;
+    private defaultMenuOperator;
+    private defaultMenuCondition;
+    private defaultMenuDraftPair;
+    private normalizeMenuDraftConditions;
+    private menuConditionsFromFieldFilter;
+    ensureMenuJoinLogic(col: ColumnDef<T>): 'and' | 'or';
+    setMenuJoinLogic(col: ColumnDef<T>, logic: 'and' | 'or'): void;
+    menuFilterConditionIsValid(col: ColumnDef<T>, draft: NgbMenuFilterConditionDraft): boolean;
+    canApplyMenuFilter(col: ColumnDef<T>): boolean;
+    canClearMenuFilter(col: ColumnDef<T>): boolean;
+    ensureMenuDraftConditions(col: ColumnDef<T>): NgbMenuFilterConditionDraft[];
+    /** First menu condition (header filter menus). */
+    ensureMenuDraft(col: ColumnDef<T>): NgbMenuFilterConditionDraft;
+    setMenuDraftOperator(col: ColumnDef<T>, operator: NgbFilterOperator, index?: number): void;
+    menuOperatorKey(field: string, index?: number): string;
+    isMenuOperatorOpen(field: string, index?: number): boolean;
+    toggleMenuOperator(field: string, index?: number): void;
+    get openFilterMenuColumn(): ColumnDef<T> | null;
+    private closeFilterMenu;
+    private resolveFilterMenuAnchor;
+    toggleFilterMenu(field: string, anchor?: HTMLElement | null): void;
+    applyMenuFilter(col: ColumnDef<T>): void;
+    clearMenuFilter(col: ColumnDef<T>): void;
+    multiCheckboxOptions(col: ColumnDef<T>): Array<{
+        label: string;
+        value: any;
+    }>;
+    multiCheckboxVisibleOptions(col: ColumnDef<T>): Array<{
+        label: string;
+        value: any;
+    }>;
+    multiCheckboxValueLabel(col: ColumnDef<T>, value: any): string;
+    private multiCheckboxValueKey;
+    ensureMultiCheckboxDraft(col: ColumnDef<T>): any[];
+    multiCheckboxSelectedCount(col: ColumnDef<T>): number;
+    multiCheckboxTotalCount(col: ColumnDef<T>): number;
+    isMultiCheckboxChecked(col: ColumnDef<T>, value: any): boolean;
+    toggleMultiCheckboxValue(col: ColumnDef<T>, value: any): void;
+    isMultiCheckboxAllSelected(col: ColumnDef<T>): boolean;
+    toggleMultiCheckboxAll(col: ColumnDef<T>): void;
+    multiCheckboxToggleLabel(col: ColumnDef<T>): string;
+    isMultiCheckboxPartiallySelected(col: ColumnDef<T>): boolean;
+    private multiCheckboxSelectedValues;
+    multiCheckboxFilterApplyLabel(): string;
+    multiCheckboxFilterCancelLabel(): string;
+    multiCheckboxFilterShowCancel(): boolean;
+    cancelMultiCheckboxFilter(col: ColumnDef<T>): void;
+    applyMultiCheckboxFilter(col: ColumnDef<T>): void;
+    filterContext(col: ColumnDef<T>, source: 'row' | 'menu'): FilterCtx<T>;
     get sorted(): T[];
+    /** True when `[data]` is a server page and `[total]` is the full result count. */
+    isServerBound(): boolean;
+    /** Row count for pager, range labels, and `aria-rowcount`. */
+    recordTotal(): number;
+    /** Collection size passed to the built-in pager. */
+    pagerCollectionSize(): number;
     get paged(): T[];
+    private shouldUseLocalDataOperations;
+    private localDataOperationsResult;
     get anyFilterable(): boolean;
     get startIndex(): number;
     get endIndex(): number;
+    get paginationActive(): boolean;
+    resolvedPageable(): NgbDatagridPageableSettings;
+    pagerShowsAt(placement: NgbDatagridPagerPosition): boolean;
+    showPagerInfo(): boolean;
+    showPagerPageSizes(): boolean;
+    pagerButtonCount(): number;
+    pagerPreviousNext(): boolean;
+    pagerType(): NgbDatagridPagerType;
+    hasCustomPagerTemplate(): boolean;
+    pagerResponsive(): boolean;
+    pagerContext(): PagerCtx<Datagrid<T>> & {
+        $implicit: PagerCtx<Datagrid<T>>;
+    };
+    dataState(): NgbDataGridState;
+    private emitDataStateChange;
+    private syncFromDataState;
+    /** Page-size options for the footer dropdown (includes [pageSize] when not listed in pageSizes). */
+    get resolvedPageSizeOptions(): number[];
     get shouldEnableScroll(): boolean;
+    onBodyHorizontalScroll(): void;
     get isHeaderSticky(): boolean;
     get isFooterSticky(): boolean;
     get detailColspan(): number;
+    isColumnPinned(col: ColumnDef<T>): boolean;
+    columnPinnedSide(col: ColumnDef<T>): 'start' | 'end' | null;
+    private columnOrderGroup;
+    resolvedDir(): 'ltr' | 'rtl' | null;
+    isRtl(): boolean;
+    hasPinnedColumns(): boolean;
+    shouldPinLeadingUtilityColumns(): boolean;
+    utilityColumnWidth(kind: UtilityColumnKind): number;
+    resolvedEditMode(): NgbEditMode;
+    isIncellEditMode(): boolean;
+    isExternalEditMode(): boolean;
+    isToolbarEditMode(): boolean;
+    showEditingToolbar(): boolean;
+    showRowEditAction(): boolean;
+    showRowDeleteAction(): boolean;
+    showActionsColumn(): boolean;
+    get externalEditableColumns(): ColumnDef<T>[];
+    isCellInEditMode(pagedIndex: number, col: ColumnDef<T>): boolean;
+    onCellClick(ev: MouseEvent, pagedIndex: number, col: ColumnDef<T>): void;
+    onCellKeydown(ev: KeyboardEvent, pagedIndex: number, col: ColumnDef<T>, colIndex: number): void;
+    startIncellEdit(pagedIndex: number, field: string): void;
+    private focusInlineEditor;
+    commitIncellEdit(close?: boolean): boolean;
+    cancelIncellEdit(): void;
+    getSingleSelectedPagedIndex(): number | null;
+    editSelectedRow(): void;
+    deleteSelectedRows(): void;
+    openExternalEdit(pagedIndex: number): void;
+    openExternalAdd(): void;
+    saveExternalEdit(): void;
+    cancelExternalEdit(): void;
+    private closeExternalEdit;
+    private focusExternalDialogFirstField;
+    utilityLeadingWidth(): number;
+    columnWidth(col: ColumnDef<T>): number;
+    isColumnResizable(col: ColumnDef<T>): boolean;
+    startColumnResize(event: MouseEvent, col: ColumnDef<T>): void;
+    onDocumentMouseMove(event: MouseEvent): void;
+    onDocumentMouseUp(): void;
+    private syncResizableColgroups;
+    autoFitColumnsToGrid(): void;
+    private clampColumnWidth;
+    private gridViewportWidth;
+    private nonDataColumnWidth;
+    private syncColumnWidthOverrides;
+    get tablePixelWidth(): number | null;
+    utilityStickyOffset(kind: Exclude<UtilityColumnKind, 'actions'>): number | null;
+    columnStartOffset(col: ColumnDef<T>): number | null;
+    columnEndOffset(col: ColumnDef<T>): number | null;
+    columnPinnedClass(col: ColumnDef<T>): string | null;
     get tableClassList(): string[];
     get responsiveWrapperClasses(): string[];
+    get densityMode(): 'comfortable' | 'compact';
+    isStackedLayout(): boolean;
+    isStackedCardsLayout(): boolean;
+    stackedGroupFor(col: ColumnDef<T>): 'start' | 'center' | 'end';
+    stackedColumnsInGroup(group: 'start' | 'center' | 'end'): ColumnDef<T>[];
+    stackedCardGroups(): Array<'start' | 'center' | 'end'>;
+    visibleColumnIndex(col: ColumnDef<T>): number;
+    stackedCardColspan(): number;
+    clearSorting(emit?: boolean): void;
+    setColumnHidden(field: string, hidden: boolean): void;
+    applyColumnVisibility(visibility: Record<string, boolean>): void;
+    get zebraStripesEnabled(): boolean;
+    getSelectedCount(): number;
+    hasSelectedRows(): boolean;
+    hasSingleSelectedRow(): boolean;
+    resolveHeaderClass(col: ColumnDef<T>): string | string[] | Record<string, boolean> | null;
+    resolveHeaderStyle(col: ColumnDef<T>): Record<string, string | number> | null;
+    resolveCellClass(row: T, rowIndex: number, col: ColumnDef<T>): string | string[] | Record<string, boolean> | null;
+    resolveCellStyle(row: T, rowIndex: number, col: ColumnDef<T>): Record<string, string | number> | null;
+    resolveRowClass(row: T, rowIndex: number): string | string[] | Record<string, boolean> | null;
+    resolveRowStyle(row: T, rowIndex: number): Record<string, string | number> | null;
     updateHighlightCache(): void;
     headerText(col: ColumnDef<T>): string;
     headerTitle(col: ColumnDef<T>): string;
     cellTitle(row: T, col: ColumnDef<T>): string;
     columnFilterAriaLabel(col: ColumnDef<T>): string;
     inputAriaLabel(col: ColumnDef<T>): string;
+    reorderColumnAriaLabel(col: ColumnDef<T>): string;
+    resizeColumnAriaLabel(col: ColumnDef<T>): string;
+    openFilterMenuAriaLabel(col: ColumnDef<T>): string;
+    clearFilterAriaLabel(col: ColumnDef<T>): string;
+    filterOperatorAriaLabel(col: ColumnDef<T>): string;
+    editRowAriaLabel(index: number): string;
+    deleteRowAriaLabel(index: number): string;
+    stickyRowToggleAriaLabel(): string;
+    booleanDisplayLabel(value: boolean): string;
+    emptyStateLabel(): string;
+    paginationRangeLabel(): string;
+    rowsPerPageLabel(): string;
+    ariaRowCount(): number;
+    ariaColCount(): number;
+    isCellFocused(rowIndex: number, colIndex: number): boolean;
+    cellTabIndex(rowIndex: number, colIndex: number): number | null;
+    focusCell(rowIndex: number, colIndex: number): void;
+    onDataCellFocus(rowIndex: number, colIndex: number): void;
+    onDataCellKeydown(ev: KeyboardEvent, rowIndex: number, colIndex: number, col: ColumnDef<T>): void;
+    private openRowFilterMenuForColumn;
+    private isRowFilterEnabledForColumn;
+    private focusFocusedCellElement;
+    announceStatus(message: string): void;
+    private labelTemplate;
+    private formatLocaleNumber;
     ariaSortFor(field: Extract<keyof T, string>): 'ascending' | 'descending' | 'none';
     sortButtonAriaLabel(col: ColumnDef<T>): string;
     exportAriaLabel(kind: 'pdf' | 'excel'): string;
@@ -400,19 +1295,31 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     private cellTplQ;
     private editTplQ;
     private filterTplQ;
+    private filterMenuTplQ;
     private globalTplQ;
+    private gridColumnQ;
     /** Internal lookup maps */
     cellTpls: Record<string, NgbCellTemplate<T>>;
     editTpls: Record<string, NgbEditorTemplate<T>>;
     filterTpls: Record<string, NgbFilterTemplate<T>>;
+    filterMenuTpls: Record<string, NgbFilterMenuTemplate<T>>;
     globalTpl: NgbGlobalFilterTemplate | null;
+    private warnedDeclarativeColumns;
     private toRecord;
     export(kind: 'pdf' | 'excel'): Promise<void>;
     private resolveDataset;
     ngAfterContentInit(): void;
     ngOnChanges(ch: SimpleChanges): void;
+    private resetEditingState;
     private getRowId;
+    /** Apply selection ids and refresh checkbox UI (for programmatic / OnPush sync). */
+    setSelectionIds(ids: Iterable<any>, options?: {
+        emit?: boolean;
+    }): void;
     private getEditService;
+    isCellEditable(col: ColumnDef<T>, row: T, isNew: boolean): boolean;
+    isRowReorderEnabled(): boolean;
+    hasActiveFilters(): boolean;
     startAdd(): void;
     saveAdd(): void;
     cancelAdd(): void;
@@ -430,13 +1337,25 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     toggleSort(field: Extract<keyof T, string>): void;
     onGlobalFilterChange(): void;
     onColumnFilterChange(): void;
+    onDocumentClick(event: MouseEvent): void;
+    canCancelToolbarEdit(): boolean;
+    isToolbarEditActive(): boolean;
+    isToolbarSaveDisabled(): boolean;
+    saveToolbarEdit(): void;
+    cancelToolbarEdit(): void;
+    private ariaUtilityColumns;
+    ariaColIndexForUtility(kind: Exclude<UtilityColumnKind, 'actions'>): number | null;
+    ariaColIndexForDataColumn(visibleColumnIndex: number): number;
+    ariaColIndexForActions(): number;
+    onEscapeKey(): void;
     onPageChange(p: number): void;
     onPageSizeChange(): void;
     toggleExpand(i: number): void;
     isExpanded(i: number): boolean;
     onRowClick(ev: MouseEvent, i: number): void;
     onPage(p: number): void;
-    onPageSize(sz: number): void;
+    onPageSize(sz: number | string): void;
+    onRowDrop(event: NgbDndDropEvent<T>): void;
     asBool(v: any): boolean;
     triggerExport(kind: 'pdf' | 'excel'): void;
     isResponsiveEnabled(): boolean;
@@ -444,10 +1363,12 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     toggleStickyRow(pagedIndex: number): void;
     stickyIcon(row: T, pagedIndex: number): string;
     stickyTop(row: T, pagedIndex: number): number | null;
+    private measuredStickyRowHeight;
     get stickyRowsEnabled(): boolean;
     get stickyHeaderEnabled(): boolean;
     get stickyFooterEnabled(): boolean;
     isSelectionEnabled(): boolean;
+    showSelectionColumn(): boolean;
     isCheckboxOnly(): boolean;
     isSelectionDisabled(row: T, pagedIndex: number): boolean;
     isRowSelected(row: T, pagedIndex: number): boolean;
@@ -460,7 +1381,61 @@ declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
     rowSelectionLabel(index: number): string;
     onRowSelect(ev: MouseEvent, pagedIndex: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<Datagrid<any>, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<Datagrid<any>, "ngb-datagrid", never, { "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "enableSorting": { "alias": "enableSorting"; "required": false; }; "enableFiltering": { "alias": "enableFiltering"; "required": false; }; "enableGlobalFilter": { "alias": "enableGlobalFilter"; "required": false; }; "enablePagination": { "alias": "enablePagination"; "required": false; }; "enableEdit": { "alias": "enableEdit"; "required": false; }; "enableDelete": { "alias": "enableDelete"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "enableAdd": { "alias": "enableAdd"; "required": false; }; "addButtonAriaLabel": { "alias": "addButtonAriaLabel"; "required": false; }; "addButtonText": { "alias": "addButtonText"; "required": false; }; "stickyRows": { "alias": "stickyRows"; "required": false; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; }; "stickyFooter": { "alias": "stickyFooter"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; "stickyRowHeight": { "alias": "stickyRowHeight"; "required": false; }; "stickyHeaderHeight": { "alias": "stickyHeaderHeight"; "required": false; }; "stickyFooterHeight": { "alias": "stickyFooterHeight"; "required": false; }; "tableOptions": { "alias": "tableOptions"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selectionBehavior": { "alias": "selectionBehavior"; "required": false; }; "selectionKeyMode": { "alias": "selectionKeyMode"; "required": false; }; "selectAllEnabled": { "alias": "selectAllEnabled"; "required": false; }; "selectionA11yLabels": { "alias": "selectionA11yLabels"; "required": false; }; "selectionDisabledFn": { "alias": "selectionDisabledFn"; "required": false; }; "highlightedIndex": { "alias": "highlightedIndex"; "required": false; }; "highlightRowKey": { "alias": "highlightRowKey"; "required": false; }; "highlightColKey": { "alias": "highlightColKey"; "required": false; }; "globalFilterAriaLabel": { "alias": "globalFilterAriaLabel"; "required": false; }; "expandRowAriaLabel": { "alias": "expandRowAriaLabel"; "required": false; }; "collapseRowAriaLabel": { "alias": "collapseRowAriaLabel"; "required": false; }; "exportPdfAriaLabel": { "alias": "exportPdfAriaLabel"; "required": false; }; "exportExcelAriaLabel": { "alias": "exportExcelAriaLabel"; "required": false; }; "newRowDefaults": { "alias": "newRowDefaults"; "required": false; }; "strictEmail": { "alias": "strictEmail"; "required": false; }; "editOnRowClick": { "alias": "editOnRowClick"; "required": false; }; "singleExpand": { "alias": "singleExpand"; "required": false; }; "exportOptions": { "alias": "exportOptions"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "editService": { "alias": "editService"; "required": false; }; "dataProviderAll": { "alias": "dataProviderAll"; "required": false; }; "dataProviderSelection": { "alias": "dataProviderSelection"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, { "rowAdd": "rowAdd"; "rowEdit": "rowEdit"; "rowSave": "rowSave"; "rowCancel": "rowCancel"; "rowDelete": "rowDelete"; "sortChange": "sortChange"; "filtersChange": "filtersChange"; "pageChange": "pageChange"; "selectionChange": "selectionChange"; }, ["exportButtonDir", "rowDetailTpl", "cellTplQ", "editTplQ", "filterTplQ", "globalTplQ"], never, true, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<Datagrid<any>, "ngb-datagrid", never, { "columns": { "alias": "columns"; "required": false; }; "data": { "alias": "data"; "required": false; }; "loading": { "alias": "loading"; "required": false; }; "total": { "alias": "total"; "required": false; }; "enableSorting": { "alias": "enableSorting"; "required": false; }; "enableFiltering": { "alias": "enableFiltering"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "enableGlobalFilter": { "alias": "enableGlobalFilter"; "required": false; }; "filterMode": { "alias": "filterMode"; "required": false; }; "filter": { "alias": "filter"; "required": false; }; "filterOperators": { "alias": "filterOperators"; "required": false; }; "filterManual": { "alias": "filterManual"; "required": false; }; "externalFiltering": { "alias": "externalFiltering"; "required": false; }; "dataOperations": { "alias": "dataOperations"; "required": false; }; "state": { "alias": "state"; "required": false; }; "multiCheckboxFilterOptions": { "alias": "multiCheckboxFilterOptions"; "required": false; }; "enablePagination": { "alias": "enablePagination"; "required": false; }; "pageable": { "alias": "pageable"; "required": false; }; "enableEdit": { "alias": "enableEdit"; "required": false; }; "enableDelete": { "alias": "enableDelete"; "required": false; }; "pageSizeOptions": { "alias": "pageSizeOptions"; "required": false; }; "enableAdd": { "alias": "enableAdd"; "required": false; }; "addButtonAriaLabel": { "alias": "addButtonAriaLabel"; "required": false; }; "addButtonText": { "alias": "addButtonText"; "required": false; }; "stickyRows": { "alias": "stickyRows"; "required": false; }; "stickyHeader": { "alias": "stickyHeader"; "required": false; }; "stickyFooter": { "alias": "stickyFooter"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; "stickyRowHeight": { "alias": "stickyRowHeight"; "required": false; }; "stickyHeaderHeight": { "alias": "stickyHeaderHeight"; "required": false; }; "stickyFooterHeight": { "alias": "stickyFooterHeight"; "required": false; }; "tableOptions": { "alias": "tableOptions"; "required": false; }; "dataLayoutMode": { "alias": "dataLayoutMode"; "required": false; }; "selectionMode": { "alias": "selectionMode"; "required": false; }; "selectionBehavior": { "alias": "selectionBehavior"; "required": false; }; "selectionKeyMode": { "alias": "selectionKeyMode"; "required": false; }; "selectAllEnabled": { "alias": "selectAllEnabled"; "required": false; }; "selectionA11yLabels": { "alias": "selectionA11yLabels"; "required": false; }; "selectionDisabledFn": { "alias": "selectionDisabledFn"; "required": false; }; "highlightedIndex": { "alias": "highlightedIndex"; "required": false; }; "highlightRowKey": { "alias": "highlightRowKey"; "required": false; }; "highlightColKey": { "alias": "highlightColKey"; "required": false; }; "globalFilterAriaLabel": { "alias": "globalFilterAriaLabel"; "required": false; }; "globalFilterPlaceholder": { "alias": "globalFilterPlaceholder"; "required": false; }; "searchHighlightTerm": { "alias": "searchHighlightTerm"; "required": false; }; "searchHighlightFields": { "alias": "searchHighlightFields"; "required": false; }; "expandRowAriaLabel": { "alias": "expandRowAriaLabel"; "required": false; }; "collapseRowAriaLabel": { "alias": "collapseRowAriaLabel"; "required": false; }; "exportPdfAriaLabel": { "alias": "exportPdfAriaLabel"; "required": false; }; "exportExcelAriaLabel": { "alias": "exportExcelAriaLabel"; "required": false; }; "newRowDefaults": { "alias": "newRowDefaults"; "required": false; }; "strictEmail": { "alias": "strictEmail"; "required": false; }; "editOnRowClick": { "alias": "editOnRowClick"; "required": false; }; "editMode": { "alias": "editMode"; "required": false; }; "toolbarEditHint": { "alias": "toolbarEditHint"; "required": false; }; "singleExpand": { "alias": "singleExpand"; "required": false; }; "exportOptions": { "alias": "exportOptions"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "trackBy": { "alias": "trackBy"; "required": false; }; "rowClass": { "alias": "rowClass"; "required": false; }; "rowStyle": { "alias": "rowStyle"; "required": false; }; "rowReorderable": { "alias": "rowReorderable"; "required": false; }; "columnReorderable": { "alias": "columnReorderable"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "actionDisplay": { "alias": "actionDisplay"; "required": false; }; "showStickyRowBadge": { "alias": "showStickyRowBadge"; "required": false; }; "stickyRowBadgeField": { "alias": "stickyRowBadgeField"; "required": false; }; "stickyRowBadgeLabel": { "alias": "stickyRowBadgeLabel"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "locale": { "alias": "locale"; "required": false; }; "dir": { "alias": "dir"; "required": false; }; "keyboardNavigation": { "alias": "keyboardNavigation"; "required": false; }; "editService": { "alias": "editService"; "required": false; }; "dataProviderAll": { "alias": "dataProviderAll"; "required": false; }; "dataProviderSelection": { "alias": "dataProviderSelection"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; }, { "rowAdd": "rowAdd"; "rowEdit": "rowEdit"; "rowSave": "rowSave"; "rowCancel": "rowCancel"; "rowDelete": "rowDelete"; "sortChange": "sortChange"; "filterChange": "filterChange"; "filtersChange": "filtersChange"; "pageChange": "pageChange"; "dataStateChange": "dataStateChange"; "selectionChange": "selectionChange"; "rowReorder": "rowReorder"; "columnReorder": "columnReorder"; }, ["exportButtonDir", "rowDetailTpl", "pagerTpl", "cellTplQ", "editTplQ", "filterTplQ", "filterMenuTplQ", "globalTplQ", "gridColumnQ"], ["ngb-datagrid-layout-toolbar"], true, never>;
+}
+
+/** Injection token for the active `ngb-datagrid` instance (layout toolbar tools). */
+declare const NGB_DATAGRID_HOST: InjectionToken<unknown>;
+
+type NgbDatagridFloatingPanelPlacement = 'menu' | 'operator';
+/**
+ * Popup-style overlay: anchors to a trigger, portals to document.body,
+ * and uses viewport-fixed coordinates.
+ */
+declare class NgbDatagridFloatingPanelDirective implements OnChanges, AfterViewInit, OnDestroy {
+    private readonly el;
+    private readonly renderer;
+    private readonly document;
+    private readonly cdr;
+    ngbDatagridFloatingPanelAnchor?: HTMLElement | null;
+    ngbDatagridFloatingPanelPlacement: NgbDatagridFloatingPanelPlacement;
+    readonly hostPosition = "fixed";
+    readonly hostZIndex = 1200;
+    readonly hostMargin = "0";
+    readonly hostTransform = "none";
+    panelTop: number;
+    panelLeft: number;
+    private active;
+    private portaled;
+    private originalParent;
+    private originalNextSibling;
+    private scrollListeners;
+    private resizeObserver;
+    private rafId;
+    private readonly scheduleUpdate;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    private tryActivate;
+    ngOnDestroy(): void;
+    /** Called when anchor/layout may have changed after the panel opens. */
+    reposition(): void;
+    private activate;
+    private deactivate;
+    private portalToBody;
+    private restoreFromBody;
+    private schedulePositionPasses;
+    private attachObservers;
+    private detachObservers;
+    private resolveAnchor;
+    /** Portaled panels must carry the grid theme so token SCSS applies on document.body. */
+    private syncThemeFromGrid;
+    private anchorRect;
+    private updatePosition;
+    private applyPosition;
+    private placementWidth;
+    private clearPositionStyles;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridFloatingPanelDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDatagridFloatingPanelDirective, "[ngbDatagridFloatingPanel]", never, { "ngbDatagridFloatingPanelAnchor": { "alias": "ngbDatagridFloatingPanelAnchor"; "required": false; }; "ngbDatagridFloatingPanelPlacement": { "alias": "ngbDatagridFloatingPanelPlacement"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 interface PdfExportPayload {
@@ -497,10 +1472,528 @@ declare class JsPdfAdapter implements PdfExportAdapter {
     export({ fileName, columns, rows, options }: PdfExportPayload): Promise<void>;
 }
 
-declare class XlsxAdapter implements ExcelExportAdapter {
-    export({ fileName, sheetName, columns, rows }: ExcelExportPayload): Promise<void>;
+declare class BrowserExcelExportAdapter implements ExcelExportAdapter {
+    export(payload: ExcelExportPayload): Promise<void>;
+    private createSpreadsheetXml;
+    private createRow;
+    private createCell;
+    private safeSheetName;
+    private baseFileName;
+    private escapeXml;
+}
+
+declare class NgbGridColumnDirective<T = any> implements ColumnDef<T> {
+    field: Extract<keyof T, string>;
+    header: string;
+    title?: string;
+    cellTitle?: string | ((row: T) => string);
+    sortable?: boolean;
+    filterable?: boolean;
+    filterType?: NgbColumnFilterType;
+    defaultFilterOperator?: NgbFilterOperator;
+    allowedFilterOperators?: NgbFilterOperator[];
+    showFilterMenu?: boolean;
+    showFilterRow?: boolean;
+    showFilterOperator?: boolean;
+    editable?: boolean;
+    type?: ColumnType;
+    options?: Array<{
+        label: string;
+        value: any;
+    }>;
+    width?: number;
+    stackedGroup?: 'start' | 'center' | 'end';
+    required?: boolean;
+    hidden?: boolean;
+    sticky?: boolean | 'start' | 'end';
+    locked?: boolean;
+    reorderable?: boolean;
+    resizable?: boolean;
+    minResizableWidth?: number;
+    maxResizableWidth?: number;
+    toColumnDef(): ColumnDef<T>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbGridColumnDirective<any>, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbGridColumnDirective<any>, "ngb-grid-column", never, { "field": { "alias": "field"; "required": false; }; "header": { "alias": "header"; "required": false; }; "title": { "alias": "title"; "required": false; }; "cellTitle": { "alias": "cellTitle"; "required": false; }; "sortable": { "alias": "sortable"; "required": false; }; "filterable": { "alias": "filterable"; "required": false; }; "filterType": { "alias": "filterType"; "required": false; }; "defaultFilterOperator": { "alias": "defaultFilterOperator"; "required": false; }; "allowedFilterOperators": { "alias": "allowedFilterOperators"; "required": false; }; "showFilterMenu": { "alias": "showFilterMenu"; "required": false; }; "showFilterRow": { "alias": "showFilterRow"; "required": false; }; "showFilterOperator": { "alias": "showFilterOperator"; "required": false; }; "editable": { "alias": "editable"; "required": false; }; "type": { "alias": "type"; "required": false; }; "options": { "alias": "options"; "required": false; }; "width": { "alias": "width"; "required": false; }; "stackedGroup": { "alias": "stackedGroup"; "required": false; }; "required": { "alias": "required"; "required": false; }; "hidden": { "alias": "hidden"; "required": false; }; "sticky": { "alias": "sticky"; "required": false; }; "locked": { "alias": "locked"; "required": false; }; "reorderable": { "alias": "reorderable"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "minResizableWidth": { "alias": "minResizableWidth"; "required": false; }; "maxResizableWidth": { "alias": "maxResizableWidth"; "required": false; }; }, {}, never, never, true, never>;
+}
+declare const DATAGRID_COLUMN_DIRECTIVES: (typeof NgbGridColumnDirective)[];
+
+type NgbDatagridButtonVariant = 'primary' | 'secondary' | 'success' | 'danger' | 'neutral' | 'icon';
+declare class NgbDatagridButtonDirective {
+    variant: NgbDatagridButtonVariant;
+    get toolbarButtonClass(): boolean;
+    get toolbarPrimary(): boolean;
+    get toolbarSecondary(): boolean;
+    get rowActionClass(): boolean;
+    get rowSuccess(): boolean;
+    get rowDanger(): boolean;
+    get rowNeutral(): boolean;
+    get iconButtonClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridButtonDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDatagridButtonDirective, "button[ngbDatagridButton], a[ngbDatagridButton]", never, { "variant": { "alias": "ngbDatagridButton"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NgbDatagridControlDirective {
+    ngbDatagridControlMode: 'filter' | 'edit';
+    get filterClass(): boolean;
+    get editClass(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridControlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDatagridControlDirective, "input[ngbDatagridControl], select[ngbDatagridControl], textarea[ngbDatagridControl]", never, { "ngbDatagridControlMode": { "alias": "ngbDatagridControlMode"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NgbDatagridFieldShellComponent {
+    icon?: string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridFieldShellComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDatagridFieldShellComponent, "ngb-datagrid-field-shell", never, { "icon": { "alias": "icon"; "required": false; }; }, {}, never, ["*"], true, never>;
+}
+
+declare class NgbDatagridSurfaceCardComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridSurfaceCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDatagridSurfaceCardComponent, "ngb-datagrid-surface-card", never, {}, {}, never, ["*"], true, never>;
+}
+
+declare class NgbDatagridLayoutToolbarComponent implements AfterContentInit, OnChanges {
+    /**
+     * Grid instance for toolbar tools. Child tools inherit this via `bindHostGrid`
+     * and do not need their own `[grid]` binding.
+     */
+    grid: Datagrid<any>;
+    ariaLabel: string;
+    private filterTools?;
+    private sortTools?;
+    private columnTools?;
+    ngAfterContentInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private syncToolHosts;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridLayoutToolbarComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDatagridLayoutToolbarComponent, "ngb-datagrid-layout-toolbar", never, { "grid": { "alias": "grid"; "required": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, ["filterTools", "sortTools", "columnTools"], ["*"], true, never>;
+}
+declare class NgbDatagridLayoutToolbarSpacerComponent {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridLayoutToolbarSpacerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDatagridLayoutToolbarSpacerComponent, "ngb-datagrid-layout-toolbar-spacer", never, {}, {}, never, never, true, never>;
+}
+
+/** Layout-toolbar tools receive the grid from the toolbar host. */
+interface NgbDatagridToolHost {
+    bindHostGrid(grid: Datagrid<any>): void;
+}
+
+declare class NgbDatagridFilterToolComponent implements NgbDatagridToolHost, OnInit, OnDestroy {
+    private readonly cdr;
+    private readonly coordinator;
+    /** Optional override when the tool is not inside `ngb-datagrid-layout-toolbar`. */
+    grid?: Datagrid<any>;
+    label: string;
+    private toolbarGrid?;
+    open: boolean;
+    expandedField: string | null;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    bindHostGrid(grid: Datagrid<any>): void;
+    private resolvedGrid;
+    get activeGrid(): Datagrid<any>;
+    get filterableColumns(): ColumnDef<any>[];
+    menuConditions(col: ColumnDef<any>): NgbMenuFilterConditionDraft[];
+    togglePanel(event: MouseEvent): void;
+    private closePanel;
+    toggleSection(field: string): void;
+    operatorsFor(col: ColumnDef<any>): NgbFilterOperator[];
+    applyColumn(col: ColumnDef<any>): void;
+    clearColumn(col: ColumnDef<any>): void;
+    clearAll(): void;
+    closeOnOutsideClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridFilterToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDatagridFilterToolComponent, "ngb-datagrid-filter-tool", never, { "grid": { "alias": "grid"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NgbDatagridSortToolComponent implements NgbDatagridToolHost, OnInit, OnDestroy {
+    private readonly cdr;
+    private readonly coordinator;
+    grid?: Datagrid<any>;
+    label: string;
+    private toolbarGrid?;
+    open: boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    bindHostGrid(grid: Datagrid<any>): void;
+    private resolvedGrid;
+    get activeGrid(): Datagrid<any>;
+    get sortableColumns(): ColumnDef<any>[];
+    togglePanel(event: MouseEvent): void;
+    private closePanel;
+    toggleSort(col: ColumnDef<any>): void;
+    clearSorting(): void;
+    closeOnOutsideClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridSortToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDatagridSortToolComponent, "ngb-datagrid-sort-tool", never, { "grid": { "alias": "grid"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NgbDatagridColumnChooserToolComponent implements OnChanges, OnInit, OnDestroy, NgbDatagridToolHost {
+    private readonly cdr;
+    private readonly coordinator;
+    grid?: Datagrid<any>;
+    label: string;
+    private toolbarGrid?;
+    open: boolean;
+    searchTerm: string;
+    draftVisibility: Record<string, boolean>;
+    bindHostGrid(grid: Datagrid<any>): void;
+    private resolvedGrid;
+    get activeGrid(): Datagrid<any>;
+    get chooserColumns(): _angular_bootstrap_ngbootstrap.ColumnDef<any>[];
+    get filteredColumns(): _angular_bootstrap_ngbootstrap.ColumnDef<any>[];
+    get selectedCount(): number;
+    get allVisible(): boolean;
+    get partiallyVisible(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    ngOnChanges(): void;
+    togglePanel(event: MouseEvent): void;
+    private closePanel;
+    toggleColumn(field: string): void;
+    toggleAll(): void;
+    apply(): void;
+    resetDraft(mark?: boolean): void;
+    closeOnOutsideClick(event: MouseEvent): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridColumnChooserToolComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDatagridColumnChooserToolComponent, "ngb-datagrid-column-chooser-tool", never, { "grid": { "alias": "grid"; "required": false; }; "label": { "alias": "label"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type NgbDataChartType = 'bar' | 'line' | 'area' | 'pie' | 'doughnut';
+type NgbDataAggregate = 'sum' | 'avg' | 'min' | 'max' | 'count';
+interface NgbDataMetricDef<T = any> {
+    key: string;
+    label: string;
+    accessor: (row: T) => number;
+    color?: string;
+}
+interface NgbDataDimensionDef<T = any> {
+    key: string;
+    label: string;
+    accessor: (row: T) => string;
+}
+interface NgbDataChartSeries {
+    key: string;
+    label: string;
+    data: number[];
+    color?: string;
+}
+interface NgbDataChartConfig {
+    type: NgbDataChartType;
+    labels: string[];
+    series: NgbDataChartSeries[];
+    title?: string;
+    height?: number;
+    emptyState?: string;
+    showLegend?: boolean;
+    legendPosition?: 'top' | 'bottom';
+    stacked?: boolean;
+    valueFormatter?: (value: number) => string;
+}
+interface NgbFullGridChartOptions<T = any> {
+    dimension: NgbDataDimensionDef<T>;
+    metric: NgbDataMetricDef<T>;
+    aggregate?: NgbDataAggregate;
+    chartType?: NgbDataChartType;
+    title?: string;
+    limit?: number;
+    sort?: 'asc' | 'desc' | null;
+    valueFormatter?: (value: number) => string;
+}
+interface NgbRowSelectionChartOptions<T = any> {
+    metrics: NgbDataMetricDef<T>[];
+    seriesLabel?: (row: T, index: number) => string;
+    chartType?: NgbDataChartType;
+    title?: string;
+    valueFormatter?: (value: number) => string;
+}
+interface NgbColumnSelectionChartOptions<T = any> {
+    dimension: NgbDataDimensionDef<T>;
+    metrics: NgbDataMetricDef<T>[];
+    chartType?: NgbDataChartType;
+    title?: string;
+    valueFormatter?: (value: number) => string;
+}
+interface NgbSparklinePoint {
+    x: number;
+    y: number;
+}
+
+declare const ngbChartPalette: (index: number) => string;
+declare const ngbAggregateValues: (values: number[], aggregate?: NgbDataAggregate) => number;
+declare const ngbBuildRowSelectionChartData: <T>(rows: T[], options: NgbRowSelectionChartOptions<T>) => NgbDataChartConfig;
+declare const ngbBuildColumnSelectionChartData: <T>(rows: T[], options: NgbColumnSelectionChartOptions<T>) => NgbDataChartConfig;
+declare const ngbBuildFullGridChartData: <T>(rows: T[], options: NgbFullGridChartOptions<T>) => NgbDataChartConfig;
+declare const ngbBuildSparklinePoints: (values: number[], width?: number, height?: number, padding?: number) => NgbSparklinePoint[];
+declare const ngbBuildChartJsConfig: (config: NgbDataChartConfig, height?: number) => ChartConfiguration;
+
+declare class NgbDataChartComponent implements AfterViewInit, OnChanges, OnDestroy {
+    config: NgbDataChartConfig | null;
+    ariaLabel: string;
+    emptyState: string;
+    private canvas?;
+    private chart?;
+    private chartConstructor?;
+    private viewReady;
+    private configSignature;
+    private rendering;
+    get chartHeight(): number;
+    ngAfterViewInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngOnDestroy(): void;
+    hasData(): boolean;
+    private renderChart;
+    private loadChartConstructor;
+    private buildConfigSignature;
+    private destroyChart;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDataChartComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDataChartComponent, "ngb-data-chart", never, { "config": { "alias": "config"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "emptyState": { "alias": "emptyState"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+declare class NgbDataSparklineComponent implements OnChanges {
+    values: number[];
+    /** Cached series used by getters so template bindings stay stable between checks. */
+    series: number[];
+    width: number;
+    height: number;
+    strokeWidth: number;
+    positiveColor: string;
+    negativeColor: string;
+    neutralColor: string;
+    color: string | null;
+    showEndDot: boolean;
+    endDotRadius: number;
+    ariaLabel: string;
+    ngOnChanges(changes: SimpleChanges): void;
+    get points(): NgbSparklinePoint[];
+    get path(): string;
+    get strokeColor(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDataSparklineComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDataSparklineComponent, "ngb-data-sparkline", never, { "values": { "alias": "values"; "required": false; }; "width": { "alias": "width"; "required": false; }; "height": { "alias": "height"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "positiveColor": { "alias": "positiveColor"; "required": false; }; "negativeColor": { "alias": "negativeColor"; "required": false; }; "neutralColor": { "alias": "neutralColor"; "required": false; }; "color": { "alias": "color"; "required": false; }; "showEndDot": { "alias": "showEndDot"; "required": false; }; "endDotRadius": { "alias": "endDotRadius"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, {}, never, never, true, never>;
+}
+
+type NgbGridChartMode = 'row-selection' | 'column-selection' | 'full-grid' | 'sparklines';
+interface NgbGridChartSparklineOptions<T = any> {
+    /** Field key rendered with an inline sparkline. */
+    field: string;
+    values: (row: T) => number[];
+    width?: number;
+    height?: number;
+    trendColor?: boolean;
+}
+interface NgbGridChartConfig<T = any> {
+    mode: NgbGridChartMode;
+    /** Tabular rows used by the grid and chart builders. */
+    rows: T[];
+    /** Primary label column (e.g. product name). */
+    dimension: NgbDataDimensionDef<T>;
+    /** Optional secondary line under the dimension label (e.g. category). */
+    subDimension?: NgbDataDimensionDef<T>;
+    /** Metrics available for charts / sparklines. */
+    metrics: NgbDataMetricDef<T>[];
+    /** Metrics plotted for row-selection mode (defaults to all metrics). */
+    rowSelectionMetrics?: NgbDataMetricDef<T>[];
+    /** Keys of metrics enabled in column-selection mode. */
+    selectedMetricKeys?: string[];
+    /** Row ids selected in row-selection mode. */
+    selectedRowIds?: Array<string | number>;
+    chartType?: NgbDataChartType;
+    chartTitle?: string;
+    valueFormatter?: (value: number) => string;
+    /** Full-grid mode options (metric + grouping). */
+    fullGrid?: Partial<NgbFullGridChartOptions<T>>;
+    sparkline?: NgbGridChartSparklineOptions<T>;
+    /** Extra grid columns appended after metric columns (e.g. growth %). */
+    trailingColumns?: Array<{
+        field: string;
+        header: string;
+        type?: 'text' | 'number';
+        width?: number;
+    }>;
+}
+
+interface NgbGridChartSelectionChange<T> {
+    selected: T[];
+    selectedRowIds: Array<string | number>;
+}
+declare class NgbGridChartComponent<T = any> implements OnChanges, AfterViewInit, AfterViewChecked {
+    config: NgbGridChartConfig<T>;
+    ariaLabel: string;
+    selectionChange: EventEmitter<NgbGridChartSelectionChange<T>>;
+    private grid?;
+    gridColumns: ColumnDef<T>[];
+    chartConfig: NgbDataChartConfig | null;
+    dimensionTemplate: boolean;
+    sparklineField: string | null;
+    sparklineColumns: ColumnDef<T>[];
+    readonly tableOptions: {
+        responsive: boolean;
+        hoverRows: boolean;
+        zebraStripes: boolean;
+    };
+    readonly rowTrackBy: (index: number, row: T) => string | number;
+    private readonly cdr;
+    private selectedIds;
+    private activeMetricKeys;
+    private lastMode;
+    private lastMetricKeys;
+    private lastChartType;
+    private lastRowIds;
+    private lastSparklineKey;
+    private lastFullGridKey;
+    private selectionSeedPending;
+    private sparklineSeriesByRowId;
+    ngOnChanges(changes: SimpleChanges): void;
+    ngAfterViewInit(): void;
+    ngAfterViewChecked(): void;
+    get chartAriaLabel(): string;
+    sparklineValues(row: T): number[];
+    sparklineColor(row: T): string | null;
+    isRowSelected(row: T): boolean;
+    seriesColor(row: T): string;
+    onGridSelectionChange(event: {
+        selected: T[];
+    }): void;
+    private applyConfigChanges;
+    private rebuildSparklineCache;
+    private syncSelectionFromConfig;
+    private rebuildChartOnly;
+    private selectedRows;
+    private activeMetrics;
+    private rowMetrics;
+    private resolveRowId;
+    private scheduleSeedSelection;
+    private seedGridSelection;
+    private buildRowSelectionColumns;
+    private buildColumnSelectionColumns;
+    private buildSparklineColumns;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbGridChartComponent<any>, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbGridChartComponent<any>, "ngb-grid-chart", never, { "config": { "alias": "config"; "required": true; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; }, { "selectionChange": "selectionChange"; }, never, ["[gridChartSummary]", "[gridChartFooter]"], true, never>;
+}
+
+interface NgbAdvancedSearchField {
+    field: string;
+    label: string;
+    type?: ColumnType;
+    filterType?: NgbColumnFilterType;
+    defaultFilterOperator?: NgbFilterOperator | '';
+    allowedFilterOperators?: NgbFilterOperator[];
+}
+interface NgbAdvancedSearchOperator {
+    value: NgbFilterOperator;
+    label: string;
+}
+interface NgbAdvancedSearchRule {
+    field: string;
+    operator: NgbFilterOperator;
+    value: any;
+}
+declare class NgbAdvancedSearchComponent {
+    private _fields;
+    private _operators;
+    private fieldConfigCache;
+    private filterTypeCache;
+    private inputTypeCache;
+    private operatorOptionsCache;
+    set fields(value: NgbAdvancedSearchField[] | null | undefined);
+    get fields(): NgbAdvancedSearchField[];
+    set operators(value: NgbAdvancedSearchOperator[] | null | undefined);
+    get operators(): NgbAdvancedSearchOperator[] | null;
+    rules: NgbAdvancedSearchRule[];
+    logic: 'and' | 'or';
+    minRules: number;
+    matchLabel: string;
+    rulesLabel: string;
+    whenLabel: string;
+    addRuleLabel: string;
+    applyLabel: string;
+    removeRuleLabel: string;
+    removeRuleAriaLabel: string;
+    fieldAriaLabel: string;
+    operatorAriaLabel: string;
+    valueAriaLabel: string;
+    valuePlaceholder: string;
+    rulesChange: EventEmitter<NgbAdvancedSearchRule[]>;
+    logicChange: EventEmitter<"and" | "or">;
+    filterChange: EventEmitter<NgbCompositeFilterDescriptor>;
+    setLogic(logic: 'and' | 'or'): void;
+    addRule(): void;
+    removeRule(index: number): void;
+    apply(): void;
+    emitRules(): void;
+    setRuleField(rule: NgbAdvancedSearchRule, field: string): void;
+    setRuleOperator(rule: NgbAdvancedSearchRule, operator: NgbFilterOperator): void;
+    inputType(rule: NgbAdvancedSearchRule): string;
+    operatorRequiresValue(operator: NgbFilterOperator): boolean;
+    operatorOptionsFor(rule: NgbAdvancedSearchRule): NgbAdvancedSearchOperator[];
+    toFilterDescriptor(): NgbCompositeFilterDescriptor;
+    private fieldConfig;
+    private filterTypeForField;
+    private allowedOperatorsForField;
+    private defaultOperatorForField;
+    private rebuildFieldCaches;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbAdvancedSearchComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbAdvancedSearchComponent, "ngb-advanced-search", never, { "fields": { "alias": "fields"; "required": false; }; "operators": { "alias": "operators"; "required": false; }; "rules": { "alias": "rules"; "required": false; }; "logic": { "alias": "logic"; "required": false; }; "minRules": { "alias": "minRules"; "required": false; }; "matchLabel": { "alias": "matchLabel"; "required": false; }; "rulesLabel": { "alias": "rulesLabel"; "required": false; }; "whenLabel": { "alias": "whenLabel"; "required": false; }; "addRuleLabel": { "alias": "addRuleLabel"; "required": false; }; "applyLabel": { "alias": "applyLabel"; "required": false; }; "removeRuleLabel": { "alias": "removeRuleLabel"; "required": false; }; "removeRuleAriaLabel": { "alias": "removeRuleAriaLabel"; "required": false; }; "fieldAriaLabel": { "alias": "fieldAriaLabel"; "required": false; }; "operatorAriaLabel": { "alias": "operatorAriaLabel"; "required": false; }; "valueAriaLabel": { "alias": "valueAriaLabel"; "required": false; }; "valuePlaceholder": { "alias": "valuePlaceholder"; "required": false; }; }, { "rulesChange": "rulesChange"; "logicChange": "logicChange"; "filterChange": "filterChange"; }, never, never, true, never>;
+}
+
+interface NgbSearchHighlightField {
+    field: string;
+    label: string;
+    disabled?: boolean;
+}
+interface NgbSearchHighlightSelectionChange {
+    term: string;
+    selectedFields: string[];
+}
+declare class NgbSearchHighlightComponent {
+    fields: NgbSearchHighlightField[];
+    selectedFields: string[];
+    term: string;
+    placeholder: string;
+    searchAriaLabel: string;
+    fieldsLabel: string;
+    fieldsAriaLabel: string;
+    searchIcon: string;
+    allowEmptySelection: boolean;
+    termChange: EventEmitter<string>;
+    selectedFieldsChange: EventEmitter<string[]>;
+    selectionChange: EventEmitter<NgbSearchHighlightSelectionChange>;
+    setTerm(term: string): void;
+    isFieldSelected(field: string): boolean;
+    toggleField(field: string): void;
+    private emitSelectionChange;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSearchHighlightComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbSearchHighlightComponent, "ngb-search-highlight", never, { "fields": { "alias": "fields"; "required": false; }; "selectedFields": { "alias": "selectedFields"; "required": false; }; "term": { "alias": "term"; "required": false; }; "placeholder": { "alias": "placeholder"; "required": false; }; "searchAriaLabel": { "alias": "searchAriaLabel"; "required": false; }; "fieldsLabel": { "alias": "fieldsLabel"; "required": false; }; "fieldsAriaLabel": { "alias": "fieldsAriaLabel"; "required": false; }; "searchIcon": { "alias": "searchIcon"; "required": false; }; "allowEmptySelection": { "alias": "allowEmptySelection"; "required": false; }; }, { "termChange": "termChange"; "selectedFieldsChange": "selectedFieldsChange"; "selectionChange": "selectionChange"; }, never, never, true, never>;
 }
 
+declare class NgbDatagridThemePickerComponent {
+    private readonly host;
+    private _value;
+    private _themes;
+    label: string;
+    get value(): NgbDataGridTheme;
+    set value(value: NgbDataGridTheme);
+    get themes(): NgbDataGridThemeOption[];
+    set themes(themes: NgbDataGridThemeOption[] | null | undefined);
+    valueChange: EventEmitter<NgbDataGridTheme>;
+    open: boolean;
+    selectedTheme: NgbDataGridThemeOption;
+    groupedThemes: Array<{
+        label: NgbDataGridThemeOption['group'];
+        items: NgbDataGridThemeOption[];
+    }>;
+    toggle(): void;
+    select(theme: NgbDataGridThemeOption): void;
+    closeOnOutsideClick(event: MouseEvent): void;
+    closeOnEscape(): void;
+    private updateSelectedTheme;
+    private buildGroupedThemes;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDatagridThemePickerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbDatagridThemePickerComponent, "ngb-datagrid-theme-picker", never, { "label": { "alias": "label"; "required": false; }; "value": { "alias": "value"; "required": false; }; "themes": { "alias": "themes"; "required": false; }; }, { "valueChange": "valueChange"; }, never, never, true, never>;
+}
+
+declare function ngbApplyDataGridOperations<T>(data: readonly T[] | null | undefined, options?: NgbDataGridProcessOptions<T>): NgbDataGridDataResult<T>;
+declare function ngbCalculateDataGridAggregates<T>(data: readonly T[] | null | undefined, descriptors: readonly NgbDataGridAggregateDescriptor[] | null | undefined): NgbDataGridAggregateResults;
+
 type DndI18n = {
     listLabel: (name?: string) => string;
     pickedUp: () => string;
@@ -518,113 +2011,45 @@ interface DndSession<T = unknown> {
     fromList?: T[];
     fromIndex?: number;
     fromIsPalette?: boolean;
+    fromListRef?: unknown;
 }
 declare class NgbDndState {
     readonly active: i0.WritableSignal<boolean>;
     private store;
     private currentId;
+    private activeDropList;
     i18n: DndI18n;
     announce?: (m: string) => void;
     constructor(announceFn: ((m: string) => void) | null, i18n: DndI18n | null);
     createSession<T>(session: DndSession<T>): string;
     get(id: string | null): DndSession | null;
     getCurrent(): DndSession | null;
+    setActiveDropList(list: unknown): void;
+    getActiveDropList(): unknown | null;
+    clearActiveDropList(list?: unknown): void;
     clear(id?: string | null): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgbDndState, [{ optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NgbDndState>;
 }
 
-interface NgbDndDropEvent<T> {
-    item: T;
-    fromIndex: number;
-    toIndex: number;
-    fromList: T[];
-    toList: T[];
-    sameList: boolean;
-}
-interface DndCanDropPayload<T = any> {
-    dragItem: T;
-    srcList: T[];
-    srcIndex: number;
-    dstList: T[];
-    dstIndex: number;
-    isExternal: boolean;
-}
-/** Guard function; return true to allow, false to block */
-type DndCanDropFn<T = any> = (payload: DndCanDropPayload<T>) => boolean;
-declare class NgbDndListDirective<T = unknown> {
-    private el;
-    private state;
-    dndChildrenKey: string | null;
-    /** Bind your array here: <div [ngbDndList]="items"> */
-    list: T[];
-    /** Optional: group barrier across lists */
-    dndGroup?: string;
-    /** Disable this list */
-    dndDisabled: boolean;
-    /** NEW: clone if source wasn't a list (e.g. palette) */
-    dndCloneOnDrop: boolean;
-    /** NEW: custom clone function */
-    dndCloneFn?: (item: T) => T;
-    dndIsPalette: boolean;
-    dndCanDrop: boolean | DndCanDropFn<any>;
-    private _denied;
-    get denied(): boolean;
-    dndAriaLabel?: string;
-    get ariaLabel(): string;
-    /** Fires after item is inserted */
-    dndDropped: EventEmitter<NgbDndDropEvent<T>>;
-    role: string;
-    hostClass: boolean;
-    private hover;
-    get isOver(): boolean;
-    private canDrop;
-    get dataDropValid(): "true" | "false";
-    private placeholder?;
-    private lastIndex;
-    onDragEnter(ev: DragEvent): void;
-    onDragOver(ev: DragEvent): void;
-    onDragLeave(ev: DragEvent): void;
-    onDocumentDrop(ev: DragEvent): void;
-    onDrop(ev: DragEvent): void;
-    private getSession;
-    private ensurePlaceholder;
-    private removePlaceholder;
-    private positionPlaceholderAt;
-    private indexFromPointer;
-    private cloneItem;
-    private isDroppingIntoOwnDescendant;
-    /**
-     * Build a guard payload using whatever drag context you already store.
-     * If some fields don’t exist in your code, the fallbacks keep it working.
-     */
-    private _buildGuardPayload;
-    /**
-     * Compute destination index from the event position (no placeholder var needed).
-     * Uses vertical list heuristics; adjust for horizontal if your list is horizontal.
-     */
-    private _computeDropIndex;
-    private _allowDrop;
-    private performDrop;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDndListDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDndListDirective<any>, "[ngbDndList]", never, { "dndChildrenKey": { "alias": "dndChildrenKey"; "required": false; }; "list": { "alias": "ngbDndList"; "required": false; }; "dndGroup": { "alias": "dndGroup"; "required": false; }; "dndDisabled": { "alias": "dndDisabled"; "required": false; }; "dndCloneOnDrop": { "alias": "dndCloneOnDrop"; "required": false; }; "dndCloneFn": { "alias": "dndCloneFn"; "required": false; }; "dndIsPalette": { "alias": "dndIsPalette"; "required": false; }; "dndCanDrop": { "alias": "dndCanDrop"; "required": false; }; "dndAriaLabel": { "alias": "dndAriaLabel"; "required": false; }; }, { "dndDropped": "dndDropped"; }, never, never, true, never>;
-}
-
 declare class NgbDndItemDirective<T = unknown> {
     private parentList?;
     private el;
     private state;
-    constructor(parentList?: NgbDndListDirective<T>);
+    constructor(parentList?: NgbDndListDirective<T> | undefined);
     /** required: the value carried by this row/panel */
     item: T;
     /** optional: constrain cross-list drops */
     dndGroup?: string;
-    /** index inside its parent list (bind to *ngFor index) */
+    /** index inside its parent list (bind to the rendered row index) */
     dndIndex?: number;
+    /** Explicit source list for recursive templates where DI can be ambiguous. */
+    dndSourceList?: T[];
     dndDisabled: boolean;
     dndDragStart: EventEmitter<T>;
     dndDragEnd: EventEmitter<void>;
     get draggable(): boolean;
+    hostClass: boolean;
     dragging: boolean;
     get ariaGrabbed(): "true" | "false";
     role: string;
@@ -634,7 +2059,28 @@ declare class NgbDndItemDirective<T = unknown> {
     onDragEnd(): void;
     onKeydown(ev: KeyboardEvent): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<NgbDndItemDirective<any>, [{ optional: true; }]>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDndItemDirective<any>, "[ngbDndItem]", never, { "item": { "alias": "ngbDndItem"; "required": false; }; "dndGroup": { "alias": "dndGroup"; "required": false; }; "dndIndex": { "alias": "dndIndex"; "required": false; }; "dndDisabled": { "alias": "dndDisabled"; "required": false; }; }, { "dndDragStart": "dndDragStart"; "dndDragEnd": "dndDragEnd"; }, never, never, true, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDndItemDirective<any>, "[ngbDndItem]", never, { "item": { "alias": "ngbDndItem"; "required": false; }; "dndGroup": { "alias": "dndGroup"; "required": false; }; "dndIndex": { "alias": "dndIndex"; "required": false; }; "dndSourceList": { "alias": "dndSourceList"; "required": false; }; "dndDisabled": { "alias": "dndDisabled"; "required": false; }; }, { "dndDragStart": "dndDragStart"; "dndDragEnd": "dndDragEnd"; }, never, never, true, never>;
+}
+
+declare class NgbDndHandleDirective {
+    private item?;
+    constructor(item?: NgbDndItemDirective | undefined);
+    draggable: string;
+    hostClass: boolean;
+    onDragStart(ev: DragEvent): void;
+    onDragEnd(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDndHandleDirective, [{ optional: true; skipSelf: true; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDndHandleDirective, "[ngbDndHandle]", never, {}, {}, never, never, true, never>;
+}
+
+declare class NgbJsonPreviewComponent {
+    value: unknown;
+    indent: number;
+    fallback: string;
+    maxHeight: number;
+    get formattedJson(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NgbJsonPreviewComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NgbJsonPreviewComponent, "ngb-json-preview", never, { "value": { "alias": "value"; "required": false; }; "indent": { "alias": "indent"; "required": false; }; "fallback": { "alias": "fallback"; "required": false; }; "maxHeight": { "alias": "maxHeight"; "required": false; }; }, {}, never, never, true, never>;
 }
 
 declare class NgbLiveAnnouncer {
@@ -643,20 +2089,7 @@ declare class NgbLiveAnnouncer {
     static ɵfac: i0.ɵɵFactoryDeclaration<NgbLiveAnnouncer, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<NgbLiveAnnouncer>;
 }
-declare const DND_LIVE_ANNOUNCE: InjectionToken<(m: string) => void>;
-
-declare class NgbPaginationComponent {
-    page: number;
-    pageSize: number;
-    collectionSize: number;
-    maxSize: number;
-    pageChange: EventEmitter<number>;
-    get totalPages(): number;
-    get pages(): Array<number | '…'>;
-    go(p: number): void;
-    static ɵfac: i0.ɵɵFactoryDeclaration<NgbPaginationComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<NgbPaginationComponent, "ngb-pagination", never, { "page": { "alias": "page"; "required": false; }; "pageSize": { "alias": "pageSize"; "required": false; }; "collectionSize": { "alias": "collectionSize"; "required": false; }; "maxSize": { "alias": "maxSize"; "required": false; }; }, { "pageChange": "pageChange"; }, never, never, true, never>;
-}
+declare const DND_LIVE_ANNOUNCE: InjectionToken<((m: string) => void) | null>;
 
 type NgbStepperOrientation = 'horizontal' | 'vertical';
 type NgbStepperLabelPosition = 'top' | 'bottom' | 'left' | 'right';
@@ -1008,5 +2441,5 @@ declare class NgbChipsComponent {
     static ɵcmp: i0.ɵɵComponentDeclaration<NgbChipsComponent, "ngb-chips", never, { "items": { "alias": "items"; "required": false; }; "removable": { "alias": "removable"; "required": false; }; "ariaLabel": { "alias": "ariaLabel"; "required": false; }; "removeLabel": { "alias": "removeLabel"; "required": false; }; }, { "remove": "remove"; }, never, never, true, never>;
 }
 
-export { DATAGRID_TEMPLATE_DIRECTIVES, DND_I18N, DND_LIVE_ANNOUNCE, Datagrid, ExcelExportAdapter, ExportButtonDirective, JsPdfAdapter, NgbCellTemplate, NgbChipsComponent, NgbDatagridDefaultEditService, NgbDndItemDirective, NgbDndListDirective, NgbDndState, NgbEditorTemplate, NgbExportService, NgbFilterTemplate, NgbGlobalFilterTemplate, NgbLiveAnnouncer, NgbPaginationComponent, NgbRowDetailTemplate, NgbSplitterComponent, NgbSplitterPaneComponent, NgbStepLabelDirective, NgbStepperComponent, NgbTreeComponent, NgbTypeaheadComponent, PdfExportAdapter, XlsxAdapter, defaultDndI18n };
-export type { CellCtx, ColumnDef, ColumnType, DndCanDropFn, DndCanDropPayload, DndI18n, DndSession, EditCtx, ExcelExportPayload, ExportButtonContext, FilterCtx, GlobalFilterCtx, NgbChip, NgbColKey, NgbDataGridExportOptions, NgbDataGridExportPages, NgbDataGridExportType, NgbDataGridResponsiveOptions, NgbDataGridTheme, NgbDatagridEditService, NgbDatagridTrackByFn, NgbDndDropEvent, NgbRowKey, NgbSelectionBehavior, NgbSelectionKeyMode, NgbSelectionLabels, NgbSelectionMode, NgbSplitterOrientation, NgbSplitterPaneSize, NgbStepperContentPosition, NgbStepperLabelPosition, NgbStepperOrientation, NgbStepperSelectionChangeEvent, NgbStepperState, NgbStepperStep, NgbStepperTheme, NgbTableOptions, NgbTableResponsive, NgbTreeI18n, NgbTreeNode, NgbTreeType, NgbTypeaheadI18n, NgbTypeaheadItem, PdfExportPayload };
+export { BrowserExcelExportAdapter, DATAGRID_COLUMN_DIRECTIVES, DATAGRID_TEMPLATE_DIRECTIVES, DND_I18N, DND_LIVE_ANNOUNCE, Datagrid, ExcelExportAdapter, ExportButtonDirective, JsPdfAdapter, NGB_BOOLEAN_FILTER_OPERATORS, NGB_DATAGRID_DEFAULT_LABELS, NGB_DATAGRID_DEFAULT_PAGEABLE, NGB_DATAGRID_HOST, NGB_DATAGRID_KEYBOARD_SHORTCUTS, NGB_DATAGRID_PAGER_BREAKPOINTS, NGB_DATAGRID_THEME_OPTIONS, NGB_DATE_FILTER_OPERATORS, NGB_NUMERIC_FILTER_OPERATORS, NGB_PAGER_BREAKPOINTS, NGB_PAGER_DEFAULT_SETTINGS, NGB_SELECT_FILTER_OPERATORS, NGB_TEXT_FILTER_OPERATORS, NgbAdvancedSearchComponent, NgbCellTemplate, NgbChipsComponent, NgbDataChartComponent, NgbDataSparklineComponent, NgbDatagridButtonDirective, NgbDatagridColumnChooserToolComponent, NgbDatagridControlDirective, NgbDatagridDefaultEditService, NgbDatagridFieldShellComponent, NgbDatagridFilterToolComponent, NgbDatagridFloatingPanelDirective, NgbDatagridLayoutToolbarComponent, NgbDatagridLayoutToolbarSpacerComponent, NgbDatagridSortToolComponent, NgbDatagridSurfaceCardComponent, NgbDatagridThemePickerComponent, NgbDndHandleDirective, NgbDndItemDirective, NgbDndListDirective, NgbDndState, NgbEditorTemplate, NgbExportService, NgbFilterMenuTemplate, NgbFilterTemplate, NgbGlobalFilterTemplate, NgbGridChartComponent, NgbGridColumnDirective, NgbJsonPreviewComponent, NgbLiveAnnouncer, NgbPagerComponent, NgbPagerTemplate, NgbPaginationComponent, NgbRowDetailTemplate, NgbSearchHighlightComponent, NgbSplitterComponent, NgbSplitterPaneComponent, NgbStepLabelDirective, NgbStepperComponent, NgbTreeComponent, NgbTypeaheadComponent, PdfExportAdapter, defaultDndI18n, ngbAggregateValues, ngbAllowedFilterOperators, ngbApplyDataGridOperations, ngbBuildChartJsConfig, ngbBuildColumnSelectionChartData, ngbBuildFullGridChartData, ngbBuildRowSelectionChartData, ngbBuildSparklinePoints, ngbCalculateDataGridAggregates, ngbChartPalette, ngbColumnTypeToFilterType, ngbDatagridPagerSettings, ngbDefaultFilterOperator, ngbFilterOperatorLabel, ngbFindFieldFilterDescriptor, ngbFlattenFilterDescriptors, ngbFormatDatagridLabel, ngbFormatPagerRangeLabel, ngbIsCompositeFilter, ngbOperatorRequiresFilterValue, ngbPagerButtonCountForDensity, ngbResolveDatagridPagerSettings, ngbResolvePageableSettings, ngbResolvePagerDensity, ngbResolvePagerPageSizeOptions, ngbResolvePagerSettings, ngbSetFieldFilter };
+export type { CellCtx, ColumnDef, ColumnType, DndCanDropFn, DndCanDropPayload, DndI18n, DndSession, EditCtx, ExcelExportPayload, ExportButtonContext, FilterCtx, GlobalFilterCtx, NgbAdvancedSearchField, NgbAdvancedSearchOperator, NgbAdvancedSearchRule, NgbChip, NgbColKey, NgbColumnFilterType, NgbColumnReorderEvent, NgbColumnReorderOptions, NgbColumnSelectionChartOptions, NgbCompositeFilterDescriptor, NgbDataAggregate, NgbDataChartConfig, NgbDataChartSeries, NgbDataChartType, NgbDataDimensionDef, NgbDataGridAggregateDescriptor, NgbDataGridAggregateFunction, NgbDataGridAggregateResults, NgbDataGridDataResult, NgbDataGridExportOptions, NgbDataGridExportPages, NgbDataGridExportType, NgbDataGridProcessOptions, NgbDataGridResponsiveOptions, NgbDataGridSortDescriptor, NgbDataGridSortDirection, NgbDataGridState, NgbDataGridTheme, NgbDataGridThemeOption, NgbDataLayoutMode, NgbDataMetricDef, NgbDatagridButtonVariant, NgbDatagridEditService, NgbDatagridFloatingPanelPlacement, NgbDatagridLabels, NgbDatagridPageableSettings, NgbDatagridPagerDensity, NgbDatagridPagerPosition, NgbDatagridPagerType, NgbDatagridTextDirection, NgbDatagridTrackByFn, NgbDndDropEvent, NgbEditMode, NgbFilterDescriptor, NgbFilterMode, NgbFilterOperator, NgbFilterState, NgbFilterable, NgbFullGridChartOptions, NgbGridChartConfig, NgbGridChartMode, NgbGridChartSelectionChange, NgbGridChartSparklineOptions, NgbMenuFilterConditionDraft, NgbMultiCheckboxFilterOptions, NgbPagerDensity, NgbPagerSettings, NgbPagerType, NgbRowKey, NgbRowSelectionChartOptions, NgbSearchHighlightField, NgbSearchHighlightSegment, NgbSearchHighlightSelectionChange, NgbSelectionBehavior, NgbSelectionKeyMode, NgbSelectionLabels, NgbSelectionMode, NgbSparklinePoint, NgbSplitterOrientation, NgbSplitterPaneSize, NgbStepperContentPosition, NgbStepperLabelPosition, NgbStepperOrientation, NgbStepperSelectionChangeEvent, NgbStepperState, NgbStepperStep, NgbStepperTheme, NgbTableOptions, NgbTableResponsive, NgbTreeI18n, NgbTreeNode, NgbTreeType, NgbTypeaheadI18n, NgbTypeaheadItem, PagerCtx, PdfExportPayload };