import { AfterViewInit, OnChanges, EventEmitter, ElementRef } from '@angular/core';
import { Column, GridOptions, GridNexaPreset, GridNexaStateStorageOptions, GridNexaSummaryOptions, GridNexaSavedViewsOptions, GridNexaCommandPaletteOptions, GridNexaChangeReviewOptions, GridNexaValidationOptions, GridNexaDiagnosticsOptions, MergedHeader, ColumnFilterModel, AdvancedFilterModel, PivotAggregation, GridTransaction, GridNexaAiOptions, ServerSideOperationState } from '@gridnexa/core';
export * from '@gridnexa/core';

interface GridNexaAngularOptions<T = Record<string, unknown>> extends GridOptions<T> {
    pageSize?: number;
    groupBy?: keyof T & string;
}
declare class GridNexaAngularComponent<T = Record<string, unknown>> implements AfterViewInit, OnChanges {
    columns: Column<T>[];
    rows: T[];
    className: string | undefined;
    theme: GridNexaAngularOptions<T>["theme"];
    density: GridNexaAngularOptions<T>["density"];
    height: number | string | undefined;
    unstyled: boolean;
    classNames: GridNexaAngularOptions<T>["classNames"];
    preset: GridNexaPreset | undefined;
    stateStorage: GridNexaStateStorageOptions | undefined;
    summaries: GridNexaSummaryOptions | undefined;
    views: GridNexaSavedViewsOptions | undefined;
    commandPalette: GridNexaCommandPaletteOptions | undefined;
    changeReview: GridNexaChangeReviewOptions | undefined;
    validation: GridNexaValidationOptions | undefined;
    diagnostics: GridNexaDiagnosticsOptions | undefined;
    loading: boolean;
    error: unknown;
    emptyState: unknown;
    toolbar: GridNexaAngularOptions<T>["toolbar"];
    footer: GridNexaAngularOptions<T>["footer"];
    sidePanel: GridNexaAngularOptions<T>["sidePanel"];
    fillWidth: GridNexaAngularOptions<T>["fillWidth"];
    columnTools: unknown;
    icons: Record<string, unknown> | undefined;
    textDisplay: unknown;
    createRow: (() => T) | undefined;
    apiRef: {
        current: unknown;
    } | undefined;
    getRowClassName: GridNexaAngularOptions<T>["getRowClassName"];
    getCellClassName: GridNexaAngularOptions<T>["getCellClassName"];
    getHeaderClassName: GridNexaAngularOptions<T>["getHeaderClassName"];
    mergedHeaders: MergedHeader[] | undefined;
    rowNumbers: boolean | undefined;
    checkboxSelection: boolean;
    enableRangeSelection: boolean;
    enableFillHandle: boolean;
    enableUndoRedo: boolean;
    enableRowReorder: boolean;
    rowReorderPosition: GridNexaAngularOptions<T>["rowReorderPosition"];
    quickFilterText: string;
    columnFilters: Record<string, ColumnFilterModel> | undefined;
    externalFilter: GridNexaAngularOptions<T>["externalFilter"];
    advancedFilter: GridNexaAngularOptions<T>["advancedFilter"];
    advancedFilterModel: AdvancedFilterModel | null | undefined;
    pageSize: number | undefined;
    groupBy: keyof T & string | undefined;
    pivotBy: keyof T & string | undefined;
    pivotValueColumns: Array<keyof T & string> | undefined;
    pivotAggregation: PivotAggregation;
    getRowId: GridNexaAngularOptions<T>["getRowId"];
    getTreeDataPath: GridNexaAngularOptions<T>["getTreeDataPath"];
    masterDetailRenderer: GridNexaAngularOptions<T>["masterDetailRenderer"];
    transaction: GridTransaction<T> | undefined;
    localeText: Record<string, string> | undefined;
    ai: GridNexaAiOptions | undefined;
    rowSelectionChange: EventEmitter<T[]>;
    selectionChanged: EventEmitter<{
        selectedRows: T[];
        selectedRowIds: Array<string | number>;
    }>;
    rowSelected: EventEmitter<{
        row: T;
        rowIndex: number;
        selected: boolean;
        selectedRows: T[];
    }>;
    selectedRowChange: EventEmitter<{
        row: T | null;
        rowIndex: number | null;
        selectedRows: T[];
    }>;
    rowOrderChange: EventEmitter<{
        rows: T[];
        movedRow: T;
        sourceIndex: number;
        targetIndex: number;
    }>;
    cellClick: EventEmitter<{
        row: T;
        rowIndex: number;
        column: Column<T>;
    }>;
    cellDoubleClick: EventEmitter<{
        row: T;
        rowIndex: number;
        column: Column<T>;
    }>;
    cellValueChange: EventEmitter<{
        row: T;
        rowIndex: number;
        column: Column<T>;
        oldValue: unknown;
        newValue: unknown;
    }>;
    cellEditStart: EventEmitter<{
        row: T;
        rowIndex: number;
        column: Column<T>;
        value: unknown;
    }>;
    cellEditStop: EventEmitter<{
        row: T;
        rowIndex: number;
        column: Column<T>;
        oldValue: unknown;
        newValue: unknown;
    }>;
    sortChanged: EventEmitter<{
        columnId: string;
        direction: "asc" | "desc";
    }[]>;
    filterChanged: EventEmitter<Record<string, ColumnFilterModel>>;
    columnMoved: EventEmitter<{
        columnId: string;
        sourceIndex: number;
        targetIndex: number;
        columnIds: string[];
    }>;
    columnResized: EventEmitter<{
        columnId: string;
        width: number;
    }>;
    columnVisible: EventEmitter<{
        columnId: string;
        visible: boolean;
        hiddenColumnIds: string[];
    }>;
    columnPinned: EventEmitter<{
        columnId: string;
        pinned: "left" | "right" | null;
    }>;
    saveAll: EventEmitter<{
        rows: T[];
        selectedRows: T[];
        visibleRows: T[];
        reason: "toolbar" | "api";
    }>;
    dataChange: EventEmitter<{
        rows: T[];
        previousRows: T[];
        reason: string;
    }>;
    rowAdd: EventEmitter<{
        row: T;
        rowIndex: number;
        rows: T[];
    }>;
    rowDelete: EventEmitter<{
        row: T;
        rowIndex: number;
        rows: T[];
        remainingRows: T[];
    }>;
    rowsDelete: EventEmitter<{
        rows: T[];
        rowIndexes: number[];
        remainingRows: T[];
    }>;
    advancedFilterModelChange: EventEmitter<AdvancedFilterModel | null>;
    pivotModelChange: EventEmitter<{
        groupBy?: keyof T & string;
        pivotBy?: keyof T & string;
        pivotValueColumns: Array<keyof T & string>;
        pivotAggregation: PivotAggregation;
    }>;
    serverSideOperation: EventEmitter<ServerSideOperationState<T>>;
    host?: ElementRef<HTMLElement>;
    private selected;
    private pageIndex;
    private sortState;
    private hiddenColumnIds;
    private activeCell;
    private rangeAnchor;
    private rangeEnd;
    private contextMenu;
    private expandedDetailIds;
    private collapsedGroups;
    private collapsedTreeKeys;
    private findText;
    private toolsOpen;
    private draggedColumnId;
    private draggedRowIndex;
    private columnWidths;
    private aiPrompt;
    private aiPlan;
    private aiBusy;
    private aiError;
    private undoStack;
    private redoStack;
    private hydratedStorageKey;
    private persistTimer;
    ngAfterViewInit(): void;
    ngOnChanges(): void;
    private rowId;
    getRows(): T[];
    setRows(rows: T[]): void;
    addRow(row?: T): void;
    deleteRow(rowIndex: number): void;
    deleteSelectedRows(): void;
    saveAllRows(reason?: "toolbar" | "api"): void;
    exportDiagnostics(): void;
    private createRowValue;
    private emitDataChange;
    private attachApi;
    private presetDefaults;
    private effectiveToolbar;
    private effectiveFooter;
    private effectiveFillWidth;
    private effectivePageSize;
    private effectiveRowNumbers;
    private effectiveCheckboxSelection;
    private effectiveRangeSelection;
    private effectiveFillHandle;
    private effectiveUndoRedo;
    private applyPersistedState;
    private schedulePersistState;
    private applyTransaction;
    private visibleRows;
    private exportRows;
    private setCellValue;
    private undo;
    private redo;
    private fillDown;
    private copyActiveCell;
    private pasteActiveCell;
    private moveRow;
    private reorderRow;
    private moveColumn;
    private makeDisplayRows;
    private isCellInRange;
    private startColumnResize;
    private pinnedStyle;
    private columnWidth;
    private fillWidthColumnIds;
    private tableMinimumWidth;
    private updateAdvancedFilter;
    private updatePivot;
    private resolveColumn;
    private createAiRequest;
    private applyAiAction;
    private applyAiPlan;
    private requestAiPlan;
    private render;
    private renderOverlay;
    private renderToolbar;
    private renderAiCommand;
    private renderTable;
    private renderMergedHeaders;
    private appendGroupRow;
    private appendDetailRow;
    private appendRow;
    private editCell;
    private createEditor;
    private renderContextMenu;
    private renderToolsPanel;
    private select;
    private renderStatus;
    private button;
}

export { GridNexaAngularComponent, type GridNexaAngularOptions };