@syidax/advanced 0.0.0-stage → 1.0.1

package/dist/types/components/grid/core/api/contracts.d.ts

@@ -0,0 +1,2104 @@
+import type { ColumnDef, GridColumnGroupDef, GridEngineTier, GridQueryResult } from '../types';
+import type { AuditEntry, AuditLogFilter } from '../audit/audit-log';
+import type { CellRenderer } from '../cell/renderer-registry';
+import type { GridComponentDefinitionFor, GridComponentErrorDetails, GridComponentKind, GridComponentLocalDefinitions, GridEditorInstance, GridEditorParams, GridExternalFilterCallbacks, GridExternalFilterInstance, GridFilterInstance } from '../component/contracts';
+import type { GridRendererDiscovery } from '../component/renderer-controller';
+import type { GridComponentRegistrationScope } from '../component/registry';
+import type { GridMountedComponentLookup } from '../component/runtime';
+import type { ContextMenuItem } from '../context-menu';
+import type { GridCellComment, GridCollabConflict, GridCollaboratorInfo, GridSyncStatus } from '../collab-types';
+import type { ConditionalFormatRule } from '../conditional-format/conditional-format';
+import type { EditTransaction } from '../edit/transaction';
+import type { EmptyStateKind } from '../empty-state-cycle';
+import type { CsvDownloadOptions, CsvExportOptions, CsvExportResult } from '../export/csv';
+import type { PdfDownloadOptions, PdfExportOptions, PdfExportResult } from '../export/grid-pdf-export';
+import type { ActiveFilter, ActiveFilterMap } from '../filter-cycle';
+import type { ConditionNode } from '../filter/condition-builder';
+import type { GridWorkbookBinding, GridWorkbookBindingChangedDetail, GridWorkbookBindingErrorDetail } from '../formula/workbook-binding';
+import type { CsvDelimiter } from '../import/csv';
+import type { SheetToRowDataOptions, XlsxGridSnapshot, XlsxImportResult } from '../import/xlsx';
+import type { GridChunkId } from '../loader/chunk-contract';
+import type { ChartLinkAccessibleReport, ChartLinkChartReport, ChartLinkCreateParams, ChartLinkCreateResult, ChartLinkDestroyResult, ChartLinkExportResult, ChartLinkFleetReport, ChartLinkMenuReport, ChartLinkPanelReport, ChartLinkPanelStop, ChartLinkSourceInput, ChartLinkUpdateResult } from '../chart-link/chart-link-chunk';
+import type { GridChartCrossFilterAction, GridChartCrossFilterResult } from '../chart-link/chart-cross-filter';
+import type { GridChartEvent, GridChartExportRequest } from '../chart-link/chart-events';
+import type { GridChartMenuPermissions, GridChartProperties } from '../chart-link/chart-menu';
+import type { GridChartModelCaptureResult, GridChartModelRestoreReport } from '../chart-link/chart-model';
+import type { GridChartSyncMutation, GridChartViewColumn, GridChartViewRow } from '../chart-link/chart-sync';
+import type { GridChunkLoadEventDetail } from '../loader/chunk-loader';
+import type { GridLocale } from '../locale/resolve';
+import type { ActivePagination } from '../pagination-cycle';
+import type { PivotPanelChangeDetail } from '../pipeline/pivot-panel';
+import type { CellRange, CellRangeBounds } from '../selection/range';
+import type { CanonicalRange, CanonicalRangeChange } from '../selection/canonical-ranges';
+import type { FillDirection, FillPlanMode } from '../selection/fill-handle';
+import type { SideBarPanelId } from '../side-bar/side-bar';
+import type { SnapshotMeta } from '../snapshot/snapshot';
+import type { SnapshotDiff } from '../snapshot/snapshot-diff';
+import type { GridTheme } from '../theme/apply';
+import type { GridData, GridEventSource, GridFieldPath, GridGetRowId, GridPathValue, GridRowId } from './base-types';
+export type { GridData, GridEventSource, GridFieldPath, GridGetRowId, GridPathValue, GridRowId, } from './base-types';
+import type { SyGridState, SyGridStateSliceKey } from '../state/contracts';
+import type { GridStateApplyOptions, SyGridStateApplyReport } from '../state/grid-state';
+import type { StateUpdateSource } from '../state/state-events';
+import type { FilterSliceApplyResult, SyGridFilterSlice } from '../state/slices/filter';
+export interface SyGridStateUpdatedDetail {
+    changedSlices: SyGridStateSliceKey[];
+    sources: StateUpdateSource[];
+    coalescedBatches: number;
+}
+export interface SyGridPreDestroyedDetail {
+    state: SyGridState;
+    captureIssues: ReadonlyArray<{
+        path: string;
+        detail: string;
+    }>;
+}
+export type { SyGridState, SyGridStateSliceKey, SyGridStateVersion, SyGridStateEnvelopeIssue, } from '../state/contracts';
+export type { GridStateApplyOptions, SyGridStateApplyReport, } from '../state/grid-state';
+export type GridMutationId = `grid-mutation-${number}`;
+export type SyGridCanonicalRange = CanonicalRange;
+export type SyGridCanonicalChange = CanonicalRangeChange;
+export type SyGridCellRangeInput = CellRange;
+export interface SyGridBatchStartOptions {
+    reentrant?: 'reject' | 'join';
+}
+export interface SyGridBatchCommitOptions {
+    atomicity?: 'atomic' | 'best-effort';
+    partialInvalid?: 'reject-all' | 'commit-valid';
+}
+export interface SyGridEditRejectedCell {
+    rowId: GridRowId;
+    colId: string;
+    reason: 'rbac' | 'validation';
+    detail: string | null;
+}
+export interface SyGridBatchCommitReport {
+    status: 'committed' | 'rejected' | 'cancelled' | 'none';
+    mutationId: GridMutationId | null;
+    writtenCount: number;
+    rejectedCells: ReadonlyArray<SyGridEditRejectedCell>;
+    transactionRejectedRowIds: ReadonlyArray<GridRowId>;
+    sessionOpen: boolean;
+}
+export interface SyGridPendingBatchCell {
+    rowId: GridRowId;
+    colId: string;
+    value: unknown;
+    oldValue: unknown;
+    sequence: number;
+}
+export interface SyGridRowEditStartEventDetail {
+    rowId: GridRowId;
+    editableColumns: string[];
+}
+export interface SyGridRowEditStopEventDetail {
+    rowId: GridRowId;
+    status: string;
+    writtenCount: number;
+    reason: 'commit' | 'cancel';
+}
+export interface SyGridRowEditReport {
+    status: 'committed' | 'rejected' | 'cancelled' | 'none';
+    mutationId: GridMutationId | null;
+    writtenCount: number;
+    rejectedCells: ReadonlyArray<SyGridEditRejectedCell>;
+    rowInvalid: {
+        cellReasons: Readonly<Record<string, string>> | null;
+        rowReason: string | null;
+    } | null;
+    droppedCount: number;
+    transactionRejectedRowIds: ReadonlyArray<GridRowId>;
+}
+export interface SyGridStateCaptureReport {
+    issues: ReadonlyArray<{
+        path: string;
+        detail: string;
+    }>;
+}
+export interface SyGridBatchEditStartEventDetail {
+    mutationId: GridMutationId;
+    sessionId: number;
+    stagedCount: number;
+}
+export interface SyGridBatchEditEndEventDetail {
+    mutationId: GridMutationId;
+    status: 'committed' | 'rejected' | 'cancelled';
+    writtenCount: number;
+    rejectedCells: ReadonlyArray<SyGridEditRejectedCell>;
+    reason?: 'escape' | 'api' | 'disconnect';
+    droppedCount?: number;
+}
+export interface SyGridRowValueChangedEventDetail {
+    mutationId: GridMutationId;
+    rowId: GridRowId;
+    writtenCount: number;
+    oldRow: Readonly<Record<string, unknown>>;
+    newRow: Readonly<Record<string, unknown>>;
+}
+export interface SyGridFillRangeOptions {
+    to: {
+        row: number;
+        col: number;
+    };
+    source?: CellRangeBounds;
+    mode?: 'copy' | 'series';
+    formatted?: boolean;
+    atomicity?: 'atomic' | 'best-effort';
+    formulaPolicy?: 'overwrite' | 'skip';
+    allowedDirections?: ReadonlyArray<FillDirection>;
+    pattern?: ((laneValues: ReadonlyArray<unknown>, index: number, target: {
+        row: number;
+        col: number;
+    }) => unknown) | null;
+    setFillValue?: ((target: {
+        row: number;
+        col: number;
+        sourceRow: number;
+        sourceCol: number;
+        proposed: unknown;
+        kind: string;
+    }) => unknown) | null;
+}
+export interface SyGridFillRejectedCell {
+    row: number;
+    col: number;
+    reason: 'rbac' | 'validation' | 'formula-protected';
+}
+export interface SyGridFillRangeReport {
+    status: 'committed' | 'rejected' | 'cancelled' | 'none';
+    mutationId: GridMutationId | null;
+    writtenCount: number;
+    rejectedCells: ReadonlyArray<SyGridFillRejectedCell>;
+    resultingRange: CellRangeBounds | null;
+    transactionRejectedRowIds: ReadonlyArray<GridRowId>;
+}
+export interface SyGridFillStartEventDetail {
+    mode: FillPlanMode;
+    source: CellRangeBounds;
+    target: CellRangeBounds | null;
+    direction: FillDirection | null;
+    mutationId: GridMutationId;
+    sourceRangeId: number;
+}
+export interface SyGridFillEndEventDetail {
+    mutationId: GridMutationId;
+    status: 'committed' | 'rejected' | 'cancelled';
+    writtenCount: number;
+    rejectedCells: ReadonlyArray<SyGridFillRejectedCell>;
+    resultingRange: CellRangeBounds;
+    reason?: unknown;
+}
+export type SyGridDisplayRowKind = 'data' | 'group' | 'group-footer' | 'tree' | 'tree-filler' | 'pivot' | 'pivot-grand-total';
+export type SyGridDisplayRowIdentity = 'row-id' | 'key-path' | 'singleton';
+export type SyGridDisplayRowFeature = 'select' | 'focus' | 'edit' | 'export' | 'quick-filter' | 'expand';
+export type SyGridDisplayRowRefusal = 'no-backing-data' | 'selects-descendants-instead' | 'derived-row' | 'not-expandable';
+export interface SyGridDisplayRowPolicy {
+    kind: SyGridDisplayRowKind;
+    hasBackingData: boolean;
+    identity: SyGridDisplayRowIdentity;
+    selectableAsData: boolean;
+    selectsDescendants: boolean;
+    editable: boolean;
+    focusable: boolean;
+    exportsAsDataRow: boolean;
+    exportsAsSummary: boolean;
+    quickFilterSubject: boolean;
+}
+export interface SyGridDisplayRowDecision {
+    allowed: boolean;
+    feature: SyGridDisplayRowFeature;
+    kind: SyGridDisplayRowKind;
+    reason: SyGridDisplayRowRefusal | null;
+    instead: string;
+}
+export interface SyGridDisplayRowInfo {
+    index: number;
+    kind: SyGridDisplayRowKind;
+    policy: SyGridDisplayRowPolicy;
+    keyPath: ReadonlyArray<string> | null;
+    level: number;
+    label: string | null;
+    features: ReadonlyArray<SyGridDisplayRowDecision>;
+}
+export type SyGridPivotCombinationFeature = 'rowGrouping' | 'treeData' | 'masterDetail' | 'serverSide' | 'viewport' | 'infinite' | 'pagination' | 'quickFilter' | 'columnFilter' | 'sort' | 'rowSpan' | 'colSpan' | 'fullWidthRows' | 'pinnedRows' | 'alignedGrids' | 'rowDrag' | 'clipboard' | 'export' | 'cellSelection';
+export type SyGridPivotCombinationSupport = 'supported' | 'delegated' | 'superseded' | 'yields' | 'unsupported';
+export type SyGridPivotCombinationWinner = 'pivot' | 'other' | 'both' | 'neither';
+export interface SyGridPivotCombinationEntry {
+    feature: SyGridPivotCombinationFeature;
+    support: SyGridPivotCombinationSupport;
+    winner: SyGridPivotCombinationWinner;
+    warning: string | null;
+    docs: string;
+}
+export interface SyGridPivotCombinationReport {
+    pivotRequested: boolean;
+    pivotActive: boolean;
+    delegated: boolean;
+    activeFeatures: ReadonlyArray<SyGridPivotCombinationFeature>;
+    ignoredFeatures: ReadonlyArray<SyGridPivotCombinationFeature>;
+    winningFeatures: ReadonlyArray<SyGridPivotCombinationFeature>;
+    warnings: ReadonlyArray<string>;
+    entries: ReadonlyArray<SyGridPivotCombinationEntry>;
+}
+export interface SyGridPivotCombinationConflictDetail {
+    feature: SyGridPivotCombinationFeature;
+    support: SyGridPivotCombinationSupport;
+    winner: SyGridPivotCombinationWinner;
+    warning: string;
+    pivotActive: boolean;
+}
+export interface SyGridPivotColumnMove {
+    colId: string;
+    from: number;
+    to: number;
+}
+export interface SyGridPivotColumnsChangedDetail {
+    retained: string[];
+    added: string[];
+    removed: string[];
+    moved: SyGridPivotColumnMove[];
+    axesChanged: boolean;
+    columnCount: number;
+}
+export type SyGridPivotColumnKind = 'row-header' | 'value' | 'total' | 'group';
+export interface SyGridPivotColumnIdentity {
+    valueColumn: string;
+    pivotKey: string;
+    isTotal: boolean;
+}
+export interface SyGridPivotSecondaryColumn {
+    colId: string;
+    kind: SyGridPivotColumnKind;
+    headerName: string;
+    identity: SyGridPivotColumnIdentity | null;
+    parentGroupId: string | null;
+    depth: number;
+    leafIndex: number;
+    width: number | null;
+    pinned: 'left' | 'right' | null;
+    generated: boolean;
+}
+export interface SyGridPivotAxes {
+    rowGroupColumns: ReadonlyArray<string>;
+    pivotColumns: ReadonlyArray<string>;
+    valueColumns: ReadonlyArray<string>;
+    includeTotals: boolean;
+}
+export interface SyGridPivotSecondaryColumns {
+    columns: ReadonlyArray<SyGridPivotSecondaryColumn>;
+    leaves: ReadonlyArray<SyGridPivotSecondaryColumn>;
+    groups: ReadonlyArray<SyGridPivotSecondaryColumn>;
+    unparsed: ReadonlyArray<string>;
+    duplicateIds: ReadonlyArray<string>;
+    axes: SyGridPivotAxes;
+}
+export type SyGridGroupCheckState = 'checked' | 'unchecked' | 'indeterminate';
+export type SyGridGroupCheckEvidence = 'complete' | 'partial';
+export type SyGridGroupDescendantScope = 'all' | 'filtered';
+export interface SyGridGroupCheckStatesOptions {
+    descendantScope?: SyGridGroupDescendantScope;
+}
+export interface SyGridGroupCheckStateEntry {
+    key: string;
+    label: string;
+    level: number;
+    state: SyGridGroupCheckState;
+    evidence: SyGridGroupCheckEvidence;
+    selected: number;
+    total: number;
+    unloaded: number;
+    unloadedSelected: boolean | null;
+}
+export type SyGridGroupCheckUnavailableReason = 'not-grouped' | 'collapsed-groups' | 'tree-data' | 'server-side' | 'pivot-mode' | 'no-row-id';
+export interface SyGridGroupCheckStatesReport {
+    status: 'ok' | 'unavailable';
+    reason: SyGridGroupCheckUnavailableReason | null;
+    groupCount: number;
+    leafCount: number;
+    descendantScope: SyGridGroupDescendantScope;
+    states: ReadonlyArray<SyGridGroupCheckStateEntry>;
+}
+export type SyGridServerRefreshMode = 'soft' | 'purge';
+export interface SyGridServerRefreshInput {
+    route?: ReadonlyArray<string>;
+    mode?: SyGridServerRefreshMode;
+}
+export type SyGridServerRefreshStatus = 'accepted' | 'invalid-route' | 'store-not-open' | 'not-server-side';
+export interface SyGridServerRefreshResult {
+    status: SyGridServerRefreshStatus;
+    storeId: string;
+    mode: SyGridServerRefreshMode;
+    reloadedStoreIds: ReadonlyArray<string>;
+    closedStoreIds: ReadonlyArray<string>;
+    recreatedStoreIds: ReadonlyArray<string>;
+    abortedStoreIds: ReadonlyArray<string>;
+    rescuedLoadingBlocks: number;
+    generation: number;
+    issue: string;
+}
+export interface SyGridServerTransactionInput {
+    route?: ReadonlyArray<string>;
+    add?: ReadonlyArray<Record<string, unknown>>;
+    addIndex?: number;
+    update?: ReadonlyArray<Record<string, unknown>>;
+    remove?: ReadonlyArray<Record<string, unknown>>;
+}
+export type SyGridServerTransactionStatus = 'applied' | 'route-invalid' | 'store-not-found' | 'store-loading' | 'cancelled' | 'not-server-side' | 'no-row-id';
+export interface SyGridServerTransactionResult {
+    status: SyGridServerTransactionStatus;
+    storeId: string;
+    added: ReadonlyArray<Record<string, unknown>>;
+    updated: ReadonlyArray<Record<string, unknown>>;
+    removed: ReadonlyArray<Record<string, unknown>>;
+    unresolved: ReadonlyArray<Record<string, unknown>>;
+    aggregateStaleStoreIds: ReadonlyArray<string>;
+    regroupOwedRowIds: ReadonlyArray<string>;
+    closedStoreIds: ReadonlyArray<string>;
+    droppedNodePaths: ReadonlyArray<string>;
+    droppedExpandedPaths: ReadonlyArray<string>;
+    issue: string;
+}
+export type SyGridServerTransactionEnqueueStatus = 'queued' | 'refused-destroyed' | 'not-server-side' | 'no-row-id';
+export interface SyGridServerTransactionEnqueue {
+    status: SyGridServerTransactionEnqueueStatus;
+    txnId: number;
+    issue: string;
+}
+export type SyGridServerFlushCause = 'window' | 'api' | 'destroy-drain';
+export type SyGridServerTransactionSettlement = {
+    disposition: 'flushed';
+    txnId: number;
+    batchId: number;
+    cause: SyGridServerFlushCause;
+    result: SyGridServerTransactionResult;
+} | {
+    disposition: 'cancelled';
+    txnId: number;
+    result: SyGridServerTransactionResult;
+} | {
+    disposition: 'destroyed';
+    txnId: number;
+    result: SyGridServerTransactionResult;
+};
+export type SyGridServerFlushStatus = 'flushed' | 'empty' | 'refused-reentrant' | 'refused-destroyed';
+export interface SyGridServerFlushReport {
+    status: SyGridServerFlushStatus;
+    batchId: number;
+    settledCount: number;
+    issue: string;
+}
+export type SyGridServerStoreStatus = 'empty' | 'loading' | 'partial' | 'loaded' | 'failed' | 'stale';
+export interface SyGridServerBlockSnapshot {
+    blockNumber: number;
+    status: 'loading' | 'loaded' | 'failed';
+    rowCount: number;
+    startRow: number;
+    endRow: number;
+    lastAccess: number;
+}
+export interface SyGridServerCacheSnapshot {
+    present: boolean;
+    blockSize: number;
+    maxBlocks: number;
+    rowCount: number;
+    lastRowKnown: boolean;
+    virtualRowCount: number;
+    loadedBlockCount: number;
+    loadingBlockCount: number;
+    failedBlockCount: number;
+    complete: boolean;
+    firstUnloadedBlock: number;
+    accessSeq: number;
+    blocks: ReadonlyArray<SyGridServerBlockSnapshot>;
+}
+export interface SyGridServerStoreSnapshot {
+    storeId: string;
+    kind: 'root' | 'nested' | 'tree' | 'pivot';
+    routeKeys: ReadonlyArray<string>;
+    path: string;
+    level: number;
+    leaf: boolean;
+    storeSeq: number;
+    generation: number;
+    status: SyGridServerStoreStatus;
+    hasParent: boolean;
+    parentStoreId: string;
+    expanded: boolean;
+    cache: SyGridServerCacheSnapshot;
+}
+export interface SyGridServerStateReport {
+    registryId: string;
+    topologySignature: string;
+    generation: number;
+    seq: number;
+    storeCount: number;
+    stores: ReadonlyArray<SyGridServerStoreSnapshot>;
+    nodesWithoutStore: ReadonlyArray<string>;
+    expandedWithoutNode: ReadonlyArray<string>;
+    discardedStaleLandings: number;
+}
+export type SyGridServerSelectionModel = 'flat' | 'group';
+export interface SyGridServerGroupToggledNode {
+    rowId: string;
+    selectAllChildren?: boolean;
+    toggledNodes?: ReadonlyArray<SyGridServerGroupToggledNode>;
+}
+export type SyGridServerSelectionStatus = 'ok' | 'not-server-side' | 'no-row-id' | 'model-mismatch';
+export interface SyGridServerSelectionState {
+    status: SyGridServerSelectionStatus;
+    model: SyGridServerSelectionModel;
+    selectAll: boolean;
+    toggledRowIds: ReadonlyArray<string>;
+    toggledNodes: ReadonlyArray<SyGridServerGroupToggledNode>;
+    selectedCount: number;
+    selectedCountKnown: boolean;
+    loadedSelectedRowIds: ReadonlyArray<string>;
+    issue: string;
+}
+export type SyGridServerSelectionSetStatus = 'applied' | 'refused' | 'not-server-side' | 'no-row-id' | 'model-mismatch';
+export interface SyGridServerSelectionSetResult {
+    status: SyGridServerSelectionSetStatus;
+    model: SyGridServerSelectionModel;
+    reason: string;
+    droppedDuplicateIds: ReadonlyArray<string>;
+    droppedInvalidCount: number;
+    loadedSelectedRowIds: ReadonlyArray<string>;
+    issue: string;
+}
+export interface SyGridServerSelectAllResult {
+    status: 'applied' | 'unchanged' | 'not-server-side' | 'no-row-id';
+    model: SyGridServerSelectionModel;
+    action: 'select' | 'clear';
+    loadedSelectedRowIds: ReadonlyArray<string>;
+    issue: string;
+}
+export interface SyGridServerGroupChildrenResult {
+    status: 'applied' | 'unchanged' | 'refused' | 'not-server-side' | 'no-row-id' | 'model-mismatch';
+    reason: string;
+    groupKeys: ReadonlyArray<string>;
+    action: 'select' | 'deselect';
+    loadedSelectedRowIds: ReadonlyArray<string>;
+    issue: string;
+}
+export type SyGridRowLayoutStatus = 'ok' | 'not-configured' | 'not-client-side' | 'auto-height';
+export type SyGridSpanCombination = 'single' | 'row' | 'column' | 'rectangular';
+export interface SyGridSpanAddress {
+    readonly rowIndex: number;
+    readonly colIndex: number;
+}
+export interface SyGridRowSpanRejection {
+    readonly reason: 'invalid-span' | 'callback-threw' | 'non-deterministic' | 'clamped-to-section' | 'clamped-to-end' | 'clamped-to-max';
+    readonly index: number;
+    readonly requested: number | null;
+    readonly applied: number;
+    readonly detail: string;
+}
+export interface SyGridColSpanRejection {
+    readonly reason: 'invalid-span' | 'callback-threw' | 'non-deterministic' | 'clamped-to-container' | 'clamped-to-boundary' | 'clamped-to-end';
+    readonly colIndex: number;
+    readonly requested: number | null;
+    readonly applied: number;
+    readonly detail: string;
+}
+export interface SyGridRowSpanReport {
+    readonly status: SyGridRowLayoutStatus;
+    readonly colId: string;
+    readonly rowCount: number;
+    readonly spans: ReadonlyArray<{
+        readonly originIndex: number;
+        readonly span: number;
+        readonly endIndex: number;
+    }>;
+    readonly rejected: ReadonlyArray<SyGridRowSpanRejection>;
+    readonly callbackCalls: number;
+    readonly cache: {
+        readonly revision: number;
+        readonly entries: number;
+        readonly hits: number;
+        readonly misses: number;
+        readonly invalidations: number;
+        readonly lastReason: 'sort' | 'filter' | 'group' | 'data' | 'height' | 'columns' | 'manual' | null;
+    };
+    readonly maxRowSpan: number;
+}
+export interface SyGridCellSpanInfo {
+    readonly status: SyGridRowLayoutStatus;
+    readonly rowIndex: number;
+    readonly colIndex: number;
+    readonly colId: string;
+    readonly origin: SyGridSpanAddress;
+    readonly rowSpan: number;
+    readonly colSpan: number;
+    readonly combination: SyGridSpanCombination;
+    readonly covered: boolean;
+    readonly container: 'left' | 'middle' | 'right';
+    readonly rect: {
+        readonly heightPx: number | null;
+        readonly widthPx: number | null;
+    };
+    readonly rejected: {
+        readonly row: ReadonlyArray<SyGridRowSpanRejection>;
+        readonly column: ReadonlyArray<SyGridColSpanRejection>;
+    };
+}
+export type SyGridSpanFeature = 'selection' | 'focus' | 'edit' | 'copy' | 'fill' | 'export' | 'aria';
+export interface SyGridSpanConflict {
+    readonly reason: 'ragged-row-span' | 'ragged-col-span' | 'overlapping-rect' | 'dropped-cover';
+    readonly rowIndex: number;
+    readonly colIndex: number;
+    readonly requestedRowSpan: number;
+    readonly requestedColSpan: number;
+    readonly appliedRowSpan: number;
+    readonly appliedColSpan: number;
+    readonly detail: string;
+}
+export interface SyGridSpanInteractionQuery {
+    readonly feature: SyGridSpanFeature;
+    readonly rowIndex: number;
+    readonly colId: string;
+}
+export interface SyGridSpanInteractionReport {
+    readonly status: SyGridRowLayoutStatus;
+    readonly window: {
+        readonly startIndex: number;
+        readonly endIndex: number;
+    };
+    readonly renderRange: {
+        readonly startIndex: number;
+        readonly endIndex: number;
+    };
+    readonly report: {
+        readonly rowCount: number;
+        readonly columnCount: number;
+        readonly cellCount: number;
+        readonly coveredCount: number;
+        readonly combinations: Readonly<Record<SyGridSpanCombination, number>>;
+        readonly conflicts: Readonly<Record<SyGridSpanConflict['reason'], number>>;
+        readonly rowAxisRejections: number;
+        readonly colAxisRejections: number;
+    } | null;
+    readonly conflicts: ReadonlyArray<SyGridSpanConflict>;
+    readonly exportMode: 'origin-once' | 'repeat';
+    readonly access: {
+        readonly feature: SyGridSpanFeature;
+        readonly requested: SyGridSpanAddress;
+        readonly origin: SyGridSpanAddress;
+        readonly redirected: boolean;
+        readonly mutating: boolean;
+    } | null;
+}
+export interface SyGridSpanConflictEventDetail {
+    readonly conflicts: ReadonlyArray<SyGridSpanConflict>;
+    readonly renderRange: {
+        readonly startIndex: number;
+        readonly endIndex: number;
+    };
+}
+export type SyGridRowDropPosition = 'above' | 'below';
+export interface SyGridRowDragItem {
+    readonly dragId: string;
+    readonly mode: 'managed' | 'unmanaged';
+    readonly sourceZoneId: string;
+    readonly rowKey: string;
+    readonly startIndex: number;
+    readonly data: unknown;
+    readonly rowKeys: ReadonlyArray<string>;
+    readonly rows: ReadonlyArray<unknown>;
+}
+export interface SyGridRowDragTarget {
+    readonly zoneId: string;
+    readonly rowIndex: number | null;
+    readonly rowKey: string | null;
+    readonly position: SyGridRowDropPosition;
+}
+export interface SyGridRowDragEventDetail {
+    readonly dragId: string;
+    readonly item: SyGridRowDragItem;
+    readonly target: SyGridRowDragTarget | null;
+    readonly insertionIndex: number | null;
+    readonly stale?: boolean;
+    readonly keyboard: boolean;
+}
+export type SyGridRowDragEndReason = 'drop' | 'escape' | 'cancel' | 'no-target' | 'pointer-cancel' | 'capture-lost' | 'blur';
+export type SyGridDragOrphanCause = 'pointer-capture-lost' | 'pointer-cancel' | 'element-disconnected' | 'permission-revoked' | 'document-hidden' | 'window-blur' | 'watchdog-timeout';
+export interface SyGridRowTransferEntry {
+    readonly rowKey: string;
+    readonly outcome: string;
+    readonly reason: string | null;
+    readonly detail: string;
+}
+export interface SyGridRowTransferReport {
+    readonly transferId: string;
+    readonly sourceZoneId: string;
+    readonly targetZoneId: string;
+    readonly mode: 'move' | 'copy';
+    readonly requested: number;
+    readonly transferred: number;
+    readonly refused: number;
+    readonly entries: ReadonlyArray<SyGridRowTransferEntry>;
+    readonly [extra: string]: unknown;
+}
+export interface SyGridRowDragEndDetail extends SyGridRowDragEventDetail {
+    readonly delegated: boolean;
+    readonly suggestedInsertionIndex: number | null;
+    readonly transfer: SyGridRowTransferReport | null;
+    readonly residue: ReadonlyArray<string>;
+}
+export interface SyGridRowDragCancelDetail {
+    readonly dragId: string;
+    readonly item: SyGridRowDragItem | null;
+    readonly reason: SyGridRowDragEndReason;
+    readonly cause: SyGridDragOrphanCause | 'escape' | 'cancel' | 'no-target' | 'keyboard';
+    readonly residue: ReadonlyArray<string>;
+}
+export interface SyGridRowsTransferredDetail {
+    readonly transferId: string;
+    readonly sourceZoneId: string;
+    readonly targetZoneId: string;
+    readonly mode: 'move' | 'copy';
+    readonly report: SyGridRowTransferReport;
+    readonly outcome: {
+        readonly outcome: 'applied';
+        readonly sourceWritten: boolean;
+        readonly targetWritten: boolean;
+    } | {
+        readonly outcome: 'reverted';
+        readonly failedSide: 'source' | 'target';
+        readonly error: string;
+        readonly targetUndone: boolean;
+    } | {
+        readonly outcome: 'compromised';
+        readonly [extra: string]: unknown;
+    };
+    readonly commit: unknown;
+}
+export interface SyGridRowDragStartInput {
+    readonly rowIndex?: number;
+    readonly rowId?: GridRowId;
+    readonly mode?: 'keyboard' | 'pointer';
+}
+export type SyGridRowDragStartResult = {
+    readonly status: 'grabbed';
+    readonly rowIndex: number;
+    readonly rowKey: string;
+} | {
+    readonly status: 'armed';
+    readonly dragId: string;
+    readonly rowKey: string;
+    readonly rowIndex: number;
+    readonly rowKeys: ReadonlyArray<string>;
+} | {
+    readonly status: 'pending';
+    readonly rowIndex: number;
+    readonly rowKey: string;
+} | {
+    readonly status: 'refused';
+    readonly reason: string;
+    readonly detail: string;
+};
+export interface SyGridRowDragSessionReport {
+    readonly enabled: boolean;
+    readonly loaded: boolean;
+    readonly gesture: {
+        readonly phase: 'idle' | 'pending' | 'armed' | 'yielded';
+        readonly pointerType: 'mouse' | 'pen' | 'touch' | null;
+        readonly travelled: number;
+        readonly yieldReason: string | null;
+        readonly [extra: string]: unknown;
+    } | null;
+    readonly session: {
+        readonly dragId: string;
+        readonly mode: 'managed' | 'unmanaged';
+        readonly phase: 'dragging' | 'ended';
+        readonly item: SyGridRowDragItem;
+        readonly target: SyGridRowDragTarget | null;
+        readonly [extra: string]: unknown;
+    } | null;
+    readonly report: unknown;
+    readonly events: ReadonlyArray<unknown>;
+    readonly residue: ReadonlyArray<string>;
+    readonly keyboard: {
+        readonly grabbed: boolean;
+        readonly originIndex: number;
+        readonly currentIndex: number;
+    } | null;
+    readonly zones: ReadonlyArray<string>;
+    readonly lastAutoScroll: unknown;
+}
+export interface SyGridDropZoneInput {
+    readonly id: string;
+    readonly kind: 'grid' | 'external';
+    readonly element?: HTMLElement | string;
+    readonly grid?: HTMLElement;
+    readonly accepting?: boolean;
+    readonly schema?: {
+        readonly id: string;
+        readonly fields: ReadonlyArray<{
+            readonly field: string;
+            readonly type: 'string' | 'number' | 'boolean' | 'date' | 'any';
+            readonly required: boolean;
+        }>;
+        readonly allowExtraFields: boolean;
+    };
+    readonly permit?: (request: {
+        readonly sourceZoneId: string;
+        readonly targetZoneId: string;
+        readonly mode: 'move' | 'copy';
+        readonly rowKey: string;
+        readonly row: unknown;
+        readonly context: unknown;
+    }) => {
+        readonly allow: true;
+    } | {
+        readonly allow: false;
+        readonly detail: string;
+    };
+    readonly adapt?: (row: unknown, sourceZoneId: string) => unknown;
+    readonly consumes?: boolean;
+    readonly mode?: 'move' | 'copy';
+    readonly duplicateIds?: 'refuse' | 'skip' | 'replace';
+    readonly atomicity?: 'all-or-nothing' | 'best-effort';
+    readonly onDrop?: (target: unknown, commit: unknown) => void;
+}
+export type SyGridDropZoneRegistration = {
+    readonly outcome: 'added';
+    readonly zoneId: string;
+    readonly generation: number;
+} | {
+    readonly outcome: 'refused';
+    readonly zoneId: string;
+    readonly reason: string;
+    readonly detail: string;
+};
+export interface SyGridDropZonesReport {
+    readonly zones: ReadonlyArray<{
+        readonly id: string;
+        readonly kind: 'grid' | 'external';
+        readonly accepting: boolean;
+        readonly consumes: boolean;
+        readonly registeredAt: number;
+    }>;
+    readonly generation: number;
+    readonly stats: unknown;
+    readonly activeTargetZoneId: string | null;
+    readonly ownZoneId: string;
+}
+export interface SyGridDragSafetyReport {
+    readonly live: number;
+    readonly stuck: ReadonlyArray<string>;
+    readonly aborts: number;
+    readonly topCauses: ReadonlyArray<{
+        readonly cause: SyGridDragOrphanCause;
+        readonly count: number;
+    }>;
+    readonly watchdogTicks: number;
+    readonly stats: unknown;
+}
+export type SyGridPinnedRowSection = 'top' | 'bottom';
+export type SyGridPinnedRowBand = 'top' | 'center' | 'bottom';
+export interface SyGridPinnedRowInput<TData = GridData> {
+    readonly id: GridRowId;
+    readonly data: TData;
+}
+export interface SyGridPinnedRowSetInput<TData = GridData> {
+    readonly top?: ReadonlyArray<SyGridPinnedRowInput<TData>>;
+    readonly bottom?: ReadonlyArray<SyGridPinnedRowInput<TData>>;
+}
+export type SyGridPinnedRowRejectionReason = 'invalid-id' | 'already-pinned' | 'duplicate-id' | 'section-conflict' | 'unknown-id' | 'invalid-slice' | 'row-id-required' | 'not-loaded';
+export interface SyGridPinnedRowRejection {
+    readonly reason: SyGridPinnedRowRejectionReason;
+    readonly id: GridRowId | null;
+    readonly detail: string;
+}
+export interface SyGridPinnedRow<TData = GridData> {
+    readonly id: GridRowId;
+    readonly section: SyGridPinnedRowSection;
+    readonly pinSeq: number;
+    readonly rev: number;
+    readonly data: TData;
+}
+export type SyGridPinnedRowChange<TData = GridData> = {
+    readonly kind: 'pinned';
+    readonly id: GridRowId;
+    readonly section: SyGridPinnedRowSection;
+    readonly index: number;
+    readonly row: SyGridPinnedRow<TData>;
+} | {
+    readonly kind: 'unpinned';
+    readonly id: GridRowId;
+    readonly section: SyGridPinnedRowSection;
+    readonly index: number;
+    readonly row: SyGridPinnedRow<TData>;
+} | {
+    readonly kind: 'moved';
+    readonly id: GridRowId;
+    readonly from: {
+        readonly section: SyGridPinnedRowSection;
+        readonly index: number;
+    };
+    readonly to: {
+        readonly section: SyGridPinnedRowSection;
+        readonly index: number;
+    };
+    readonly row: SyGridPinnedRow<TData>;
+} | {
+    readonly kind: 'updated';
+    readonly id: GridRowId;
+    readonly section: SyGridPinnedRowSection;
+    readonly index: number;
+    readonly row: SyGridPinnedRow<TData>;
+    readonly previous: SyGridPinnedRow<TData>;
+};
+export interface SyGridPinnedRowsResult<TData = GridData> {
+    readonly status: 'applied' | 'unchanged' | 'refused';
+    readonly changes: ReadonlyArray<SyGridPinnedRowChange<TData>>;
+    readonly rejected: ReadonlyArray<SyGridPinnedRowRejection>;
+    readonly top: ReadonlyArray<GridRowId>;
+    readonly bottom: ReadonlyArray<GridRowId>;
+}
+export type SyGridPinnedRowFeature = 'row-selection' | 'range-selection' | 'cell-edit' | 'row-edit' | 'fill' | 'clipboard-copy' | 'clipboard-paste' | 'export-csv' | 'export-xlsx' | 'export-pdf' | 'formula-evaluate' | 'formula-reference' | 'rbac-read' | 'rbac-write' | 'keyboard-navigate';
+export interface SyGridPinnedRowPolicyDecision {
+    readonly feature: SyGridPinnedRowFeature;
+    readonly support: 'supported' | 'unsupported' | 'delegated';
+    readonly reason: string;
+    readonly detail: string;
+    readonly delegateKey: 'row-id' | 'pinned-address' | null;
+    readonly mutating: boolean;
+}
+export interface SyGridPinnedRowsReport<TData = GridData> {
+    readonly loaded: boolean;
+    readonly top: ReadonlyArray<SyGridPinnedRow<TData>>;
+    readonly bottom: ReadonlyArray<SyGridPinnedRow<TData>>;
+    readonly count: number;
+    readonly displayCount: number;
+    readonly centerCount: number;
+    readonly dangling: ReadonlyArray<GridRowId>;
+    readonly idCollisions: ReadonlyArray<GridRowId>;
+    readonly stableRowIds: boolean;
+    readonly policy: ReadonlyArray<SyGridPinnedRowPolicyDecision>;
+}
+export interface SyGridPinnedRowInfo<TData = GridData> {
+    readonly displayIndex: number;
+    readonly band: SyGridPinnedRowBand;
+    readonly index: number;
+    readonly row: SyGridPinnedRow<TData> | null;
+    readonly policy: ReadonlyArray<SyGridPinnedRowPolicyDecision>;
+}
+export interface SyGridPinnedRowsChangedDetail<TData = GridData> {
+    readonly changes: ReadonlyArray<SyGridPinnedRowChange<TData>>;
+    readonly top: ReadonlyArray<GridRowId>;
+    readonly bottom: ReadonlyArray<GridRowId>;
+    readonly source: 'api' | 'prop' | 'state-restore';
+}
+export type SyGridFullWidthRowKind = 'detail' | 'group' | 'group-footer' | 'loading' | 'custom';
+export type SyGridFullWidthMode = 'full-width' | 'embedded';
+export type SyGridFullWidthContainer = 'left' | 'middle' | 'right';
+export interface SyGridFullWidthRenderParams<TData = GridData> {
+    readonly row: TData;
+    readonly rowId: GridRowId;
+    readonly rowIndex: number;
+    readonly rowKind: SyGridFullWidthRowKind;
+    readonly startCol: number;
+    readonly endCol: number;
+    readonly mountKey: string;
+    readonly container: SyGridFullWidthContainer | null;
+}
+export interface SyGridFullWidthRenderer<TData = GridData> {
+    readonly mode?: SyGridFullWidthMode;
+    readonly create: (params: SyGridFullWidthRenderParams<TData>) => HTMLElement | {
+        readonly gui: HTMLElement;
+    };
+    readonly refresh?: (instance: HTMLElement | {
+        readonly gui: HTMLElement;
+    }, params: SyGridFullWidthRenderParams<TData>) => boolean;
+    readonly destroy?: (instance: HTMLElement | {
+        readonly gui: HTMLElement;
+    }, params: SyGridFullWidthRenderParams<TData>) => void;
+}
+export interface SyGridFullWidthSegment {
+    readonly container: SyGridFullWidthContainer | null;
+    readonly startCol: number;
+    readonly endCol: number;
+    readonly colSpan: number;
+    readonly mountKey: string;
+}
+export interface SyGridFullWidthRowInfo<TData = GridData> {
+    readonly rowIndex: number;
+    readonly kind: 'cells' | 'full-width';
+    readonly rowId: GridRowId | null;
+    readonly mode: SyGridFullWidthMode | null;
+    readonly height: number | null;
+    readonly heightSource: 'measured' | 'declared' | 'uniform' | null;
+    readonly segments: ReadonlyArray<SyGridFullWidthSegment>;
+    readonly mounted: boolean;
+    readonly rowKind?: TData;
+}
+export type SyGridFullWidthRefusalReason = 'predicate-threw' | 'non-deterministic' | 'renderer-missing' | 'renderer-threw' | 'mode-mismatch' | 'kind-conflict' | 'invalid-row-id' | 'duplicate-row-id' | 'empty-container' | 'invalid-height';
+export interface SyGridFullWidthLayoutReport {
+    readonly declared: boolean;
+    readonly loaded: boolean;
+    readonly rowCount: number;
+    readonly fullWidthCount: number;
+    readonly mountCount: number;
+    readonly refusals: ReadonlyArray<{
+        readonly reason: SyGridFullWidthRefusalReason;
+        readonly rowIndex: number;
+        readonly rowId: GridRowId | null;
+        readonly requested: string;
+        readonly applied: string;
+        readonly detail: string;
+    }>;
+    readonly predicateCalls: number;
+}
+export interface SyGridRowLayoutRefusedDetail {
+    readonly area: 'pinned-rows' | 'full-width-rows' | 'aligned-grids' | 'reparent';
+    readonly feature: string;
+    readonly reason: string;
+    readonly detail: string;
+    readonly rowIndex: number | null;
+    readonly colIndex: number | null;
+}
+export type SyGridAlignedPinSide = 'left' | 'right' | null;
+export interface SyGridAlignedColumnState {
+    readonly colId: string;
+    readonly width: number;
+    readonly visible: boolean;
+    readonly pinned: SyGridAlignedPinSide;
+}
+export type SyGridAlignedMismatchReason = 'absent-locally' | 'extra-locally' | 'disjoint' | 'duplicate-column' | 'unknown-column';
+export interface SyGridAlignedMismatch {
+    readonly reason: SyGridAlignedMismatchReason;
+    readonly memberId: string;
+    readonly colId: string | null;
+    readonly detail: string;
+}
+export type SyGridAlignedGridsInput = {
+    readonly group: string;
+} | ReadonlyArray<HTMLElement> | null;
+export type SyGridAlignedGridsRefusalReason = 'invalid-input' | 'empty-group-name' | 'no-peers' | 'not-a-grid' | 'peer-refused';
+export interface SyGridAlignedGridsResult {
+    readonly status: 'joined' | 'left' | 'unchanged' | 'refused';
+    readonly group: string | null;
+    readonly reason: SyGridAlignedGridsRefusalReason | null;
+    readonly detail: string | null;
+    readonly seeded: boolean;
+    readonly members: ReadonlyArray<string>;
+    readonly mismatches: ReadonlyArray<SyGridAlignedMismatch>;
+    readonly peersConfigured: number;
+}
+export interface SyGridAlignedStats {
+    readonly accepted: number;
+    readonly echoes: number;
+    readonly noOps: number;
+    readonly refused: number;
+    readonly publishes: number;
+    readonly queued: number;
+    readonly maxDrainDepth: number;
+    readonly drainOverflows: number;
+    readonly applyThrew: number;
+}
+export interface SyGridAlignedGridsReport {
+    readonly configured: boolean;
+    readonly group: string | null;
+    readonly memberId: string;
+    readonly members: ReadonlyArray<string>;
+    readonly generation: number;
+    readonly alignedColumns: ReadonlyArray<string>;
+    readonly canonical: {
+        readonly columns: ReadonlyArray<SyGridAlignedColumnState>;
+        readonly scrollLeft: number;
+    } | null;
+    readonly mismatches: ReadonlyArray<SyGridAlignedMismatch>;
+    readonly stats: SyGridAlignedStats | null;
+}
+export type SyGridReparentAtomicity = 'all-or-nothing' | 'best-effort';
+export type SyGridReparentRefusalReason = 'unknown-node' | 'unknown-parent' | 'self-drop' | 'descendant-drop' | 'unresolved-ancestry' | 'existing-cycle' | 'filtered-parent' | 'unloaded-parent' | 'no-op' | 'stale-revision' | 'duplicate-node' | 'depth-limit' | 'ambiguous-id' | 'partial-failure' | 'empty-request' | 'index-out-of-range' | 'not-id-linkage' | 'disposed';
+export interface SyGridReparentEntry {
+    readonly nodeId: string;
+    readonly status: 'moved' | 'refused';
+    readonly reason: SyGridReparentRefusalReason | null;
+    readonly detail: string;
+    readonly previousParentId: string | null;
+    readonly descendantCount: number;
+}
+export interface SyGridReparentRequest {
+    readonly nodeIds: ReadonlyArray<string>;
+    readonly newParentId: string | null;
+    readonly childIndex?: number;
+    readonly atomicity?: SyGridReparentAtomicity;
+    readonly maxDepth?: number;
+    readonly allowFilteredParent?: boolean;
+    readonly expectedRevisions?: Readonly<Record<string, number>>;
+}
+export type SyGridReparentResult = {
+    readonly status: 'applied';
+    readonly newParentId: string | null;
+    readonly moved: ReadonlyArray<SyGridReparentEntry>;
+    readonly refused: ReadonlyArray<SyGridReparentEntry>;
+    readonly rowCount: number;
+} | {
+    readonly status: 'refused';
+    readonly reason: SyGridReparentRefusalReason;
+    readonly detail: string;
+    readonly entries: ReadonlyArray<SyGridReparentEntry>;
+};
+export interface SyGridTreeReparentedDetail {
+    readonly newParentId: string | null;
+    readonly childIndex: number;
+    readonly moved: ReadonlyArray<SyGridReparentEntry>;
+    readonly refused: ReadonlyArray<SyGridReparentEntry>;
+    readonly bumped: ReadonlyArray<string>;
+    readonly source: 'api' | 'drag';
+}
+export interface SyGridServerPivotColumnDescriptor {
+    colId: string;
+    kind: 'value' | 'group';
+    headerName: string;
+    field: string;
+    groupPath: ReadonlyArray<string>;
+    identityKey: string;
+    hasParentGroup: boolean;
+    parentGroupId: string;
+    depth: number;
+    leafIndex: number;
+    meta: Readonly<Record<string, unknown>>;
+}
+export interface SyGridServerPivotColumnsReport {
+    status: 'ok' | 'no-metadata' | 'refused';
+    source: 'columns' | 'fields' | 'none';
+    stale: boolean;
+    columns: ReadonlyArray<SyGridServerPivotColumnDescriptor>;
+    leafCount: number;
+    groupCount: number;
+    coverageChecked: boolean;
+    fieldsWithoutColumn: ReadonlyArray<string>;
+    leavesWithoutField: ReadonlyArray<string>;
+    duplicateIds: ReadonlyArray<string>;
+    issue: string;
+}
+export type SyGridServerPivotUsageDisposition = 'live' | 'live-stale' | 'unknown-column';
+export interface SyGridServerPivotColumnAudit {
+    status: 'ok' | 'no-metadata' | 'refused';
+    stale: boolean;
+    results: ReadonlyArray<{
+        colId: string;
+        disposition: SyGridServerPivotUsageDisposition;
+    }>;
+    liveCount: number;
+    staleCount: number;
+    unknownCount: number;
+    clean: boolean;
+    issue: string;
+}
+export type SyGridServerStoreUpdateKind = 'fetch-started' | 'block-loaded' | 'block-failed' | 'fetch-aborted' | 'stale-load-discarded' | 'rows-changed';
+export interface SyGridServerStoreUpdatedDetail {
+    mutationId: GridMutationId;
+    storeId: string;
+    storeSeq: number;
+    update: SyGridServerStoreUpdateKind;
+    generation: number;
+    previousStatus: SyGridServerStoreStatus;
+    status: SyGridServerStoreStatus;
+    requestId?: number;
+    blockNumber?: number;
+    rowsLoaded?: number;
+    rowsChanged?: {
+        added: number;
+        updated: number;
+        removed: number;
+    };
+}
+export type SyGridWorkbookInactiveReason = 'formulas-off' | 'not-bound';
+export type SyGridWorkbookFlushCause = 'enroll' | 'resync' | 'commit' | 'flush' | 'spill' | 'spill-undo';
+export interface SyGridWorkbookPropagationDetail {
+    workbookId: string;
+    sheetName: string;
+    workbookKey: number;
+    sheetId: number;
+    registrationId: number;
+    txId: number;
+    generation: number;
+    snapshotHash: string;
+    publishedCellCount: number;
+    changedCellCount: number;
+    clearedCellCount: number;
+    importedCellCount: number;
+    importFailureCount: number;
+    cyclicCellCount: number;
+    unroutedCellCount: number;
+    cause: SyGridWorkbookFlushCause;
+}
+export type SyGridWorkbookRegistrationFailureCode = 'missing-sheet' | 'ambiguous-sheet' | 'stale-binding' | 'unbounded-remote-range' | 'remote-range-too-large' | 'formula-syntax' | 'unexpected';
+export interface SyGridWorkbookRegistrationFailure {
+    col: number;
+    row: number;
+    field: string;
+    source: string;
+    code: SyGridWorkbookRegistrationFailureCode;
+    message: string;
+}
+export interface SyGridWorkbookPublicationStamp {
+    txId: number;
+    generation: number;
+    snapshotHash: string;
+    publishedCellCount: number;
+}
+export interface SyGridWorkbookPropagationState {
+    status: 'active' | 'inactive';
+    reason: SyGridWorkbookInactiveReason | null;
+    workbookId: string;
+    sheetName: string;
+    workbookKey: number;
+    sheetId: number;
+    registrationId: number;
+    generation: number;
+    registeredFormulaCells: number;
+    registrationFailures: ReadonlyArray<SyGridWorkbookRegistrationFailure>;
+    lastPublication: SyGridWorkbookPublicationStamp | null;
+    hubTrackedFormulas: number;
+    hubCyclicCells: number;
+    issue: string;
+}
+export interface SyGridWorkbookFlushReport {
+    status: 'flushed' | 'empty' | 'inactive';
+    reason: SyGridWorkbookInactiveReason | null;
+    transactionCount: number;
+    generations: ReadonlyArray<number>;
+    issue: string;
+}
+export interface SyGridWorkbookSnapshotCell {
+    col: number;
+    row: number;
+    field: string;
+    value: string | number | boolean | null;
+    canonical: string;
+}
+export interface SyGridWorkbookSnapshotReport {
+    status: 'ok' | 'unpublished' | 'inactive';
+    reason: SyGridWorkbookInactiveReason | null;
+    workbookKey: number;
+    sheetId: number;
+    registrationId: number;
+    generation: number;
+    snapshotHash: string;
+    cells: ReadonlyArray<SyGridWorkbookSnapshotCell>;
+    issue: string;
+}
+export type SyGridWorkbookCellVerdict = 'cyclic' | 'cycle-dependent' | 'unproven' | 'proven-acyclic';
+export interface SyGridWorkbookIntegrityCell {
+    col: number;
+    row: number;
+    verdict: SyGridWorkbookCellVerdict;
+}
+export interface SyGridWorkbookIntegrityReport {
+    status: 'ok' | 'inactive';
+    reason: SyGridWorkbookInactiveReason | null;
+    cyclicCells: number;
+    cycleDependentCells: number;
+    unprovenCells: number;
+    provenAcyclicCells: number;
+    sheetVerdicts: ReadonlyArray<SyGridWorkbookIntegrityCell>;
+    publishingCycleCells: number;
+    issue: string;
+}
+export type SyGridSpillRefusalReason = 'workbook-inactive' | 'engine-lane-unsupported' | 'outside-grid' | 'row-unaddressable' | 'invalid-formula' | 'invalid-argument' | 'collision';
+export interface SyGridSpillTarget {
+    col: number;
+    row: number;
+}
+export interface SyGridSpillApplyInput {
+    col: number;
+    row: number;
+    source: string;
+}
+export interface SyGridSpillCollision {
+    col: number;
+    row: number;
+    classes: ReadonlyArray<'occupied' | 'protected' | 'merged-span' | 'spill-overlap'>;
+}
+export interface SyGridSpillApplyResult {
+    status: 'landed' | 'landed-blocked' | 'refused';
+    reason: SyGridSpillRefusalReason | null;
+    mutationId: GridMutationId | null;
+    anchor: SyGridSpillTarget;
+    rows: number;
+    cols: number;
+    collisions: ReadonlyArray<SyGridSpillCollision>;
+    blockingCell: SyGridSpillTarget | null;
+    reconciledEmptyCells: number;
+    unpaintedCells: number;
+    rangeHash: string;
+    stateHash: string;
+    issue: string;
+}
+export interface SyGridSpillClearResult {
+    status: 'cleared' | 'not-an-anchor' | 'refused';
+    reason: SyGridSpillRefusalReason | null;
+    mutationId: GridMutationId | null;
+    anchor: SyGridSpillTarget;
+    issue: string;
+}
+export interface SyGridSpillUndoResult {
+    status: 'undone' | 'unknown-mutation' | 'refused';
+    reason: SyGridSpillRefusalReason | null;
+    mutationId: GridMutationId | null;
+    appliedWrites: number;
+    issue: string;
+}
+export interface SyGridSpillRangeReport {
+    anchor: SyGridSpillTarget;
+    source: string;
+    rows: number;
+    cols: number;
+    status: 'spilled' | 'blocked';
+    rangeHash: string;
+    cellCount: number;
+    cells: ReadonlyArray<SyGridWorkbookSnapshotCell>;
+    unpaintedCells: number;
+}
+export interface SyGridSpillReport {
+    status: 'ok' | 'refused';
+    reason: SyGridSpillRefusalReason | null;
+    engineLane: 'js' | 'dual' | 'none';
+    anchors: ReadonlyArray<SyGridSpillRangeReport>;
+    overlaps: ReadonlyArray<{
+        col: number;
+        row: number;
+        anchors: ReadonlyArray<SyGridSpillTarget>;
+    }>;
+    stateHash: string;
+    issue: string;
+}
+export type SyGridChartCreateParams = ChartLinkCreateParams;
+export type SyGridChartSourceInput = ChartLinkSourceInput;
+export type SyGridChartReport = ChartLinkChartReport;
+export type SyGridChartCreateResult = ChartLinkCreateResult;
+export type SyGridChartUpdateResult = ChartLinkUpdateResult;
+export type SyGridChartDestroyResult = ChartLinkDestroyResult;
+export type SyGridChartMenuReport = ChartLinkMenuReport;
+export type SyGridChartPanelReport = ChartLinkPanelReport;
+export type SyGridChartPanelStop = ChartLinkPanelStop;
+export type SyGridChartFleetReport = ChartLinkFleetReport;
+export type SyGridChartAccessibleReport = ChartLinkAccessibleReport;
+export type SyGridChartExportResult = ChartLinkExportResult;
+export type SyGridChartExportRequest = GridChartExportRequest;
+export type SyGridChartEvent = GridChartEvent;
+export type SyGridChartPermissions = GridChartMenuPermissions;
+export type SyGridChartProperties = GridChartProperties;
+export type SyGridChartSyncMutation = GridChartSyncMutation;
+export type SyGridChartViewColumn = GridChartViewColumn;
+export type SyGridChartViewRow = GridChartViewRow;
+export type SyGridChartCrossFilterAction = GridChartCrossFilterAction;
+export type SyGridChartCrossFilterResult = GridChartCrossFilterResult;
+export type SyGridChartCaptureResult = GridChartModelCaptureResult;
+export interface SyGridChartUpdatePatch {
+    readonly chartType?: string;
+    readonly source?: SyGridChartSourceInput;
+    readonly properties?: Partial<SyGridChartProperties>;
+}
+export interface SyGridChartSyncReport {
+    readonly mutation: SyGridChartSyncMutation;
+    readonly emitted: number;
+    readonly suppressed: number;
+    readonly stale: number;
+}
+export interface SyGridChartRestoreResult {
+    readonly report: GridChartModelRestoreReport;
+    readonly created: readonly SyGridChartReport[];
+}
+export type GridLiveObjectKind = 'column' | 'columnGroup' | 'row';
+export type GridLiveObjectEventType = 'widthChanged' | 'visibilityChanged' | 'pinnedChanged' | 'sortChanged' | 'aggregationChanged' | 'expandedChanged' | 'selectionChanged' | 'dataChanged' | 'valueChanged' | 'heightChanged' | 'focused' | 'editingStarted' | 'invalidated';
+export interface GridLiveObjectEvent<TData = GridData, TValue = unknown> {
+    readonly mutationId: GridMutationId;
+    readonly kind: GridLiveObjectKind;
+    readonly type: GridLiveObjectEventType;
+    readonly id: string | GridRowId;
+    readonly source: GridEventSource;
+    readonly timestamp: number;
+    readonly field?: string;
+    readonly data?: Readonly<TData>;
+    readonly value?: TValue;
+    readonly before?: unknown;
+    readonly after?: unknown;
+    readonly reason?: GridRefInvalidationReason;
+}
+export type GridLiveObjectListener<TData = GridData, TValue = unknown> = (event: GridLiveObjectEvent<TData, TValue>) => void;
+export type GridRefInvalidationReason = 'removed' | 'definitions-replaced' | 'data-replaced' | 'disconnected';
+export interface GridLiveRef<TData = GridData, TValue = unknown> {
+    readonly id: string | GridRowId;
+    isValid(): boolean;
+    getInvalidationReason(): GridRefInvalidationReason | null;
+    addEventListener(type: GridLiveObjectEventType | '*', listener: GridLiveObjectListener<TData, TValue>): () => void;
+    removeEventListener(type: GridLiveObjectEventType | '*', listener: GridLiveObjectListener<TData, TValue>): void;
+}
+export interface GridColumnSortState {
+    readonly direction: 'asc' | 'desc';
+    readonly index: number;
+}
+export interface GridColumnRef<TData = GridData, TValue = unknown, TContext = unknown> extends GridLiveRef<TData, TValue> {
+    readonly id: string;
+    getDefinition(): Readonly<ColumnDef<TData, TValue, TContext>> | null;
+    getActualWidth(): number | null;
+    isVisible(): boolean;
+    getPinned(): 'left' | 'right' | null;
+    getSort(): GridColumnSortState | null;
+    getAggFunc(): string | null;
+    isPivotActive(): boolean;
+    getParent(): GridColumnGroupRef<TData, TContext> | null;
+    setWidth(width: number): Promise<boolean>;
+    setVisible(visible: boolean): Promise<boolean>;
+    setPinned(side: 'left' | 'right' | null): Promise<boolean>;
+    setSort(direction: 'asc' | 'desc' | null, options?: {
+        multi?: boolean;
+    }): Promise<boolean>;
+    setAggFunc(name: string | null): Promise<boolean>;
+    getFilterModel(): Promise<unknown>;
+    setFilterModel(model: unknown | null): Promise<boolean>;
+}
+export interface GridColumnGroupRef<TData = GridData, TContext = unknown> extends GridLiveRef<TData> {
+    readonly id: string;
+    getDefinition(): Readonly<GridColumnGroupDef<TData, TContext>> | null;
+    getChildren(): ReadonlyArray<GridColumnRef<TData, unknown, TContext> | GridColumnGroupRef<TData, TContext>>;
+    getLeafColumns(): ReadonlyArray<GridColumnRef<TData, unknown, TContext>>;
+    getParent(): GridColumnGroupRef<TData, TContext> | null;
+    isExpanded(): boolean;
+    isPadding(): boolean;
+    isDisplayed(): boolean;
+    setExpanded(expanded: boolean): Promise<boolean>;
+}
+export interface GridRowRef<TData = GridData, TContext = unknown> extends GridLiveRef<TData> {
+    readonly id: GridRowId;
+    getSourceIndex(): number | null;
+    getDisplayIndex(): number | null;
+    getData(): Readonly<TData> | null;
+    getParent(): GridRowRef<TData, TContext> | null;
+    getChildren(): ReadonlyArray<GridRowRef<TData, TContext>>;
+    isGroup(): boolean;
+    isLeaf(): boolean;
+    isMaster(): boolean;
+    isDetail(): boolean;
+    getLevel(): number;
+    getRoute(): readonly string[];
+    isSelected(): boolean;
+    isExpanded(): boolean;
+    setSelected(selected: boolean): Promise<boolean>;
+    setExpanded(expanded: boolean): Promise<boolean>;
+    setData(data: TData): Promise<boolean>;
+    updateData(patch: Partial<TData>): Promise<boolean>;
+    setValue<TField extends GridFieldPath<TData>>(field: TField, value: GridPathValue<TData, TField>): Promise<boolean>;
+    setHeight(height: number | null): Promise<boolean>;
+    focus(field?: GridFieldPath<TData>): Promise<boolean>;
+    startEditing(field: GridFieldPath<TData>): Promise<boolean>;
+}
+export type GridColumnDefinition<TData = GridData, TContext = unknown, TValue = unknown> = ColumnDef<TData, TValue, TContext> | GridColumnGroupDef<TData, TContext, TValue>;
+export interface GridRowTransaction<TData = GridData> {
+    add?: ReadonlyArray<TData>;
+    addIndex?: number;
+    update?: ReadonlyArray<Partial<TData>>;
+    remove?: ReadonlyArray<TData | Record<string, unknown>>;
+}
+export type SyGridEditSource = 'local' | 'remote' | 'undo' | 'redo';
+export interface SyGridSortModelEntry {
+    field: string;
+    direction: 'asc' | 'desc';
+}
+export interface SyGridColumnState {
+    field: string;
+    width: number | null;
+    order: number | null;
+    hidden: boolean;
+    sortDirection: 'asc' | 'desc' | null;
+    isSorted: boolean;
+    sortIndex?: number | null;
+    pinned?: 'left' | 'right' | null;
+}
+export interface SyGridApplyColumnStateOptions {
+    applyOrder?: boolean;
+}
+export interface SyGridRowTransactionResult<TData = GridData> {
+    rows: TData[];
+    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;
+    }>;
+    meta: {
+        txId: number;
+        timestamp: number;
+    };
+}
+export interface SyGridSortChangedEventDetail {
+    field: string | null;
+    direction: 'asc' | 'desc' | null;
+    previous: SyGridSortModelEntry | null;
+    sortModel: SyGridSortModelEntry[];
+    previousModel: SyGridSortModelEntry[];
+}
+export interface SyGridSelectionChangedEventDetail {
+    mode: 'single' | 'multi' | 'none';
+    selectedRowIds: ReadonlyArray<GridRowId>;
+    addedIds: ReadonlyArray<GridRowId>;
+    removedIds: ReadonlyArray<GridRowId>;
+}
+export interface SyGridRowDataChangedEventDetail<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?: SyGridEditSource;
+    origin?: unknown;
+}
+export interface SyGridCellValueChangedEventDetail<TData = GridData, TValue = unknown, TContext = unknown> {
+    rowIndex: number;
+    colIndex: number;
+    field: GridFieldPath<TData>;
+    rowId: GridRowId;
+    oldValue: TValue;
+    newValue: TValue;
+    data: Readonly<TData>;
+    context: TContext | undefined;
+    source: SyGridEditSource;
+    origin?: unknown;
+}
+export interface SyGridHistoryChangedEventDetail {
+    kind: 'recorded' | 'undone' | 'redone' | 'cleared';
+    depth: {
+        undo: number;
+        redo: number;
+    };
+    label?: string;
+}
+export interface SyGridColumnResizedEventDetail {
+    colId: string;
+    oldWidth: number;
+    newWidth: number;
+    wasClamped: boolean;
+}
+export interface SyGridColumnReorderedEventDetail {
+    colId: string;
+    originIndex: number;
+    finalIndex: number;
+    orderBefore: ReadonlyArray<string>;
+    orderAfter: ReadonlyArray<string>;
+}
+export interface SyGridColumnVisibilityChangedEventDetail {
+    colId: string;
+    hidden: boolean;
+    hiddenIds: ReadonlyArray<string>;
+}
+export interface SyGridActiveCell {
+    rowIndex: number;
+    colIndex: number;
+}
+export interface SyGridActiveCellChangedEventDetail {
+    active: SyGridActiveCell | null;
+    previous: SyGridActiveCell | null;
+}
+export type SyGridRowClickButton = 'left' | 'middle' | 'right' | 'other';
+export interface SyGridRowClickModifiers {
+    ctrl: boolean;
+    shift: boolean;
+    meta: boolean;
+    alt: boolean;
+}
+export interface SyGridCellClickedEventDetail<TData = GridData> {
+    row: TData;
+    rowIndex: number;
+    colIndex: number;
+    field: GridFieldPath<TData>;
+    button?: SyGridRowClickButton;
+    modifiers?: SyGridRowClickModifiers;
+    doubleClick?: boolean;
+    dragged?: boolean;
+}
+export interface SyGridCellDoubleClickedEventDetail<TData = GridData> {
+    row: TData;
+    rowIndex: number;
+    colIndex: number;
+    field: GridFieldPath<TData>;
+    button: SyGridRowClickButton;
+    modifiers: SyGridRowClickModifiers;
+}
+export interface SyGridRowClickedEventDetail<TData = GridData> {
+    row: TData;
+    rowIndex: number;
+    button: SyGridRowClickButton;
+    modifiers: SyGridRowClickModifiers;
+    doubleClick: boolean;
+    dragged: boolean;
+}
+export interface SyGridCellEditingRequestedEventDetail<TData = GridData> {
+    row: TData;
+    rowIndex: number;
+    colIndex: number;
+    field: GridFieldPath<TData>;
+}
+export interface SyGridCellEditingCancelledEventDetail {
+    rowIndex: number;
+    colIndex: number;
+}
+export interface SyGridCellEditingCommittedEventDetail<TValue = unknown> {
+    rowIndex: number;
+    colIndex: number;
+    originalValue: TValue;
+    draftValue: TValue;
+}
+type SyGridClipboardPastedEventDetail<TData, TValue, TContext> = {
+    applied: number;
+    skipped: number;
+    top: number;
+    left: number;
+    changes: Array<SyGridCellValueChangedEventDetail<TData, TValue, TContext>>;
+};
+type SyGridRemoteEditAppliedEventDetail<TData, TValue, TContext> = {
+    changes: ReadonlyArray<SyGridCellValueChangedEventDetail<TData, TValue, TContext>>;
+    origin?: unknown;
+};
+export interface SyGridEventMap<TData = GridData, TContext = unknown, TValue = unknown> {
+    queryComplete: GridQueryResult & {
+        tier: GridEngineTier;
+    };
+    sortChanged: SyGridSortChangedEventDetail;
+    filterChanged: {
+        field: string;
+        filter: ActiveFilter | null;
+        activeMap: ActiveFilterMap;
+        customModel?: unknown;
+        previousCustomModel?: unknown;
+        source?: 'ui' | 'api' | 'restore' | 'component';
+    };
+    filterModified: {
+        field: string;
+        source: 'component';
+    };
+    conditionFilterChanged: {
+        model: ConditionNode<TData> | null;
+    };
+    conditionPresetsChanged: {
+        presets: Array<{
+            name: string;
+            json: string;
+        }>;
+    };
+    columnGroupToggled: {
+        groupId: string;
+        open: boolean;
+    };
+    rowGroupToggled: {
+        key: string | null;
+        expanded: boolean;
+    };
+    treeNodeToggled: {
+        path: readonly string[];
+        expanded: boolean;
+    };
+    detailRowToggled: {
+        rowId: GridRowId;
+        expanded: boolean;
+    };
+    detailRowCreated: {
+        rowId: GridRowId;
+        master: TData | null;
+    };
+    detailRowDestroyed: {
+        rowId: GridRowId;
+    };
+    rangeSelectionChanged: {
+        ranges: CellRangeBounds[];
+    };
+    toolPanelToggled: {
+        id: SideBarPanelId;
+        open: boolean;
+    };
+    csvImported: {
+        rowCount: number;
+        columnCount: number;
+    };
+    clipboardCopied: {
+        text: string;
+        ranges: CellRangeBounds[];
+    };
+    clipboardPasted: SyGridClipboardPastedEventDetail<TData, TValue, TContext>;
+    paginationChanged: {
+        pageIndex: number;
+        pageSize: number;
+        pageCount: number;
+        totalRows: number;
+        previous: ActivePagination;
+    };
+    quickFilterChanged: {
+        value: string;
+        previous: string;
+    };
+    emptyStateActionClicked: {
+        kind: EmptyStateKind;
+        action: 'clear-filters' | 'reload';
+    };
+    activeCellChanged: SyGridActiveCellChangedEventDetail;
+    cellClicked: SyGridCellClickedEventDetail<TData>;
+    cellDoubleClicked: SyGridCellDoubleClickedEventDetail<TData>;
+    rowClicked: SyGridRowClickedEventDetail<TData>;
+    cellEditingRequested: SyGridCellEditingRequestedEventDetail<TData>;
+    cellEditingCancelled: SyGridCellEditingCancelledEventDetail;
+    cellEditingCommitted: SyGridCellEditingCommittedEventDetail<TValue>;
+    formulaEvaluated: {
+        rowIndex: number;
+        colIndex: number;
+        field: string;
+        formula: string;
+        value: unknown;
+    };
+    formulaError: {
+        rowIndex: number;
+        colIndex: number;
+        field: string;
+        formula: string;
+        type: string;
+        description: string;
+    };
+    workbookBindingChanged: GridWorkbookBindingChangedDetail;
+    workbookBindingError: GridWorkbookBindingErrorDetail;
+    chunkLoading: GridChunkLoadEventDetail;
+    chunkLoaded: GridChunkLoadEventDetail;
+    chunkLoadFailed: GridChunkLoadEventDetail;
+    componentError: GridComponentErrorDetails;
+    rowDataChanged: SyGridRowDataChangedEventDetail<TData>;
+    cellValueChanged: SyGridCellValueChangedEventDetail<TData, TValue, TContext>;
+    rowMoved: {
+        fromIndex: number;
+        toIndex: number;
+        row: TData;
+    };
+    rowGroupChanged: {
+        groupBy: string | null;
+    };
+    pivotPanelChanged: PivotPanelChangeDetail;
+    pivotChanged: PivotPanelChangeDetail;
+    pivotModeChanged: {
+        pivotMode: boolean;
+    };
+    contextMenuItemClicked: {
+        id: string;
+        rowIndex: number;
+        field?: string;
+    };
+    remoteEditApplied: SyGridRemoteEditAppliedEventDetail<TData, TValue, TContext>;
+    presenceChanged: {
+        collaborators: ReadonlyArray<GridCollaboratorInfo>;
+    };
+    collabConflictResolved: GridCollabConflict;
+    collaboratorJoined: GridCollaboratorInfo;
+    collaboratorLeft: {
+        id: string;
+    };
+    syncStatusChanged: {
+        status: GridSyncStatus;
+    };
+    cellCommentsChanged: {
+        rowId: string;
+        field: string;
+        comments: GridCellComment[];
+    };
+    commentMentioned: {
+        rowId: string;
+        field: string;
+        comment: GridCellComment;
+    };
+    auditLogChanged: {
+        entry: AuditEntry;
+    };
+    conditionalFormatsChanged: {
+        rules: ConditionalFormatRule[];
+    };
+    cellValidationFailed: {
+        rowIndex: number;
+        field: string;
+        value: unknown;
+        message: string;
+    };
+    snapshotCaptured: {
+        id: string;
+        name: string;
+        rowCount: number;
+    };
+    snapshotRestored: {
+        id: string;
+        name: string;
+        rowCount: number;
+    };
+    xlsxImported: {
+        sheetName: string;
+        snapshot: XlsxGridSnapshot;
+        workbookSheetCount: number;
+    };
+    historyChanged: SyGridHistoryChangedEventDetail;
+    columnResized: SyGridColumnResizedEventDetail;
+    columnReordered: SyGridColumnReorderedEventDetail;
+    columnVisibilityChanged: SyGridColumnVisibilityChangedEventDetail;
+    selectionChanged: SyGridSelectionChangedEventDetail;
+    spanConflict: SyGridSpanConflictEventDetail;
+    rowDragEnter: SyGridRowDragEventDetail;
+    rowDragMove: SyGridRowDragEventDetail;
+    rowDragLeave: SyGridRowDragEventDetail;
+    rowDragEnd: SyGridRowDragEndDetail;
+    rowDragCancel: SyGridRowDragCancelDetail;
+    rowsTransferred: SyGridRowsTransferredDetail;
+    pinnedRowsChanged: SyGridPinnedRowsChangedDetail<TData>;
+    rowLayoutRefused: SyGridRowLayoutRefusedDetail;
+    treeReparented: SyGridTreeReparentedDetail;
+    rowHoverChanged: {
+        hoveredRowId: GridRowId | null;
+        previousRowId: GridRowId | null;
+    };
+    themeChanged: {
+        theme: GridTheme;
+        resolvedTokens: Record<string, string>;
+    };
+    localeChanged: {
+        locale: GridLocale;
+        resolvedMessages: Record<string, string>;
+    };
+    gridObjectChanged: GridLiveObjectEvent<TData, TValue>;
+    stateUpdated: SyGridStateUpdatedDetail;
+    preDestroyed: SyGridPreDestroyedDetail;
+    batchEditStart: SyGridBatchEditStartEventDetail;
+    batchEditEnd: SyGridBatchEditEndEventDetail;
+    rowValueChanged: SyGridRowValueChangedEventDetail;
+    rowEditStart: SyGridRowEditStartEventDetail;
+    rowEditStop: SyGridRowEditStopEventDetail;
+    fillStart: SyGridFillStartEventDetail;
+    fillEnd: SyGridFillEndEventDetail;
+    pivotCombinationConflict: SyGridPivotCombinationConflictDetail;
+    pivotColumnsChanged: SyGridPivotColumnsChangedDetail;
+    serverStoreUpdated: SyGridServerStoreUpdatedDetail;
+    workbookValuesPropagated: SyGridWorkbookPropagationDetail;
+    chartCreated: SyGridChartEvent;
+    chartRangeChanged: SyGridChartEvent;
+    chartOptionsChanged: SyGridChartEvent;
+    chartDestroyed: SyGridChartEvent;
+}
+export type SyGridCustomEvent<TDetail, TData = GridData, TContext = unknown, TValue = unknown> = CustomEvent<TDetail> & {
+    readonly currentTarget: (EventTarget & SyGridApi<TData, TContext, TValue>) | null;
+};
+export type SyGridEventListener<TDetail, TData = GridData, TContext = unknown, TValue = unknown> = (this: SyGridApi<TData, TContext, TValue>, event: SyGridCustomEvent<TDetail, TData, TContext, TValue>) => void;
+export interface SyGridCollabConnectOptions {
+    realtimeUrl?: string;
+    userName?: string;
+    userColor?: string;
+    presence?: boolean;
+    persistence?: 'none' | 'indexeddb';
+}
+export interface SyGridExcelGenerateOptions {
+    sheetName?: string;
+    onlySelected?: boolean;
+    columnKeys?: readonly string[];
+    skipHeaders?: boolean;
+}
+export interface SyGridExcelDownloadOptions extends SyGridExcelGenerateOptions {
+    fileName?: string;
+}
+export interface SyGridCsvImportOptions {
+    delimiter?: CsvDelimiter;
+    hasHeader?: boolean;
+}
+export interface SyGridXlsxImportOptions {
+    sheetName?: string;
+    snapshot?: SheetToRowDataOptions;
+}
+export interface SyGridApiPdfAutoFontOptions {
+    autoFont?: boolean;
+    fallbackFontUrl?: string;
+}
+export type SyGridApiPdfExportOptions<TData = GridData> = Omit<PdfExportOptions<TData>, 'columns' | 'rows'> & SyGridApiPdfAutoFontOptions;
+export type SyGridApiPdfDownloadOptions<TData = GridData> = Omit<PdfDownloadOptions<TData>, 'columns' | 'rows'> & SyGridApiPdfAutoFontOptions;
+export interface SyGridCellTooltipTarget<TData = GridData> {
+    rowIndex: number;
+    field: GridFieldPath<TData>;
+    displayedText?: string;
+    isOverflowing?: boolean;
+}
+export interface SyGridImperativeMethods<TData = GridData, TContext = unknown, TValue = unknown, TFilterModel = unknown> {
+    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>;
+    openCellCommentPanel(rowId: GridRowId, field: string): Promise<void>;
+    closeCellCommentPanel(): Promise<void>;
+    getApi<TNextData = TData, TNextContext = TContext, TNextValue = TValue, TNextFilterModel = TFilterModel>(): Promise<SyGridApi<TNextData, TNextContext, TNextValue, TNextFilterModel>>;
+    getColumn<TValue = unknown>(columnId: string): Promise<GridColumnRef<TData, TValue, TContext> | null>;
+    getColumns(): Promise<ReadonlyArray<GridColumnRef<TData, unknown, TContext>>>;
+    getColumnGroup(groupId: string): Promise<GridColumnGroupRef<TData, TContext> | null>;
+    getColumnGroups(): Promise<ReadonlyArray<GridColumnGroupRef<TData, TContext>>>;
+    getRow(rowId: GridRowId): Promise<GridRowRef<TData, TContext> | null>;
+    getDisplayedRowAtIndex(index: number): Promise<GridRowRef<TData, TContext> | null>;
+    forEachRow(callback: (row: GridRowRef<TData, TContext>) => void): Promise<void>;
+    forEachDisplayedRow(callback: (row: GridRowRef<TData, TContext>) => void): Promise<void>;
+    getWorkbookBinding(): Promise<GridWorkbookBinding | null>;
+    reconnectWorkbook(): Promise<GridWorkbookBinding | null>;
+    disconnectWorkbook(): Promise<boolean>;
+    sortBy(column: string, direction?: 'asc' | 'desc' | null): Promise<void>;
+    setSortModel(model: ReadonlyArray<SyGridSortModelEntry>): Promise<void>;
+    getSortModel(): Promise<SyGridSortModelEntry[]>;
+    setQuery(query: string): Promise<void>;
+    getActiveTier(): Promise<GridEngineTier>;
+    registerAggFunc(name: string, fn: (values: unknown[], rows: readonly TData[]) => unknown): Promise<void>;
+    unregisterAggFunc(name: string): Promise<void>;
+    getRegisteredAggFuncNames(): Promise<string[]>;
+    setRowGroupExpanded(key: string | null, expanded: boolean): Promise<void>;
+    expandAllRowGroups(): Promise<void>;
+    collapseAllRowGroups(): Promise<void>;
+    setTreeNodeExpanded(path: readonly string[], expanded: boolean): Promise<void>;
+    expandAllTreeNodes(): Promise<void>;
+    collapseAllTreeNodes(): Promise<void>;
+    setDetailRowExpanded(rowId: GridRowId, expanded: boolean): Promise<void>;
+    expandAllDetailRows(): Promise<void>;
+    collapseAllDetailRows(): Promise<void>;
+    setColumnGroupOpened(groupId: string, open: boolean): Promise<void>;
+    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>;
+    diffSnapshots(idA: string, idB?: string): Promise<SnapshotDiff<TData>>;
+    restoreSnapshot(id: string): Promise<boolean>;
+    getCellRanges(): Promise<CellRangeBounds[]>;
+    copyRangeToClipboard(): Promise<boolean>;
+    pasteFromClipboard(): Promise<boolean>;
+    clearCellRanges(): Promise<void>;
+    refreshInfiniteCache(): Promise<void>;
+    refreshRowHeights(): Promise<void>;
+    scrollToTop(): Promise<void>;
+    selectRows(ids: GridRowId[]): Promise<void>;
+    getSelectedRowIds(): Promise<ReadonlyArray<GridRowId>>;
+    applyTransaction(transaction: GridRowTransaction<TData>, label?: string, opts?: {
+        source?: SyGridEditSource;
+        origin?: unknown;
+    }): Promise<SyGridRowTransactionResult<TData>>;
+    undo(): Promise<boolean>;
+    redo(): Promise<boolean>;
+    clearHistory(): Promise<void>;
+    connectCollabRoom(opts?: SyGridCollabConnectOptions): Promise<GridSyncStatus>;
+    preloadChunks(ids: GridChunkId[]): Promise<void>;
+    disconnectCollabRoom(): Promise<void>;
+    getSyncStatus(): Promise<GridSyncStatus>;
+    getCollaborators(): Promise<GridCollaboratorInfo[]>;
+    addCellComment(rowId: GridRowId, field: string, text: string, parentId?: string): Promise<string | null>;
+    getCellComments(rowId: GridRowId, field: string): Promise<GridCellComment[]>;
+    setCellCommentResolved(rowId: GridRowId, field: string, commentId: string, resolved: boolean): Promise<boolean>;
+    deleteCellComment(rowId: GridRowId, field: string, commentId: string): Promise<boolean>;
+    getDataAsCsv(options?: Omit<CsvExportOptions<TData>, 'columns' | 'rows'>): Promise<CsvExportResult>;
+    exportDataAsCsv(options?: Omit<CsvDownloadOptions<TData>, 'columns' | 'rows'>): Promise<CsvExportResult>;
+    getDataAsExcel(options?: SyGridExcelGenerateOptions): Promise<Uint8Array>;
+    exportDataAsExcel(options?: SyGridExcelDownloadOptions): Promise<void>;
+    importCsvText(text: string, options?: SyGridCsvImportOptions): Promise<{
+        rowCount: number;
+        columnCount: number;
+    }>;
+    getDataAsPdf(options?: SyGridApiPdfExportOptions<TData>): Promise<PdfExportResult>;
+    exportDataAsPdf(options?: SyGridApiPdfDownloadOptions<TData>): Promise<PdfExportResult>;
+    importDataFromXlsx(source: ArrayBuffer | Uint8Array, options?: SyGridXlsxImportOptions): Promise<XlsxImportResult>;
+    getContextMenuItems(target: {
+        rowIndex: number;
+        field?: string;
+    }): Promise<ContextMenuItem<TData>[]>;
+    copyCellAt(rowIndex: number, field: string): Promise<boolean>;
+    copyRowAt(rowIndex: number): Promise<boolean>;
+    getCellTooltipText(target: SyGridCellTooltipTarget<TData>): 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>;
+    setColumnPinned(field: string, side: 'left' | 'right' | null): Promise<void>;
+    getColumnPinned(field: string): Promise<'left' | 'right' | null>;
+    setColumnOrder(orderedColIds: string[]): Promise<void>;
+    getColumnOrder(): Promise<string[]>;
+    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<SyGridColumnState[]>;
+    applyColumnState(state: SyGridColumnState[], opts?: SyGridApplyColumnStateOptions): Promise<void>;
+    getState(): Promise<SyGridState>;
+    setState(state: SyGridState, options?: GridStateApplyOptions): Promise<SyGridStateApplyReport>;
+    getFilterModel(): Promise<SyGridFilterSlice>;
+    setFilterModel(model: SyGridFilterSlice | null): Promise<FilterSliceApplyResult['report']>;
+    setHoveredRow(rowId: GridRowId | null): Promise<void>;
+    getHoveredRowId(): Promise<GridRowId | null>;
+    getActiveEditTransaction(): Promise<EditTransaction | null>;
+    commitActiveEdit(): Promise<boolean>;
+    cancelActiveEdit(): Promise<boolean>;
+    registerCellRenderer(name: string, renderer: CellRenderer<TData>): Promise<boolean>;
+    listRegisteredCellRenderers(): Promise<ReadonlyArray<string>>;
+    unregisterCellRenderer(name: string): Promise<boolean>;
+    registerGridComponent<TKind extends GridComponentKind>(scope: GridComponentRegistrationScope, kind: TKind, name: string, definition: GridComponentDefinitionFor<TKind, TData, TValue, TFilterModel, TContext>): Promise<void>;
+    replaceGridComponent<TKind extends GridComponentKind>(scope: GridComponentRegistrationScope, kind: TKind, name: string, definition: GridComponentDefinitionFor<TKind, TData, TValue, TFilterModel, TContext>): 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<TData, TValue, TContext>>;
+    destroyCellRendererInstance(rowId: GridRowId, colId: string): Promise<boolean>;
+    focusCellRendererInstance(rowId: GridRowId, colId: string, direction: 'in' | 'out'): Promise<boolean>;
+    getCellEditorInstance(): Promise<GridMountedComponentLookup<GridEditorInstance<TData, TValue, TContext>, GridEditorParams<TData, TValue, TContext>, HTMLElement> | null>;
+    getColumnFilterInstance<TColumnValue = TValue, TModel = TFilterModel>(columnId: string): Promise<GridFilterInstance<TData, TColumnValue, TModel, TContext> | null>;
+    getColumnFilterModel<TModel = TFilterModel>(columnId: string): Promise<TModel | null>;
+    setColumnFilterModel<TModel = TFilterModel>(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>;
+    setPivotColumns(columns: string[]): Promise<boolean>;
+    setValueColumns(columns: string[]): Promise<boolean>;
+    setConditionFilter(model: ConditionNode<TData> | null): Promise<void>;
+    getConditionFilter(): Promise<ConditionNode<TData> | null>;
+    setConditionPresets(presets: ReadonlyArray<{
+        name: string;
+        json: string;
+    }>): Promise<void>;
+    getConditionPresets(): Promise<Array<{
+        name: string;
+        json: string;
+    }>>;
+    openToolPanel(id: string): Promise<boolean>;
+    closeToolPanel(): Promise<void>;
+    getOpenedToolPanel(): Promise<string | null>;
+    getCanonicalRanges(): Promise<SyGridCanonicalRange[]>;
+    setCanonicalRanges(ranges: SyGridCellRangeInput[]): Promise<SyGridCanonicalChange[]>;
+    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>;
+    startRowEdit(rowId: GridRowId): Promise<boolean>;
+    stageRowEditCell(colId: string, value: unknown): Promise<boolean>;
+    stopRowEdit(reason?: 'commit' | 'cancel'): Promise<SyGridRowEditReport>;
+    getStateCaptureReport(): Promise<SyGridStateCaptureReport>;
+    fillRange(options: SyGridFillRangeOptions): Promise<SyGridFillRangeReport>;
+    getDisplayRowInfo(index: number): Promise<SyGridDisplayRowInfo | null>;
+    getPivotCombinationReport(): Promise<SyGridPivotCombinationReport>;
+    getPivotSecondaryColumns(): Promise<SyGridPivotSecondaryColumns | null>;
+    getGroupCheckStates(options?: SyGridGroupCheckStatesOptions): Promise<SyGridGroupCheckStatesReport>;
+    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>;
+    getServerSideSelectionState(): Promise<SyGridServerSelectionState>;
+    setServerSideSelectionState(input: unknown): Promise<SyGridServerSelectionSetResult>;
+    selectAllServerSide(action?: 'select' | 'clear'): Promise<SyGridServerSelectAllResult>;
+    getServerGroupSelectionState(): Promise<SyGridServerSelectionState>;
+    setServerGroupSelectionState(input: unknown): Promise<SyGridServerSelectionSetResult>;
+    selectServerGroupChildren(groupKeys: ReadonlyArray<string>, action?: 'select' | 'deselect'): Promise<SyGridServerGroupChildrenResult>;
+    getRowSpan(colId: string): Promise<SyGridRowSpanReport | null>;
+    getCellSpan(rowIndex: number, colId: string): Promise<SyGridCellSpanInfo | null>;
+    getSpanInteraction(query?: SyGridSpanInteractionQuery): Promise<SyGridSpanInteractionReport>;
+    startRowDrag(input: SyGridRowDragStartInput): Promise<SyGridRowDragStartResult>;
+    getRowDragSession(): Promise<SyGridRowDragSessionReport>;
+    registerDropZone(input: SyGridDropZoneInput): Promise<SyGridDropZoneRegistration>;
+    unregisterDropZone(zoneId: string): Promise<boolean>;
+    getDropZones(): Promise<SyGridDropZonesReport>;
+    getDragSafetyReport(): Promise<SyGridDragSafetyReport>;
+    setPinnedRows(input: SyGridPinnedRowSetInput<TData>): Promise<SyGridPinnedRowsResult<TData>>;
+    getPinnedRows(): Promise<SyGridPinnedRowsReport<TData>>;
+    getPinnedRowInfo(displayIndex: number): Promise<SyGridPinnedRowInfo<TData> | null>;
+    getFullWidthRowInfo(rowIndex?: number): Promise<SyGridFullWidthRowInfo<TData> | SyGridFullWidthLayoutReport | null>;
+    setAlignedGrids(input: SyGridAlignedGridsInput): Promise<SyGridAlignedGridsResult>;
+    getAlignedGrids(): Promise<SyGridAlignedGridsReport>;
+    reparentRows(request: SyGridReparentRequest): Promise<SyGridReparentResult>;
+    getWorkbookPropagationState(): Promise<SyGridWorkbookPropagationState>;
+    flushWorkbookPropagation(): Promise<SyGridWorkbookFlushReport>;
+    getWorkbookSnapshotReport(): Promise<SyGridWorkbookSnapshotReport>;
+    getWorkbookIntegrityReport(): Promise<SyGridWorkbookIntegrityReport>;
+    applySpillFormula(input: SyGridSpillApplyInput): Promise<SyGridSpillApplyResult>;
+    clearSpillFormula(target: SyGridSpillTarget): Promise<SyGridSpillClearResult>;
+    undoSpillTransaction(mutationId: GridMutationId): Promise<SyGridSpillUndoResult>;
+    getSpillReport(): Promise<SyGridSpillReport>;
+    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>;
+}
+export interface SyGridApi<TData = GridData, TContext = unknown, TValue = unknown, TFilterModel = unknown> extends HTMLElement, SyGridImperativeMethods<TData, TContext, TValue, TFilterModel> {
+    rowData?: TData[];
+    columnDefs?: Array<GridColumnDefinition<TData, TContext, TValue>>;
+    context?: TContext;
+    getRowId?: GridGetRowId<TData>;
+    components?: GridComponentLocalDefinitions<TData, TValue, TFilterModel, TContext>;
+    externalFilter?: GridExternalFilterCallbacks<TData> | GridExternalFilterInstance<TData, TContext>;
+    componentTimeoutMs?: number;
+    addEventListener<K extends keyof SyGridEventMap<TData, TContext, TValue>>(type: K, listener: SyGridEventListener<SyGridEventMap<TData, TContext, TValue>[K], TData, TContext, TValue> | null, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof SyGridEventMap<TData, TContext, TValue>>(type: K, listener: SyGridEventListener<SyGridEventMap<TData, TContext, TValue>[K], TData, TContext, TValue> | null, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject | null, options?: boolean | EventListenerOptions): void;
+}
+export type SyGridBindings<TData = GridData, TContext = unknown, TValue = unknown, TFilterModel = unknown> = {
+    rowData?: TData[];
+    columnDefs?: Array<GridColumnDefinition<TData, TContext, TValue>>;
+    context?: TContext;
+    getRowId?: GridGetRowId<TData>;
+    components?: GridComponentLocalDefinitions<TData, TValue, TFilterModel, TContext>;
+    externalFilter?: GridExternalFilterCallbacks<TData> | GridExternalFilterInstance<TData, TContext>;
+    componentTimeoutMs?: number;
+} & {
+    [K in keyof SyGridEventMap<TData, TContext, TValue> as K extends string ? `on${Capitalize<K>}` : never]?: SyGridEventListener<SyGridEventMap<TData, TContext, TValue>[K], TData, TContext, TValue>;
+};
+export declare function defineSyGridBindings<TData, TContext = unknown, TValue = unknown, TFilterModel = unknown>(bindings: SyGridBindings<TData, TContext, TValue, TFilterModel>): SyGridBindings<TData, TContext, TValue, TFilterModel>;
+export declare function getSyGridApi<TData = GridData, TContext = unknown, TValue = unknown, TFilterModel = unknown>(element: unknown): SyGridApi<TData, TContext, TValue, TFilterModel>;