import * as i0 from '@angular/core';
import { EventEmitter, AfterViewInit, OnDestroy, ElementRef, ChangeDetectorRef, TemplateRef, OnInit, OnChanges, SimpleChanges, AfterContentInit, InjectionToken, 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?: unknown;
    ignoreCase?: boolean;
}
/** Single condition in a column filter menu or layout-toolbar filter tool. */
interface NgbMenuFilterConditionDraft {
    operator: NgbFilterOperator;
    value: unknown;
}
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?: unknown, options?: {
    requiresValue?: (operator: NgbFilterOperator) => boolean;
}): NgbCompositeFilterDescriptor;

type ColumnType = 'text' | 'number' | 'email' | 'boolean' | 'date' | 'select';
interface ColumnDef<T = any> {
    /** key of the property on your row object */
    field: Extract<keyof T, string>;
    /** human‐readable header text */
    header: string;
    /** Optional tooltip/title for the header cell; defaults to header text. */
    title?: string;
    /** Optional tooltip/title for body cells; defaults to the cell text. */
    cellTitle?: string | ((row: T) => string);
    /** enable clicking to sort */
    sortable?: boolean;
    /** enable filtering on this column */
    filterable?: 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: unknown;
    }>;
    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;

type NgbDataGridSortDirection = 'asc' | 'desc';
interface NgbDataGridSortDescriptor {
    field: string;
    direction: NgbDataGridSortDirection;
}
interface NgbDataGridGroupDescriptor {
    field: string;
    dir?: NgbDataGridSortDirection;
    aggregates?: NgbDataGridAggregateDescriptor[];
}
interface NgbDataGridGroupChange {
    group: NgbDataGridGroupDescriptor[];
}
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[];
    group?: NgbDataGridGroupDescriptor[];
    filter?: NgbCompositeFilterDescriptor;
    globalFilter?: string;
}
type NgbDataGridAggregateFunction = 'count' | 'sum' | 'average' | 'avg' | 'min' | 'max';
type NgbDataGridAggregateType = NgbDataGridAggregateFunction;
interface NgbDataGridAggregateDescriptor {
    field: string;
    aggregate: NgbDataGridAggregateFunction;
}
type NgbDataGridAggregateResults = Record<string, Partial<Record<NgbDataGridAggregateFunction, number | string | Date | null>>>;
interface NgbDataGridGroupingSettings {
    showFooter?: boolean;
    stickyHeaders?: boolean;
    stickyFooters?: boolean;
}
interface NgbDataGridProcessOptions<T = unknown> {
    state?: NgbDataGridState | null;
    aggregates?: NgbDataGridAggregateDescriptor[];
    groupedData?: NgbDataGridGroupResult<T>[] | null;
    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;
    groupedData?: NgbDataGridGroupResult<T>[];
}
interface NgbDataGridGroupResult<T = unknown> {
    field: string;
    value: unknown;
    dir: NgbDataGridSortDirection;
    level: number;
    count: number;
    aggregates?: NgbDataGridAggregateResults;
    items: Array<NgbDataGridGroupResult<T> | T>;
}
type NgbDataGridExportType = 'pdf' | 'excel' | 'both';
type NgbDataGridExportPages = 'all' | 'current' | 'selection';
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;
    pages: NgbDataGridExportPages;
    fileName?: string;
    pdf?: {
        pageSize?: 'A4' | 'Letter' | string;
        landscape?: boolean;
        margins?: [number, number, number, number];
    };
    excel?: {
        sheetName?: string;
    };
}
interface NgbDataGridResponsiveOptions {
    enabled: boolean;
    breakpoints?: {
        mobile?: number;
        tablet?: number;
        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 {
    key: string;
    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 = unknown> {
    /** 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;
}

interface CellCtx<T = any> {
    $implicit: any;
    row: T;
    col: ColumnDef<T>;
    index: number;
}
interface EditCtx<T = any> {
    $implicit: AbstractControl | null;
    control: AbstractControl | null;
    row: T;
    col: ColumnDef<T>;
    form: FormGroup;
    index: number;
    isNew: boolean;
}
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;
}
interface GroupHeaderCtx<T = any> {
    $implicit: NgbDataGridGroupResult<T>;
    group: NgbDataGridGroupResult<T>;
    field: string;
    value: unknown;
    items: Array<NgbDataGridGroupResult<T> | T>;
    level: number;
    count: number;
    aggregates: NgbDataGridAggregateResults;
}
interface GroupColumnCtx<T = any> extends GroupHeaderCtx<T> {
    col: ColumnDef<T>;
}
declare class NgbCellTemplate<T = any> {
    readonly template: TemplateRef<CellCtx<T>>;
    field: string;
    constructor(template: TemplateRef<CellCtx<T>>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbCellTemplate<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbCellTemplate<any>, "ng-template[ngbCell]", never, { "field": { "alias": "ngbCell"; "required": false; }; }, {}, never, never, true, never>;
}
declare class NgbEditorTemplate<T = any> {
    readonly template: TemplateRef<EditCtx<T>>;
    field: string;
    constructor(template: TemplateRef<EditCtx<T>>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbEditorTemplate<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbEditorTemplate<any>, "ng-template[ngbEditor]", never, { "field": { "alias": "ngbEditor"; "required": false; }; }, {}, never, never, true, never>;
}
declare class NgbFilterTemplate<T = any> {
    readonly template: TemplateRef<FilterCtx<T>>;
    field: string;
    constructor(template: TemplateRef<FilterCtx<T>>);
    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>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbGlobalFilterTemplate, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbGlobalFilterTemplate, "ng-template[ngbGlobalFilter]", never, {}, {}, never, never, true, never>;
}
declare class NgbRowDetailTemplate<T = any> {
    readonly template: TemplateRef<{
        $implicit: T;
        index: number;
    }>;
    constructor(template: TemplateRef<{
        $implicit: T;
        index: number;
    }>);
    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>;
}
declare class NgbDataGridGroupHeaderTemplateDirective<T = any> {
    readonly template: TemplateRef<GroupHeaderCtx<T>>;
    constructor(template: TemplateRef<GroupHeaderCtx<T>>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDataGridGroupHeaderTemplateDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDataGridGroupHeaderTemplateDirective<any>, "ng-template[ngbDatagridGroupHeaderTemplate], ng-template[ngbGroupHeader]", never, {}, {}, never, never, true, never>;
}
declare class NgbDataGridGroupHeaderColumnTemplateDirective<T = any> {
    readonly template: TemplateRef<GroupColumnCtx<T>>;
    field: string;
    set legacyField(value: string);
    constructor(template: TemplateRef<GroupColumnCtx<T>>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDataGridGroupHeaderColumnTemplateDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDataGridGroupHeaderColumnTemplateDirective<any>, "ng-template[ngbDatagridGroupHeaderColumnTemplate], ng-template[ngbGroupHeaderColumn]", never, { "field": { "alias": "ngbDatagridGroupHeaderColumnTemplate"; "required": false; }; "legacyField": { "alias": "ngbGroupHeaderColumn"; "required": false; }; }, {}, never, never, true, never>;
}
declare class NgbDataGridGroupFooterTemplateDirective<T = any> {
    readonly template: TemplateRef<GroupColumnCtx<T>>;
    field: string;
    set legacyField(value: string);
    constructor(template: TemplateRef<GroupColumnCtx<T>>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbDataGridGroupFooterTemplateDirective<any>, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbDataGridGroupFooterTemplateDirective<any>, "ng-template[ngbDatagridGroupFooterTemplate], ng-template[ngbGroupFooter]", never, { "field": { "alias": "ngbDatagridGroupFooterTemplate"; "required": false; }; "legacyField": { "alias": "ngbGroupFooter"; "required": false; }; }, {}, never, never, true, never>;
}
/** Handy constant to import in consumer apps */
declare const DATAGRID_TEMPLATE_DIRECTIVES: (typeof NgbCellTemplate | typeof NgbFilterTemplate | typeof NgbGlobalFilterTemplate | typeof NgbPagerTemplate | typeof NgbDataGridGroupHeaderTemplateDirective)[];

type NgbDatagridRowId = unknown;
type NgbDatagridTrackByFn<T> = (index: number, row: T) => NgbDatagridRowId;
interface NgbDatagridEditService<T> {
    /**
     * Create a new row in the provided data set.
     * Implementations may mark the row as "new" until `saveChanges` is called.
     */
    create(data: readonly T[], newRow: T, rowIndex: number, rowId: NgbDatagridRowId): T[];
    /**
     * Update an existing row in the provided data set.
     * Implementations may snapshot the original row to support `cancelChanges` and `hasChanges`.
     */
    update(data: readonly T[], updatedRow: T, rowIndex: number, rowId: NgbDatagridRowId): T[];
    /**
     * Remove a row from the provided data set.
     */
    remove(data: readonly T[], rowIndex: number, rowId: NgbDatagridRowId): T[];
    /**
     * Used by the datagrid while editing to compute a new row instance.
     * Default behavior is a shallow merge of the values into the row.
     */
    assignValues(row: T, values: Partial<T>): T;
    /**
     * Whether this row is considered newly created (not yet saved).
     */
    isNew(rowId: NgbDatagridRowId): boolean;
    /**
     * Whether the row differs from its captured baseline (after `update`/`create` starts tracking).
     */
    hasChanges(rowId: NgbDatagridRowId, currentRow: T): boolean;
    /**
     * Commit current changes (and clear tracking state) for the row.
     */
    saveChanges(data: readonly T[], rowIndex: number, rowId: NgbDatagridRowId, currentRow: T): T[];
    /**
     * Revert tracked changes for the row (or remove it if it was new).
     */
    cancelChanges(data: readonly T[], rowIndex: number, rowId: NgbDatagridRowId): T[];
}
declare class NgbDatagridDefaultEditService<T> implements NgbDatagridEditService<T> {
    private originals;
    private newRows;
    create(data: readonly T[], newRow: T, _rowIndex: number, rowId: NgbDatagridRowId): T[];
    update(data: readonly T[], updatedRow: T, rowIndex: number, rowId: NgbDatagridRowId): T[];
    remove(data: readonly T[], rowIndex: number, rowId: NgbDatagridRowId): T[];
    assignValues(row: T, values: Partial<T>): T;
    isNew(rowId: NgbDatagridRowId): boolean;
    hasChanges(rowId: NgbDatagridRowId, currentRow: T): boolean;
    saveChanges(data: readonly T[], _rowIndex: number, rowId: NgbDatagridRowId, _currentRow: T): T[];
    cancelChanges(data: readonly T[], rowIndex: number, rowId: NgbDatagridRowId): T[];
    private replaceRow;
    private removeRow;
}

interface ExportButtonContext {
    $implicit: (kind: 'pdf' | 'excel') => void;
}
declare class ExportButtonDirective {
    readonly templateRef: TemplateRef<ExportButtonContext>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ExportButtonDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<ExportButtonDirective, "[ngbExportButton]", never, {}, {}, never, never, true, never>;
}

interface HighlightItem {
    row: NgbDatagridRowId;
    columnKey?: unknown;
}
type RowKeyFn = (row: unknown, rowIndex: number) => NgbDatagridRowId;
type ColKeyFn = (column: unknown, columnIndex: number) => unknown;
declare class NgbGridHighlightDirective implements OnInit, OnChanges {
    private grid;
    rowKey?: string | RowKeyFn;
    highlightColumnIndex?: string | ColKeyFn;
    highlightedIndex: HighlightItem[];
    constructor(grid: Datagrid<unknown>);
    ngOnInit(): void;
    ngOnChanges(_ch: SimpleChanges): void;
    private apply;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbGridHighlightDirective, [{ optional: true; }]>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbGridHighlightDirective, "[ngbGridHighlight]", never, { "rowKey": { "alias": "ngbGridHighlight"; "required": false; }; "highlightColumnIndex": { "alias": "highlightColumnIndex"; "required": false; }; "highlightedIndex": { "alias": "highlightedIndex"; "required": false; }; }, {}, never, never, true, never>;
}

interface NgbDndDropEvent<T> {
    item: T;
    fromIndex: number;
    toIndex: number;
    fromList: T[];
    toList: T[];
    sameList: boolean;
}
interface DndCanDropPayload<T = unknown> {
    dragItem: T;
    srcList: T[];
    srcIndex: number;
    dstList: T[];
    dstIndex: number;
    isExternal: boolean;
}
/** Guard function; return true to allow, false to block */
type DndCanDropFn<T = unknown> = (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<T>;
    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;
    emitDropEvent(event: NgbDndDropEvent<T>): void;
    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 DraftValues<T> = Partial<Record<KeyOf<T>, unknown>>;
type UtilityColumnKind = 'selection' | 'detail' | 'sticky-toggle' | 'actions';
type StackedGroup = 'start' | 'center' | 'end';
type MultiCheckboxOption = {
    label: string;
    value: unknown;
};
type GroupSortDir = 'asc' | 'desc';
interface NgbDatagridGroupRenderRow<T> {
    kind: 'group';
    key: string;
    group: NgbDataGridGroupResult<T>;
    collapsed: boolean;
    level: number;
    startIndex: number;
}
interface NgbDatagridGroupFooterRenderRow<T> {
    kind: 'group-footer';
    key: string;
    group: NgbDataGridGroupResult<T>;
    level: number;
    startIndex: number;
}
interface NgbDatagridDataRenderRow<T> {
    kind: 'data';
    key: NgbDatagridRowId;
    row: T;
    pagedIndex: number;
    level: number;
}
type NgbDatagridRenderRow<T> = NgbDatagridGroupRenderRow<T> | NgbDatagridGroupFooterRenderRow<T> | NgbDatagridDataRenderRow<T>;
type NgbTableResponsive = true | false | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
interface NgbTableOptions {
    stripedRows?: boolean;
    stripedColumns?: boolean;
    hoverRows?: boolean;
    activeRows?: boolean;
    bordered?: boolean;
    borderless?: boolean;
    small?: boolean;
    groupDividers?: boolean;
    align?: 'top' | 'middle' | 'bottom';
    caption?: string;
    captionSide?: 'top' | 'bottom';
    responsive?: NgbTableResponsive;
    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';
type NgbRowKey = string | ((row: unknown, rowIndex: number) => NgbDatagridRowId);
type NgbColKey = string | ((column: unknown, columnIndex: number) => unknown);
interface NgbSelectionLabels {
    selectAll?: string;
    unselectAll?: string;
    selectRow?: string;
    unselectRow?: string;
}
declare class Datagrid<T = any> implements AfterContentInit, OnChanges {
    /** Column definitions to render */
    private _columns;
    renderTick: number;
    get columns(): ColumnDef<T>[];
    set columns(value: ColumnDef<T>[] | null | undefined);
    /** Row data to display */
    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);
    private _filterOperators?;
    get filterOperators(): Partial<Record<ColumnType, NgbFilterOperator[]>> | undefined;
    set filterOperators(value: Partial<Record<ColumnType, NgbFilterOperator[]>> | undefined);
    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);
    private _groupable;
    get groupable(): boolean | NgbDataGridGroupingSettings;
    set groupable(value: boolean | NgbDataGridGroupingSettings | null | undefined);
    private _group;
    get group(): NgbDataGridGroupDescriptor[];
    set group(value: NgbDataGridGroupDescriptor[] | null | undefined);
    private _groupedData;
    get groupedData(): NgbDataGridGroupResult<T>[] | null;
    set groupedData(value: NgbDataGridGroupResult<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[];
    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. */
    addButtonText: string;
    /** Shows sticky toggle column and keeps pinned rows at the top of the list. */
    stickyRows: boolean;
    /** Enables sticky column header when scrolling. */
    stickyHeader: boolean;
    /** Enables sticky footer when scrolling. */
    stickyFooter: boolean;
    /** Enables scroll table body container */
    scrollable: boolean;
    /** Row height used to stack multiple sticky rows without overlap (px). */
    stickyRowHeight: number;
    /** Header height (px) used to offset sticky rows below the header. */
    stickyHeaderHeight: number;
    /** Footer height (px) used to offset scrollable area. */
    stickyFooterHeight: number;
    /** Bootstrap-like table styling options. */
    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. */
    selectionBehavior: NgbSelectionBehavior;
    /** Keyboard modifier rules for multi-select. */
    selectionKeyMode: NgbSelectionKeyMode;
    /** Enable header select-all checkbox for multiple mode. */
    selectAllEnabled: boolean;
    /** A11y labels for selection controls. */
    selectionA11yLabels: NgbSelectionLabels;
    /** Disable selection for specific rows. */
    selectionDisabledFn?: (row: T, index: number) => boolean;
    /** Highlight items (row/cell). */
    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;
    private _searchHighlightTerm;
    /** When set, matching substrings in visible cells are wrapped with `.grid-search-highlight`. */
    get searchHighlightTerm(): string;
    set searchHighlightTerm(value: string | null | undefined);
    private _searchHighlightFields;
    /** Column fields included in search highlighting; all visible columns when empty. */
    get searchHighlightFields(): string[] | null;
    set searchHighlightFields(value: string[] | null | undefined);
    /** Accessible label announced when expanding a row. */
    expandRowAriaLabel: string;
    /** Accessible label announced when collapsing a row. */
    collapseRowAriaLabel: string;
    /** Accessible label for the PDF export button. */
    exportPdfAriaLabel: string;
    /** Accessible label for the Excel export button. */
    exportExcelAriaLabel: string;
    /** Optional defaults for new rows */
    newRowDefaults: DraftValues<T> | (() => DraftValues<T>) | 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;
    private _exportOptions;
    get exportOptions(): NgbDataGridExportOptions;
    set exportOptions(value: NgbDataGridExportOptions | null | undefined);
    theme: NgbDataGridTheme;
    responsive: NgbDataGridResponsiveOptions | boolean;
    private _trackBy?;
    get trackBy(): NgbDatagridTrackByFn<T> | undefined;
    set trackBy(value: NgbDatagridTrackByFn<T> | undefined);
    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<T[]> | Promise<T[]> | T[];
    dataProviderSelection?: () => T[];
    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;
    }>;
    rowEdit: EventEmitter<{
        row: T;
        index: number;
    }>;
    rowSave: EventEmitter<{
        original: T;
        updated: T;
        index: number;
    }>;
    rowCancel: EventEmitter<{
        row: T;
        index: number;
    }>;
    rowDelete: EventEmitter<{
        row: T;
        index: number;
    }>;
    groupChange: EventEmitter<NgbDataGridGroupChange>;
    sortChange: EventEmitter<{
        active: string | null;
        direction: "asc" | "desc" | "";
    }>;
    filterChange: EventEmitter<NgbCompositeFilterDescriptor>;
    filtersChange: EventEmitter<{
        global: string;
        columns: Record<string, string>;
    }>;
    pageChange: EventEmitter<{
        page: number;
        pageSize: number;
    }>;
    dataStateChange: EventEmitter<NgbDataGridState>;
    selectionChange: EventEmitter<{
        selected: T[];
        lastAction: {
            row: T;
            index: number;
            selected: boolean;
        } | null;
    }>;
    rowReorder: EventEmitter<{
        row: T;
        fromIndex: number;
        toIndex: number;
        data: T[];
    }>;
    columnReorder: EventEmitter<NgbColumnReorderEvent<ColumnDef<T>>>;
    rowDetailTpl?: NgbRowDetailTemplate<T>;
    pagerTpl?: NgbPagerTemplate<T>;
    groupHeaderTpl?: NgbDataGridGroupHeaderTemplateDirective<T>;
    private exporter;
    expanded: Set<number>;
    private fb;
    filterForm: FormGroup;
    globalFilterCtrl: FormControl<string>;
    addingNew: boolean;
    draftNew: DraftValues<T> | null;
    errorsNew: Partial<Record<KeyOf<T>, string>>;
    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<NgbDatagridRowId>;
    selectedRowIds: Set<NgbDatagridRowId>;
    private selectionAnchor;
    private highlightRowMap;
    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, unknown[]>;
    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 renderRowsCache;
    stickyGroupHeaderRows: NgbDatagridGroupRenderRow<T>[];
    stickyGroupFooterRows: NgbDatagridGroupFooterRenderRow<T>[];
    stickyGroupOverlayColumnWidths: number[];
    stickyGroupHeaderTranslateY: number;
    stickyGroupFooterTranslateY: number;
    private resolvedColumnsDirty;
    private visibleColumnsDirty;
    private filteredDirty;
    private sortedDirty;
    private pagedDirty;
    private renderRowsDirty;
    private stickyGroupSyncQueued;
    private rowMetaMap;
    private rowMetaSource;
    private rowMetaTrackBy;
    private filterOperatorsCache;
    private searchHighlightCache;
    private multiCheckboxOptionsCache;
    private multiCheckboxVisibleOptionsCache;
    private stackedColumnsCache;
    private stackedCardGroupsCache;
    private tableClassListCache;
    private responsiveWrapperClassesCache;
    private collapsedGroupKeys;
    private groupRenderRowLookup;
    private groupFooterRenderRowLookup;
    groupDragField: string | null;
    groupPanelDragActive: boolean;
    groupPanelDragDenied: boolean;
    private norm;
    private keyOf;
    private readFieldValue;
    private getDefaults;
    private toDraftValues;
    private formDraftValues;
    private assignDraftValues;
    private patchFieldValue;
    private compareSortValues;
    private readModifierKeys;
    private defaultFor;
    private numberValidator;
    private dateValidator;
    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 invalidateRowIdentityCache;
    private invalidateDataCaches;
    private markGridForCheck;
    private scheduleViewRefresh;
    private ensureRowMetaMap;
    private resolveRowMeta;
    private dataIndexOf;
    private syncColumnOrder;
    isGroupingEnabled(): boolean;
    isGroupingActive(): boolean;
    isColumnGroupable(col: ColumnDef<T>): boolean;
    isFieldGrouped(field: string): boolean;
    groupedColumns(): NgbDataGridGroupDescriptor[];
    groupingSettings(): NgbDataGridGroupingSettings;
    showGroupFooters(): boolean;
    showStickyGroupHeaders(): boolean;
    showStickyGroupFooters(): boolean;
    hasStickyGroupHeaders(): boolean;
    hasStickyGroupFooters(): boolean;
    groupColumnHeader(field: string): string;
    groupHandleAriaLabel(col: ColumnDef<T>): string;
    groupDirectionAriaLabel(descriptor: NgbDataGridGroupDescriptor): string;
    groupRemoveAriaLabel(descriptor: NgbDataGridGroupDescriptor): string;
    groupPanelLabel(): string;
    groupFieldLabel(descriptor: NgbDataGridGroupDescriptor): string;
    groupDirectionLabel(descriptor: NgbDataGridGroupDescriptor): string;
    toggleGroupField(field: string): void;
    addGroupField(field: string, dir?: GroupSortDir, emit?: boolean): void;
    removeGroupField(field: string, emit?: boolean): void;
    toggleGroupDirection(field: string): void;
    private setGroupDescriptors;
    private normalizeGroupDescriptors;
    private syncCollapsedGroups;
    private clearGroupDragState;
    private canAcceptGroupedField;
    onGroupHandleDragStart(event: DragEvent, field: string): void;
    onGroupHandleDragEnd(): void;
    onGroupPanelDragOver(event: DragEvent): void;
    onGroupPanelDragLeave(event: DragEvent): void;
    onGroupPanelDrop(event: DragEvent): void;
    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;
    private groupColumn;
    groupColumnField(col: ColumnDef<T>): string;
    private formatGroupValue;
    groupRowLabel(group: NgbDataGridGroupResult<T>): string;
    groupRowCountLabel(group: NgbDataGridGroupResult<T>): string;
    groupLeadColumnField(group: NgbDataGridGroupResult<T>): string | null;
    isGroupLeadColumn(col: ColumnDef<T>, group: NgbDataGridGroupResult<T>): boolean;
    shouldRenderGroupCell(col: ColumnDef<T>, group: NgbDataGridGroupResult<T>): boolean;
    groupCellColspan(col: ColumnDef<T>, group: NgbDataGridGroupResult<T>): number | null;
    hasGroupHeaderColumnTemplate(field: string): boolean;
    hasGroupFooterTemplate(field: string): boolean;
    groupHeaderColumnTemplate(field: string): NgbDataGridGroupHeaderColumnTemplateDirective<T> | null;
    groupFooterTemplate(field: string): NgbDataGridGroupFooterTemplateDirective<T> | null;
    groupHeaderContext(group: NgbDataGridGroupResult<T>): GroupHeaderCtx<T>;
    groupColumnContext(group: NgbDataGridGroupResult<T>, col: ColumnDef<T>): GroupColumnCtx<T>;
    groupRowIndent(level: number): number;
    private groupLeadColumnSpan;
    private isCoveredByGroupLeadSpan;
    private groupLeadColumnIndex;
    private groupColumnIndex;
    private groupKeyFor;
    isGroupCollapsed(group: NgbDataGridGroupResult<T>, level: number, startIndex: number): boolean;
    toggleGroupCollapsed(group: NgbDataGridGroupResult<T>, level: number, startIndex: number): void;
    private isGroupResult;
    private cloneAggregateDescriptors;
    private cloneAggregateResults;
    private cloneGroupResults;
    getSearchHighlightSegments(value: unknown, field: string): NgbSearchHighlightSegment[];
    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>): MultiCheckboxOption[];
    multiCheckboxVisibleOptions(col: ColumnDef<T>): MultiCheckboxOption[];
    multiCheckboxValueLabel(col: ColumnDef<T>, value: unknown): string;
    private multiCheckboxValueKey;
    ensureMultiCheckboxDraft(col: ColumnDef<T>): unknown[];
    multiCheckboxSelectedCount(col: ColumnDef<T>): number;
    multiCheckboxTotalCount(col: ColumnDef<T>): number;
    isMultiCheckboxChecked(col: ColumnDef<T>, value: unknown): boolean;
    toggleMultiCheckboxValue(col: ColumnDef<T>, value: unknown): 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[];
    get renderRows(): NgbDatagridRenderRow<T>[];
    hasRenderableRows(): boolean;
    private shouldUseLocalDataOperations;
    private localDataOperationsResult;
    private usingProvidedGroupedData;
    private groupingResults;
    private ensureRenderRows;
    private rebuildGroupedRowLookups;
    private groupingSourceRows;
    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;
    onWindowResize(): void;
    private scheduleStickyGroupSync;
    private syncStickyGroupOverlays;
    private collectStickyGroupMeasurements;
    private resolveStickyHeaderRows;
    private resolveStickyFooterRows;
    private measurementStackHeight;
    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;
    onCellMouseDown(ev: MouseEvent, pagedIndex: number, col: ColumnDef<T>): void;
    private tryStartIncellEdit;
    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>): StackedGroup;
    stackedColumnsInGroup(group: StackedGroup): ColumnDef<T>[];
    stackedCardGroups(): StackedGroup[];
    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;
    private withStickyRowsFirst;
    private dataIndexFromPaged;
    private rebuildFilterForm;
    private cellTplQ;
    private editTplQ;
    private filterTplQ;
    private filterMenuTplQ;
    private globalTplQ;
    private groupHeaderColumnTplQ;
    private groupFooterTplQ;
    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;
    groupHeaderColumnTpls: Record<string, NgbDataGridGroupHeaderColumnTemplateDirective<T>>;
    groupFooterTpls: Record<string, NgbDataGridGroupFooterTemplateDirective<T>>;
    private warnedDeclarativeColumns;
    private toRecord;
    export(kind: 'pdf' | 'excel'): Promise<void>;
    private resolveDataset;
    ngAfterContentInit(): void;
    ngOnChanges(ch: SimpleChanges): void;
    private resetEditingState;
    private getRowId;
    private selectedDataRows;
    /** Apply selection ids and refresh checkbox UI (for programmatic / OnPush sync). */
    setSelectionIds(ids: Iterable<NgbDatagridRowId>, 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;
    startEdit(i: number): void;
    saveEdit(i: number): void;
    cancelEdit(i: number): void;
    onNewDraftChange(col: ColumnDef<T>): void;
    validateInto(col: ColumnDef<T>, targetDraft: DraftValues<T> | null, targetErrors: Partial<Record<KeyOf<T>, string>>): void;
    deleteRow(i: number): void;
    trackRow: (index: number, row: T) => unknown;
    private rowKeyValue;
    private colKeyValue;
    isRowHighlighted(row: T, rowIndex: number): boolean;
    isCellHighlighted(row: T, rowIndex: number, column: ColumnDef<T>, colIndex: number): boolean;
    toggleSort(field: Extract<keyof T, string>): void;
    onGlobalFilterChange(): void;
    onColumnFilterChange(): void;
    onDocumentClick(event: MouseEvent): void;
    private isEventInsideSelector;
    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 | string): void;
    onRowDrop(event: NgbDndDropEvent<T>): void;
    asBool(v: unknown): boolean;
    triggerExport(kind: 'pdf' | 'excel'): void;
    isResponsiveEnabled(): boolean;
    isRowSticky(row: T, pagedIndex: number): boolean;
    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;
    toggleSelection(pagedIndex: number, event?: Event): void;
    private emitSelection;
    toggleSelectAllCurrentPage(): void;
    isPageAllSelected(): boolean;
    isPageIndeterminate(): boolean;
    selectAllLabel(): string;
    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; }; "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; }; "groupable": { "alias": "groupable"; "required": false; }; "group": { "alias": "group"; "required": false; }; "groupedData": { "alias": "groupedData"; "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"; "groupChange": "groupChange"; "sortChange": "sortChange"; "filterChange": "filterChange"; "filtersChange": "filtersChange"; "pageChange": "pageChange"; "dataStateChange": "dataStateChange"; "selectionChange": "selectionChange"; "rowReorder": "rowReorder"; "columnReorder": "columnReorder"; }, ["exportButtonDir", "rowDetailTpl", "pagerTpl", "groupHeaderTpl", "cellTplQ", "editTplQ", "filterTplQ", "filterMenuTplQ", "globalTplQ", "groupHeaderColumnTplQ", "groupFooterTplQ", "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 PdfExportOptions {
    pageSize?: 'A4' | 'Letter' | string;
    landscape?: boolean;
    margins?: [number, number, number, number];
}
interface PdfExportPayload {
    fileName: string;
    columns: string[];
    rows: Array<Record<string, unknown>>;
    options?: PdfExportOptions;
}
interface ExcelExportPayload {
    fileName: string;
    sheetName: string;
    columns: Array<{
        key: string;
        title: string;
    }>;
    rows: Array<Record<string, unknown>>;
}
declare abstract class PdfExportAdapter {
    abstract export(p: PdfExportPayload): Promise<void>;
}
declare abstract class ExcelExportAdapter {
    abstract export(p: ExcelExportPayload): Promise<void>;
}
declare class NgbExportService {
    private pdf;
    private excel;
    exportPdf(p: PdfExportPayload): Promise<void>;
    exportExcel(p: ExcelExportPayload): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbExportService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgbExportService>;
}

declare class JsPdfAdapter implements PdfExportAdapter {
    export(payload: PdfExportPayload): Promise<void>;
    private createPdf;
    private resolveMargin;
    private toTableLines;
    private contentStream;
    private chunk;
    private printable;
    private pdfText;
    private serializePdf;
}

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: unknown;
    }>;
    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: unknown;
}
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 ngbGroupData<T>(data: readonly T[] | null | undefined, descriptors: readonly NgbDataGridGroupDescriptor[] | null | undefined): NgbDataGridGroupResult<T>[];
declare function ngbCalculateDataGridAggregates<T>(data: readonly T[] | null | undefined, descriptors: readonly NgbDataGridAggregateDescriptor[] | null | undefined): NgbDataGridAggregateResults;

