SyGridImperativeMethods

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>;
}