@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/grid/sy-grid.d.ts

@@ -0,0 +1,2136 @@
+import { EventEmitter } from '../../stencil-public-runtime';
+import { type CsvDownloadOptions, type CsvExportOptions, type CsvExportResult } from './core/export/csv';
+import type { PdfDownloadOptions, PdfExportOptions, PdfExportResult } from './core/export/grid-pdf-export';
+import { type CsvDelimiter } from './core/import/csv';
+import type { SheetToRowDataOptions, XlsxGridSnapshot, XlsxImportResult } from './core/import/xlsx/grid-import-chunk';
+import type { ContextMenuItem, ContextMenuContext } from './core/context-menu/types';
+import { type RowClickButton, type RowClickModifiers } from './core/event';
+import { type GridChunkLoadEventDetail } from './core/loader/chunk-loader';
+import type { GridChunkId } from './core/loader/chunk-contract';
+import { type AuditEntry, type AuditLogFilter } from './core/audit/audit-log';
+import { type CanReadCellFn, type CanEditCellFn } from './core/rbac/cell-access';
+import { type ConditionalFormatRule } from './core/conditional-format/conditional-format';
+import { type ValidationRule } from './core/validation/validation';
+import { type SnapshotMeta } from './core/snapshot/snapshot';
+import { type SnapshotDiff } from './core/snapshot/snapshot-diff';
+import type { CfDraftRule } from './core/conditional-format/cf-builder';
+import type { GridCollabSession, GridCellComment, GridSyncStatus, GridCollaboratorInfo, GridCollabConflict } from './core/collab-types';
+import type { AggFunc } from './core/pipeline/aggregate';
+import type { PivotPanelChangeDetail } from './core/pipeline/pivot-panel';
+import { type InfiniteCacheState } from './core/row-model/block-cache';
+import type { InfiniteRowDatasource } from './core/row-model/datasource';
+import type { ViewportDatasource, ViewportState } from './core/row-model/viewport';
+import type { ServerSideDatasource, ServerSideDisplayRow, ServerSideState } from './core/row-model/server-side';
+import type { ServerStoreRegistry } from './core/row-model/server-store-routes';
+import type { SsrmSelection, SsrmSelectionProjection } from './core/row-model/ssrm-ops-chunk';
+import { type RowDropPosition } from './core/row-drag/reorder';
+import { type RowVirtualizerResult, type VariableRowVirtualizerResult } from './core/virtualizer';
+import { type ActiveSort } from './core/sort-cycle';
+import { type SortModelEntry } from './core/sort-model';
+import { type ActiveFilter, type ActiveFilterMap } from './core/filter-cycle';
+import { type ActivePagination } from './core/pagination-cycle';
+import { type ConditionNode } from './core/filter/condition-builder';
+import type { FilterFormState, FilterUiKind } from './core/filter/filter-ui-types';
+import { type ColumnPinSide } from './core/column/column-pin';
+import type { GridColumnRef, GridColumnGroupRef, GridData, GridLiveObjectEvent, GridEventSource, GridRowId, GridRowRef, SyGridApi } from './core/api';
+import type { GridComponentDefinitionFor, GridComponentErrorDetails, GridComponentKind, GridComponentLocalDefinitions, GridEditorInstance, GridEditorParams, GridExternalFilterCallbacks, GridExternalFilterInstance, GridFilterInstance } from './core/component/contracts';
+import type { GridComponentRegistrationScope } from './core/component/registry';
+import type { GridMountedComponentLookup } from './core/component/runtime';
+import type { GridRendererDiscovery } from './core/component/renderer-controller';
+import { type EmptyStateKind } from './core/empty-state-cycle';
+import { type LoadingMode } from './core/loading-cycle';
+import { type ActiveCell } from './core/cell-cycle';
+import type { ColumnDef, DetailGridOptions, GridColumnGroupDef, GridColumnDef, GridEngineMode, GridEngineTier, GridQueryResult, GridRow, GridSortDirection, GridUnavailableBehaviour } from './core/types';
+import { type GridTheme } from './core/theme/apply';
+import { type GridLocale } from './core/locale/resolve';
+import type { MessageMap } from './core/locale/messages';
+import { type RowSelectionMode, type RowSelectionState } from './core/selection/row';
+import { type SideBarPanelId } from './core/side-bar/side-bar';
+import type { CellRangeBounds } from './core/selection/range';
+import { type EditTransaction, type EditTransactionStore } from './core/edit/transaction';
+import { type ApplyRowTransactionResult, type RowTransaction as RowDataTransaction } from './core/edit/transaction-api';
+import { type ColumnStateEntry, type ApplyColumnStateOptions } from './core/column/column-state';
+import { type GridStateApplyOptions, type SyGridStateApplyReport } from './core/state/grid-state';
+import type { SyGridState } from './core/state/contracts';
+import { type FilterSliceApplyResult, type SyGridFilterSlice } from './core/state/slices/filter';
+import type { GridMutationId, SyGridBatchCommitOptions, SyGridBatchCommitReport, SyGridBatchEditEndEventDetail, SyGridBatchEditStartEventDetail, SyGridBatchStartOptions, SyGridCanonicalChange, SyGridCanonicalRange, SyGridCellRangeInput, SyGridFillEndEventDetail, SyGridFillRangeOptions, SyGridFillRangeReport, SyGridFillStartEventDetail, SyGridDisplayRowInfo, SyGridGroupCheckStatesOptions, SyGridGroupCheckStatesReport, SyGridPendingBatchCell, SyGridPivotColumnsChangedDetail, SyGridPivotCombinationConflictDetail, SyGridPivotCombinationReport, SyGridPivotSecondaryColumns, SyGridPreDestroyedDetail, SyGridRowEditReport, SyGridRowEditStartEventDetail, SyGridRowEditStopEventDetail, SyGridRowValueChangedEventDetail, SyGridServerFlushReport, SyGridServerPivotColumnAudit, SyGridServerPivotColumnsReport, SyGridServerRefreshInput, SyGridServerRefreshResult, SyGridServerStateReport, SyGridServerSelectionState, SyGridServerSelectionSetResult, SyGridServerSelectAllResult, SyGridServerGroupChildrenResult, SyGridRowSpanReport, SyGridCellSpanInfo, SyGridSpanInteractionQuery, SyGridSpanInteractionReport, SyGridSpanConflictEventDetail, SyGridRowDragEventDetail, SyGridRowDragEndDetail, SyGridRowDragCancelDetail, SyGridRowsTransferredDetail, SyGridRowDragStartInput, SyGridRowDragStartResult, SyGridRowDragSessionReport, SyGridDropZoneInput, SyGridDropZoneRegistration, SyGridDropZonesReport, SyGridDragSafetyReport, SyGridPinnedRowSetInput, SyGridPinnedRowsResult, SyGridPinnedRowsReport, SyGridPinnedRowInfo, SyGridPinnedRowsChangedDetail, SyGridRowLayoutRefusedDetail, SyGridAlignedGridsInput, SyGridAlignedGridsReport, SyGridAlignedGridsResult, SyGridReparentRequest, SyGridReparentResult, SyGridTreeReparentedDetail, SyGridFullWidthRenderer, SyGridFullWidthRowInfo, SyGridFullWidthLayoutReport, SyGridServerStoreUpdatedDetail, SyGridServerTransactionEnqueue, SyGridServerTransactionInput, SyGridServerTransactionResult, SyGridServerTransactionSettlement, SyGridChartAccessibleReport, SyGridChartCaptureResult, SyGridChartCreateParams, SyGridChartCreateResult, SyGridChartCrossFilterAction, SyGridChartCrossFilterResult, SyGridChartDestroyResult, SyGridChartEvent, SyGridChartExportRequest, SyGridChartExportResult, SyGridChartFleetReport, SyGridChartMenuReport, SyGridChartPanelReport, SyGridChartPermissions, SyGridChartReport, SyGridChartRestoreResult, SyGridChartSyncMutation, SyGridChartSyncReport, SyGridChartUpdatePatch, SyGridChartUpdateResult, SyGridSpillApplyInput, SyGridSpillApplyResult, SyGridSpillClearResult, SyGridSpillReport, SyGridSpillTarget, SyGridSpillUndoResult, SyGridStateCaptureReport, SyGridStateUpdatedDetail, SyGridWorkbookFlushReport, SyGridWorkbookIntegrityReport, SyGridWorkbookPropagationDetail, SyGridWorkbookPropagationState, SyGridWorkbookSnapshotReport } from './core/api/contracts';
+import type { AutocompleteEditorState } from './core/edit/autocomplete-editor';
+import { type CellRenderer, type CellRenderOutput } from './core/cell/renderer-registry';
+import type { GridWorkbookBinding, GridWorkbookBindingChangedDetail, GridWorkbookBindingErrorDetail } from './core/formula/workbook-binding';
+import type { GridColumnMenuContext, GridColumnMenuItem } from './core/pro-panels/column-menu';
+import type { GridCellNotesAdapter } from './core/notes/cell-notes';
+type GridTreeDataModule = typeof import('./core/tree/tree-data-chunk');
+export interface GridSelectionChangedDetail {
+    mode: RowSelectionMode;
+    selectedRowIds: ReadonlyArray<string | number>;
+    addedIds: ReadonlyArray<string | number>;
+    removedIds: ReadonlyArray<string | number>;
+    serverSide?: SyGridServerSelectionState;
+}
+export interface GridRowHoverChangedDetail {
+    hoveredRowId: string | number | null;
+    previousRowId: string | number | null;
+}
+export interface GridThemeChangedDetail {
+    theme: GridTheme;
+    resolvedTokens: Record<string, string>;
+}
+export interface GridLocaleChangedDetail {
+    locale: GridLocale;
+    resolvedMessages: Record<string, string>;
+}
+export interface GridSortChangedDetail {
+    field: string | null;
+    direction: 'asc' | 'desc' | null;
+    previous: ActiveSort | null;
+    sortModel: SortModelEntry[];
+    previousModel: SortModelEntry[];
+}
+export interface GridFilterChangedDetail {
+    field: string;
+    filter: ActiveFilter | null;
+    activeMap: ActiveFilterMap;
+    customModel?: unknown;
+    previousCustomModel?: unknown;
+    source?: 'ui' | 'api' | 'restore' | 'component';
+}
+export interface GridFilterModifiedDetail {
+    field: string;
+    source: 'component';
+}
+export interface GridPaginationChangedDetail {
+    pageIndex: number;
+    pageSize: number;
+    pageCount: number;
+    totalRows: number;
+    previous: ActivePagination;
+}
+export interface GridQuickFilterChangedDetail {
+    value: string;
+    previous: string;
+}
+export interface GridEmptyStateActionDetail {
+    kind: EmptyStateKind;
+    action: 'clear-filters' | 'reload';
+}
+export interface GridActiveCellChangedDetail {
+    active: ActiveCell | null;
+    previous: ActiveCell | null;
+}
+export interface GridCellClickedDetail<TData = GridData> {
+    row: TData;
+    rowIndex: number;
+    colIndex: number;
+    field: string;
+    button?: RowClickButton;
+    modifiers?: RowClickModifiers;
+    doubleClick?: boolean;
+    dragged?: boolean;
+}
+export interface GridCellDoubleClickedDetail<TData = GridData> {
+    row: TData;
+    rowIndex: number;
+    colIndex: number;
+    field: string;
+    button: RowClickButton;
+    modifiers: RowClickModifiers;
+}
+export interface GridRowClickedDetail<TData = GridData> {
+    row: TData;
+    rowIndex: number;
+    button: RowClickButton;
+    modifiers: RowClickModifiers;
+    doubleClick: boolean;
+    dragged: boolean;
+}
+export interface GridCellEditingRequestedDetail<TData = GridData> {
+    row: TData;
+    rowIndex: number;
+    colIndex: number;
+    field: string;
+}
+export interface GridCellEditingCancelledDetail {
+    rowIndex: number;
+    colIndex: number;
+}
+export interface GridCellEditingCommittedDetail<TValue = unknown> {
+    rowIndex: number;
+    sourceRowIndex?: number;
+    colIndex: number;
+    rowId?: string | number;
+    field?: string;
+    originalValue: TValue;
+    draftValue: TValue;
+    dataWritten?: boolean;
+    changed?: boolean;
+    txId?: number;
+    surface?: 'editor' | 'formula-bar';
+}
+export type GridEditSource = 'local' | 'remote' | 'undo' | 'redo';
+export interface GridCellValueChangedDetail<TData = GridData, TValue = unknown, TContext = unknown> {
+    rowIndex: number;
+    sourceRowIndex?: number;
+    colIndex: number;
+    field: string;
+    rowId: string | number;
+    oldValue: TValue;
+    newValue: TValue;
+    data: Readonly<TData>;
+    context: TContext | undefined;
+    source: GridEditSource;
+    origin?: unknown;
+    txId?: number;
+}
+export interface GridRemoteEditAppliedDetail<TData = GridData, TContext = unknown> {
+    changes: ReadonlyArray<GridCellValueChangedDetail<TData, unknown, TContext>>;
+    origin?: unknown;
+}
+export interface GridPresenceChangedDetail {
+    collaborators: ReadonlyArray<GridCollaboratorInfo>;
+}
+export interface GridFormulaEvaluatedDetail {
+    rowIndex: number;
+    colIndex: number;
+    field: string;
+    formula: string;
+    value: unknown;
+}
+export interface GridFormulaErrorDetail {
+    rowIndex: number;
+    colIndex: number;
+    field: string;
+    formula: string;
+    type: string;
+    description: string;
+}
+export interface GridRowDataChangedDetail<TData = GridData> {
+    added: ReadonlyArray<{
+        row: TData;
+        index: number;
+    }>;
+    updated: ReadonlyArray<{
+        row: TData;
+        previous: TData;
+        index: number;
+    }>;
+    removed: ReadonlyArray<{
+        row: TData;
+        index: number;
+    }>;
+    rejected: ReadonlyArray<{
+        kind: 'add' | 'update' | 'remove';
+        row: unknown;
+        reason: string;
+    }>;
+    txId: number;
+    source?: GridEditSource;
+    origin?: unknown;
+}
+export interface GridXlsxImportedDetail {
+    sheetName: string;
+    snapshot: XlsxGridSnapshot;
+    workbookSheetCount: number;
+}
+export interface GridHistoryChangedDetail {
+    kind: 'recorded' | 'undone' | 'redone' | 'cleared';
+    depth: {
+        undo: number;
+        redo: number;
+    };
+    label?: string;
+}
+export interface GridColumnResizedDetail {
+    colId: string;
+    oldWidth: number;
+    newWidth: number;
+    wasClamped: boolean;
+}
+export interface GridColumnReorderedDetail {
+    colId: string;
+    originIndex: number;
+    finalIndex: number;
+    orderBefore: ReadonlyArray<string>;
+    orderAfter: ReadonlyArray<string>;
+}
+export interface GridColumnVisibilityChangedDetail {
+    colId: string;
+    hidden: boolean;
+    hiddenIds: ReadonlyArray<string>;
+}
+export type SyGridPdfAutoFontOptions = {
+    autoFont?: boolean;
+    fontUrl?: string;
+};
+export type SyGridPdfExportOptions = Omit<PdfExportOptions<GridRow>, 'columns' | 'rows'> & SyGridPdfAutoFontOptions;
+export type SyGridPdfDownloadOptions = Omit<PdfDownloadOptions<GridRow>, 'columns' | 'rows'> & SyGridPdfAutoFontOptions;
+export declare class SyGrid {
+    host: HTMLElement;
+    rowData?: GridData[];
+    columnDefs?: Array<ColumnDef | GridColumnGroupDef>;
+    context?: unknown;
+    components?: GridComponentLocalDefinitions<GridData, unknown, unknown, unknown>;
+    externalFilter?: GridExternalFilterCallbacks<GridData> | GridExternalFilterInstance<GridData, unknown>;
+    componentTimeoutMs: number;
+    csvImport: boolean;
+    pdfFontUrl?: string;
+    pdfAutoFont: boolean;
+    formulas?: boolean;
+    showFormulas?: boolean;
+    formulaBar?: boolean;
+    workbookId?: string;
+    sheetName?: string;
+    defaultColDef?: Partial<ColumnDef>;
+    theme: GridTheme;
+    height?: string | number;
+    locale: GridLocale;
+    pagination: boolean;
+    pageSize: number;
+    pageSizeOptions: readonly number[];
+    rowHeight: number;
+    rowHeightFn?: (index: number, row: GridData) => number;
+    virtualScroll: boolean;
+    quickFilter: boolean;
+    quickFilterText: string;
+    quickFilterPlaceholder?: string;
+    quickFilterMode: 'and' | 'or';
+    quickFilterRegex: boolean;
+    quickFilterDebounce: number;
+    showEmptyState: boolean;
+    emptyMessage?: string;
+    noMatchesMessage?: string;
+    clearFiltersLabel?: string;
+    loading: boolean;
+    loadingMessage?: string;
+    loadingMode: LoadingMode;
+    minLoadingDuration: number;
+    datasource?: InfiniteRowDatasource;
+    cacheBlockSize: number;
+    maxBlocksInCache?: number;
+    serverSideDatasource?: ServerSideDatasource<GridRow>;
+    serverSideGroupCols?: string[];
+    serverSideTransactionWaitMs?: number;
+    viewportDatasource?: ViewportDatasource<GridRow>;
+    rowDragManaged: boolean;
+    spanExportMode: 'origin-once' | 'repeat';
+    rowDragMultiRow: boolean;
+    rowDragText?: (params: {
+        count: number;
+        label: string;
+    }) => string;
+    cellChangeFlash: boolean;
+    enableCellChangeFlash: boolean;
+    contextMenu: boolean;
+    columnMenu: boolean;
+    find: boolean;
+    cellNotes: boolean;
+    cellNotesAdapter?: GridCellNotesAdapter;
+    batchEditToolbar: boolean;
+    columnMenuItems?: (context: GridColumnMenuContext) => readonly GridColumnMenuItem[];
+    contextMenuItemsCallback?: (ctx: ContextMenuContext<GridRow>) => ContextMenuItem<GridRow>[];
+    keyboardNavigation: boolean;
+    rowSelection: RowSelectionMode;
+    getRowId?: (row: Readonly<GridData>) => GridRowId;
+    selectionCheckbox: boolean;
+    showSelectionCheckbox: boolean;
+    shiftClickAdditive: boolean;
+    rowHover: 'css-only' | 'stateful' | 'off';
+    resizableColumns: boolean;
+    reorderableColumns: boolean;
+    columnHiding: boolean;
+    hideableColumns: boolean;
+    autoSizeOnDoubleClick: boolean;
+    multiSort: boolean;
+    enableMultiSort: boolean;
+    headerFilterRow: boolean;
+    conditionBuilder: boolean;
+    virtualizeColumns?: boolean;
+    groupBy?: string | string[];
+    pivotMode: boolean;
+    pivotRowGroupColumns?: string[];
+    pivotColumns?: string[];
+    pivotValueColumns?: string[];
+    pivotAggFuncs?: Record<string, string>;
+    pivotSubtotals: 'off' | 'top' | 'bottom';
+    pivotGrandTotal: 'off' | 'top' | 'bottom';
+    pivotPanelShow: 'always' | 'onlyWhenPivoting' | 'never';
+    pivotPanel: boolean;
+    groupPanel: boolean;
+    getDataPath?: (row: Record<string, unknown>) => readonly string[];
+    treeIdField?: string;
+    treeParentField?: string;
+    treeLabelField?: string;
+    masterDetail: boolean;
+    detailRowHeight: number;
+    detailCellRenderer?: (params: {
+        row: Record<string, unknown>;
+        rowId: string | number;
+    }) => CellRenderOutput;
+    detailGridOptions?: DetailGridOptions;
+    getDetailRowData?: (params: {
+        row: Record<string, unknown>;
+        rowId: string | number;
+    }) => unknown[] | Promise<unknown[]>;
+    detailNestingLevel: number;
+    rangeSelection: boolean;
+    clipboardEscapeFormulae: boolean;
+    statusBar?: boolean | {
+        panels?: ReadonlyArray<{
+            panel: string;
+            align?: string;
+        }>;
+    };
+    sideBar?: boolean | string | {
+        panels?: ReadonlyArray<{
+            id: string;
+        } | string>;
+        defaultOpen?: string;
+    };
+    rows: GridRow[];
+    columns: GridColumnDef[];
+    maxRendered: number;
+    engine: GridEngineMode;
+    proThreshold: number;
+    unavailable: GridUnavailableBehaviour;
+    brandLogo?: string;
+    collaborationRoom?: string;
+    realtimeUrl?: string;
+    collabUserName?: string;
+    collabUserColor?: string;
+    collabPresence: boolean;
+    collabConflictUi: boolean;
+    auditLog: boolean;
+    auditLogMax: number;
+    canReadCell?: CanReadCellFn;
+    maskedCellValue: string;
+    canEditCell?: CanEditCellFn;
+    conditionalFormats?: ConditionalFormatRule[];
+    conditionalFormatUi: boolean;
+    validationRules?: ValidationRule[];
+    invalidEditMode: 'allow' | 'revert' | 'block';
+    maxSnapshots: number;
+    collabPersistence: 'none' | 'indexeddb';
+    queryComplete: EventEmitter<GridQueryResult & {
+        tier: GridEngineTier;
+    }>;
+    sortChanged: EventEmitter<GridSortChangedDetail>;
+    filterChanged: EventEmitter<GridFilterChangedDetail>;
+    filterModified: EventEmitter<GridFilterModifiedDetail>;
+    conditionFilterChanged: EventEmitter<{
+        model: ConditionNode | null;
+    }>;
+    conditionPresetsChanged: EventEmitter<{
+        presets: Array<{
+            name: string;
+            json: string;
+        }>;
+    }>;
+    columnGroupToggled: EventEmitter<{
+        groupId: string;
+        open: boolean;
+    }>;
+    rowGroupToggled: EventEmitter<{
+        key: string | null;
+        expanded: boolean;
+    }>;
+    treeNodeToggled: EventEmitter<{
+        path: readonly string[];
+        expanded: boolean;
+    }>;
+    detailRowToggled: EventEmitter<{
+        rowId: string | number;
+        expanded: boolean;
+    }>;
+    detailRowCreated: EventEmitter<{
+        rowId: string | number;
+        master: GridRow | null;
+    }>;
+    detailRowDestroyed: EventEmitter<{
+        rowId: string | number;
+    }>;
+    rangeSelectionChanged: EventEmitter<{
+        ranges: CellRangeBounds[];
+    }>;
+    toolPanelToggled: EventEmitter<{
+        id: SideBarPanelId;
+        open: boolean;
+    }>;
+    csvImported: EventEmitter<{
+        rowCount: number;
+        columnCount: number;
+    }>;
+    clipboardCopied: EventEmitter<{
+        text: string;
+        ranges: CellRangeBounds[];
+    }>;
+    clipboardPasted: EventEmitter<{
+        applied: number;
+        skipped: number;
+        top: number;
+        left: number;
+        changes: GridCellValueChangedDetail[];
+    }>;
+    paginationChanged: EventEmitter<GridPaginationChangedDetail>;
+    quickFilterChanged: EventEmitter<GridQuickFilterChangedDetail>;
+    emptyStateActionClicked: EventEmitter<GridEmptyStateActionDetail>;
+    activeCellChanged: EventEmitter<GridActiveCellChangedDetail>;
+    cellClicked: EventEmitter<GridCellClickedDetail>;
+    cellDoubleClicked: EventEmitter<GridCellDoubleClickedDetail>;
+    rowClicked: EventEmitter<GridRowClickedDetail>;
+    cellEditingRequested: EventEmitter<GridCellEditingRequestedDetail>;
+    cellEditingCancelled: EventEmitter<GridCellEditingCancelledDetail>;
+    cellEditingCommitted: EventEmitter<GridCellEditingCommittedDetail>;
+    formulaEvaluated: EventEmitter<GridFormulaEvaluatedDetail>;
+    formulaError: EventEmitter<GridFormulaErrorDetail>;
+    workbookBindingChanged: EventEmitter<GridWorkbookBindingChangedDetail>;
+    workbookBindingError: EventEmitter<GridWorkbookBindingErrorDetail>;
+    chunkLoading: EventEmitter<GridChunkLoadEventDetail>;
+    chunkLoaded: EventEmitter<GridChunkLoadEventDetail>;
+    chunkLoadFailed: EventEmitter<GridChunkLoadEventDetail>;
+    componentError: EventEmitter<GridComponentErrorDetails>;
+    rowDataChanged: EventEmitter<GridRowDataChangedDetail>;
+    cellValueChanged: EventEmitter<GridCellValueChangedDetail>;
+    rowMoved: EventEmitter<{
+        fromIndex: number;
+        toIndex: number;
+        row: unknown;
+    }>;
+    rowGroupChanged: EventEmitter<{
+        groupBy: string | null;
+    }>;
+    pivotPanelChanged: EventEmitter<PivotPanelChangeDetail>;
+    pivotChanged: EventEmitter<PivotPanelChangeDetail>;
+    pivotModeChanged: EventEmitter<{
+        pivotMode: boolean;
+    }>;
+    contextMenuItemClicked: EventEmitter<{
+        id: string;
+        rowIndex: number;
+        field?: string;
+    }>;
+    remoteEditApplied: EventEmitter<GridRemoteEditAppliedDetail>;
+    presenceChanged: EventEmitter<GridPresenceChangedDetail>;
+    collabConflictResolved: EventEmitter<GridCollabConflict>;
+    collaboratorJoined: EventEmitter<GridCollaboratorInfo>;
+    collaboratorLeft: EventEmitter<{
+        id: string;
+    }>;
+    syncStatusChanged: EventEmitter<{
+        status: GridSyncStatus;
+    }>;
+    cellCommentsChanged: EventEmitter<{
+        rowId: string;
+        field: string;
+        comments: GridCellComment[];
+    }>;
+    commentMentioned: EventEmitter<{
+        rowId: string;
+        field: string;
+        comment: GridCellComment;
+    }>;
+    auditLogChanged: EventEmitter<{
+        entry: AuditEntry;
+    }>;
+    conditionalFormatsChanged: EventEmitter<{
+        rules: ConditionalFormatRule[];
+    }>;
+    cellValidationFailed: EventEmitter<{
+        rowIndex: number;
+        field: string;
+        value: unknown;
+        message: string;
+    }>;
+    snapshotCaptured: EventEmitter<{
+        id: string;
+        name: string;
+        rowCount: number;
+    }>;
+    snapshotRestored: EventEmitter<{
+        id: string;
+        name: string;
+        rowCount: number;
+    }>;
+    xlsxImported: EventEmitter<GridXlsxImportedDetail>;
+    historyChanged: EventEmitter<GridHistoryChangedDetail>;
+    columnResized: EventEmitter<GridColumnResizedDetail>;
+    columnReordered: EventEmitter<GridColumnReorderedDetail>;
+    columnVisibilityChanged: EventEmitter<GridColumnVisibilityChangedDetail>;
+    selectionChanged: EventEmitter<GridSelectionChangedDetail>;
+    rowHoverChanged: EventEmitter<GridRowHoverChangedDetail>;
+    themeChanged: EventEmitter<GridThemeChangedDetail>;
+    localeChanged: EventEmitter<GridLocaleChangedDetail>;
+    gridObjectChanged: EventEmitter<GridLiveObjectEvent<GridData>>;
+    stateUpdated: EventEmitter<SyGridStateUpdatedDetail>;
+    preDestroyed: EventEmitter<SyGridPreDestroyedDetail>;
+    private liveObjectModel;
+    private liveObjectModelPromise;
+    private liveMutationDepth;
+    private warnedLiveDuplicateRowIds;
+    private warnedLiveInvalidRowIds;
+    private warnedLiveDuplicateColumnIds;
+    private warnedLiveDuplicateColumnGroupIds;
+    private readonly liveRowHeights;
+    private liveRowSnapshotCache;
+    private activeTier;
+    private fallbackReason?;
+    private formulaSheet;
+    private formulaCore;
+    private formulaCoreLoading;
+    private formulaCoreArmed;
+    private readonly workbookBindingHooks;
+    private workbookBindingControllerRef;
+    private workbookBindingPendingReason;
+    private readonly workbookBindingController;
+    private workbookBinding;
+    private formulaVersion;
+    resolvedMessages: MessageMap;
+    private activeSortModel;
+    private get activeSort();
+    private activeFilters;
+    private activeConditionTree;
+    private builderDraft;
+    private builderFocusKey;
+    private conditionPresets;
+    private presetNameDraft;
+    private columnPinned;
+    private dropdownAnchor;
+    private bodyScrollbarWidth;
+    private hScrollLeft;
+    private collapsedGroups;
+    private collapsedRowGroups;
+    private pivotCollapsedRowGroups;
+    customAggFuncs: ReadonlyMap<string, AggFunc<GridRow>>;
+    private warnedAggFuncs;
+    private warnedLargeTextSeed;
+    private collapsedTreeNodes;
+    private warnedTreeGroupConflict;
+    private warnedGroupDetailUnstable;
+    private expandedDetailRows;
+    private rangeState;
+    private contextMenuState;
+    private contextMenuEl;
+    private contextMenuFocused;
+    private contextMenuReturnFocus;
+    cfBuilderOpen: boolean;
+    cfDraftRules: CfDraftRule[];
+    private flashingCells;
+    private flashTimers;
+    private rowDragState;
+    private rowDragCleanup;
+    private rowLayoutVersion;
+    private rowLayoutChunk;
+    private rowLayoutState;
+    private rowLayoutFrame;
+    private rowLayoutKickSeq;
+    private spanConflictSignature;
+    private pinnedRowsFacade;
+    private pinnedRowsVersion;
+    private pinnedFocus;
+    private renderingPinnedBand;
+    private pendingPinnedRows;
+    private fullWidthFacade;
+    private fullWidthVersion;
+    private fullWidthRefusalSignature;
+    private lastBodyRenderWindow;
+    private rowDragBinding;
+    private unmanagedDragTarget;
+    private unmanagedDragSource;
+    private dragLive;
+    private columnDragOverGroupPanel;
+    pivotPanelAnnouncement: string;
+    pivotPanelFocusField: string | null;
+    pivotPanelFocusControl: 'destination' | 'move-up' | 'move-down';
+    private groupPanelEl;
+    private openFilterField;
+    private filterForm;
+    private filterDropdownEl;
+    private filterDropdownReturnFocus;
+    private filterDropdownFocused;
+    private activePagination;
+    private latestPaginatedMeta;
+    private quickFilterValue;
+    private effectiveLoading;
+    private activeCell;
+    private formulaBarDraft;
+    private cellTooltip;
+    private readonly cellTooltipDelay;
+    private readonly headerTooltipDelay;
+    editingCell: ActiveCell | null;
+    editStore: EditTransactionStore;
+    private editCommitInProgress;
+    private incrementalRowDataAssignment;
+    private sourceRowIndexCache;
+    private warnedIdentityEdit;
+    private warnedUnbackedValueSetter;
+    private undoRedoStack;
+    private undoRedoUnsubscribe;
+    collabSession: GridCollabSession | null;
+    private collabGlue;
+    private chunkLoader;
+    private componentManager;
+    private componentManagerPromise;
+    private editorFacade;
+    private componentPopupPlacement;
+    private componentEditorValidationPresenter;
+    private filterFacade;
+    private componentManagerEpoch;
+    private componentManagerFailureReportedEpoch;
+    private componentRegistryRevision;
+    private readonly localGridComponentRegistrations;
+    private lifecycleEditorVersion;
+    private lifecycleEditorRef;
+    private lifecycleEditorCell;
+    private lifecycleEditorAttachTask;
+    private lifecycleEditorHost;
+    private lifecycleEditorSequence;
+    private lifecycleEditorRequestRevision;
+    private lifecycleEditorRequestTask;
+    private lifecycleEditorQueuedRequestRevision;
+    private lifecycleEditorStartTask;
+    private lifecycleEditorAttachmentReady;
+    private lifecycleEditorAttachedWrapper;
+    private lifecycleEditorValidationPresentation;
+    private lifecycleEditorPopupReposition;
+    private lifecycleEditorNavigationTarget;
+    private lifecycleFilterVersion;
+    private componentFilterReconcileSequence;
+    private componentFilterReconcileTask;
+    private componentFilterPeerNotificationTask;
+    private componentFilterPeerNotificationRevision;
+    private componentFilterReconcileInputs;
+    private componentFilterRevision;
+    private componentFilterReadyRevision;
+    private readonly componentFilterValueGetters;
+    private readonly componentFilterModels;
+    private componentFilterDesiredIds;
+    private readonly componentRecentlyDestroyedFilters;
+    private componentFilterChangeBatchDepth;
+    private componentFilterRemoteChangePending;
+    private componentFilterRemoteFlushRevision;
+    private componentFilterRestorePending;
+    private readonly componentFilterHosts;
+    private readonly componentFloatingFilterHosts;
+    private readonly componentFilterHostRefs;
+    private externalFilterApplied;
+    private externalFilterRevision;
+    private externalFilterReadyRevision;
+    private readonly componentRemoteFilterErrors;
+    private readonly componentRowTokens;
+    private componentRowTokenSequence;
+    private componentIdentityIndex;
+    private readonly componentIdentityReportedErrors;
+    private pendingComponentIdentityErrors;
+    private queueComponentIdentityError;
+    private isPivotSubtotalDisplayRow;
+    private componentIdentityRow;
+    private componentObjectToken;
+    private ensureComponentIdentityIndex;
+    private componentRowId;
+    private componentColumnId;
+    private componentLogicalCellExists;
+    private componentFacadeIdentity;
+    private componentRendererCellKey;
+    private sameComponentIdentity;
+    private releaseFocusedLifecycleRenderer;
+    private activeLifecycleRendererIdentity;
+    private focusActiveLifecycleRenderer;
+    private emitComponentError;
+    private componentFilterExecutionMode;
+    private invalidateComponentFilterRuntime;
+    private runComponentFilterChangeBatch;
+    private externalFilterRuntimeReady;
+    private handleComponentFilterChanged;
+    private scheduleLifecycleFilterPeerNotification;
+    private getComponentManager;
+    private disposeComponentManager;
+    private getChunkLoader;
+    private loadExportXlsxChunk;
+    private loadExportPdfChunk;
+    private loadImportXlsxChunk;
+    collabOverlayEl: HTMLElement | null;
+    collabRowIndexCache: {
+        rows: unknown;
+        map: Map<string, number>;
+    } | null;
+    private auditTrail;
+    private canReadWarned;
+    private canEditWarned;
+    private snapshotStore;
+    private snapshotCounter;
+    private syncAuditTrail;
+    onAuditLogChange(): void;
+    onAuditLogMaxChange(): void;
+    onCanReadCellChange(): void;
+    onCanEditCellChange(): void;
+    onMaxSnapshotsChange(): void;
+    private currentAuditRows;
+    private auditEntriesForPublicRead;
+    private recordAudit;
+    private fireRowDataChanged;
+    fireSelectionChanged(detail: GridSelectionChangedDetail, source?: GridEventSource): void;
+    getAuditLog(filter?: AuditLogFilter): Promise<AuditEntry[]>;
+    clearAuditLog(): Promise<void>;
+    getAuditLogAsCsv(filter?: AuditLogFilter): Promise<string>;
+    getAuditLogAsJson(filter?: AuditLogFilter, pretty?: boolean): Promise<string>;
+    exportAuditLogAsCsv(fileName?: string, filter?: AuditLogFilter): Promise<void>;
+    exportAuditLogAsJson(fileName?: string, filter?: AuditLogFilter): Promise<void>;
+    private downloadTextFile;
+    cellCommentIndex: ReadonlyMap<string, {
+        count: number;
+        unresolved: number;
+    }>;
+    commentIndexKey(rowId: string | number, field: string): string;
+    private cellCommentBadge;
+    private cellCommentBadgeFor;
+    seenCommentIds: Set<string>;
+    conflictFlashCells: ReadonlySet<string>;
+    collabConflictToast: string | null;
+    conflictFlashTimers: Map<string, number>;
+    conflictToastTimer: ReturnType<typeof setTimeout> | null;
+    private clearConflictUi;
+    commentPanel: {
+        rowId: string;
+        field: string;
+    } | null;
+    commentPanelAnchor: {
+        x: number;
+        y: number;
+    } | null;
+    commentPanelOffscreen: boolean;
+    commentPanelThread: GridCellComment[];
+    commentPanelInputEl: HTMLTextAreaElement | null;
+    commentPanelRowIndex: number;
+    private openCommentPanelAt;
+    closeCommentPanel(): void;
+    openCellCommentPanel(rowId: string | number, field: string): Promise<void>;
+    closeCellCommentPanel(): Promise<void>;
+    commentWriteAllowed(member: string): boolean;
+    private columnWidths;
+    private columnResizeController;
+    private readonly minimumColumnWidth;
+    private readonly interactiveColumnMinWidth;
+    private readonly compactHeaderControlsWidth;
+    private columnResizePointerId;
+    private columnResizeEscHandler;
+    private columnResizeHandleEl;
+    private columnResizeGuide;
+    private columnResizeGuideStartX;
+    private columnResizeGuideStartWidth;
+    private columnOrder;
+    private columnReorderController;
+    private columnReorderPointerId;
+    private columnReorderEscHandler;
+    private columnReorderDocPointerMoveHandler;
+    private columnReorderDocPointerUpHandler;
+    private columnReorderDocPointerCancelHandler;
+    private columnReorderHeaderEl;
+    private columnReorderHeaderRowEl;
+    private columnReorderPreviewEl;
+    private columnReorderStartRects;
+    private columnReorderStartPointerX;
+    private columnReorderPointerToRightEdge;
+    private columnReorderPointerOffsetX;
+    private columnReorderPointerOffsetY;
+    private columnHidden;
+    private columnVisibilityController;
+    private columnVisibilityChangedUnsubscribe;
+    private columnVisibilityResetUnsubscribe;
+    private columnVisibilityForwardSuppressed;
+    private columnVisibilityEventSource;
+    withColumnVisibilitySource<T>(source: GridEventSource, action: () => T): T;
+    private readonly sortController;
+    private autoSizeCanvasCache;
+    private textEditorState;
+    private numberEditorState;
+    private dateEditorState;
+    private calendarState;
+    private calendarFocusedIso;
+    private calendarKbdNavigated;
+    private calendarAnchor;
+    private selectEditorState;
+    private selectTriggerEl;
+    autocompleteEditorState: AutocompleteEditorState<unknown> | null;
+    autocompleteInputEl: HTMLInputElement | null;
+    autocompleteAnchor: {
+        x: number;
+        y: number;
+        width: number;
+    } | null;
+    private richSelect;
+    private richSelectArming;
+    richSelectTick: number;
+    private richSelectArmed;
+    private armRichSelect;
+    private checkboxEditorState;
+    private checkboxEditorEl;
+    private textareaEditorState;
+    private textareaEditorEl;
+    private largeTextConfig;
+    private largeTextAnchor;
+    private largeTextAnchorEl;
+    private cellRendererRegistry;
+    private cellRendererVersion;
+    private cellRendererWarnedFields;
+    private pendingLifecycleRenderers;
+    private lifecycleRendererReconcileSequence;
+    private lifecycleRendererPresentationVersion;
+    private readonly lifecycleRendererPresentations;
+    private rendererPresentationsByCoordinate;
+    private focusedLifecycleRenderer;
+    private lifecycleRendererFocusSequence;
+    private textEditorEl;
+    selectionState: RowSelectionState;
+    rangeAnchorRowId: string | number | null;
+    private hoverState;
+    private pendingHoverRowId;
+    private hoverRafHandle;
+    private viewportMouseMoveHandler;
+    private viewportMouseLeaveHandler;
+    private viewportHoverEl;
+    private viewportSize;
+    private scrollTop;
+    virtualWindow: RowVirtualizerResult | VariableRowVirtualizerResult | null;
+    private virtualWindowRowCount;
+    private virtualWindowViewportHeight;
+    private columnWindowLive;
+    private scrollPassViewportHeight;
+    private virtualWindowDetailSet;
+    private rowHeightCache;
+    private lastMeasuredRowsRef;
+    private lastMeasuredLayoutSig;
+    private measuringAutoHeight;
+    private autoHeightRenderMode;
+    private autoHeightVersion;
+    private csvWizard;
+    private csvFileInputEl;
+    private csvImportButtonEl;
+    private csvWizardEl;
+    private csvWizardFocused;
+    private detachVirtualScroll;
+    private resizeObserver;
+    viewportEl: HTMLElement | null;
+    infiniteCache: InfiniteCacheState<GridRow> | null;
+    serverSideState: ServerSideState<GridRow> | null;
+    ssrmSelection: SsrmSelection | null;
+    ssrmSelectionProjection: SsrmSelectionProjection | null;
+    ssrmProjectionSource: unknown;
+    viewportState: ViewportState<GridRow> | null;
+    private viewportGen;
+    private serverDisplayRowsCache;
+    private cachedPivot;
+    private serverSideGen;
+    private lastServerFetchWindow;
+    private ssrmRegistry;
+    private ssrmEpoch;
+    private ssrmRegistryEpoch;
+    private ssrmRuntime;
+    private ssrmRefreshFloors;
+    private ssrmDiscardedStaleLandings;
+    private serverPivotResultsStale;
+    private lastFetchedWindow;
+    private infiniteCacheGen;
+    private quickFilterDebounceTimer;
+    private loadingDebouncer;
+    private loadingDebounceTimer;
+    private pendingScrollIntoView;
+    private quickFilterPendingValue;
+    private quickFilterInputEl;
+    getApi<TData = GridData, TContext = unknown, TValue = unknown, TFilterModel = unknown>(): Promise<SyGridApi<TData, TContext, TValue, TFilterModel>>;
+    getColumn<TValue = unknown>(columnId: string): Promise<GridColumnRef<GridData, TValue, unknown> | null>;
+    getColumns(): Promise<ReadonlyArray<GridColumnRef<GridData, unknown, unknown>>>;
+    getColumnGroup(groupId: string): Promise<GridColumnGroupRef<GridData, unknown> | null>;
+    getColumnGroups(): Promise<ReadonlyArray<GridColumnGroupRef<GridData, unknown>>>;
+    getRow(rowId: GridRowId): Promise<GridRowRef<GridData, unknown> | null>;
+    getDisplayedRowAtIndex(index: number): Promise<GridRowRef<GridData, unknown> | null>;
+    forEachRow(callback: (row: GridRowRef<GridData, unknown>) => void): Promise<void>;
+    forEachDisplayedRow(callback: (row: GridRowRef<GridData, unknown>) => void): Promise<void>;
+    private ensureLiveObjects;
+    private publishLiveObjectChange;
+    private publishLiveObjectChanges;
+    private publishLiveRowExpansions;
+    private resolveGridCellValue;
+    private formatGridCellValue;
+    private liveColumnId;
+    private liveColumnSnapshotGraph;
+    private liveRowSnapshotGraph;
+    private liveRowsForPublication;
+    private applyLiveMutation;
+    private cancelledLiveMutation;
+    private completeLiveMutation;
+    private liveWritableColumn;
+    private liveRowWriteAllowed;
+    private applyLiveMutationUnchecked;
+    private setupInternalSubscriptions;
+    private proGateRef;
+    private licenseRevision;
+    private licenseRenderTick;
+    private proGate;
+    engineAwaitingLicense: boolean;
+    private proAllowed;
+    private proWorkAllowed;
+    private proNewWorkAllowed;
+    private proModuleAvailable;
+    private proUiChunks;
+    private readonly proUiChunksArming;
+    private proUiChunkTick;
+    private proUiChunk;
+    private armProUiChunk;
+    private armProUiChunks;
+    private declaredProFilterKind;
+    private loadProUiChunk;
+    private loadProFiltersChunk;
+    private loadProPanelsChunk;
+    private loadRangeSelectionChunk;
+    private acceptProUiChunk;
+    private armProEngineChunks;
+    private groupByDeclared;
+    private treeDeclaredMember;
+    private armGroupPivotChunkForGrouping;
+    private residentGroupPivotChunk;
+    private engineArriving;
+    private treeEngineArriving;
+    private viewportEngineArriving;
+    private pivotWinsOnArrival;
+    private groupEngineStep;
+    private treeEngineStep;
+    private masterDetailEngineStep;
+    private residentEngine;
+    private groupPivotEngine;
+    private treeDataEngine;
+    private masterDetailEngine;
+    private ssrmEngine;
+    private viewportEngine;
+    private proFiltersHost;
+    private proPanelsHost;
+    private columnMenuHost;
+    private findHost;
+    private notesHost;
+    private batchUiHost;
+    private renderNotesToolbar;
+    private renderBatchToolbar;
+    private renderFindToolbar;
+    private renderColumnMenuButton;
+    private rangeSelectionHost;
+    private auditProDeclarations;
+    private proMethod;
+    private proRun;
+    private proRuntimeResident;
+    private licenseHostAttributes;
+    licenseSafePoint(): boolean;
+    initialStateLicenseFeatures: string[] | null;
+    private readonly formulaFreeze;
+    pivotRecomputeHeld: boolean;
+    viewportFeedHeld: boolean;
+    private readonly heldLicenseInits;
+    private readonly collabFreeze;
+    private retireLostFormulaAcceleration;
+    private accelerationPortRef;
+    private accelerationPort;
+    notifyAccelerationPort(): void;
+    onBrandLogoChange(): void;
+    private renderBrand;
+    componentWillLoad(): void;
+    onThemeChanged(): void;
+    onLocaleChanged(): void;
+    onRowSelectionModeChanged(): void;
+    private seedInitialQuickFilter;
+    private seedInitialPagination;
+    onPageSizeChange(newValue: number): void;
+    onColumnDefsChanged(): void;
+    onExternalFilterInputsChanged(): void;
+    onLifecycleComponentDefinitionsChanged(): void;
+    private hasStableLiveRowIds;
+    onGetRowIdChanged(): void;
+    onKeyboardNavigationChanged(newValue: boolean): void;
+    reEvaluateEngine(_newValue?: unknown, oldValue?: unknown, propName?: string): void;
+    rebuildFormulaSheet(newValue?: unknown, _oldValue?: unknown, propName?: string): void;
+    private formulaSeedToken;
+    private formulaSheetSeeding;
+    private scheduleFormulaUpgradeKick;
+    onWorkbookBindingInputsChanged(): void;
+    getWorkbookBinding(): Promise<GridWorkbookBinding | null>;
+    reconnectWorkbook(): Promise<GridWorkbookBinding | null>;
+    private loadFormulaCore;
+    disconnectWorkbook(): Promise<boolean>;
+    private syncWorkbookBinding;
+    private syncWorkbookBindingHostState;
+    private formulaUpgradeToken;
+    private formulaDualEngine;
+    private formulaAccelerationLoad;
+    private formulaAccelerationReadyGeneration;
+    private formulaWasmEventTargetBridge;
+    private formulaWasmAllowed;
+    formulaWasmAwaitingLicense: boolean;
+    private registerFormulaWasmEventTarget;
+    private unregisterFormulaWasmEventTarget;
+    private ensureFormulaAccelerationProvider;
+    private disposeFormulaDualEngine;
+    private upgradeFormulaSheet;
+    private readonly onFormulaEngineReady;
+    private validateColumnDefs;
+    private multiSortActive;
+    private seedInitialSortFromColumnDefs;
+    private applySortModel;
+    onMultiSortFlagChange(): void;
+    sortBy(column: string, direction?: GridSortDirection | null): Promise<void>;
+    setSortModel(model: ReadonlyArray<{
+        field: string;
+        direction: 'asc' | 'desc';
+    }>): Promise<void>;
+    getSortModel(): Promise<SortModelEntry[]>;
+    setQuery(query: string): Promise<void>;
+    getActiveTier(): Promise<GridEngineTier>;
+    private innerEngine;
+    private activeTag;
+    private handleQueryComplete;
+    private usingColumnDefsApi;
+    private resolveColDef;
+    private columnDefsSource;
+    private pivotComputing;
+    resolvedColumnDefs(): ColumnDef[];
+    onPivotConfigChange(): void;
+    private pivotModeActive;
+    private pivotAxesDeclared;
+    private warnedPivotConflicts;
+    private pendingPivotConflicts;
+    private notePivotConflict;
+    private resolvePivotAggFuncs;
+    private pivotComputation;
+    private aggregationSpecs;
+    registerAggFunc(name: string, fn: (values: unknown[], rows: readonly unknown[]) => unknown): Promise<void>;
+    unregisterAggFunc(name: string): Promise<void>;
+    getRegisteredAggFuncNames(): Promise<string[]>;
+    declaredColumnDefs(): ColumnDef[];
+    private effectiveGroupFields;
+    private readonly groupDeclaration;
+    private effectiveGroupBy;
+    onGroupByChange(newValue?: string | string[]): void;
+    private currentGroupKeys;
+    private currentMultiGroupKeys;
+    setRowGroupExpanded(key: string | null, expanded: boolean): Promise<void>;
+    private applyRowGroupExpanded;
+    expandAllRowGroups(): Promise<void>;
+    collapseAllRowGroups(): Promise<void>;
+    private treeSurfaceCache;
+    private treeSurface;
+    private readonly treeDeclaration;
+    private inertTreeDeclaration;
+    private treeSurfaceOf;
+    private treeRowComparator;
+    private currentTreeParentKeys;
+    onTreeSurfaceChange(): void;
+    setTreeNodeExpanded(path: readonly string[], expanded: boolean): Promise<void>;
+    private applyTreeNodeExpanded;
+    expandAllTreeNodes(): Promise<void>;
+    collapseAllTreeNodes(): Promise<void>;
+    private detailRowHeightPx;
+    private masterDetailActive;
+    private currentMasterIds;
+    setDetailRowExpanded(rowId: string | number, expanded: boolean): Promise<void>;
+    private applyDetailRowExpanded;
+    private masterRowsById;
+    private masterIdAt;
+    private allFilteredMasterIds;
+    expandAllDetailRows(): Promise<void>;
+    collapseAllDetailRows(): Promise<void>;
+    private lastMasterIds;
+    private mountedDetailIds;
+    private detailRowIds;
+    private withDetailRows;
+    setColumnGroupOpened(groupId: string, open: boolean): Promise<void>;
+    private applyColumnGroupOpened;
+    private headerGroupDepth;
+    private bodyAriaRowIndex;
+    private engineColumns;
+    private engineRows;
+    private engineRowsMemo;
+    private engineRowsInputs;
+    private formulaFieldGetter;
+    private formulaAwareConditionNode;
+    private buildFilterStages;
+    private columnFilterValueGetter;
+    private targetForColumnField;
+    private pivotSourceTargetsForFilter;
+    private sourceTargetsForFilter;
+    private buildPredicateForTarget;
+    private buildSourcePredicate;
+    private setFilterCatalogueRows;
+    private setFilterCatalogueTarget;
+    private declaredColumnFieldSet;
+    private isPivotDisplaySortField;
+    private pivotSourceSortColumn;
+    private pivotSourceSortModel;
+    private pivotDisplaySortModel;
+    private isSortNullish;
+    private pivotDisplaySortValue;
+    private comparePivotMarkersForDisplay;
+    private sortPivotMarkersForDisplay;
+    private pivotDisplayFilterPredicates;
+    private filterPivotMarkersForDisplay;
+    private buildSortStage;
+    private computeEngineRows;
+    private maybeUpdatePaginatedMeta;
+    private quickFilterFieldList;
+    private quickFilterTarget;
+    private buildPredicate;
+    private hostStyle;
+    private handleHeaderClick;
+    private builtInFilterDecl;
+    offeredFilterUiKind(filter: ColumnDef['filter']): FilterUiKind | null;
+    private filterUiKind;
+    private proFilterKindChunk;
+    private proFilterKindReady;
+    private filterKindAllowed;
+    private declaredFilterKinds;
+    private defaultFormForKind;
+    private formFromMultiPart;
+    private buildInitialForm;
+    private formStateFromActive;
+    private numberToInputValue;
+    private dateValueToInput;
+    private handleFilterIconClick;
+    private computeFilterDropdownAnchor;
+    private toggleFilterDropdown;
+    private closeFilterDropdown;
+    private maybeFocusFilterDropdown;
+    private updateFilterForm;
+    private patchForm;
+    formAt(subIndex: number | null): FilterFormState | null;
+    private setFormSelectsAll;
+    private subFormIsInactive;
+    private multiFormActiveParts;
+    private buildActiveFilterFromForm;
+    private handleFilterApply;
+    private filterApplyAllowed;
+    private handleFilterClear;
+    private handleFilterCancel;
+    private handleDocumentLifecycleEditorKeyDown;
+    private handleDocumentClick;
+    handleWindowKeyDown(event: KeyboardEvent): void;
+    private commitPagination;
+    private handleGoToPage;
+    private handlePrevPage;
+    private handleNextPage;
+    private handlePageSizeChange;
+    private handlePaginationKeyDown;
+    onQuickFilterTextPropChanged(newValue: string): void;
+    onQuickFilterConfigChanged(): void;
+    onLoadingChanged(): void;
+    onLoadingModeChanged(newValue: LoadingMode, oldValue: LoadingMode): void;
+    onMinLoadingDurationChanged(): void;
+    private updateLoadingState;
+    private cancelLoadingDebounce;
+    private nowMs;
+    private cancelQuickFilterDebounce;
+    private commitQuickFilterValue;
+    private handleQuickFilterInput;
+    private handleQuickFilterKeyDown;
+    private handleQuickFilterClear;
+    private normalizedQuickFilterDebounce;
+    private syncQuickFilterInputValue;
+    private shouldRenderQuickFilterToolbar;
+    private hasAnyActiveFilter;
+    private resolveEmptyStateKind;
+    private handleEmptyStateClearFilters;
+    private normalizedPageSizeOptions;
+    private activeColCount;
+    private renderedColumnCount;
+    private activeRowCount;
+    private isKeyboardNavEnabled;
+    private commitActiveCell;
+    private focusOutsideGridRoot;
+    private gridOwnsDocumentFocus;
+    private isFocusableForGridEscape;
+    private handleViewportKeyDown;
+    private viewportRowCount;
+    private handleCellMouseClick;
+    private lastCellClickedAt?;
+    private lastCellClickedKey?;
+    private lastCellMouseDown?;
+    private lastRowMouseDown?;
+    private lastRowClickedAt?;
+    private lastRowClickedIndex?;
+    private rangeSelectionActive;
+    private rowReorderEnabled;
+    private cellChangeFlashActive;
+    private flashCell;
+    private handleRowDragStart;
+    private handleRowDragMove;
+    private handleRowDragEnd;
+    rowIndexAtPoint(x: number, y: number): {
+        index: number;
+        position: RowDropPosition;
+    } | null;
+    private renderRowDragHandle;
+    private rowDragDropClass;
+    private normalizedRanges;
+    private emitRangeChange;
+    isSentinelDisplayRow(row: GridRow | undefined): boolean;
+    private handleRangeDragStart;
+    private extendRangeByKeyboard;
+    private handleRangeDragEnter;
+    private finishRangeDrag;
+    private rangeCellClasses;
+    onRangeSelectionChange(newValue?: boolean): void;
+    private clampRangesAfterChange;
+    private copyableDataRowAt;
+    private readPolicyConfigured;
+    private editPolicyConfigured;
+    private isCellReadable;
+    private applyReadMask;
+    private passesEditPolicy;
+    private passesEditPolicyAt;
+    private validateCell;
+    getValidationErrors(): Promise<Array<{
+        rowIndex: number;
+        rowId: unknown;
+        field: string;
+        value: unknown;
+        message: string;
+    }>>;
+    captureSnapshot(name?: string): Promise<string>;
+    listSnapshots(): Promise<SnapshotMeta[]>;
+    deleteSnapshot(id: string): Promise<boolean>;
+    private snapshotRowIdentity;
+    private snapshotRowById;
+    private snapshotRowByValue;
+    private snapshotDiffForPublicRead;
+    diffSnapshots(idA: string, idB?: string): Promise<SnapshotDiff<GridRow>>;
+    restoreSnapshot(id: string): Promise<boolean>;
+    private rawFieldValue;
+    private maskDeniedFields;
+    private maskRowsForRead;
+    private cellDisplayText;
+    private formulaCellDisplay;
+    private formulaWorkHeld;
+    private cellRawValue;
+    private writeClipboardText;
+    private copySelectionToClipboard;
+    private hostTextSelected;
+    getCellRanges(): Promise<CellRangeBounds[]>;
+    copyRangeToClipboard(): Promise<boolean>;
+    private coercePastedValue;
+    private pasteUndoWarned;
+    private undoableRowId;
+    private commitPastePlan;
+    private recordPasteUndo;
+    private applyClipboardText;
+    private handleViewportPaste;
+    pasteFromClipboard(): Promise<boolean>;
+    clearCellRanges(): Promise<void>;
+    private handleCellMouseDown;
+    private classifyCellClick;
+    private emitRowClicked;
+    private cellClickKey;
+    private snapshotMouseEvent;
+    private applyRowClickSelection;
+    private applyRowToggleSelection;
+    extractRowId(row: GridRow, rowIndex: number): string | number | undefined;
+    private selectionCheckboxActive;
+    private columnHidingActive;
+    private shouldRenderCheckboxColumn;
+    private checkboxColumnOffset;
+    collectVisibleRowIds(): ReadonlyArray<string | number>;
+    private handleHeaderCheckboxClick;
+    private handleHeaderCheckboxKeyDown;
+    private handleBodyCheckboxClick;
+    private handleBodyCheckboxKeyDown;
+    private resolveHoverRowIdFromTarget;
+    private applyHoverTransition;
+    private hoverListenerTarget;
+    private setupHoverListener;
+    private maybeReattachHoverListener;
+    private teardownHoverListener;
+    private dgHover;
+    private dgRow;
+    private dgCell;
+    private handleViewportMouseDown;
+    private handleViewportClick;
+    private handleViewportContextMenu;
+    private handleViewportHover;
+    private handleViewportFocus;
+    private dgTooltipEnter;
+    private maybeScrollActiveCellIntoView;
+    private skipDetailRows;
+    private clampActiveCellAfterChange;
+    componentDidLoad(): void;
+    connectedCallback(): void;
+    private hasDisconnected;
+    private handoffLifecycleRendererFocus;
+    private lifecycleFilterDeclaration;
+    private componentFilterColumnId;
+    private configuredLifecycleFilterCount;
+    private componentFilterValueGetter;
+    private componentFilterIsActive;
+    private sameComponentFilterInputs;
+    private reconcileComponentFilters;
+    private componentFilterHostMap;
+    private releaseComponentFilterHost;
+    private claimComponentFilterHost;
+    private componentFilterHostRef;
+    private attachComponentFilterHost;
+    private reconcileLifecycleRenderers;
+    componentDidRender(): void;
+    private emptyStateOverlayRendered;
+    private emptyStateOverlayInset;
+    private syncEmptyStateOverlayInset;
+    private reconcileDetailMounts;
+    private measureAutoHeightRows;
+    private syncLargeTextAnchor;
+    private syncCalendarAnchor;
+    private syncAutocompleteAnchor;
+    private maybeFocusActiveTextEditor;
+    disconnectedCallback(): void;
+    onRowHoverModeChanged(): void;
+    onVirtualizationInputsChanged(): void;
+    onVirtualizationMetricsChanged(): void;
+    private setupVirtualizer;
+    private syncHeaderHorizontalScroll;
+    private teardownVirtualizer;
+    private ensureVirtualizerAttached;
+    private recomputeVirtualWindow;
+    private uniformRowHeight;
+    private estimatedViewportHeight;
+    private estimatedViewportHeightFromHost;
+    private measuredHostHeight;
+    private elementHeight;
+    rowHeightForIndex(fn: (index: number, row: GridData) => number, index: number, row: GridRow | undefined, fallback: number): number;
+    autoHeightActive(): boolean;
+    private rowHeightLayoutSignature;
+    private ensureRowHeightCacheFor;
+    private computeVirtualWindowForRows;
+    getDisplayRows(): GridRow[];
+    private memoizedServerRows;
+    serverSideModeActive(): boolean;
+    private serverSidePivotModeActive;
+    private normalizeServerSideFields;
+    private serverSideRowGroupFields;
+    private serverSideColumnField;
+    private serverSideColumnDescriptor;
+    private serverSideRequestColumns;
+    private isServerSidePivotResultColumn;
+    private serverSidePivotResultColumnDef;
+    private serverSidePivotColumnDefs;
+    serverGroupKeyOf: (row: GridRow, level: number) => string;
+    serverSideFlatten(): ServerSideDisplayRow<GridRow>[];
+    private materializeServerSideRows;
+    private maybeFetchServerBlocks;
+    private dispatchServerBlock;
+    private retryServerBlock;
+    private initServerSide;
+    serverSideDatasourceChanged(): void;
+    serverSideGroupColsChanged(): void;
+    private viewportModeActive;
+    private initViewport;
+    viewportDatasourceChanged(_value: ViewportDatasource<GridRow> | undefined, oldValue: ViewportDatasource<GridRow> | undefined): void;
+    private maybeUpdateViewportRange;
+    private infiniteModeActive;
+    private initInfiniteCache;
+    datasourceChanged(): void;
+    private maybeFetchInfiniteBlocks;
+    private effectiveBlockSize;
+    private requestInfiniteBlocks;
+    private infiniteSortModel;
+    private infiniteFilterModel;
+    private licensedActiveFilters;
+    private infiniteQuickFilter;
+    private infiniteConditionModel;
+    infiniteModelInputsChanged(): void;
+    private onInfiniteBlockSuccess;
+    private onInfiniteBlockFailure;
+    private retryInfiniteBlock;
+    refreshInfiniteCache(): Promise<void>;
+    refreshRowHeights(): Promise<void>;
+    scrollToTop(): Promise<void>;
+    selectRows(ids: Array<string | number>): Promise<void>;
+    getSelectedRowIds(): Promise<ReadonlyArray<string | number>>;
+    applyTransaction(transaction: RowDataTransaction<GridRow>, label?: string, opts?: {
+        source?: GridEditSource;
+        origin?: unknown;
+    }): Promise<ApplyRowTransactionResult<GridRow>>;
+    private emitCellValueChanges;
+    collabRowId(row: GridData, index: number): string | number;
+    undo(): Promise<boolean>;
+    redo(): Promise<boolean>;
+    clearHistory(): Promise<void>;
+    connectCollabRoom(opts?: {
+        realtimeUrl?: string;
+        userName?: string;
+        userColor?: string;
+        presence?: boolean;
+        persistence?: 'none' | 'indexeddb';
+    }): Promise<GridSyncStatus>;
+    private kickCollabConnect;
+    preloadChunks(ids: GridChunkId[]): Promise<void>;
+    private collabConnectGen;
+    onCollaborationRoomChange(): void;
+    disconnectCollabRoom(): Promise<void>;
+    getSyncStatus(): Promise<GridSyncStatus>;
+    getCollaborators(): Promise<GridCollaboratorInfo[]>;
+    addCellComment(rowId: string | number, field: string, text: string, parentId?: string): Promise<string | null>;
+    private cellNotesModule;
+    getCellComments(rowId: string | number, field: string): Promise<GridCellComment[]>;
+    setCellCommentResolved(rowId: string | number, field: string, commentId: string, resolved: boolean): Promise<boolean>;
+    deleteCellComment(rowId: string | number, field: string, commentId: string): Promise<boolean>;
+    getDataAsCsv(options?: Omit<CsvExportOptions<GridRow>, 'columns' | 'rows'>): Promise<CsvExportResult>;
+    exportDataAsCsv(options?: Omit<CsvDownloadOptions<GridRow>, 'columns' | 'rows'>): Promise<CsvExportResult>;
+    private createCsvExportResult;
+    private downloadCsvFile;
+    getDataAsExcel(options?: {
+        sheetName?: string;
+        onlySelected?: boolean;
+        columnKeys?: readonly string[];
+        skipHeaders?: boolean;
+    }): Promise<Uint8Array>;
+    exportDataAsExcel(options?: {
+        fileName?: string;
+        sheetName?: string;
+        onlySelected?: boolean;
+        columnKeys?: readonly string[];
+        skipHeaders?: boolean;
+    }): Promise<void>;
+    private createExcelBytes;
+    private excelCellValue;
+    private downloadXlsxFile;
+    importCsvText(text: string, options?: {
+        delimiter?: CsvDelimiter;
+        hasHeader?: boolean;
+    }): Promise<{
+        rowCount: number;
+        columnCount: number;
+    }>;
+    private applyCsvImport;
+    private openCsvFilePicker;
+    private handleCsvFileChosen;
+    private updateCsvWizard;
+    private cancelCsvWizard;
+    private confirmCsvWizard;
+    private restoreCsvWizardFocus;
+    private maybeFocusCsvWizard;
+    private handleCsvWizardKeyDown;
+    getDataAsPdf(options?: SyGridPdfExportOptions): Promise<PdfExportResult>;
+    exportDataAsPdf(options?: SyGridPdfDownloadOptions): Promise<PdfExportResult>;
+    private createPdfExportInput;
+    private withAutoPdfFont;
+    private collectPdfFontProbeTexts;
+    private collectExportColumns;
+    private collectExportRows;
+    importDataFromXlsx(source: ArrayBuffer | Uint8Array, options?: {
+        sheetName?: string;
+        snapshot?: SheetToRowDataOptions;
+    }): Promise<XlsxImportResult>;
+    getContextMenuItems(target: {
+        rowIndex: number;
+        field?: string;
+    }): Promise<ContextMenuItem[]>;
+    private buildContextMenuCtx;
+    private openContextMenu;
+    private closeContextMenu;
+    private maybeFocusContextMenu;
+    private enabledContextMenuItems;
+    handleContextMenuKeyDown: (event: KeyboardEvent) => void;
+    private renderCsvWizard;
+    private cfBuilder;
+    private toggleCfBuilder;
+    private renderConditionalFormatBuilder;
+    private renderContextMenu;
+    copyCellAt(rowIndex: number, field: string): Promise<boolean>;
+    copyRowAt(rowIndex: number): Promise<boolean>;
+    getCellTooltipText(target: {
+        rowIndex: number;
+        field: string;
+        displayedText?: string;
+        isOverflowing?: boolean;
+    }): Promise<string>;
+    getUndoRedoDepth(): Promise<{
+        undo: number;
+        redo: number;
+    }>;
+    setColumnWidth(colId: string, width: number): Promise<void>;
+    resetColumnWidth(colId: string): Promise<void>;
+    getColumnWidth(colId: string): Promise<number | null>;
+    private resolveEffectiveColumnWidth;
+    private resolveProgrammaticColumnMinWidth;
+    private resolveInteractiveColumnMinWidth;
+    private resolveColumnMaxWidth;
+    private columnLayoutStyle;
+    private shouldHideHeaderControls;
+    private columnResizeGuideXFromHandle;
+    private columnResizeWidthFromHandle;
+    private showColumnResizeGuide;
+    private hideColumnResizeGuide;
+    private handleColumnResizePointerDown;
+    private handleColumnResizePointerMove;
+    private handleColumnResizePointerUp;
+    private handleColumnResizePointerCancel;
+    private commitColumnResize;
+    private cancelColumnResize;
+    private teardownColumnResizeDrag;
+    private applyColumnOrder;
+    effectiveColumns(): ColumnDef[];
+    pinSideOf(col: ColumnDef): ColumnPinSide | null;
+    pinnedWidthOf: (col: ColumnDef) => number | null;
+    private totalColumnsWidthPx;
+    private pinnedOffsetsContext;
+    setColumnPinned(field: string, side: ColumnPinSide | null): Promise<void>;
+    getColumnPinned(field: string): Promise<ColumnPinSide | null>;
+    private effectiveColumnIds;
+    setColumnOrder(orderedColIds: string[]): Promise<void>;
+    getColumnOrder(): Promise<string[]>;
+    private guardHideableColumns;
+    private applyColumnVisibility;
+    hideColumn(colId: string): Promise<void>;
+    showColumn(colId: string): Promise<void>;
+    toggleColumnVisibility(colId: string): Promise<boolean>;
+    setHiddenColumns(colIds: string[]): Promise<void>;
+    resetColumnVisibility(): Promise<void>;
+    getHiddenColumns(): Promise<string[]>;
+    autoSizeColumn(colId: string): Promise<number | null>;
+    autoSizeAllColumns(): Promise<void>;
+    getColumnState(): Promise<ColumnStateEntry[]>;
+    applyColumnState(state: ColumnStateEntry[], opts?: ApplyColumnStateOptions): Promise<void>;
+    initialState?: SyGridState;
+    private pendingStateUiRestore;
+    private pendingStateUiSlices;
+    private gridStateCaptureInput;
+    getState(): Promise<SyGridState>;
+    setState(state: SyGridState, options?: GridStateApplyOptions): Promise<SyGridStateApplyReport>;
+    private gridStateApplyContexts;
+    private executeGridStatePlan;
+    private maybeApplyPendingStateUiRestore;
+    private restorePinnedRowsSlice;
+    getFilterModel(): Promise<SyGridFilterSlice>;
+    setFilterModel(model: SyGridFilterSlice | null): Promise<FilterSliceApplyResult['report']>;
+    private filterModelLicenseRefusal;
+    private proFiltersModuleStep;
+    private gridMutationSequence;
+    private mintGridMutationId;
+    private canonicalSelection;
+    private canonicalMirror;
+    editType: 'cell' | 'fullRow';
+    private rowEditSessionRowId;
+    private activeCellRowId;
+    private batchCommitState;
+    private batchEdit;
+    private loadBatchEditChunk;
+    private batchLive;
+    private batchPendingCells;
+    private rowEditState;
+    batchEditStart: EventEmitter<SyGridBatchEditStartEventDetail>;
+    batchEditEnd: EventEmitter<SyGridBatchEditEndEventDetail>;
+    rowValueChanged: EventEmitter<SyGridRowValueChangedEventDetail>;
+    rowEditStart: EventEmitter<SyGridRowEditStartEventDetail>;
+    rowEditStop: EventEmitter<SyGridRowEditStopEventDetail>;
+    private ensureCanonicalSelection;
+    getCanonicalRanges(): Promise<SyGridCanonicalRange[]>;
+    setCanonicalRanges(ranges: SyGridCellRangeInput[]): Promise<SyGridCanonicalChange[]>;
+    private rowByStableId;
+    private displayIndexOfRow;
+    private storedCellValue;
+    private identityRbacVerdict;
+    private identityValidationVerdict;
+    private editGatesConfigured;
+    private validationRulesConfigured;
+    private applyIdentityWrites;
+    private toPublicRejectedCell;
+    private emitBatchLedgerStart;
+    private emitBatchLedgerEnd;
+    startBatchEdit(options?: SyGridBatchStartOptions): Promise<boolean>;
+    isBatchEditing(): Promise<boolean>;
+    stageBatchCell(rowId: GridRowId, colId: string, value: unknown): Promise<boolean>;
+    getPendingBatchCells(): Promise<SyGridPendingBatchCell[]>;
+    cancelBatchEdit(): Promise<number>;
+    commitBatchEdit(options?: SyGridBatchCommitOptions): Promise<SyGridBatchCommitReport>;
+    private finalizeBatchEditOnDisconnect;
+    private rowEditKindOf;
+    startRowEdit(rowId: GridRowId): Promise<boolean>;
+    stopRowEdit(reason?: 'commit' | 'cancel'): Promise<SyGridRowEditReport>;
+    stageRowEditCell(colId: string, value: unknown): Promise<boolean>;
+    private finishRowEditSession;
+    getStateCaptureReport(): Promise<SyGridStateCaptureReport>;
+    enableFillHandle?: boolean;
+    fillHandleAxes?: 'both' | 'x' | 'y';
+    fillHandleMode?: 'copy' | 'series';
+    private fillPreview;
+    private fillBinding;
+    onEnableFillHandleChanged(value?: boolean): void;
+    private fillHandleActive;
+    private fillHandleCellAt;
+    private fillPreviewClasses;
+    private fillPolicyClosures;
+    private applyFillPlan;
+    cellAtFillPoint(x: number, y: number): {
+        row: number;
+        col: number;
+    } | null;
+    private armFillHandle;
+    private fillHandle;
+    writeFillPreview(plan: import('./core/selection/fill-handle').FillPlan | null): void;
+    applyFillPlanFromGesture(transaction: import('./core/selection/fill-transaction').FillTransactionPlan, geometry: import('./core/selection/fill-handle').FillPlan, sourceRangeId: number): void;
+    private handleFillHandlePointerDown;
+    private handleFillHandleDoubleClick;
+    private handleFillHandleKeyDown;
+    private renderFillHandle;
+    fillStart: EventEmitter<SyGridFillStartEventDetail>;
+    fillEnd: EventEmitter<SyGridFillEndEventDetail>;
+    private loadFillChunk;
+    fillRange(options: SyGridFillRangeOptions): Promise<SyGridFillRangeReport>;
+    pivotCombinationConflict: EventEmitter<SyGridPivotCombinationConflictDetail>;
+    pivotColumnsChanged: EventEmitter<SyGridPivotColumnsChangedDetail>;
+    private loadGroupPivotChunk;
+    private groupPivotChunkModule;
+    private groupPivotChunkArming;
+    private ensureGroupPivotChunkArmed;
+    groupPivotChunkTick: number;
+    private pivotModelGlue;
+    private notifyPivotColumnModel;
+    getDisplayRowInfo(index: number): Promise<SyGridDisplayRowInfo | null>;
+    getPivotCombinationReport(): Promise<SyGridPivotCombinationReport>;
+    private detectedPivotFeatures;
+    getPivotSecondaryColumns(): Promise<SyGridPivotSecondaryColumns | null>;
+    getGroupCheckStates(options?: SyGridGroupCheckStatesOptions): Promise<SyGridGroupCheckStatesReport>;
+    private groupCheckStatesRefusal;
+    serverStoreUpdated: EventEmitter<SyGridServerStoreUpdatedDetail>;
+    rowDragEnter: EventEmitter<SyGridRowDragEventDetail>;
+    rowDragMove: EventEmitter<SyGridRowDragEventDetail>;
+    rowDragLeave: EventEmitter<SyGridRowDragEventDetail>;
+    rowDragEnd: EventEmitter<SyGridRowDragEndDetail>;
+    rowDragCancel: EventEmitter<SyGridRowDragCancelDetail>;
+    rowsTransferred: EventEmitter<SyGridRowsTransferredDetail>;
+    private unmanagedRowDragEnabled;
+    private rowDrag;
+    private syncRowDrag;
+    paintDragTarget(target: {
+        zoneId: string;
+        rowIndex: number | null;
+        position: import('./core/row-drag/row-drag-chunk').RowDragPaintPosition;
+    } | null, source: number | null): void;
+    announceDrag(announcement: {
+        politeness: 'polite' | 'assertive';
+        text: string;
+    }): void;
+    emitDrag(event: {
+        kind: string;
+        detail: unknown;
+    }): void;
+    writeRows(rows: readonly GridRow[]): void;
+    private handleUnmanagedDragPointerDown;
+    private handleUnmanagedDragKeyDown;
+    private teardownUnmanagedDrag;
+    private renderDragLiveRegions;
+    startRowDrag(input: SyGridRowDragStartInput): Promise<SyGridRowDragStartResult>;
+    getRowDragSession(): Promise<SyGridRowDragSessionReport>;
+    registerDropZone(input: SyGridDropZoneInput): Promise<SyGridDropZoneRegistration>;
+    unregisterDropZone(zoneId: string): Promise<boolean>;
+    getDropZones(): Promise<SyGridDropZonesReport>;
+    getDragSafetyReport(): Promise<SyGridDragSafetyReport>;
+    spanConflict: EventEmitter<SyGridSpanConflictEventDetail>;
+    private spansDeclared;
+    private rowLayout;
+    private syncRowLayout;
+    alignedGrids?: SyGridAlignedGridsInput | string;
+    private alignedFacade;
+    private alignedApplying;
+    private alignedMemberIdMinted;
+    private pendingAlignedScroll;
+    onAlignedGridsChanged(): void;
+    private alignedDeclared;
+    private alignedMemberId;
+    private syncAlignedGrids;
+    private ensureAlignedFacade;
+    private alignedSnapshot;
+    private applyAlignedProjection;
+    private alignedNotify;
+    setAlignedGrids(input: SyGridAlignedGridsInput): Promise<SyGridAlignedGridsResult>;
+    getAlignedGrids(): Promise<SyGridAlignedGridsReport>;
+    treeReparented: EventEmitter<SyGridTreeReparentedDetail>;
+    private reparentIdMapsCache;
+    private treeIdLinkageActive;
+    private treeRowId;
+    private treeRowParentId;
+    private treeRowWithParent;
+    private reparentIdMaps;
+    reparentHost(): import('./core/tree/tree-data-chunk').ReparentHostView<GridRow> | null;
+    reparentFacadeFactory(): GridTreeDataModule['createReparentFacade'] | null;
+    dragRowIdOf(row: GridRow, index: number): string | number | undefined;
+    reparentNodeAt(rowIndex: number): string | null;
+    rowBandRatio(rowIndex: number, y: number): number | null;
+    reparentRows(request: SyGridReparentRequest): Promise<SyGridReparentResult>;
+    isFullWidthRow?: (params: {
+        row: GridRow;
+        rowIndex: number;
+        builtInKind: 'detail' | 'group' | 'group-footer' | 'loading' | 'custom' | null;
+    }) => boolean;
+    fullWidthCellRenderer?: SyGridFullWidthRenderer<GridRow>;
+    fullWidthRowHeight?: number | ((row: GridRow, rowIndex: number) => number);
+    onFullWidthConfigChanged(): void;
+    private fullWidthDeclared;
+    private fullWidth;
+    private fullWidthEntryAt;
+    private isFullWidthDisplayRow;
+    private reconcileFullWidthMounts;
+    private renderFullWidthRow;
+    getFullWidthRowInfo(rowIndex?: number): Promise<SyGridFullWidthRowInfo<GridRow> | SyGridFullWidthLayoutReport | null>;
+    pinnedTopRowData?: GridRow[];
+    pinnedBottomRowData?: GridRow[];
+    pinnedRowsChanged: EventEmitter<SyGridPinnedRowsChangedDetail<GridRow>>;
+    rowLayoutRefused: EventEmitter<SyGridRowLayoutRefusedDetail>;
+    onPinnedRowDataChanged(): void;
+    private pinnedRowsDeclared;
+    private pinnedRowId;
+    private pinnedRowsFromProps;
+    private pinnedRows;
+    private syncPinnedRows;
+    private applyPinnedRows;
+    private pinnedTopCount;
+    private pinnedBottomCount;
+    private refusePinnedRowFeature;
+    private enterPinnedBandFromBody;
+    private focusPinnedBandCell;
+    private leavePinnedBand;
+    private handlePinnedBandClick;
+    private handlePinnedBandFocusOut;
+    private handlePinnedBandKeyDown;
+    setPinnedRows(input: SyGridPinnedRowSetInput<GridRow>): Promise<SyGridPinnedRowsResult<GridRow>>;
+    getPinnedRows(): Promise<SyGridPinnedRowsReport<GridRow>>;
+    getPinnedRowInfo(displayIndex: number): Promise<SyGridPinnedRowInfo<GridRow> | null>;
+    private rowLayoutHostView;
+    private buildRowLayoutFrame;
+    private spanAwareMove;
+    private spanAwareCellText;
+    getRowSpan(colId: string): Promise<SyGridRowSpanReport | null>;
+    getCellSpan(rowIndex: number, colId: string): Promise<SyGridCellSpanInfo | null>;
+    getSpanInteraction(query?: SyGridSpanInteractionQuery): Promise<SyGridSpanInteractionReport>;
+    private loadSsrmOpsChunk;
+    private ssrmDeclared;
+    private ssrmOps;
+    advanceSsrmRegistryWith(chunk: typeof import('./core/row-model/ssrm-ops-chunk')): ServerStoreRegistry;
+    private ensureSsrmRuntime;
+    private teardownSsrmRuntime;
+    private ssrmSel;
+    private ssrmSelGesture;
+    private ssrmOpsGated;
+    private ssrmGroupCheckAttrs;
+    getServerSideSelectionState(): Promise<SyGridServerSelectionState>;
+    getServerGroupSelectionState(): Promise<SyGridServerSelectionState>;
+    setServerSideSelectionState(input: unknown): Promise<SyGridServerSelectionSetResult>;
+    setServerGroupSelectionState(input: unknown): Promise<SyGridServerSelectionSetResult>;
+    selectAllServerSide(action?: 'select' | 'clear'): Promise<SyGridServerSelectAllResult>;
+    selectServerGroupChildren(groupKeys: ReadonlyArray<string>, action?: 'select' | 'deselect'): Promise<SyGridServerGroupChildrenResult>;
+    private ssrmRefusedTxn;
+    refreshServerSide(input?: SyGridServerRefreshInput): Promise<SyGridServerRefreshResult>;
+    applyServerSideTransaction(transaction: SyGridServerTransactionInput): Promise<SyGridServerTransactionResult>;
+    applyServerSideTransactionAsync(transaction: SyGridServerTransactionInput, onSettle?: (settlement: SyGridServerTransactionSettlement) => void): Promise<SyGridServerTransactionEnqueue>;
+    flushServerSideAsyncTransactions(): Promise<SyGridServerFlushReport>;
+    getServerSideStoreState(): Promise<SyGridServerStateReport | null>;
+    getServerPivotResultColumns(): Promise<SyGridServerPivotColumnsReport | null>;
+    auditServerPivotResultColumns(colIds: ReadonlyArray<string>): Promise<SyGridServerPivotColumnAudit | null>;
+    workbookValuesPropagated: EventEmitter<SyGridWorkbookPropagationDetail>;
+    private workbookOpsChunk;
+    private workbookOpsEnrollment;
+    private workbookOpsKickSeq;
+    private workbookOpsHostBag;
+    private workbookOpsHost;
+    private loadWorkbookOpsChunk;
+    private workbookOpsInactiveReason;
+    private enrollWorkbookOpsWith;
+    private syncWorkbookOps;
+    private teardownWorkbookOps;
+    private workbookOps;
+    private workbookOpsChunkIfActive;
+    private assertWorkbookModules;
+    private workbookOpsEnrolled;
+    private recordWorkbookOpsCommit;
+    getWorkbookPropagationState(): Promise<SyGridWorkbookPropagationState>;
+    private wbInactiveReason;
+    private workbookInactiveState;
+    flushWorkbookPropagation(): Promise<SyGridWorkbookFlushReport>;
+    getWorkbookSnapshotReport(): Promise<SyGridWorkbookSnapshotReport>;
+    getWorkbookIntegrityReport(): Promise<SyGridWorkbookIntegrityReport>;
+    applySpillFormula(input: SyGridSpillApplyInput): Promise<SyGridSpillApplyResult>;
+    private spillInactiveResult;
+    clearSpillFormula(target: SyGridSpillTarget): Promise<SyGridSpillClearResult>;
+    undoSpillTransaction(mutationId: GridMutationId): Promise<SyGridSpillUndoResult>;
+    getSpillReport(): Promise<SyGridSpillReport>;
+    chartCreated: EventEmitter<SyGridChartEvent>;
+    chartRangeChanged: EventEmitter<SyGridChartEvent>;
+    chartOptionsChanged: EventEmitter<SyGridChartEvent>;
+    chartDestroyed: EventEmitter<SyGridChartEvent>;
+    private chartLinkChunk;
+    private chartLinkRuntimeRef;
+    private chartLinkGeneration;
+    private chartLinkHostBag;
+    private chartLinkPermissionState;
+    private loadChartLinkChunk;
+    private applyChartLinkFilterModel;
+    private chartLinkRows;
+    private chartLinkHost;
+    private chartLinkRuntime;
+    createRangeChart(params: SyGridChartCreateParams): Promise<SyGridChartCreateResult>;
+    updateChart(chartId: string, patch: SyGridChartUpdatePatch): Promise<SyGridChartUpdateResult>;
+    destroyChart(chartId: string): Promise<SyGridChartDestroyResult>;
+    getChartRefs(): Promise<SyGridChartReport[]>;
+    syncCharts(mutation?: SyGridChartSyncMutation): Promise<SyGridChartSyncReport>;
+    getChartMenuModel(permissions?: SyGridChartPermissions): Promise<SyGridChartMenuReport>;
+    openChartToolPanel(permissions?: SyGridChartPermissions): Promise<SyGridChartPanelReport>;
+    closeChartToolPanel(): Promise<SyGridChartPanelReport>;
+    getChartToolPanelReport(): Promise<SyGridChartPanelReport>;
+    activateChartToolPanelItem(): Promise<SyGridChartCreateResult>;
+    getChartModels(): Promise<SyGridChartCaptureResult>;
+    restoreChartModels(envelope: unknown): Promise<SyGridChartRestoreResult>;
+    exportChartImage(chartId: string, request: SyGridChartExportRequest): Promise<SyGridChartExportResult>;
+    applyChartCrossFilter(chartId: string, colId: string, action: SyGridChartCrossFilterAction, categories: unknown[]): Promise<SyGridChartCrossFilterResult>;
+    resetChartCrossFilter(): Promise<SyGridChartCrossFilterResult>;
+    getChartAccessibleSummary(chartId: string): Promise<SyGridChartAccessibleReport | null>;
+    getChartFleetReport(): Promise<SyGridChartFleetReport>;
+    private teardownChartLink;
+    private readonly stateChangeTracker;
+    private readonly stateEventCoalescer;
+    private stateUpdatedFlushScheduled;
+    private stateAtomSnapshot;
+    private noteStateAtomsAfterRender;
+    private noteStateBatchSource;
+    private scheduleStateUpdatedFlush;
+    private flushStateUpdated;
+    private emitPreDestroyedOnce;
+    private applyInitialGridState;
+    private computeAutoSizeWidth;
+    private resolveAutoSizeFont;
+    private harvestVisibleCellTexts;
+    private measureTextPx;
+    private createAutoSizeContext;
+    private handleColumnReorderPointerDown;
+    private attachColumnReorderDocumentListeners;
+    private detachColumnReorderDocumentListeners;
+    private captureColumnReorderStartRects;
+    private computeReorderTargetIndex;
+    private handleColumnReorderPointerMove;
+    private handleColumnReorderPointerUp;
+    private pointerOverGroupPanel;
+    private setGroupByFromPanel;
+    private clearGroupByFromPanel;
+    private handleColumnReorderPointerCancel;
+    private commitColumnReorder;
+    private cancelColumnReorder;
+    private teardownColumnReorderDrag;
+    setHoveredRow(rowId: string | number | null): Promise<void>;
+    getHoveredRowId(): Promise<string | number | null>;
+    getActiveEditTransaction(): Promise<EditTransaction | null>;
+    commitActiveEdit(): Promise<boolean>;
+    cancelActiveEdit(): Promise<boolean>;
+    registerCellRenderer(name: string, renderer: CellRenderer): Promise<boolean>;
+    listRegisteredCellRenderers(): Promise<ReadonlyArray<string>>;
+    unregisterCellRenderer(name: string): Promise<boolean>;
+    registerGridComponent<TKind extends GridComponentKind>(scope: GridComponentRegistrationScope, kind: TKind, name: string, definition: GridComponentDefinitionFor<TKind, GridData, unknown, unknown, unknown>): Promise<void>;
+    replaceGridComponent<TKind extends GridComponentKind>(scope: GridComponentRegistrationScope, kind: TKind, name: string, definition: GridComponentDefinitionFor<TKind, GridData, unknown, unknown, unknown>): Promise<void>;
+    unregisterGridComponent(scope: GridComponentRegistrationScope, kind: GridComponentKind, name: string): Promise<boolean>;
+    getRegisteredGridComponentNames(scope: GridComponentRegistrationScope, kind: GridComponentKind): Promise<ReadonlyArray<string>>;
+    getCellRendererInstance(rowId: GridRowId, colId: string): Promise<GridRendererDiscovery<GridData, unknown, unknown>>;
+    destroyCellRendererInstance(rowId: GridRowId, colId: string): Promise<boolean>;
+    focusCellRendererInstance(rowId: GridRowId, colId: string, direction: 'in' | 'out'): Promise<boolean>;
+    getCellEditorInstance(): Promise<GridMountedComponentLookup<GridEditorInstance<GridData, unknown, unknown>, GridEditorParams<GridData, unknown, unknown>, HTMLElement> | null>;
+    getColumnFilterInstance<TColumnValue = unknown, TModel = unknown>(columnId: string): Promise<GridFilterInstance<GridData, TColumnValue, TModel, unknown> | null>;
+    getColumnFilterModel<TModel = unknown>(columnId: string): Promise<TModel | null>;
+    setColumnFilterModel<TModel = unknown>(columnId: string, model: TModel | null): Promise<boolean>;
+    onFilterChanged(): Promise<void>;
+    refreshExternalFilter(): Promise<boolean>;
+    destroyColumnFilter(columnId: string): Promise<boolean>;
+    recreateColumnFilter(columnId: string, options?: {
+        preserveModel?: boolean;
+    }): Promise<boolean>;
+    private lifecycleEditorCellElement;
+    private registerLifecycleEditorDocumentOwner;
+    private focusLifecycleEditorDocumentOwner;
+    private unregisterLifecycleEditorDocumentOwner;
+    private ownsLifecycleEditorDocumentEvent;
+    private waitForLifecycleEditorAttachment;
+    private settleLifecycleEditorAttachment;
+    private clearLifecycleEditorValidation;
+    private currentLifecycleEditorValidationTarget;
+    private reportLifecycleEditorInvalidBlock;
+    private resetLifecycleEditorPresentation;
+    private invalidateLifecycleEditorRequests;
+    private handleLifecycleEditorStop;
+    private beginLifecycleEditor;
+    private lifecycleEditorPlacement;
+    private applyLifecycleEditorPlacement;
+    private lifecycleEditorDomHost;
+    private attachLifecycleEditor;
+    private richSelectDeclared;
+    private editableCellTarget;
+    private queuedCellEditTarget;
+    private resolveQueuedCellEditTarget;
+    private beginCellEdit;
+    private requestCellEdit;
+    private beginCellEditNow;
+    private beginEditTransaction;
+    private selectOptionsFromColumn;
+    private numberConstraintsFromColumn;
+    private dateConstraintsFromColumn;
+    cancelEditTransaction(): void;
+    private sourceIndexForDisplayRow;
+    private editRowIdentity;
+    private resolveCellEditTarget;
+    private prepareGridCellEdit;
+    private cellEditTargetStillCurrent;
+    private finalizeCommittedEditor;
+    private reportRejectedCellEdit;
+    private commitPreparedCellEdit;
+    commitEditTransaction(): boolean;
+    private applyFormulaEdit;
+    private publicNumericValue;
+    private activeCellContext;
+    private activeCellRawText;
+    private activeCellRefLabel;
+    private commitFormulaBar;
+    private formulaSuggest;
+    private formulaSuggestAnchor;
+    private updateFormulaSuggest;
+    private handleSuggestKeyIntercept;
+    private applyFormulaSuggestion;
+    private applyCellSuggestion;
+    private syncFormulaSuggestAnchor;
+    private renderFormulaBar;
+    private renderCellFormulaSuggest;
+    private resetVirtualScrollPosition;
+    private pivotPanelVisible;
+    private groupPanelActive;
+    setPivotColumns(columns: string[]): Promise<boolean>;
+    setValueColumns(columns: string[]): Promise<boolean>;
+    private maybeRestorePivotPanelFocus;
+    private renderPivotPanel;
+    private renderGroupPanel;
+    private renderHeader;
+    private renderHeaderGroupRows;
+    private columnWindowContext;
+    private columnWindowEnabled;
+    private columnWindowContextInner;
+    private renderColumnSpacer;
+    private withColumnSpacers;
+    private applyPinnedStyle;
+    private renderConditionBuilder;
+    private renderHeaderFilterRow;
+    private floatingFilterValue;
+    private floatingFilterSummary;
+    private handleFloatingFilterInput;
+    private applyFilterDirect;
+    setConditionFilter(model: ConditionNode | null): Promise<void>;
+    getConditionFilter(): Promise<ConditionNode | null>;
+    private applyConditionTree;
+    private maybeFocusBuilder;
+    handleBuilderApply: () => void;
+    handleBuilderClear: () => void;
+    setConditionPresets(presets: ReadonlyArray<{
+        name: string;
+        json: string;
+    }>): Promise<void>;
+    getConditionPresets(): Promise<Array<{
+        name: string;
+        json: string;
+    }>>;
+    private emitPresetsChanged;
+    handlePresetSave: () => void;
+    handlePresetLoad(preset: {
+        name: string;
+        json: string;
+    }): void;
+    handlePresetDelete(name: string): void;
+    private renderSetFilterBody;
+    private renderFilterFormActions;
+    private renderFilterDropdown;
+    private renderFilterDropdownForm;
+    private renderScalarFilterBody;
+    private filterOpOptions;
+    private openToolPanelId;
+    columnsPanelSearch: string;
+    filtersPanelSearch: string;
+    private sideBarWarned;
+    private sideBarSpec;
+    onSideBarChanged(): void;
+    openToolPanel(id: string): Promise<boolean>;
+    closeToolPanel(): Promise<void>;
+    getOpenedToolPanel(): Promise<string | null>;
+    private renderSideBar;
+    lastFilteredDataRowCount: number | null;
+    private statusBarWarned;
+    private statusBarSpec;
+    private renderStatusBar;
+    private renderPaginationBar;
+    private renderHeaderCheckboxCell;
+    private renderBodyCheckboxCell;
+    private lifecycleRendererDeclaration;
+    private rendererPresentationCoordinateKey;
+    private rendererPresentationFromOutput;
+    private sameRendererPresentation;
+    private updateLifecycleRendererPresentation;
+    private recordRendererPresentation;
+    private rendererPresentationAt;
+    private rendererPresentationClasses;
+    private renderLifecycleRenderer;
+    private resolveCellRenderer;
+    private renderCellContent;
+    private renderEditorForCell;
+    private renderTextEditorForCell;
+    private renderNumberEditorForCell;
+    private pickCalendarDay;
+    private stepCalendarMonth;
+    private handleCalendarKeyNav;
+    private renderActiveDateCalendar;
+    private renderDateCalendar;
+    private renderDateEditorForCell;
+    private renderSelectEditorForCell;
+    private renderCheckboxEditorForCell;
+    private renderTextareaEditorForCell;
+    private renderLargeTextEditorForCell;
+    private renderActiveLargeTextEditor;
+    private cycleLargeTextFocus;
+    private cancelLargeTextEdit;
+    private handleCellTooltipLeave;
+    private handleHeaderTooltipEnter;
+    private handleHeaderTooltipLeave;
+    private showHeaderTooltip;
+    private showCellTooltip;
+    private tooltipPortalEl;
+    private syncTooltipPortal;
+    private teardownTooltipPortal;
+    private renderCellTooltip;
+    private renderGroupRow;
+    private formatAggValue;
+    private renderGroupFooterRow;
+    private renderPivotRow;
+    private togglePivotRowGroup;
+    private renderTreeNodeRow;
+    private handleTreeCellClick;
+    private renderDetailToggle;
+    private detailRendererWarned;
+    private renderDetailContent;
+    private renderDetailGrid;
+    private configureDetailGrid;
+    private resolveDetailChildRows;
+    private settleDetailRows;
+    private warnDetailData;
+    private detailRowDataCache;
+    private detailRowLoading;
+    private detailFetchToken;
+    private detailDataVersion;
+    private detailGridDataWarned;
+    private renderPinnedBand;
+    private pinnedBandCellHost;
+    private renderPinnedBandRow;
+    private renderDetailRow;
+    private renderLoadingRow;
+    private renderRow;
+    private renderColumnDefsBody;
+    private startColumnReorderPreview;
+    private updateColumnReorderPreview;
+    private removeColumnReorderPreview;
+    private renderColumnResizeGuide;
+    private safeRowHeightSample;
+    private renderToolbar;
+    private emptyStateMessage;
+    private renderEmptyState;
+    private renderEmptyStateLiveRegion;
+    private renderLoadingSpinner;
+    private localeDataAttribute;
+    render(): any;
+}
+export {};