type DndI18n = {
    listLabel: (name?: string) => string;
    pickedUp: () => string;
    dropped: () => string;
    canceled?: () => string;
    moveToIndex: (pos: number, total: number) => string;
    dropHere: () => string;
    cannotDropHere: () => string;
};
declare const DND_I18N: InjectionToken<DndI18n>;
declare const defaultDndI18n: DndI18n;

interface DndSession<T = unknown> {
    item: T;
    group?: string;
    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>;
}

declare class NgbDndItemDirective<T = unknown> {
    private parentList?;
    private el;
    private state;
    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 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;
    tabIndex: number;
    private sessionId;
    private keyboardDragState;
    private sourceList;
    private resolveIndex;
    private beginDragSession;
    private endDragSession;
    onDragStart(ev: DragEvent): void;
    onDragEnd(): void;
    private moveWithinKeyboardList;
    private emitKeyboardDrop;
    private cancelKeyboardDrag;
    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; }; "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 {
    private node;
    announce(message: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbLiveAnnouncer, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NgbLiveAnnouncer>;
}
declare const DND_LIVE_ANNOUNCE: InjectionToken<((m: string) => void) | null>;

type NgbStepperOrientation = 'horizontal' | 'vertical';
type NgbStepperLabelPosition = 'top' | 'bottom' | 'left' | 'right';
type NgbStepperContentPosition = 'top' | 'bottom';
type NgbStepperTheme = 'bootstrap' | 'material' | 'tailwind';
type NgbStepperState = 'number' | 'done' | 'active' | 'error' | 'disabled' | string;
interface NgbStepperStep {
    /** Unique id for the step, otherwise index is used */
    id?: string;
    /** Simple text label (used when no custom label template is provided) */
    label?: string;
    /** Optional description / helper text */
    description?: string;
    /** Current state of the step (maps to icon + CSS classes) */
    state?: NgbStepperState;
    /** Error message to display when step is invalid and visited */
    errorMessage?: string | null;
    /** Whether this step is optional (used only for styling / a11y text) */
    optional?: boolean;
    /** Whether this step is disabled */
    disabled?: boolean;
}

