@rowsncolumns/spreadsheet 10.2.68

package/dist/esm/components/canvas-grid/typings.d.ts

@@ -0,0 +1,2027 @@
+import type { CalculatorFunction } from "@rowsncolumns/common-types";
+import type { FormulaResult } from "@rowsncolumns/fast-formula-parser";
+import type { Align, AreaStyle, CellInterface, CellPosition, Direction, GridProps, GridRange, GridRef, OptionalCellInterface, ScrollCoords, SelectionArea, Style, ViewPortProps } from "@rowsncolumns/grid";
+import type { Mention, MentionTagComponentProps, OptionItem, ProseMirrorEditorProps, TextFormatRun } from "@rowsncolumns/ui";
+import type { CellDiff } from "@rowsncolumns/version-comparison";
+import type { ElementType } from "react";
+import type React from "react";
+import type { ContextMenuWrapperProps } from "../../hooks/use-context-menu";
+import type { PasteSpecialType } from "../../hooks/use-copy-paste-cut";
+import type { MakeEditableOptions } from "../../hooks/use-editable";
+import type { ExportRangeOutput } from "../../hooks/use-export-range";
+import type { useFlash } from "../../hooks/use-flash";
+import type { useNavigateToSheetRange } from "../../hooks/use-navigate-sheet-range";
+import type { UseSelectionOptions } from "../../hooks/use-selection";
+import type { GetCellDimensionsOptions as SizerGetCellDimensionsOptions, useSizer } from "../../hooks/use-sizer";
+import type { AgentSuggestion, BandedDefinition, BandedRange, BorderStyle, CellFormat, Collaborator, Color, ColorFilterCriteria, ConditionType, ConditionValue, DataValidationRule, DataValidationRuleRecord, EmbeddedObject, IconFilterCriteria, Maybe, NamedRange, ParsedToken, PivotTable, ProtectedRange, Sheet, SheetCoordinate, SheetProtection, SheetRange, Slicer, SortOrder, SortSpecs, TableTheme, TableView } from "../../types";
+import type { AXIS, CellData, ConditionalFormatRule, EmbeddedChart, FilterView } from "../../types";
+import type { CellProps } from "../cell/typings";
+import type { CellEditorProps } from "../cell-editor";
+import type { StructuredResultProps } from "../cell-structured/types";
+import type { CellTooltipProps } from "../cell-tooltip";
+import type { ContextMenuProps } from "../context-menu";
+import type { ChartComponentProps, EmbedComponentProps, SlicerComponentProps } from "../embeds";
+import type { AvailableIcon } from "../filter-box";
+import { type FilterBoxProps } from "../filter-box";
+import type { HeaderCellProps } from "../header-cell";
+import type { DragComponentProps } from "../header-move";
+import type { HiddenColumnMarkersProps, HiddenRowMarkersProps } from "../hidden-markers";
+import type { MagicFillContentProps, MagicFillProps } from "../selection/magic-fill";
+import type { PasteMenuProps } from "../selection/paste-menu";
+import type { QuickEditProps } from "../selection/quick-edit";
+import type { SuggestionActionProps } from "../selection/suggestion-action";
+import type { SelectionTitleProps } from "../selection/title";
+import type { BorderLocation } from "../toolbar";
+export type ExtractMentionType<T> = T extends CellData<any, infer M> ? M : Mention;
+/**
+ * Color / icon / custom-list sort options shared by the column-, table-
+ * and range-sort callbacks. Mirrors the engine's `DimensionSortSpec`
+ * subset (without `sortOrder`, which is passed separately).
+ */
+export type SortColumnSortOptions = {
+    sortBy?: Maybe<"value" | "cellColor" | "fontColor" | "icon">;
+    sortColor?: Maybe<string>;
+    sortIcon?: Maybe<{
+        iconSet: string;
+        iconId: number;
+    }>;
+    customList?: Maybe<string[]>;
+};
+/**
+ * An additional ("then by") sort level for multi-level column sort. Pins
+ * its own absolute `columnIndex` and direction alongside the color/icon/
+ * custom-list options.
+ */
+export type SortColumnLevelOption = {
+    columnIndex: number;
+    sortOrder: SortOrder;
+} & SortColumnSortOptions;
+export type CanvasGridProps<T extends CellData = CellData<any, any>> = {
+    licenseKey?: string;
+    /**
+     * ID of the selected sheet
+     */
+    sheetId: number;
+    /**
+     * Instance of the spreadsheet
+     */
+    instanceId?: string;
+    /**
+     * Initial active cell of the sheet
+     */
+    activeCell?: CellInterface;
+    /**
+     * Initial cell selections of the sheet
+     */
+    selections?: SelectionArea<SelectionAttributes>[];
+    /**
+     * Spreadsheet theme
+     */
+    theme?: SpreadsheetTheme;
+    /**
+     * Automatically focus on the Spreadsheet
+     */
+    autoFocus?: boolean;
+    /**
+     * Fired when focus leaves the spreadsheet entirely (i.e. focus moves to an
+     * element outside the grid container). In-spreadsheet focus moves
+     * (formula bar, toolbar, dropdowns, dialogs) do not trigger this.
+     * `isEditing` is true if a cell edit was still in progress at the moment
+     * of blur. Use this to auto-save or run cleanup when the user navigates away.
+     */
+    onBlur?: (e: React.FocusEvent<HTMLDivElement>, isEditing: boolean) => void;
+    /**
+     * Frozen row count
+     */
+    frozenRowCount?: Maybe<number>;
+    /**
+     * Frozen column count
+     */
+    frozenColumnCount?: Maybe<number>;
+    /**
+     * Total no of rows
+     */
+    rowCount?: number;
+    /**
+     * Total no of columns
+     */
+    columnCount?: number;
+    /**
+     * Scaling factor
+     */
+    scale?: number;
+    /**
+     * Speed at which scroll zoom is performed
+     */
+    zoomSpeed?: number;
+    /**
+     * Basic filter or Autofilter for quick filtering
+     * For more advanced filtering and column referencing
+     * use tables instead
+     */
+    basicFilter?: Maybe<FilterView>;
+    /**
+     * Filter views
+     */
+    tables?: Maybe<TableView[]>;
+    /**
+     * Pivot tables
+     */
+    pivotTables?: Maybe<PivotTable[]>;
+    /**
+     * Named ranges
+     */
+    namedRanges?: Maybe<NamedRange[]>;
+    /**
+     * Banded ranges
+     */
+    bandedRanges?: Maybe<BandedRange[]>;
+    /**
+     * Collaborators of the sheetsActivecell + Selections of the
+     * collaborator will be highlighted. Exclude current user
+     */
+    users?: Maybe<Collaborator[]>;
+    /**
+     * Optional hook for customizing the rendered cursor style per collaborator.
+     *
+     * Inspired by Tiptap's `CollaborationCursor.configure({ render })`, this lets
+     * callers swap the default border style (e.g. an agent slate squircle vs. a
+     * human cursor color) based on `Collaborator.kind` / `agentInitiator`. The
+     * returned `Style` overrides the default border for that collaborator's
+     * `activeCell` pin and any range-shaped `selections`. Return `undefined` to
+     * keep the default.
+     */
+    renderCollaboratorCursor?: (collaborator: Collaborator) => Style | undefined;
+    /**
+     * Current user's userId
+     */
+    userId?: number | string;
+    /**
+     * Color of filter view border
+     */
+    tableBorderColor?: string;
+    /**
+     * Color of the filter icon
+     */
+    filterIconColor?: string;
+    /**
+     * Show filter icon in header cells
+     */
+    showFilterIcon?: boolean;
+    /**
+     * Show calculated column icon
+     */
+    showCalculatedColumnIcon?: boolean;
+    /**
+     * Allow users to resize formula selection
+     */
+    showSelectionResizeHandles?: boolean;
+    /**
+     * Conditional formatting
+     */
+    conditionalFormats?: Maybe<ConditionalFormatRule[]>;
+    /**
+     * Embedded chart
+     */
+    charts?: Maybe<EmbeddedChart[]>;
+    /**
+     * Embed any object on top of a sheet
+     */
+    embeds?: Maybe<EmbeddedObject[]>;
+    /**
+     * Slicers for filtering tables and pivot tables
+     */
+    slicers?: Maybe<Slicer[]>;
+    /**
+     * Default font size in points
+     */
+    defaultFontSizePoint?: number;
+    /**
+     * Default row height
+     */
+    defaultRowHeight?: number;
+    /**
+     * Default column width
+     */
+    defaultColumnWidth?: number;
+    /**
+     * Default column header height
+     */
+    columnHeaderHeight?: number;
+    /**
+     * Default row header width
+     */
+    rowHeaderWidth?: number;
+    /**
+     * Color of the sheet grid lines
+     */
+    gridLineColor?: string;
+    /**
+     * Default text color
+     */
+    cellColor?: Maybe<Color>;
+    /**
+     * Header color of banded cell
+     */
+    bandedHeaderColor?: Maybe<Color>;
+    /**
+     * Opacity of first band
+     */
+    bandedOpacity?: number;
+    /**
+     * Default background color of a cell
+     */
+    cellBackgroundColor?: string;
+    /**
+     * Border color of header cell
+     */
+    headerBorderColor?: string;
+    /**
+     * Background color of header cells
+     */
+    headerBackgroundColor?: string;
+    /**
+     * Header text color
+     */
+    headerColor?: string;
+    /**
+     * When a cell is selected
+     */
+    headerActiveBackgroundColor?: string;
+    /**
+     * Header background when an entire row or column is selected
+     */
+    headerSelectedBackgroundColor?: string;
+    /**
+     * Text color of header when an entire row or column is selected
+     */
+    headerSelectedColor?: string;
+    /**
+     * Header background for table cells
+     */
+    headerTableBackgroundColor?: string;
+    /**
+     * Header background when table cell is selected
+     */
+    headerTableActiveBackgroundColor?: string;
+    /**
+     * When an entire header row or column is selected
+     */
+    headerTableSelectedBackgroundColor?: string;
+    /**
+     * Selected border color for charts
+     */
+    chartSelectedColor?: string;
+    /**
+     * Background color of chips
+     */
+    chipBackgroundColor?: string;
+    /**
+     * Shadow color of frozen row
+     */
+    frozenShadowColor?: string;
+    /**
+     * Thickness of frozen shadow
+     */
+    frozenShadowThickness?: number;
+    /**
+     * Border color of selections
+     */
+    selectionBorderColor?: string;
+    /**
+     * Background selection color
+     */
+    selectionBackgroundColor?: string;
+    /**
+     * Border color when selection is dragged
+     */
+    selectionDragBorderColor?: string;
+    /**
+     * Merged cells
+     */
+    merges?: Maybe<GridRange[]>;
+    /**
+     * Protected cell ranges
+     */
+    protectedRanges?: Maybe<ProtectedRange[]>;
+    /**
+     * Workbook-level structural protection. Matches Excel's
+     * `workbookProtection lockStructure="1"`. When true, host-driven
+     * structural operations (add / delete / rename / move / duplicate /
+     * hide / show / tab color) should be refused even on otherwise
+     * unprotected sheets. Cell-level edits are independently governed
+     * by `protectedRanges` and `canEditCell`.
+     */
+    isWorkbookProtected?: boolean;
+    /**
+     * Worksheet-level protection (`<sheetProtection>`) lookup. When a sheet's
+     * protection is active (`sheet: true`), `canEditCell` refuses edits on
+     * LOCKED cells — a cell is locked unless its `protection.locked` is
+     * `false` (Excel's default) — while unlocked cells stay editable, and
+     * structural operations gate on the matching action flag through
+     * `isActionBlockedBySheetProtection`. Absent (or returning nullish) =
+     * unprotected.
+     */
+    getSheetProtection?(sheetId: number): SheetProtection | null | undefined;
+    /**
+     * Additional bordered areas in the grid
+     */
+    borderStyles?: Maybe<RangeBorderStyle[]>;
+    /**
+     * Meta data of a row
+     */
+    rowMetadata?: Maybe<Sheet["columnMetadata"]>;
+    /**
+     * Compact sorted [start, end] (inclusive, grid
+     * row-index space) tuples of body rows hidden by the active basic filter. When
+     * provided, CanvasGrid derives row-hidden state and `visibleRowRanges` from these
+     * via binary search instead of from per-row `rowMetadata.hiddenByFilter`, so a
+     * million-row filter renders without ~1M rowMetadata entries.
+     */
+    hostHiddenRowRanges?: [number, number][];
+    /**
+     * Meta data of a column
+     */
+    columnMetadata?: Maybe<Sheet["columnMetadata"]>;
+    /**
+     * Enable sticky editor
+     */
+    stickyEditor?: boolean;
+    /**
+     * Scrollbar size
+     */
+    scrollbarSize?: number;
+    /**
+     * Show grid lines
+     */
+    showGridLines?: Maybe<boolean>;
+    /**
+     * Show frozen line separator for row and column
+     */
+    showFrozenSeparator?: boolean;
+    /**
+     * Show formulas in cells
+     */
+    showFormulas?: boolean;
+    /**
+     * Hide formulas from users
+     */
+    protectFormulas?: boolean;
+    /**
+     * Show spreadsheet row and column headers
+     */
+    showHeaders?: boolean;
+    /**
+     * Snaps to row or column while scrolling
+     * Recommended for 60fps scrolling, Since canvas
+     * does not need to redraw at each scroll frame
+     */
+    scrollSnap?: boolean;
+    /**
+     * How fast scroll should snap to row or column
+     */
+    scrollThrottleTimeout?: number;
+    /**
+     * Prevent browser default scrolling
+     */
+    preventBrowserDefaultScroll?: boolean;
+    /**
+     * Mouse move throttle timeout, to delay cell hover
+     */
+    mouseMoveThrottleTimeout?: number;
+    /**
+     * Tooltip intent interval in ms, delay before showing tooltip
+     */
+    tooltipIntentInterval?: number;
+    /**
+     * Cell selection policy
+     */
+    selectionPolicy?: UseSelectionOptions["selectionPolicy"];
+    /**
+     * Enable enter key to edit a cell
+     * When false, pressing enter will select the next cell
+     */
+    enableEditOnEnterKey?: boolean;
+    /**
+     * Show header menu button that invokes context menu
+     */
+    showHeaderMenuButton?: boolean;
+    /**
+     * Enable text overflow to neighbouring empty cells
+     * Enabling it will have an performance impact
+     */
+    enableTextOverflow?: boolean;
+    /**
+     * Number of additional columns to
+     * render on the left and right
+     * Useful, when text overflows adjacent cells
+     */
+    overscanCount?: number;
+    /**
+     * All functions supported by the
+     * calculator, used for suggestions
+     * in the formula dropdown
+     */
+    functionDescriptions?: Maybe<CalculatorFunction[]>;
+    /**
+     * Show or hide notes in cells
+     */
+    showNotes?: boolean;
+    /**
+     * Show or hide comments in cells
+     */
+    showComments?: boolean;
+    /**
+     * Locale of the spreadsheet
+     */
+    locale?: string;
+    /**
+     * Enable row and column resizer to overflow outside the container
+     */
+    enableResizerOverflow?: boolean;
+    /**
+     * Flag to indicate if the sheet is readonly
+     * Similar to protected sheet
+     */
+    readonly?: boolean;
+    /**
+     * Whether version comparison mode is active
+     * When true, getCellDiff will be called to compute diff highlighting
+     */
+    isComparing?: boolean;
+    /**
+     * Get diff state for a cell (for version comparison)
+     * Returns CellDiff if the cell has changed between versions, null otherwise
+     * Only called when isComparing is true
+     */
+    getCellDiff?: (sheetId: number, rowIndex: number, columnIndex: number) => CellDiff | null;
+    /**
+     * Enable magic fill component
+     */
+    enableMagicFill?: boolean;
+    /**
+     * Enable quick edit component
+     */
+    enableQuickEdit?: boolean;
+    /**
+     * Enable navigating to data boundary
+     */
+    enableDataBoundaryNavigation?: boolean;
+    /**
+     * Agent suggestions
+     */
+    agentSuggestions?: Map<string, AgentSuggestion>;
+    /**
+     * Tell user when a suggestion is accepted or rejected
+     * @param suggestion
+     * @param action
+     * @returns
+     */
+    onReviewSuggestion?: (suggestion: AgentSuggestion, action: AgentSuggestion["status"]) => void;
+    /**
+     * Callback fired when user switches to a new agent suggestion
+     * @param suggestionId
+     * @returns
+     */
+    onChangeActiveSuggestion?: (suggestionId: AgentSuggestion["id"]) => void;
+    /**
+     * Magic fill component
+     */
+    MagicFillComponent?: React.ComponentType<MagicFillProps>;
+    /**
+     * Magic fill content component
+     */
+    MagicFillContent?: React.ComponentType<MagicFillContentProps>;
+    /**
+     * Quick edit component
+     */
+    QuickEdit?: React.ComponentType<QuickEditProps>;
+    /**
+     * Paste menu component, shown after a paste operation
+     */
+    PasteMenu?: React.ComponentType<PasteMenuProps>;
+    /**
+     * Agent suggestion action component
+     */
+    SuggestionAction?: React.ComponentType<SuggestionActionProps>;
+    /**
+     * Hidden row markers, shown in the row header for hidden rows
+     */
+    HiddenRowMarkers?: React.ComponentType<HiddenRowMarkersProps>;
+    /**
+     * Hidden column markers, shown in the column header for hidden columns
+     */
+    HiddenColumnMarkers?: React.ComponentType<HiddenColumnMarkersProps>;
+    /**
+     * Header renderer
+     */
+    HeaderCell?: ElementType<HeaderCellProps>;
+    /**
+     * Cell renderer
+     */
+    Cell?: ElementType<CellProps<NonNullable<NonNullable<T["effectiveValue"]>["structuredValue"]>>>;
+    /**
+     * Structured results cell renderer
+     */
+    StructuredResult?(props: StructuredResultProps<NonNullable<NonNullable<T["effectiveValue"]>["structuredValue"]>>): React.ReactNode;
+    /**
+     * Selection title component
+     */
+    SelectionTitleComponent?: ElementType<SelectionTitleProps>;
+    /**
+     * Cell Editor
+     */
+    CellEditor?: ElementType<CellEditorProps>;
+    /**
+     * Tooltip
+     */
+    CellTooltip?: ElementType<CellTooltipProps>;
+    /**
+     * Optional error resolution UI for tooltips
+     */
+    errorResolutionComponent?: (sheetId: number, rowIndex: number, columnIndex: number) => React.ReactNode;
+    /**
+     * Context menu content component
+     */
+    ContextMenu?: ElementType<ContextMenuProps>;
+    /**
+     * Context menu content component
+     */
+    ContextMenuWrapper?: ElementType<ContextMenuWrapperProps>;
+    /**
+     * Filterbox component
+     */
+    FilterBox?: ElementType<FilterBoxProps>;
+    /**
+     * Column/Row drag component
+     */
+    HeaderMoveDragComponent?: React.ComponentType<DragComponentProps>;
+    /**
+     * Suggestions dropdown
+     */
+    SuggestionsDropdown?: ProseMirrorEditorProps["SuggestionsDropdown"];
+    /**
+     * Grid footer height
+     */
+    footerHeight?: GridProps["footerHeight"];
+    /**
+     * Grid footer component
+     */
+    footerComponent?: GridProps["footerComponent"];
+    /**
+     * Total no of non-empty rows
+     */
+    getDataRowCount?(sheetId?: number): number | undefined;
+    /**
+     * Total no of non-empty columns
+     */
+    getDataColumnCount?(sheetId: number): number | undefined;
+    /**
+     * Chart component
+     */
+    getChartComponent?(props: ChartComponentProps): React.ReactElement;
+    /**
+     * Embed component
+     */
+    getEmbedComponent?(props: EmbedComponentProps): React.ReactElement;
+    /**
+     * Slicer component
+     */
+    getSlicerComponent?(props: SlicerComponentProps): React.ReactElement;
+    /**
+     * Enable or disable cell expansion
+     * @param cellData
+     */
+    cellExpandPredicate?(sheetId: number, rowIndex: number, columnIndex: number): boolean;
+    /**
+     * Get content of a cell expansion
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    onRequestExpand?(sheetId: number, rowIndex: number, columnIndex: number): void | Promise<void>;
+    /**
+     * Get cell popover contents
+     * const api = useSpreadsheet()
+     */
+    getCellPopoverContent?(sheetId: number, rowIndex: number, columnIndex: number): Maybe<React.ReactElement | string>;
+    /**
+     * User scrolls the grid
+     * @param scrollCoords
+     */
+    onScroll?(scrollCoords: ScrollCoords): void;
+    /**
+     * View port changes
+     */
+    onViewPortChange?(viewport: ViewPortProps): void;
+    /**
+     * Evaluate conditional formatting only within the (padded, tile-quantized)
+     * visible viewport. Bounds the per-cell CF evaluation to O(window) for
+     * whole-column rules on huge sheets — without this, a million-row rule
+     * range stalls the main thread for seconds on every recompute. Rules whose
+     * covered-cell total is small are always evaluated in full, so statistics
+     * (gradient / topBottom / distinct / dataBar) only become window-relative
+     * on ranges large enough to need it. Off by default.
+     */
+    windowConditionalFormats?: boolean;
+    /**
+     * The host's engine evaluates aggregate conditional-format rules
+     * (TOP/BOTTOM-N, DUPLICATE/UNIQUE, above/below-average) and stamps the
+     * per-cell result on `cellData.conditionalFormattingResultById[ruleId]` —
+     * the same channel boolean/CUSTOM_FORMULA rules already flow through. When
+     * set, the overlay reads those stamps instead of recomputing the aggregate
+     * from loaded cell data, which is wrong on windowed large documents (the
+     * window only sees a slice of the rule's range). Rules over the engine's
+     * coverage cap (`ENGINE_CF_AGGREGATE_MAX_CELLS`) keep the JS computation.
+     * Off by default (engine-free documents compute aggregates in JS).
+     */
+    engineConditionalFormatResults?: boolean;
+    /**
+     * Callback when user changes a cell value
+     * @param sheetId
+     * @param cell
+     * @param value
+     */
+    onChange?(sheetId: number, cell: CellInterface, value: string | boolean, textFormatRuns: Maybe<TextFormatRun[]>, previousValue?: string | boolean | null | undefined, isDirty?: boolean, 
+    /**
+     * Runs the cell carried before this edit. Lets the host detect a
+     * pure-formatting change (value unchanged, runs differ — Cmd+B on
+     * existing text) and the reverse "unformat to plain" case (runs
+     * cleared, value unchanged). Optional; legacy callers that omit it
+     * fall back to the `Array.isArray(textFormatRuns) && length > 0`
+     * heuristic in `useOnChange`.
+     */
+    previousTextFormatRuns?: Maybe<TextFormatRun[]>): void;
+    /**
+     * Batch modify cells starting from a range
+     */
+    onChangeBatch?(sheetId: number, range: GridRange | GridRange[], values: (string | boolean | null | number | undefined)[][] | string | boolean | number | null | undefined, formatting?: (CellFormat | undefined | null)[][] | CellFormat | null | undefined, citations?: (string | undefined | null)[][] | string | null | undefined, options?: ChangeBatchOptions): void;
+    /**
+     * Batch modify cells from a stream
+     */
+    onChangeBatchStream?(sheetId: number, range: GridRange, stream: AsyncIterable<ChangeBatchStreamCell[][]>, options?: ChangeBatchStreamOptions): void | Promise<void>;
+    /**
+     * User is deleting a cell or selections
+     * @param sheetId
+     * @param cell
+     * @param selections
+     */
+    onDelete?(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * When user changes editor value
+     * @param value
+     * @param sheetId
+     * @param cell
+     */
+    onChangeEditorValue?(value: string, sheetId: number, cell: CellInterface): void;
+    /**
+     * For result preview panel in cell editor
+     * @param value Example: =SUM(4,4)
+     * @param sheetId
+     * @param cell
+     *
+     * @returns FormulaResult
+     */
+    onRequestCalculate?(value: string, sheetId: number, rowIndex: number, columnIndex: number, options?: {
+        isArray?: boolean;
+        disablePreview?: boolean;
+        overrides?: Map<string, string | number | boolean | Date | null | undefined>;
+        skipOnDemand?: boolean;
+    }): Promise<undefined | null | string | number | boolean | Date | (string | number | boolean | Date)[][]>;
+    /**
+     * Fill
+     * @param cell
+     * @param selections
+     */
+    onFill?(sheetId: number, cell: CellInterface, fillSelection: SelectionArea<SelectionAttributes>, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Callback when user moves a selection
+     * @param from
+     * @param to
+     */
+    onMoveSelection?(sheetId: number, from: SelectionArea<SelectionAttributes>, to: SelectionArea<SelectionAttributes>): void;
+    /**
+     * Callback when active cell changes
+     */
+    onChangeActiveCell?(sheetId: number, cell: CellInterface): void;
+    /**
+     * Callback when selections cell changes
+     */
+    onChangeSelections?(sheetId: number, selections: SelectionArea<SelectionAttributes>[], finishedSelection?: boolean): void;
+    /**
+     * Formulas can trigger sheet change
+     */
+    onChangeActiveSheet?(sheetId: number): void;
+    /**
+     * Get data of a specific cell
+     * @param rowIndex
+     * @param columnIndex
+     * @returns CellData
+     */
+    getCellData?(sheetId: number, rowIndex: number, columnIndex: number): T | null | undefined;
+    /**
+     * Resolves a cell's note. When omitted, the grid falls back to
+     * `getCellData(...)?.note`. Hosts that keep notes OFF the cell data
+     * (the rnc engine serves notes over their own channel, so its cells
+     * never carry `.note`) must pass their note lookup here — otherwise
+     * note indicators, tooltips, and the note editor's initial value
+     * can't see stored notes.
+     */
+    getNote?(sheetId: number, rowIndex: number, columnIndex: number): string | undefined;
+    /**
+     * Resolves the rich-text runs attached to a cell's SharedStrings
+     * entry (if any). Rich text is persisted on the SST side now, not
+     * on `CellData` — so the canvas grid needs an SST-aware lookup to
+     * render per-segment formatting. The host typically passes the
+     * `getTextFormatRuns` returned by `useSpreadsheetState` here.
+     * Returns `undefined` for cells without rich text. When the prop
+     * is omitted, cells with rich runs render as plain text.
+     */
+    getTextFormatRuns?(sheetId: number, rowIndex: number, columnIndex: number): TextFormatRun[] | null | undefined;
+    /**
+     * Get data validation of a specific cell
+     * @param rowIndex
+     * @param columnIndex
+     * @returns CellData
+     */
+    getDataValidation?(sheetId: number, rowIndex: number, columnIndex: number): DataValidationRule | null | undefined;
+    /**
+     * Returns cellformat of a cell
+     * This in place as we are going to begin
+     * phasing out cellData.effectiveFormat
+     * and instead use a cellFormatRegistry
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getEffectiveFormat?(sheetId: number, rowIndex: number, columnIndex: number): CellFormat | null | undefined;
+    /**
+     * Callback when user resizes a column or row
+     * @param sheetId
+     * @param index
+     * @param axis
+     * @param autoFit
+     */
+    onResize?(sheetId: number, indexes: number[], dimension: number, axis: AXIS, autoFit?: boolean): void;
+    /**
+     * Sets the dimension of the given column or row to fit its contents.
+     * @param sheetId
+     * @param index
+     * @param axis
+     */
+    onAutoResize?(sheetId: number, indexes: number[], axis: AXIS): void;
+    /**
+     * Hide column
+     * @param columnIndexes
+     */
+    onHideColumn?(sheetId: number, columnIndexes: number[]): void;
+    /**
+     * Hide column
+     * @param columnIndexes
+     */
+    onRequestResize?(sheetId: number, indexes: number[], axis: AXIS): void;
+    /**
+     * Hide row
+     * @param rowIndexes
+     */
+    onHideRow?(sheetId: number, rowIndexes: number[]): void;
+    /**
+     * Show column
+     * @param columnIndex
+     */
+    onShowColumn?(sheetId: number, columnIndexes: number[]): void;
+    /**
+     * Show row
+     * @param rowIndex
+     */
+    onShowRow?(sheetId: number, rowIndexes: number[]): void;
+    /**
+     * Group rows — bumps outlineLevel on the contiguous block of
+     * `rowIndexes` (Excel Data → Group → Rows).
+     */
+    onGroupRows?(sheetId: number, rowIndexes: number[]): void;
+    /** Inverse of `onGroupRows`. */
+    onUngroupRows?(sheetId: number, rowIndexes: number[]): void;
+    /**
+     * Collapse the outline group whose summary sits at
+     * `summaryRowIndex`. Children get `hiddenByGroup=true`; summary gets
+     * `collapsed=true`.
+     */
+    onCollapseRowGroup?(sheetId: number, summaryRowIndex: number): void;
+    /** Inverse of `onCollapseRowGroup`. */
+    onExpandRowGroup?(sheetId: number, summaryRowIndex: number): void;
+    /** Column-axis mirror of `onGroupRows`. */
+    onGroupColumns?(sheetId: number, columnIndexes: number[]): void;
+    /** Column-axis mirror of `onUngroupRows`. */
+    onUngroupColumns?(sheetId: number, columnIndexes: number[]): void;
+    /** Column-axis mirror of `onCollapseRowGroup`. */
+    onCollapseColumnGroup?(sheetId: number, summaryColumnIndex: number): void;
+    /** Column-axis mirror of `onExpandRowGroup`. */
+    onExpandColumnGroup?(sheetId: number, summaryColumnIndex: number): void;
+    /**
+     * Set the outline display depth — Excel's "1, 2, 3" level buttons.
+     * `depth` = N: groups at level >= N collapse; groups at level < N
+     * expand. So `depth=1` collapses every group; `depth=maxLevel + 1`
+     * expands every group.
+     */
+    onSetOutlineDepth?(sheetId: number, axis: "row" | "column", depth: number): void;
+    /**
+     * Delete column
+     * @param columnIndex
+     */
+    onDeleteColumn?(sheetId: number, columnIndexes: number[]): void;
+    /**
+     * Delete row
+     * @param rowIndex
+     */
+    onDeleteRow?(sheetId: number, rowIndexes: number[]): void;
+    /**
+     * Insert column
+     * @param columnIndex
+     */
+    onInsertColumn?(sheetId: number, columnIndex: number, numColumns: number): void;
+    /**
+     * Insert row
+     * @param rowIndex
+     */
+    onInsertRow?(sheetId: number, rowIndex: number, numRows: number): void;
+    /**
+     * When user inserts cell and shift down
+     * @param cell
+     */
+    onInsertCellsShiftDown?(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * When user inserts cell and shift right
+     * @param cell
+     */
+    onInsertCellsShiftRight?(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Delete cells and shift left
+     * @param cell
+     */
+    onDeleteCellsShiftLeft?(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Delete cells and shift up
+     * @param cell
+     */
+    onDeleteCellsShiftUp?(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Callback when columns are moved
+     * @param dims
+     * @param toColumn
+     */
+    onMoveColumns?(sheetId: number, dims: number[], toColumn: number): void;
+    /**
+     * Callback when rows are moved
+     * @param dims
+     * @param toRow
+     */
+    onMoveRows?(sheetId: number, dims: number[], toRow: number): void;
+    /**
+     * User pressed a key to select previous sheet
+     */
+    onSelectPreviousSheet?(currentSheetId: number, e?: React.KeyboardEvent<HTMLDivElement>): void;
+    /**
+     * User pressed a key to select previous sheet
+     */
+    onSelectNextSheet?(currentSheetId: number, e?: React.KeyboardEvent<HTMLDivElement>): void;
+    /**
+     * Shift + Fn + F11
+     * To insert a new sheet
+     */
+    onCreateNewSheet?(sheet?: Partial<Sheet>): Sheet | undefined;
+    /**
+     * Callback to delete sheet
+     * @param sheetId
+     */
+    onDeleteSheet?(sheetId: number): void;
+    /**
+     * Callback to copy a  sheet
+     * @param sheetId
+     */
+    onDuplicateSheet?(sheetId: number): void;
+    /**
+     * User tries to update a sheet
+     */
+    onUpdateSheet?(sheetId: number, sheet?: Partial<Sheet>): Sheet | undefined;
+    /**
+     * Keydown handler
+     */
+    onKeyDown?(e: React.KeyboardEvent<HTMLDivElement>): void;
+    /**
+     * Invoked from `Ctrl + ~` keyboard shortcut
+     * @param displayValue
+     */
+    onShowFormulas?(sheetId: number, displayValue: boolean): void;
+    /**
+     * When user changes formatting, Eg: bold, underline
+     */
+    onChangeFormatting?<T extends FormattingType>(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[], type: T, value: FormattingValue<T>): void;
+    /**
+     * When user presses F4, we can replay the last formatting
+     * on a new cell
+     * @param sheetId
+     */
+    onRepeatFormatting?(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * User is trying to clear all formatting from
+     * cells
+     */
+    onClearFormatting?(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Callback when user clears contents
+     */
+    onClearContents?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Called when user tries to edit a protected cell
+     * @param cell
+     */
+    onRequestEditProtectedRange?(sheetId: number, cell?: CellInterface): void;
+    /**
+     * Return sheet name from sheetId
+     * @param sheetId
+     */
+    getSheetName?(sheetId: number): string;
+    /**
+     * Return sheet id for a sheet name
+     * @param sheetName
+     */
+    getSheetId?(sheetName: string): number | undefined;
+    /**
+     * Get row count of a sheet
+     * @param sheetId
+     */
+    getSheetRowCount?(sheetId: number): number;
+    /**
+     * Get column count of a sheet
+     * @param sheetId
+     */
+    getSheetColumnCount?(sheetId: number): number;
+    /**
+     * Callback when user resizes a chart
+     * @param width
+     * @param height
+     */
+    onResizeChart?(chartId: string | number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number, width: number, height: number): void;
+    /**
+     * User is trying to delete an embed
+     * @param chartId
+     */
+    onDeleteChart?(chartId: string | number): void;
+    /**
+     * Fired when user moves a chart
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     */
+    onMoveChart?(chartId: string | number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number): void;
+    /**
+     * Callback when user resizes an embed
+     * @param width
+     * @param height
+     */
+    onResizeEmbed?(embedId: string | number, sheetId: number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number, width: number, height: number): void;
+    /**
+     * User is trying to delete an embed
+     * @param embedId
+     */
+    onDeleteEmbed?(embedId: string | number): void;
+    /**
+     * User is editing an embed
+     * @param embedId
+     */
+    onRequestEditEmbed?(embed: EmbeddedObject): void;
+    /**
+     * Fired when user moves an embed
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     */
+    onMoveEmbed?(embedId: string | number, sheetId: number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number): void;
+    /**
+     * Callback when user resizes a slicer
+     * @param slicerId
+     * @param sheetId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     * @param width
+     * @param height
+     */
+    onResizeSlicer?(slicerId: string | number, sheetId: number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number, width: number, height: number): void;
+    /**
+     * User is trying to delete a slicer
+     * @param slicerId
+     */
+    onDeleteSlicer?(slicerId: string | number): void;
+    /**
+     * User is editing a slicer
+     * @param slicer
+     */
+    onRequestEditSlicer?(slicer: Slicer): void;
+    /**
+     * Fired when user moves a slicer
+     * @param slicerId
+     * @param sheetId
+     * @param anchorCell
+     * @param offsetXPixels
+     * @param offsetYPixels
+     */
+    onMoveSlicer?(slicerId: string | number, sheetId: number, anchorCell: CellInterface, offsetXPixels: number, offsetYPixels: number): void;
+    /**
+     * When user tries to fill range
+     * @param activeCell
+     * @param selections
+     * @param direction
+     *
+     * Command + Enter => Fill range
+     * Command + D => Fill down
+     * Command + R => Fill right
+     */
+    onFillRange?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], direction?: Direction): void;
+    /**
+     * Disable Cmd/Ctrl + R fill right shortcut.
+     * When true, key combo falls through to the browser default.
+     */
+    disableFillRightShortcut?: boolean;
+    /**
+     * User is creating a new chart
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param chartSpec
+     */
+    onCreateChart?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], chartSpec?: EmbeddedChart): void;
+    /**
+     * Update a chart
+     * @param chartSpec
+     */
+    onUpdateChart?(chartSpec: EmbeddedChart): void;
+    /**
+     * Create an embed
+     * @param spec
+     */
+    onCreateEmbed?(spec: EmbeddedObject): void;
+    /**
+     * Update an embed in place (spec patches the existing record).
+     */
+    onUpdateEmbed?(embed: EmbeddedObject): void;
+    /**
+     * Create a named range. Pairs with `useSpreadsheetState`'s
+     * `onCreateNamedRange` callback.
+     */
+    onCreateNamedRange?(sheetId: number, namedRange: NamedRange): void;
+    /**
+     * Delete a named range by ID.
+     */
+    onDeleteNamedRange?(id: NamedRange["namedRangeId"]): void;
+    /**
+     * Clone a single cell's contents (value + format) from one position
+     * to another. Implemented as an `onChange` for the value plus a
+     * format-copy via `paintFormat`. Used by the imperative API.
+     */
+    onCloneCell?(sheetId: number, fromCell: CellInterface, toCell: CellInterface): void;
+    /**
+     * On insert current time
+     * @param activeCell
+     * @param selections
+     */
+    onInsertTime?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * On insert date
+     * @param activeCell
+     * @param selections
+     */
+    onInsertDate?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Insert date time
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    onInsertDateTime?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * On insert auto sum. Inserts a formula at the active cell that
+     * aggregates the contiguous data range above (or to the left)
+     * using the given function. Defaults to `SUM` to preserve the
+     * legacy Alt+= shortcut; the toolbar AutoSum dropdown can also
+     * request `AVERAGE`, `COUNT`, `MAX`, `MIN`.
+     * @param sheetId
+     * @param activeCell
+     * @param functionName Aggregate function name. Defaults to `SUM`.
+     */
+    onInsertAutoSum?(sheetId: number, activeCell: CellInterface, functionName?: "SUM" | "AVERAGE" | "COUNT" | "MAX" | "MIN"): void;
+    /**
+     * Freeze columns
+     * @param sheetId
+     * @param columnIndex
+     */
+    onFreezeColumn?(sheetId: number, columnIndex: number): void;
+    /**
+     * Freeze rows
+     * @param sheetId
+     * @param columnIndex
+     */
+    onFreezeRow?(sheetId: number, rowIndex: number): void;
+    /**
+     * User tries to undo an action
+     */
+    onUndo?(): void;
+    /**
+     * User tries to redo an action
+     */
+    onRedo?(): void;
+    /**
+     * Callback when user paste a set of cells
+     * @param e Browser event
+     * @param copiedSelections Selection that user copied
+     * @param activeCell Current active cell
+     * @param selections Current active selections
+     * @param shouldDeleteSource If user has cut a selection, we should delete copiedSelections
+     */
+    onPaste?(e: ClipboardEvent | undefined, sourceSheetId: number | undefined, destinationSheetId: number, copiedSelections: SelectionArea<SelectionAttributes>[] | undefined, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[] | undefined, finalSelections: SelectionArea<SelectionAttributes>[] | undefined, shouldDeleteSource: boolean): void;
+    /**
+     * Callback when user copies a selection
+     * useful to save copied selection till user
+     * paste's the selection
+     * @param e
+     * @param copiedSelections Selections that user copied
+     */
+    onCopy?(e: ClipboardEvent | undefined, sheetId: number, copiedSelections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Callback when user cuts a selection
+     * @param e
+     */
+    onCut?(e: ClipboardEvent | undefined, sheetId: number): void;
+    /**
+     * Sort sheet by columnIndex
+     * @param columnIndex
+     * @param sortOrder
+     */
+    onSortColumn?(sheetId: number, columnIndex: number, sortOrder: SortOrder, 
+    /**
+     * Optional — sort by cell/font color, CF icon, or a custom list
+     * instead of the cell value.
+     */
+    options?: SortColumnSortOptions, 
+    /**
+     * Optional "then by" levels for multi-level sort. Each level pins its
+     * own absolute `columnIndex`, direction and options. Omitting this
+     * keeps the single-column behavior identical.
+     */
+    additionalLevels?: SortColumnLevelOption[]): void;
+    /**
+     * Callback when user sorts a basicFilter or Table.
+     *
+     * Two call forms are supported:
+     *  - Single-dimension (filter-box A→Z / Z→A buttons):
+     *    `(sheetId, filter, dimensionIndex, direction, options?)`.
+     *  - Multi-dimension (custom sort dialog):
+     *    `(sheetId, filter, specs)` where `specs` is the full ordered
+     *    `SortSpecs` list (primary first, then tiebreakers).
+     */
+    onSortTable?: {
+        (sheetId: number, filter: FilterView | TableView, columnIndex: number, direction: SortOrder, options?: SortColumnSortOptions): void;
+        (sheetId: number, filter: FilterView | TableView, specs: SortSpecs[]): void;
+    };
+    /**
+     * Callback when applies a filter
+     * @param columnIndex
+     * @param conditionType
+     * @param conditionValue
+     * @param visibleValues
+     */
+    onFilterTable?(sheetId: number, filter: FilterView | TableView, columnIndex: number, conditionType: ConditionType | undefined, conditionValue: ConditionValue[] | undefined, 
+    /**
+     * User can show all values if visibleValues is set to undefined
+     */
+    visibleValues: Maybe<string[]>, 
+    /**
+     * Optional color / icon filter criteria. Pass `null` for either to
+     * clear an existing criterion; omit to preserve it.
+     */
+    extras?: {
+        colorFilter?: ColorFilterCriteria | null;
+        iconFilter?: IconFilterCriteria | null;
+        /**
+         * Reader for the rendered CF overlay format of a cell. The grid
+         * injects this at call time so `colorFilter` can match CF-painted
+         * fills / font colors, which the effective format doesn't carry.
+         * Not persisted on the filter spec.
+         */
+        getCellConditionalFormat?(sheetId: number, rowIndex: number, columnIndex: number): CellFormat | undefined;
+    }): void;
+    /**
+     * Filter pivot tables via a slicer. Hosts wire this to
+     * `usePivot.applySlicerSelectionToPivots`. Empty `selectedValues`
+     * clears the bound pivots' filter on the field; a non-empty list
+     * keeps only those values.
+     */
+    onFilterPivot?(pivotTableIds: (string | number)[], fieldName: string, selectedValues: string[]): void;
+    /**
+     * Callback when user resizes a table
+     * @param sheetId
+     * @param tableId
+     * @param range
+     */
+    onResizeTable?(sheetId: number, table: TableView, range: GridRange): void;
+    /**
+     * On Request edit a table
+     * Developers can choose to show a modal dialog
+     * @param table
+     */
+    onRequestEditTable?(table: TableView): void;
+    /**
+     * On Request edit pivot table
+     * @param pivotTable
+     */
+    onRequestEditPivotTable?(pivotTable: PivotTable): void;
+    /**
+     * On Request delete pivot table
+     * @param pivotTable
+     */
+    onRequestDeletePivotTable?(pivotId: PivotTable["pivotId"]): void;
+    /**
+     * Handle keyboard shortcut to create a new table
+     * Option + Command + T
+     * Ctrl + Option + T
+     */
+    onCreateTable?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], tableSpec?: Partial<TableView>, theme?: TableTheme, bandedRange?: BandedDefinition): void;
+    /**
+     * Callback for updating a table view
+     * @param sheetId
+     * @param tableView
+     * @param previousTable
+     */
+    onUpdateTable?(sheetId: number, tableId: TableView["id"], updatedTable: Partial<TableView>): void;
+    /**
+     * Insert a table column
+     * @param table
+     * @param relativeRowIndex
+     */
+    onInsertTableRow?(table: TableView, relativeRowIndex?: number, rowData?: Record<string, Maybe<string>>[]): void;
+    /**
+     * Insert a table column
+     * @param table
+     * @param relativeColumnIndex
+     */
+    onInsertTableColumn?(table: TableView, relativeColumnIndex: number, direction: Direction.Left | Direction.Right): void;
+    /**
+     * Delete a table column
+     * @param table
+     * @param referenceColumnIndex
+     */
+    onDeleteTableColumn?(table: TableView, referenceColumnIndex: number): void;
+    /**
+     * Delete a table row
+     * @param table
+     * @param referenceRowIndex
+     */
+    onDeleteTableRow?(table: TableView, rowIndexes: number[]): void;
+    /**
+     * Create a basic filter
+     * Ctrl+Shift+F
+     * Cmd+Shift+F
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    onCreateBasicFilter?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], basicFilterSpec?: Partial<FilterView>): void;
+    /**
+     * Remove table
+     * @param table
+     */
+    onRemoveTable?(table: TableView): void;
+    /**
+     * Callback when user updates or adds a new note
+     * @param sheetId
+     * @param cell
+     * @param notes
+     */
+    onUpdateNote?(sheetId: number, cell: CellInterface, notes?: string): void;
+    /**
+     * User wants to protect a range of cells or sheet
+     * @param sheetId
+     * @param cell
+     * @param selections
+     */
+    onProtectRange?(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[] | undefined): void;
+    /**
+     * Un protect range by Id
+     * @param sheetId
+     * @param protectedRangeId
+     */
+    onUnProtectRange?(sheetId: number, protectedRangeId: number | string): void;
+    /**
+     * Sort a selection range
+     * @param sheetId
+     * @param selection
+     */
+    onSortRange?(sheetId: number, selection: SelectionArea<SelectionAttributes>[], sortOrder: SortOrder, 
+    /**
+     * Optional per-column sort specifications, one per column in selection
+     * order (column 0 = `selection.range.startColumnIndex`). Consumed as
+     * multi-level "then by" specs. When omitted the uniform-direction
+     * behavior is preserved.
+     */
+    specs?: ({
+        sortOrder: SortOrder;
+    } & SortColumnSortOptions)[]): void;
+    /**
+     * Define a new or edit an existing named range
+     */
+    onRequestDefineNamedRange?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Request conditional formatting
+     */
+    onRequestConditionalFormat?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Request conditional formatting
+     */
+    onRequestDataValidation?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], initialDataValidationRule?: DataValidationRuleRecord, showEditUI?: boolean): void;
+    /**
+     * User is requesting to format cells. Show a format cell dialog
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    onRequestFormatCells?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * User is requesting to add a comment
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    onRequestInsertComment?(sheetId: number, activeCell: CellInterface): void;
+    /**
+     * User is requesting to insert a hyperlink at the active cell.
+     * Triggered by the `Cmd/Ctrl+K` shortcut. Host typically opens
+     * the link editor popover.
+     */
+    onRequestInsertLink?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Get text for a row header
+     * @param rowIndex
+     */
+    getRowHeaderText?(rowIndex: number): string;
+    /**
+     * Get text for a column header
+     * @param columnIndex
+     */
+    getColumnHeaderText?(columnIndex: number): string;
+    /**
+     * Parses a text value to return tokens
+     * @param value
+     */
+    tokenizer?(value: string | undefined, sheetName?: string): ParsedToken[];
+    /**
+     * User is requesting to search a sheet
+     */
+    onRequestSearch?(): void;
+    /**
+     * User is requesting Find & Replace (Cmd/Ctrl+H). Same surface as
+     * onRequestSearch but signals the host to open the search panel with
+     * its Replace pane expanded.
+     */
+    onRequestReplace?(): void;
+    /**
+     * Increase indent
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    onIncreaseIndent?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Decrease indent
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    onDecreaseIndent?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * To enable scroll and zoom interaction.
+     * User can change zoom by using mousewheel and pressing Ctrl + Shift or Ctrl + Alt/Opt
+     * @param scale
+     */
+    onChangeScale?(scale: number): void;
+    /**
+     * User is creating a conditional formatting rule
+     * @param rule
+     */
+    onCreateConditionalFormattingRule?(rule: ConditionalFormatRule): void;
+    /**
+     * User is updating a conditional formatting rule
+     * @param rule
+     */
+    onUpdateConditionalFormattingRule?(rule: ConditionalFormatRule, previousRule: ConditionalFormatRule): void;
+    /**
+     * Delete a rule
+     * @param rule
+     */
+    onDeleteConditionalFormattingRule?(rule: ConditionalFormatRule): void;
+    /**
+     * User is creating a validation rule
+     * @param rule
+     */
+    onCreateDataValidationRule?(rule: DataValidationRule): void;
+    /**
+     * User is updating a validation rule
+     * @param rule
+     */
+    onUpdateDataValidationRule?(rule: DataValidationRule, previousRule: DataValidationRule): void;
+    /**
+     * Delete a rule
+     * @param rule
+     */
+    onDeleteDataValidationRule?(rule: DataValidationRule): void;
+    /**
+     * Change decimals places
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param type
+     * @returns
+     */
+    onChangeDecimals?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], type: "increment" | "decrement"): void;
+    /**
+     * Remove an hyperlink
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     */
+    onRemoveLink?(sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * User selects an hyperlink
+     * @param sheetId
+     * @param activeCell
+     * @param hyperlink
+     */
+    onSelectLink?(sheetId: number, activeCell: CellInterface, hyperlink: T["hyperlink"]): void;
+    /**
+     * Change border
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param location
+     * @param color
+     * @param style
+     */
+    onChangeBorder?(sheetId: number, activeCell: CellInterface, selections: SelectionArea<SelectionAttributes>[], location: BorderLocation, color: Color | undefined, style: BorderStyle): void;
+    /**
+     * Change spreadsheet theme
+     * @param theme
+     */
+    onChangeTheme?(theme: SpreadsheetTheme): void;
+    /**
+     * Split text to columns
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @param delimiter
+     * @returns
+     */
+    onSplitTextToColumns?: (sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[], delimiter?: string) => void;
+    /**
+     * Remove duplicate rows
+     * @param sheetId
+     * @param activeCell
+     * @param selections
+     * @returns
+     */
+    onRemoveDuplicates?: (sheetId: number, activeCell: CellInterface, selections?: SelectionArea<SelectionAttributes>[]) => void;
+    /**
+     * Callback to get effective value of a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getEffectiveExtendedValue?(sheetId: number, rowIndex: number, columnIndex: number): T["effectiveValue"];
+    /**
+     * Callback to get user entered value of a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getUserEnteredExtendedValue?(sheetId: number, rowIndex: number, columnIndex: number): T["ue"];
+    /**
+     * Callback to get formatted value of a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getFormattedValue?(sheetId: number, rowIndex: number, columnIndex: number): Maybe<string>;
+    /**
+     * Host-computed distinct values for a column's
+     * basic-filter checklist. When provided (windowed sheets), CanvasGrid uses these
+     * instead of scanning every row via `getFormattedValue` — that O(rows) scan floods
+     * the windowed tile-fetcher and blanks the grid. Return `undefined` to fall back to
+     * the built-in scan, `[]` while loading, else the values.
+     */
+    getFilterValues?(sheetId: number, columnIndex: number, range: {
+        startRowIndex: number;
+        endRowIndex: number;
+    }): string[] | undefined;
+    /**
+     * Optional host-computed distinct fill/font colors + CF icons for the FilterBox's
+     * "Filter by color" picker. Windowed engines supply this (one engine-side column scan)
+     * because the JS per-row `getEffectiveFormat` scan is disabled when `getFilterValues`
+     * is wired — without it the color/icon picker never renders on those hosts.
+     */
+    getFilterColors?(sheetId: number, columnIndex: number, range: {
+        startRowIndex: number;
+        endRowIndex: number;
+    }): {
+        availableCellColors?: string[];
+        availableFontColors?: string[];
+        availableIcons?: AvailableIcon[];
+    } | undefined;
+    /**
+     * Optional full-store per-cell reader used when resolving data-validation source
+     * ranges (dropdown options + commit-time checks). Windowed engines supply an
+     * off-window-safe reader here; defaults to `getFormattedValue`.
+     */
+    getValidationSourceValue?(sheetId: number, rowIndex: number, columnIndex: number): Maybe<string>;
+    /**
+     * Callback to get custom tooltip content for a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     * @returns ReactNode (component) or string content for the tooltip
+     */
+    getTooltipContent?(sheetId: number, rowIndex: number, columnIndex: number): React.ReactNode | string | undefined;
+    /**
+     * Callback to get formatted value of a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getEffectiveValue?(sheetId: number, rowIndex: number, columnIndex: number): Maybe<string | number | Date | boolean>;
+    /**
+     * Expand collapse cells
+     */
+    onExpandCollapse?(sheetId: number, cell: CellInterface, groupKeys: string[], newExpandedState: boolean, childrenCount?: number): void;
+    /**
+     * Excel "Show Details" — double-clicking a pivot value cell drills
+     * down into the source rows behind it (handled by the host, e.g.
+     * `usePivot().onDrillDownToSheet`). When provided, a double-click on a
+     * pivot data cell calls this instead of entering edit mode.
+     */
+    onPivotDrillDown?(pivotId: string | number, sheetRowIndex: number, sheetColumnIndex: number): void;
+    /**
+     * Get additional cell spacing
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getAdditionalCellSpacing?(sheetId: number, rowIndex: number, columnIndex: number): Maybe<number>;
+    /**
+     * This is used for LLM agent to invoke from UI
+     * to read spreadsheet values of the current sheet
+     * @param sheetId
+     */
+    getAgentSpreadsheetValues?(sheetId: number, range: GridRange): string | undefined | null;
+    /**
+     * Get mentions for a query
+     * @param query
+     */
+    getMentions?(query: Maybe<string>): Promise<Maybe<ExtractMentionType<T>[]>>;
+    /**
+     * Get structured properties from a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getStructuredProperties?(sheetId: number, rowIndex: number, columnIndex: number): OptionItem[] | undefined;
+    /**
+     * Suggestion provider for function parameters
+     */
+    getFunctionParameterSuggestions?: (functionName: string, parameterIndex: number, parameters: string[]) => OptionItem[] | undefined | Promise<OptionItem[] | undefined> | Promise<OptionItem[]>;
+    /**
+     * Predicate for Suggestion provider for function parameters
+     */
+    shouldFetchFunctionParameters?: (functionName: string, parameterIndex: number, parameters: string[]) => boolean;
+    /**
+     * Mention component
+     * @param props
+     * @returns
+     */
+    MentionTagComponent?: React.ComponentType<MentionTagComponentProps<ExtractMentionType<T>>>;
+    /**
+     * Mention dropdown item component
+     */
+    MentionDropdownItemComponent?: React.ComponentType<{
+        mention: ExtractMentionType<T>;
+    }>;
+    /**
+     * Precedent and dependent arrows inside scrollview
+     */
+    arrowComponents?: React.ReactNode[] | null | undefined;
+};
+export type CanvasGridHTMLAttributes = Omit<React.HTMLAttributes<HTMLDivElement>, "onChange" | "onResize" | "onCopy" | "onPaste" | "onCut" | "onScroll" | "onBlur">;
+export type GetSelectionFromNamedRange = (namedRangeName: string) => SelectionArea<SelectionAttributes> | undefined | FormulaResult;
+export type FormattingType = keyof CellFormat;
+export type FormattingValue<T extends FormattingType> = CellFormat[T];
+export type ChangeBatchOptions = {
+    enableEvaluation?: boolean;
+    enableHistory?: boolean;
+    formattingOnly?: boolean;
+};
+export type CanvasGridRefAttribute = {
+    ref?: React.Ref<CanvasGridMethods>;
+};
+export type GetCellDimensionsOptions = SizerGetCellDimensionsOptions;
+export type ChangeBatchStreamCell = {
+    value?: string | boolean | number | null | undefined;
+    formula?: string | null | undefined;
+    cell_styles?: CellFormat;
+};
+export type ChangeBatchStreamOptions = {
+    disableDelta?: boolean;
+    disableEvaluation?: boolean;
+    shouldUpdateRowHeights?: boolean;
+    /**
+     * Regex pattern to ignore formulas that match.
+     * Formulas matching this pattern will be treated as plain text values.
+     */
+    ignoreFormulaPattern?: RegExp;
+    /**
+     * Silently drop a streamed value that fails the target cell's
+     * data-validation rule (the previous cell content is preserved). A
+     * streamed write has no dialog to confirm through, so blocking rules
+     * behave like Excel refusing the entry: Excel's default errorStyle is
+     * "stop" — only an explicit warning/information alert lets the value
+     * write through (flagged, like a user clicking past the prompt).
+     * Formula-based rules whose result isn't computed yet fail open.
+     * Defaults to false: invalid values are written and flagged.
+     */
+    skipInvalidValues?: boolean;
+    /**
+     * Leave the existing cell untouched when the streamed input for it is
+     * empty (a hole in the row array, null, or ""), instead of clearing the
+     * cell. Cumulative AI feeds re-send the whole range every chunk with
+     * holes for cells they never fill; without this the first partial chunk
+     * wipes pre-filled cells (e.g. dropdown defaults). Explicit clears are
+     * still possible with the option off. Defaults to false.
+     */
+    preserveExistingValues?: boolean;
+    isAborted?(): boolean;
+};
+export type CanvasGridMethods = {
+    /**
+     * Call edit on a cell. Pass `initialValue` to open the editor pre-filled
+     * (e.g. Insert Function inserts `=SUM(`); the value is applied to the
+     * editor). `options` carries `autoFocus` / `isPointerDevice` /
+     * `fromKeystroke`.
+     * @param cell
+     * @param initialValue
+     * @param options
+     */
+    makeEditable?(sheetId: number, cell: CellInterface, initialValue?: string, options?: MakeEditableOptions): void;
+    /**
+     * Imperatively edit a cell — works both ways:
+     *  - if a cell is already being edited, `initialValue` is inserted into the
+     *    open editor at the cursor (append);
+     *  - otherwise the editor opens on `cell`, optionally pre-filled with
+     *    `initialValue`.
+     * Preferred over `makeEditable` for host-driven insertions (e.g. Insert
+     * Function) since it handles the in-progress-edit case.
+     * @param cell
+     * @param initialValue
+     * @param options
+     */
+    editCell?(sheetId: number, cell: CellInterface, initialValue?: string, options?: MakeEditableOptions): void;
+    /**
+     * Get next cell to focus when user presses enter or tab
+     * @param currentCell
+     * @param direction
+     */
+    getNextFocusableCell?(sheetId: number, currentCell: CellInterface, direction?: Direction, restrictWithinSelection?: boolean): CellInterface | null;
+    /**
+     * Submit an editor
+     * @param value
+     * @param activeCell
+     * @param nextActiveCell
+     */
+    submitEditor?(value: string, textFormatRuns: TextFormatRun[] | undefined, sheetId: number, activeCell: CellInterface, nextActiveCell?: CellInterface | null | undefined): void;
+    /**
+     * Cancel editing
+     * @param e
+     */
+    cancelEditor?(e?: React.KeyboardEvent<HTMLDivElement>): void;
+    /**
+     * Commit the in-progress cell edit using the current editor state. Submits
+     * when dirty, cancels when clean, no-ops when no edit is active. Does not
+     * refocus the grid. Returns true if there was an edit to flush.
+     *
+     * ```tsx
+     * <CanvasGrid onBlur={(e, isEditing) => isEditing && ref.current?.commit?.()} />
+     * ```
+     */
+    commit?(): boolean;
+    /**
+     * Callback when user enters text on editor.
+     * Used for cell selection in formulaMode
+     * @param e
+     */
+    onEditorKeyDown?(e: React.KeyboardEvent<HTMLDivElement>): void;
+    /**
+     * Scroll to cell
+     * @param cell
+     */
+    scrollToCell?(cell: OptionalCellInterface, align?: Align): void;
+    /**
+     * Scroll to bottom of the sheet
+     */
+    scrollToBottom?(): void;
+    /**
+     * Switch focus to sheet
+     */
+    focusSheet?(): void;
+    /**
+     * Can edit a cell
+     * @param cell
+     */
+    canEditCell?(sheetId: number, cell: CellInterface): boolean;
+    /**
+     * Can user edit a sheet
+     * @param sheetId
+     */
+    isSheetProtected?(sheetId: number): boolean;
+    /**
+     * Whether the workbook is structurally protected. Returns true when
+     * sheet-structural operations (add/delete/rename/move/duplicate/
+     * hide/show/tab color) should be refused workbook-wide.
+     */
+    isWorkbookProtected?(): boolean;
+    /**
+     * Worksheet-level protection (`<sheetProtection>`) lookup — the
+     * `getSheetProtection` prop surfaced through context so interaction
+     * layers (e.g. `useCanPerformSheetAction` in spreadsheet-state) can gate
+     * structural operations on the sheet's granular protection flags.
+     */
+    getSheetProtection?(sheetId: number): SheetProtection | null | undefined;
+    /**
+     * Get all selections from formula
+     * @param value
+     */
+    getSelectionsFromFormula?(value: string, anchorCell?: CellInterface): SelectionArea<SelectionAttributes>[];
+    /**
+     * Get address from selection
+     * @param value
+     */
+    getAddressFromSelection?(selections: SelectionArea<SelectionAttributes>, sheetName: string | undefined, anchorCell?: SheetCoordinate): string | undefined;
+    /**
+     * Get R1C1 address notation
+     * @param range
+     * @param sheetName
+     */
+    getR1C1AddressFromSelection?(range: GridRange, sheetName?: string): string | undefined;
+    /**
+     * Set main editor value
+     * @param value Set
+     * @param cell
+     */
+    setEditorValue?(value: string, textFormatRuns: Maybe<TextFormatRun[]>, sheetId: number, cell: CellInterface): void;
+    /**
+     * Get cell bounds
+     * @param coords
+     * @param spanMerges
+     */
+    getCellBounds?(coords: CellInterface, spanMerges?: boolean | undefined): GridRange;
+    /**
+     * Get all table names
+     */
+    getTableNames?(): OptionItem[] | undefined;
+    /**
+     * Get column names of a table
+     * @param tableName
+     */
+    getTableColumnNames?(tableName: string): OptionItem[] | undefined;
+    /**
+     * Get structured properties from a cell
+     * @param sheetId
+     * @param rowIndex
+     * @param columnIndex
+     */
+    getStructuredProperties?(sheetName: string | undefined, rowIndex: number, columnIndex: number): OptionItem[] | undefined;
+    /**
+     * Get named range names
+     */
+    getNamedRanges?(): OptionItem[] | undefined;
+    /**
+     * When activeCell or selections are modified from the outside,
+     * we have to update
+     * selectionStart.current
+     * selectionEnd.current
+     *
+     * in useSelection hook. This is used for multiple selections, appending etc
+     * @param cell
+     * @param selections
+     */
+    updateSelectionStartEndReference?(cell: CellInterface | undefined, selections?: SelectionArea<SelectionAttributes>[] | undefined): void;
+    /**
+     * Tokenize string
+     * @param str
+     */
+    tokenizer(str: string): ParsedToken[];
+    /**
+     * Get dimensions of a cell
+     */
+    getCellDimensions?(sheetId: number, rowIndex: number, columnIndex: number, axis?: AXIS | undefined, options?: GetCellDimensionsOptions): {
+        width: number;
+        height: number;
+    };
+    /**
+     * Get row height
+     * @param rowIndex
+     * @param columnIndexToExclude
+     */
+    getRowHeight?(sheetId: number, rowIndex: number, shouldExclude?: (index: number) => boolean): number;
+    /**
+     * Get columnwidth
+     * @param rowIndex
+     * @param columnIndexToExclude
+     */
+    getColumnWidth?: ReturnType<typeof useSizer>["getColumnWidth"];
+    /**
+     * Get a range of contentful cells
+     * Useful when user wants to create a table, by
+     * selecting a single cell
+     */
+    getContentfulGridRangeAroundCell?: (sheetId: number, startCell: CellInterface) => GridRange;
+    /**
+     * Get cell from x, y position
+     * Eg: getCellCoordsFromOffset(e.nativeEvent.clientX, e.nativeEvent.clientY)
+     * @param x
+     * @param y
+     * @param includeFrozen
+     */
+    getCellCoordsFromOffset?(x: number, y: number, includeFrozen: boolean): CellInterface | undefined;
+    /**
+     * Get cell position relative to grid container
+     * Useful, if you want to position tooltips or overlay
+     * @param cell
+     */
+    getCellOffsetFromCoords?(cell: CellInterface): CellPosition | undefined;
+    /**
+     * Get user entered values from a range
+     * Used for validation
+     */
+    getEffectiveValuesFromRange?: (address: string) => ConditionValue[];
+    /**
+     * Show notes tooltip and let user enter a note
+     * @param sheetId
+     * @param cell
+     */
+    onInsertNote?(sheetId: number, cell: CellInterface, selections: SelectionArea<SelectionAttributes>[]): void;
+    /**
+     * Pin tooltip cell
+     */
+    onPinToolTip?(sheetId: number, cell: CellInterface): void;
+    /**
+     * Remove pinned tooltip
+     */
+    onUnpinTooltip?(): void;
+    /**
+     * Get current sheet dimensions
+     */
+    getSheetDimensions?(): readonly [width: number, height: number];
+    /**
+     * Expand a row based on the value of a cell
+     * @param rowIndex
+     * @param columnIndex
+     * @param value
+     */
+    getFinalRowHeight?(sheetId: number, rowIndex: number, columnIndex: number, options?: GetCellDimensionsOptions): number | undefined;
+    /**
+     * Get sheet name from id
+     */
+    getSheetName?: CanvasGridProps["getSheetName"];
+    /**
+     * Get sheet id from name
+     */
+    getSheetId?: CanvasGridProps["getSheetId"];
+    /**
+     * Show a cell popover. Use `getCellPopoverContent()` in <CanvasGrid />
+     * to set popover content
+     * @param popoverRange
+     */
+    showCellPopover?(popoverRange: SheetRange | SheetCoordinate, content: Maybe<React.ReactNode | React.ComponentType>): void;
+    /**
+     * Redraw current sheet
+     */
+    redrawGrid?(): void;
+    /**
+     * Flash a cell area
+     */
+    flash?: ReturnType<typeof useFlash>["flash"];
+    /**
+     * Navigate to sheet range
+     */
+    navigateToSheetRange?: ReturnType<typeof useNavigateToSheetRange>;
+    /**
+     * Highlight
+     */
+    mark?: ReturnType<typeof useFlash>["mark"];
+    /**
+     * Remove Highlight
+     */
+    unmark?: ReturnType<typeof useFlash>["unmark"];
+    /**
+     * Split text to columns
+     */
+    splitTextToColumns?: CanvasGridProps["onSplitTextToColumns"];
+    /**
+     * Exports a range as image
+     * @param range
+     * @returns
+     */
+    exportRange?: ExportRangeOutput;
+    /**
+     * Current current viewport
+     * @returns
+     */
+    getViewPort?: () => ViewPortProps;
+    /**
+     * Context method to set active cell
+     * @param sheetId
+     * @param activeCell
+     * @param shouldScroll
+     * @returns
+     */
+    setActiveCell?: (sheetId: number, activeCell: CellInterface, shouldScroll?: boolean, align?: Align) => void;
+    /**
+     * Get current grid ref
+     * @returns
+     */
+    getGridRef?: () => GridRef | null;
+    /**
+     * Get mentions
+     */
+    getMentions?: CanvasGridProps["getMentions"];
+    /**
+     * Imperatively dispatch a keyboard event
+     * @param type
+     * @param eventInitDict
+     * @returns
+     */
+    dispatchEvent?: (event: Event) => void;
+    /**
+     * Copies current selections
+     * @returns
+     */
+    copy?: () => void;
+    /**
+     * Cuts current selections
+     * @returns
+     */
+    cut?: () => void;
+    /**
+     * Copies current selections
+     * @returns
+     */
+    paste?: (pasteSpecial?: PasteSpecialType) => void;
+};
+export type SelectionAttributes = RangeStyle & {
+    sheetName?: string;
+};
+export type RangeStyle = AreaStyle & {
+    table?: TableView;
+    pivotTable?: PivotTable;
+    agentSuggestion?: AgentSuggestion;
+};
+export type RangeBorderStyle = RangeStyle & {
+    /**
+     * Border style requires an id to prevent re-rendering
+     */
+    id: number | string;
+};
+export type SheetRangeBorderStyle = Omit<RangeBorderStyle, "range"> & {
+    range: SheetRange;
+};
+export type ExportFormats = "image/png" | "image/jpeg" | "image/jpg" | "image/webp" | "clipboard" | "blob";
+/**
+ * Spreadsheet theme
+ */
+export type SpreadsheetTheme = {
+    name: string;
+    /**
+     * Body typeface — the theme's minor font, used for regular cells
+     * (OOXML `<a:fontScheme><a:minorFont>`).
+     */
+    primaryFontFamily: string;
+    /**
+     * Heading typeface — the theme's major font (OOXML
+     * `<a:fontScheme><a:majorFont>`). Optional; when absent the theme
+     * behaves as before and `primaryFontFamily` covers both roles.
+     */
+    headingFontFamily?: string;
+    themeColors: Record<ThemeColors, string>;
+    darkThemeColors?: Partial<Record<ThemeColors, string>>;
+};
+export type ThemeColors = "text1" | "text2" | "background1" | "background2" | "accent1" | "accent2" | "accent3" | "accent4" | "accent5" | "accent6" | "hyperlink";
+/**
+ * Naming conventions callbacks
+ * In React, it is generally recommended to follow a consistent naming convention for component props. The most commonly used convention for prop names is to start with a verb that describes what the prop does, followed by a noun that describes the type of data it expects. onChangeSelections follows the convention of starting with a verb (onChange) that describes the action, followed by a noun (Selections) that describes the type of data being changed. This is a common convention used in React, so it may be more familiar to other developers who are working on the same project.
+ */
+//# sourceMappingURL=typings.d.ts.map