declare class NgbStepLabelDirective {
    template: TemplateRef<unknown>;
    for?: string | number;
    constructor(template: TemplateRef<unknown>);
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbStepLabelDirective, never>;
    static ɵdir: i0.ɵɵDirectiveDeclaration<NgbStepLabelDirective, "[ngbStepLabel]", never, { "for": { "alias": "ngbStepLabel"; "required": false; }; }, {}, never, never, true, never>;
}

interface NgbStepperSelectionChangeEvent {
    previousIndex: number;
    currentIndex: number;
    step: NgbStepperStep | undefined;
}
declare class NgbStepperComponent implements AfterContentInit {
    /** Steps definition */
    steps: NgbStepperStep[];
    /** Orientation of the stepper */
    orientation: NgbStepperOrientation;
    /** Position of labels around the indicator */
    labelPosition: NgbStepperLabelPosition;
    /** Position of content relative to header (horizontal only) */
    contentPosition: NgbStepperContentPosition;
    /** Allow navigating back to previous steps by clicking header */
    allowRevisit: boolean;
    /** Enable lazy loading of step content (default true) */
    lazy: boolean;
    /** Theme keyword (only CSS classes, no external deps) */
    theme: NgbStepperTheme;
    /** Whether to apply responsive helper class */
    responsive: boolean;
    /** Disable transition / animation helpers */
    disableAnimation: boolean;
    /** Animation duration (ms) for step transitions when enabled */
    animationDuration: number;
    /** Label strings (for i18n) */
    nextLabel: string;
    previousLabel: string;
    resetLabel: string;
    cancelLabel: string;
    optionalLabel: string;
    /** Custom mapping from state -> icon text */
    stateIcons: Record<string, string>;
    /** Current selected index */
    selectedIndex: number;
    /** Emits when selectedIndex changes (programmatically or by user) */
    selectedIndexChange: EventEmitter<number>;
    /** Emits when selection changes with rich event */
    selectionChange: EventEmitter<NgbStepperSelectionChangeEvent>;
    /** Navigation events */
    nextClicked: EventEmitter<number>;
    prevClicked: EventEmitter<number>;
    resetClicked: EventEmitter<void>;
    cancelClicked: EventEmitter<void>;
    /** Custom label template (applied for all steps) */
    stepLabelTplDir?: NgbStepLabelDirective;
    /** Custom icon template for step indicator */
    customIconTpl?: TemplateRef<any>;
    /** Content template; user will typically use <ng-template #stepContent ...> */
    stepContentTpl?: TemplateRef<any>;
    /** Track which steps have been visited */
    private visited;
    /** Used when allowRevisit=false to block earlier steps */
    visitedFrom: number;
    ngAfterContentInit(): void;
    get stepLabelTpl(): TemplateRef<any> | null;
    get labelPositionClass(): string;
    get currentErrorMessage(): string | null;
    stepId(i: number): string;
    contentId(i: number): string;
    private markVisited;
    stepState(i: number): NgbStepperState;
    isStepInError(i: number): boolean;
    indicatorClass(i: number): string;
    defaultIconForState(state: NgbStepperState, index: number): string;
    onHeaderClick(i: number): void;
    onHeaderKeydown(event: KeyboardEvent | Event, i: number): void;
    next(): void;
    prev(): void;
    onReset(): void;
    onCancel(): void;
    private changeIndex;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbStepperComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbStepperComponent, "ngb-stepper", never, { "steps": { "alias": "steps"; "required": false; }; "orientation": { "alias": "orientation"; "required": false; }; "labelPosition": { "alias": "labelPosition"; "required": false; }; "contentPosition": { "alias": "contentPosition"; "required": false; }; "allowRevisit": { "alias": "allowRevisit"; "required": false; }; "lazy": { "alias": "lazy"; "required": false; }; "theme": { "alias": "theme"; "required": false; }; "responsive": { "alias": "responsive"; "required": false; }; "disableAnimation": { "alias": "disableAnimation"; "required": false; }; "animationDuration": { "alias": "animationDuration"; "required": false; }; "nextLabel": { "alias": "nextLabel"; "required": false; }; "previousLabel": { "alias": "previousLabel"; "required": false; }; "resetLabel": { "alias": "resetLabel"; "required": false; }; "cancelLabel": { "alias": "cancelLabel"; "required": false; }; "optionalLabel": { "alias": "optionalLabel"; "required": false; }; "stateIcons": { "alias": "stateIcons"; "required": false; }; "selectedIndex": { "alias": "selectedIndex"; "required": false; }; }, { "selectedIndexChange": "selectedIndexChange"; "selectionChange": "selectionChange"; "nextClicked": "nextClicked"; "prevClicked": "prevClicked"; "resetClicked": "resetClicked"; "cancelClicked": "cancelClicked"; }, ["stepLabelTplDir", "customIconTpl", "stepContentTpl"], never, true, never>;
}

declare class NgbSplitterPaneComponent {
    size: string;
    min: string;
    max: string;
    scrollable: boolean;
    collapsible: boolean;
    collapsed: boolean;
    collapsedChange: EventEmitter<boolean>;
    template: TemplateRef<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSplitterPaneComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbSplitterPaneComponent, "ngb-splitter-pane", never, { "size": { "alias": "size"; "required": false; }; "min": { "alias": "min"; "required": false; }; "max": { "alias": "max"; "required": false; }; "scrollable": { "alias": "scrollable"; "required": false; }; "collapsible": { "alias": "collapsible"; "required": false; }; "collapsed": { "alias": "collapsed"; "required": false; }; }, { "collapsedChange": "collapsedChange"; }, never, ["*"], true, never>;
}

declare class NgbSplitterComponent {
    private el;
    panes: QueryList<NgbSplitterPaneComponent>;
    orientation: 'horizontal' | 'vertical';
    handleThickness: number;
    handleIconColor: string;
    verticalMinHeight: string;
    resizable: boolean;
    barColor: string;
    lineColor: string;
    private isDragging;
    private currentHandleIndex;
    constructor(el: ElementRef);
    onMouseMove(event: MouseEvent): void;
    onMouseUp(): void;
    onMouseDown(event: MouseEvent, index: number): void;
    private resize;
    onHandleToggle(event: Event, index: number): void;
    getCollapseIcon(pane: NgbSplitterPaneComponent): string;
    getPaneFlex(pane: NgbSplitterPaneComponent): string;
    private sizeToPercent;
    togglePane(index: number): void;
    getSeparatorAriaOrientation(): 'horizontal' | 'vertical';
    getHandleValueNow(index: number): number | null;
    getHandleValueMin(index: number): number | null;
    getHandleValueMax(index: number): number | null;
    onHandleKeyDown(event: KeyboardEvent, index: number): void;
    private resizeByPercent;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbSplitterComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbSplitterComponent, "ngb-splitter", never, { "orientation": { "alias": "orientation"; "required": false; }; "handleThickness": { "alias": "handleThickness"; "required": false; }; "handleIconColor": { "alias": "handleIconColor"; "required": false; }; "verticalMinHeight": { "alias": "verticalMinHeight"; "required": false; }; "resizable": { "alias": "resizable"; "required": false; }; "barColor": { "alias": "barColor"; "required": false; }; "lineColor": { "alias": "lineColor"; "required": false; }; }, {}, ["panes"], never, true, never>;
}

type NgbSplitterOrientation = 'horizontal' | 'vertical';
interface NgbSplitterPaneSize {
    size?: string;
    min?: string;
    max?: string;
}

interface NgbTypeaheadItem {
    id: string | number;
    label: string;
    value?: any;
    disabled?: boolean;
}
interface NgbTypeaheadI18n {
    placeholder?: string;
    noResults?: string;
    clearSelection?: string;
    clear?: string;
    dropdownButtonLabel?: string;
}

declare class NgbTypeaheadComponent implements AfterViewInit, OnChanges, OnDestroy, ControlValueAccessor {
    private host;
    private cdr;
    data: NgbTypeaheadItem[];
    debounceTime: number;
    characterTyped: number;
    limit: number;
    selectExact: boolean;
    multiSelect: boolean;
    matchSelection: boolean;
    showDropdownButton: boolean;
    showClearButton: boolean;
    updateOnBlur: boolean;
    updateOnTab: boolean;
    separator: string | string[];
    chips: boolean;
    vScroll: boolean;
    vItemSize: number;
    itemTemplate?: any;
    i18n?: NgbTypeaheadI18n;
    projectedItemTemplate?: any;
    completeMethod: EventEmitter<string>;
    onSelect: EventEmitter<NgbTypeaheadItem>;
    onUnselect: EventEmitter<NgbTypeaheadItem>;
    onAdd: EventEmitter<NgbTypeaheadItem>;
    onFocus: EventEmitter<FocusEvent>;
    onBlur: EventEmitter<FocusEvent>;
    onDropdownClick: EventEmitter<MouseEvent>;
    onClear: EventEmitter<Event>;
    onInputKeydown: EventEmitter<KeyboardEvent>;
    onKeyUp: EventEmitter<KeyboardEvent>;
    onShow: EventEmitter<Event>;
    onHide: EventEmitter<Event>;
    onLazyLoad: EventEmitter<void>;
    selectedItems: EventEmitter<NgbTypeaheadItem[]>;
    selectionChange: EventEmitter<NgbTypeaheadItem[]>;
    onChange: EventEmitter<string>;
    onScrollEvent: EventEmitter<void>;
    scroller: ElementRef<HTMLElement>;
    inputEl?: ElementRef<HTMLInputElement>;
    itemButtons?: QueryList<ElementRef<HTMLButtonElement>>;
    disabled: boolean;
    query: string;
    filtered: NgbTypeaheadItem[];
    visible: NgbTypeaheadItem[];
    selected: NgbTypeaheadItem[];
    overlayVisible: boolean;
    private openedByDropdown;
    private hasSearched;
    activeIndex: number;
    private inputFocused;
    private pointerDownInside;
    private lastFilterTerm;
    private keepOpenOnEmpty;
    readonly overlayId: string;
    viewportHeight: number;
    itemHeight: number;
    beforePadding: number;
    afterPadding: number;
    private viewportStartIndex;
    private debounceId?;
    private onControlChange;
    private onControlTouched;
    private controlValue;
    ngAfterViewInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    ngOnDestroy(): void;
    constructor(host: ElementRef<HTMLElement>, cdr: ChangeDetectorRef);
    onDocumentMouseDown(event: MouseEvent): void;
    onDocumentFocusIn(event: FocusEvent): void;
    get activeDescendantId(): string | null;
    get showNoResults(): boolean;
    get displayQuery(): string;
    get selectionSummary(): string;
    get resolvedItemTemplate(): any;
    writeValue(value: any): void;
    private applyControlValue;
    registerOnChange(fn: any): void;
    registerOnTouched(fn: any): void;
    setDisabledState(isDisabled: boolean): void;
    onInput(value: string): void;
    onNativeInput(event: Event): void;
    onKeydown(event: KeyboardEvent): void;
    onKeyup(event: KeyboardEvent): void;
    onInputFocus(event: FocusEvent): void;
    onInputBlur(event: FocusEvent): void;
    onScroll(event: Event): void;
    selectItem(item: NgbTypeaheadItem): void;
    focusInput(): void;
    removeSelected(item: NgbTypeaheadItem): void;
    clearSelection(): void;
    isSelected(item: NgbTypeaheadItem): boolean;
    trackById: (_: number, item: NgbTypeaheadItem) => string | number;
    getOptionId(index: number): string;
    onDropdownButtonClick(event: MouseEvent): void;
    onClearClick(event: Event): void;
    private applyFilter;
    private updateViewport;
    private activatePreferredOption;
    private moveActive;
    private activeGlobalIndex;
    private setActiveGlobalIndex;
    private validateItem;
    private showOverlay;
    private hideOverlay;
    private commitInputOnClose;
    private splitBySeparators;
    private addToken;
    private propagateControlValue;
    private coerceToItem;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTypeaheadComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTypeaheadComponent, "ngb-typeahead", never, { "data": { "alias": "data"; "required": false; }; "debounceTime": { "alias": "debounceTime"; "required": false; }; "characterTyped": { "alias": "characterTyped"; "required": false; }; "limit": { "alias": "limit"; "required": false; }; "selectExact": { "alias": "selectExact"; "required": false; }; "multiSelect": { "alias": "multiSelect"; "required": false; }; "matchSelection": { "alias": "matchSelection"; "required": false; }; "showDropdownButton": { "alias": "showDropdownButton"; "required": false; }; "showClearButton": { "alias": "showClearButton"; "required": false; }; "updateOnBlur": { "alias": "updateOnBlur"; "required": false; }; "updateOnTab": { "alias": "updateOnTab"; "required": false; }; "separator": { "alias": "separator"; "required": false; }; "chips": { "alias": "chips"; "required": false; }; "vScroll": { "alias": "vScroll"; "required": false; }; "vItemSize": { "alias": "vItemSize"; "required": false; }; "itemTemplate": { "alias": "itemTemplate"; "required": false; }; "i18n": { "alias": "i18n"; "required": false; }; }, { "completeMethod": "completeMethod"; "onSelect": "onSelect"; "onUnselect": "onUnselect"; "onAdd": "onAdd"; "onFocus": "onFocus"; "onBlur": "onBlur"; "onDropdownClick": "onDropdownClick"; "onClear": "onClear"; "onInputKeydown": "onInputKeydown"; "onKeyUp": "onKeyUp"; "onShow": "onShow"; "onHide": "onHide"; "onLazyLoad": "onLazyLoad"; "selectedItems": "selectedItems"; "selectionChange": "selectionChange"; "onChange": "onChange"; "onScrollEvent": "onScrollEvent"; }, ["projectedItemTemplate"], never, true, never>;
}

type NgbTreeType = 'text' | 'json';
interface NgbTreeNode {
    id: string;
    label: string;
    children?: NgbTreeNode[];
    expanded?: boolean;
    selected?: boolean;
    disabled?: boolean;
}
interface NgbTreeI18n {
    treeLabel?: string;
    expand?: string;
    collapse?: string;
    expandAll?: string;
    collapseAll?: string;
    select?: string;
}

declare class NgbTreeComponent {
    nodes: NgbTreeNode[];
    type: NgbTreeType;
    showCheckbox: boolean;
    i18n?: NgbTreeI18n;
    expandIcon: string;
    collapseIcon: string;
    plusIcon: string;
    minusIcon: string;
    expand: EventEmitter<NgbTreeNode>;
    collapse: EventEmitter<NgbTreeNode>;
    expandAll: EventEmitter<void>;
    collapseAll: EventEmitter<void>;
    selectionChange: EventEmitter<NgbTreeNode[]>;
    nodeButtons: QueryList<ElementRef<HTMLButtonElement>>;
    trackById: (_: number, node: NgbTreeNode) => string;
    hasChildren(node: NgbTreeNode): boolean;
    toggleNode(node: NgbTreeNode): void;
    toggleSelection(node: NgbTreeNode, value: boolean): void;
    expandAllNodes(): void;
    collapseAllNodes(): void;
    onNodeKeydown(event: KeyboardEvent, node: NgbTreeNode): void;
    private focusSibling;
    private setExpanded;
    private collectSelection;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbTreeComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<NgbTreeComponent, "ngb-tree", never, { "nodes": { "alias": "nodes"; "required": false; }; "type": { "alias": "type"; "required": false; }; "showCheckbox": { "alias": "showCheckbox"; "required": false; }; "i18n": { "alias": "i18n"; "required": false; }; "expandIcon": { "alias": "expandIcon"; "required": false; }; "collapseIcon": { "alias": "collapseIcon"; "required": false; }; "plusIcon": { "alias": "plusIcon"; "required": false; }; "minusIcon": { "alias": "minusIcon"; "required": false; }; }, { "expand": "expand"; "collapse": "collapse"; "expandAll": "expandAll"; "collapseAll": "collapseAll"; "selectionChange": "selectionChange"; }, never, never, true, never>;
}

type NgbChip = {
    id: string | number;
    label: string;
    disabled?: boolean;
};
declare class NgbChipsComponent {
    items: NgbChip[];
    removable: boolean;
    ariaLabel?: string;
    removeLabel?: string;
    remove: EventEmitter<NgbChip>;
    trackById: (_: number, item: NgbChip) => string | number;
    static ɵfac: i0.ɵɵFactoryDeclaration<NgbChipsComponent, never>;
    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 { 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, NgbDataGridGroupFooterTemplateDirective, NgbDataGridGroupHeaderColumnTemplateDirective, NgbDataGridGroupHeaderTemplateDirective, NgbDataSparklineComponent, NgbDatagridButtonDirective, NgbDatagridColumnChooserToolComponent, NgbDatagridControlDirective, NgbDatagridDefaultEditService, NgbDatagridFieldShellComponent, NgbDatagridFilterToolComponent, NgbDatagridFloatingPanelDirective, NgbDatagridLayoutToolbarComponent, NgbDatagridLayoutToolbarSpacerComponent, NgbDatagridSortToolComponent, NgbDatagridSurfaceCardComponent, NgbDatagridThemePickerComponent, NgbDndHandleDirective, NgbDndItemDirective, NgbDndListDirective, NgbDndState, NgbEditorTemplate, NgbExportService, NgbFilterMenuTemplate, NgbFilterTemplate, NgbGlobalFilterTemplate, NgbGridChartComponent, NgbGridColumnDirective, NgbGridHighlightDirective, 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, ngbGroupData, ngbIsCompositeFilter, ngbOperatorRequiresFilterValue, ngbPagerButtonCountForDensity, ngbResolveDatagridPagerSettings, ngbResolvePageableSettings, ngbResolvePagerDensity, ngbResolvePagerPageSizeOptions, ngbResolvePagerSettings, ngbSetFieldFilter };
export type { CellCtx, ColumnDef, ColumnType, DndCanDropFn, DndCanDropPayload, DndI18n, DndSession, EditCtx, ExcelExportPayload, ExportButtonContext, FilterCtx, GlobalFilterCtx, GroupColumnCtx, GroupHeaderCtx, HighlightItem, NgbAdvancedSearchField, NgbAdvancedSearchOperator, NgbAdvancedSearchRule, NgbChip, NgbColKey, NgbColumnFilterType, NgbColumnReorderEvent, NgbColumnReorderOptions, NgbColumnSelectionChartOptions, NgbCompositeFilterDescriptor, NgbDataAggregate, NgbDataChartConfig, NgbDataChartSeries, NgbDataChartType, NgbDataDimensionDef, NgbDataGridAggregateDescriptor, NgbDataGridAggregateFunction, NgbDataGridAggregateResults, NgbDataGridAggregateType, NgbDataGridDataResult, NgbDataGridExportOptions, NgbDataGridExportPages, NgbDataGridExportType, NgbDataGridGroupChange, NgbDataGridGroupDescriptor, NgbDataGridGroupResult, NgbDataGridGroupingSettings, NgbDataGridProcessOptions, NgbDataGridResponsiveOptions, NgbDataGridSortDescriptor, NgbDataGridSortDirection, NgbDataGridState, NgbDataGridTheme, NgbDataGridThemeOption, NgbDataLayoutMode, NgbDataMetricDef, NgbDatagridButtonVariant, NgbDatagridEditService, NgbDatagridFloatingPanelPlacement, NgbDatagridLabels, NgbDatagridPageableSettings, NgbDatagridPagerDensity, NgbDatagridPagerPosition, NgbDatagridPagerType, NgbDatagridRowId, 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, PdfExportOptions, PdfExportPayload };