@simple-table/angular 3.0.0-beta.10

package/dist/cjs/core/src/managers/SelectionManager/mouseUtils.d.ts

@@ -0,0 +1,15 @@
+import type Cell from "../../types/Cell";
+/**
+ * Calculate the nearest cell to a given mouse position.
+ * Uses row buckets: one getBoundingClientRect per row to find the row, then only
+ * measures cells in that row (O(rows + cols) instead of O(rows * cols)).
+ */
+export declare function calculateNearestCell(clientX: number, clientY: number): Cell | null;
+/**
+ * Get cell from mouse position (element under point, or nearest cell).
+ */
+export declare function getCellFromMousePosition(clientX: number, clientY: number): Cell | null;
+/**
+ * Handle auto-scrolling when dragging near table edges.
+ */
+export declare function handleAutoScroll(clientX: number, clientY: number): void;

package/dist/cjs/core/src/managers/SelectionManager/selectionRangeUtils.d.ts

@@ -0,0 +1,7 @@
+import type Cell from "../../types/Cell";
+import type TableRowType from "../../types/TableRow";
+/**
+ * Compute the set of cell IDs for a selection range.
+ * Resolves rowId to current row index (for virtualized/sorted tables) then fills the rectangle.
+ */
+export declare function computeSelectionRange(startCell: Cell, endCell: Cell, tableRows: TableRowType[], enableRowSelection: boolean): Set<string>;

package/dist/cjs/core/src/managers/SelectionManager/types.d.ts

@@ -0,0 +1,22 @@
+import type HeaderObject from "../../types/HeaderObject";
+import type { Accessor } from "../../types/HeaderObject";
+import type TableRowType from "../../types/TableRow";
+import type Cell from "../../types/Cell";
+import type { CustomTheme } from "../../types/CustomTheme";
+export declare const createSetString: ({ rowIndex, colIndex, rowId }: Cell) => string;
+export interface SelectionManagerConfig {
+    selectableCells: boolean;
+    headers: HeaderObject[];
+    tableRows: TableRowType[];
+    onCellEdit?: (props: any) => void;
+    cellRegistry?: Map<string, any>;
+    collapsedHeaders?: Set<Accessor>;
+    rowHeight: number;
+    enableRowSelection?: boolean;
+    copyHeadersToClipboard?: boolean;
+    customTheme: CustomTheme;
+    /** Called when a selection drag ends so the table can re-render and apply selection classes. */
+    onSelectionDragEnd?: () => void;
+    /** Root element of the table; sync scopes cell queries to this so only this table's cells are updated. */
+    tableRoot?: HTMLElement;
+}

package/dist/cjs/core/src/managers/SortManager.d.ts

@@ -0,0 +1,42 @@
+import HeaderObject, { Accessor } from "../types/HeaderObject";
+import Row from "../types/Row";
+import SortColumn, { SortDirection } from "../types/SortColumn";
+export interface SortManagerConfig {
+    headers: HeaderObject[];
+    tableRows: Row[];
+    externalSortHandling: boolean;
+    onSortChange?: (sort: SortColumn | null) => void;
+    rowGrouping?: string[];
+    initialSortColumn?: string;
+    initialSortDirection?: SortDirection;
+    announce?: (message: string) => void;
+}
+export interface SortManagerState {
+    sort: SortColumn | null;
+    sortedRows: Row[];
+}
+type StateChangeCallback = (state: SortManagerState) => void;
+export declare class SortManager {
+    private config;
+    private state;
+    private subscribers;
+    private headerLookup;
+    constructor(config: SortManagerConfig);
+    private updateHeaderLookup;
+    private getInitialSort;
+    private sortNestedRows;
+    private computeSortedRows;
+    updateConfig(config: Partial<SortManagerConfig>): void;
+    subscribe(callback: StateChangeCallback): () => void;
+    private notifySubscribers;
+    updateSort(props?: {
+        accessor: Accessor;
+        direction?: SortDirection;
+    }): void;
+    computeSortedRowsPreview(accessor: Accessor): Row[];
+    getState(): SortManagerState;
+    getSortColumn(): SortColumn | null;
+    getSortedRows(): Row[];
+    destroy(): void;
+}
+export {};

package/dist/cjs/core/src/types/AggregationTypes.d.ts

@@ -0,0 +1,8 @@
+import type CellValue from "./CellValue";
+export type AggregationType = "sum" | "average" | "count" | "min" | "max" | "custom";
+export type AggregationConfig = {
+    type: AggregationType;
+    parseValue?: (value: CellValue) => number;
+    formatResult?: (value: number) => string;
+    customFn?: (values: CellValue[]) => number;
+};

package/dist/cjs/core/src/types/BoundingBox.d.ts

@@ -0,0 +1,11 @@
+type BoundingBox = {
+    bottom: number;
+    height: number;
+    left: number;
+    right: number;
+    top: number;
+    width: number;
+    x: number;
+    y: number;
+};
+export default BoundingBox;

package/dist/cjs/core/src/types/Cell.d.ts

@@ -0,0 +1,7 @@
+import { RowId } from "./RowId";
+type Cell = {
+    colIndex: number;
+    rowId: RowId;
+    rowIndex: number;
+};
+export default Cell;

package/dist/cjs/core/src/types/CellChangeProps.d.ts

@@ -0,0 +1,9 @@
+import CellValue from "./CellValue";
+import { Accessor } from "./HeaderObject";
+import Row from "./Row";
+type CellChangeProps = {
+    accessor: Accessor;
+    newValue: CellValue;
+    row: Row;
+};
+export default CellChangeProps;

package/dist/cjs/core/src/types/CellClickProps.d.ts

@@ -0,0 +1,11 @@
+import CellValue from "./CellValue";
+import { Accessor } from "./HeaderObject";
+import Row from "./Row";
+type CellClickProps = {
+    accessor: Accessor;
+    colIndex: number;
+    row: Row;
+    rowIndex: number;
+    value: CellValue;
+};
+export default CellClickProps;

package/dist/cjs/core/src/types/CellRendererProps.d.ts

@@ -0,0 +1,32 @@
+import type { Accessor } from "./HeaderObject";
+import type Row from "./Row";
+import type Theme from "./Theme";
+import type CellValue from "./CellValue";
+interface CellRendererProps {
+    accessor: Accessor;
+    colIndex: number;
+    row: Row;
+    rowIndex: number;
+    rowPath?: (string | number)[];
+    theme: Theme;
+    value: CellValue;
+    formattedValue?: string | number | string[] | number[] | null | undefined | boolean;
+}
+/**
+ * CellRenderer return type:
+ * - string | number | null: rendered as text in the cell
+ * - Node (HTMLElement, DocumentFragment, etc.): appended directly into the cell for full DOM control
+ *
+ * Example (text):
+ *   cellRenderer: ({ value, row }) => `${value} (${row.status})`
+ *
+ * Example (custom HTML):
+ *   cellRenderer: ({ row }) => {
+ *     const span = document.createElement('span');
+ *     span.className = 'badge';
+ *     span.textContent = String(row.status);
+ *     return span;
+ *   }
+ */
+export type CellRenderer = (props: CellRendererProps) => string | number | null | Node;
+export default CellRendererProps;

package/dist/cjs/core/src/types/CellValue.d.ts

@@ -0,0 +1,2 @@
+type CellValue = string | number | boolean | undefined | null | string[] | number[] | Record<string, unknown>[];
+export default CellValue;

package/dist/cjs/core/src/types/ColumnEditorConfig.d.ts

@@ -0,0 +1,32 @@
+import HeaderObject from "./HeaderObject";
+import { ColumnEditorRowRenderer } from "./ColumnEditorRowRendererProps";
+/**
+ * Custom search function for filtering columns in the column editor
+ * @param header - The header object to check
+ * @param searchTerm - The current search term
+ * @returns true if the header matches the search term, false otherwise
+ */
+export type ColumnEditorSearchFunction = (header: HeaderObject, searchTerm: string) => boolean;
+/**
+ * Configuration options for the column editor/visibility drawer
+ */
+export interface ColumnEditorConfig {
+    /** Text displayed on the column editor button (default: "Columns") */
+    text?: string;
+    /** Enable search functionality in the column editor (default: true) */
+    searchEnabled?: boolean;
+    /** Placeholder text for the search input (default: "Search columns...") */
+    searchPlaceholder?: string;
+    /** Custom search function to override default search behavior. Receives header and searchTerm, returns true if header matches. */
+    searchFunction?: ColumnEditorSearchFunction;
+    /**
+     * When false, hides pin/unpin controls (L/R) in the column editor. Pinned sections still appear if columns are pinned.
+     * Default: true.
+     */
+    allowColumnPinning?: boolean;
+    /** Custom renderer for column editor row layout to reposition icons and labels */
+    rowRenderer?: ColumnEditorRowRenderer;
+}
+export declare const DEFAULT_COLUMN_EDITOR_CONFIG: Required<Omit<ColumnEditorConfig, "searchFunction" | "rowRenderer">>;
+/** Column editor config with defaults applied (text, searchEnabled, searchPlaceholder are required) */
+export type MergedColumnEditorConfig = Required<Pick<ColumnEditorConfig, "text" | "searchEnabled" | "searchPlaceholder" | "allowColumnPinning">> & Pick<ColumnEditorConfig, "searchFunction" | "rowRenderer">;

package/dist/cjs/core/src/types/ColumnEditorRowRendererProps.d.ts

@@ -0,0 +1,39 @@
+import type { Accessor } from "./HeaderObject";
+import type HeaderObject from "./HeaderObject";
+import type { IconElement } from "./IconsConfig";
+import type { PanelSection } from "./PanelSection";
+export interface ColumnEditorRowRendererComponents {
+    expandIcon?: IconElement;
+    checkbox?: HTMLElement | string;
+    dragIcon?: IconElement;
+    labelContent?: string | HTMLElement;
+    /** Default pin column (outline / filled); omit when building a fully custom row */
+    pinIcon?: IconElement;
+}
+/** Pin / unpin actions for column editor rows (also use for lock/tooltip UX via HeaderObject.isEssential). */
+export interface ColumnEditorPinControl {
+    pinnedSide: "left" | "right" | null;
+    canPinLeft: boolean;
+    canPinRight: boolean;
+    canUnpin: boolean;
+    pinLeft: () => void;
+    pinRight: () => void;
+    unpin: () => void;
+}
+interface ColumnEditorRowRendererProps {
+    accessor: Accessor;
+    header: HeaderObject;
+    components: ColumnEditorRowRendererComponents;
+    /** Which panel section this row is rendered in */
+    panelSection?: PanelSection;
+    /** Resolved from HeaderObject.isEssential / essentialAccessors */
+    isEssential?: boolean;
+    /** False when visibility cannot be toggled (essential columns) */
+    canToggleVisibility?: boolean;
+    /** Mirrors `columnEditorConfig.allowColumnPinning` (default true) */
+    allowColumnPinning?: boolean;
+    pinControl?: ColumnEditorPinControl;
+}
+export type ColumnEditorRowRenderer = (props: ColumnEditorRowRendererProps) => HTMLElement | string | null;
+export default ColumnEditorRowRendererProps;
+export type { PanelSection };

package/dist/cjs/core/src/types/ColumnVisibilityTypes.d.ts

@@ -0,0 +1,4 @@
+import { Accessor } from "./HeaderObject";
+export interface ColumnVisibilityState {
+    [accessor: Accessor]: boolean;
+}

package/dist/cjs/core/src/types/CustomTheme.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Custom theme configuration for SimpleTable
+ * Contains all customizable dimensions and spacing values used in calculations and styling
+ * All properties are optional - missing values will be filled with defaults
+ */
+export interface CustomThemeProps {
+    rowHeight?: number;
+    headerHeight?: number;
+    footerHeight?: number;
+    rowSeparatorWidth?: number;
+    borderWidth?: number;
+    pinnedBorderWidth?: number;
+    nestedGridBorderWidth?: number;
+    nestedGridPaddingTop?: number;
+    nestedGridPaddingBottom?: number;
+    nestedGridPaddingLeft?: number;
+    nestedGridPaddingRight?: number;
+    nestedGridMaxHeight?: number;
+    selectionColumnWidth?: number;
+}
+export type CustomTheme = Required<CustomThemeProps>;
+/**
+ * Default theme values
+ * These match the original hardcoded constants throughout the codebase
+ */
+export declare const DEFAULT_CUSTOM_THEME: CustomTheme;

package/dist/cjs/core/src/types/DragHandlerProps.d.ts

@@ -0,0 +1,14 @@
+import HeaderObject, { Accessor } from "./HeaderObject";
+type useDragHandlerProps = {
+    draggedHeaderRef: {
+        current: HeaderObject | null;
+    };
+    essentialAccessors?: ReadonlySet<Accessor | string>;
+    headers: HeaderObject[];
+    hoveredHeaderRef: {
+        current: HeaderObject | null;
+    };
+    onColumnOrderChange?: (newHeaders: HeaderObject[]) => void;
+    onTableHeaderDragEnd: (newHeaders: HeaderObject[]) => void;
+};
+export default useDragHandlerProps;

package/dist/cjs/core/src/types/EnumOption.d.ts

@@ -0,0 +1,5 @@
+type EnumOption = {
+    label: string;
+    value: string;
+};
+export default EnumOption;

package/dist/cjs/core/src/types/FilterTypes.d.ts

@@ -0,0 +1,22 @@
+import CellValue from "./CellValue";
+import { Accessor } from "./HeaderObject";
+export type StringFilterOperator = "equals" | "notEquals" | "contains" | "notContains" | "startsWith" | "endsWith" | "isEmpty" | "isNotEmpty";
+export type NumberFilterOperator = "equals" | "notEquals" | "greaterThan" | "lessThan" | "greaterThanOrEqual" | "lessThanOrEqual" | "between" | "notBetween" | "isEmpty" | "isNotEmpty";
+export type BooleanFilterOperator = "equals" | "isEmpty" | "isNotEmpty";
+export type DateFilterOperator = "equals" | "notEquals" | "before" | "after" | "between" | "notBetween" | "isEmpty" | "isNotEmpty";
+export type EnumFilterOperator = "in" | "notIn" | "isEmpty" | "isNotEmpty";
+export type FilterOperator = StringFilterOperator | NumberFilterOperator | BooleanFilterOperator | DateFilterOperator | EnumFilterOperator;
+export interface FilterCondition {
+    accessor: Accessor;
+    operator: FilterOperator;
+    value?: CellValue;
+    values?: CellValue[];
+}
+export interface TableFilterState {
+    [accessor: Accessor]: FilterCondition;
+}
+export declare const FILTER_OPERATOR_LABELS: Record<FilterOperator, string>;
+export declare const getAvailableOperators: (columnType: "string" | "number" | "boolean" | "date" | "enum") => FilterOperator[];
+export declare const requiresSingleValue: (operator: FilterOperator) => boolean;
+export declare const requiresMultipleValues: (operator: FilterOperator) => boolean;
+export declare const requiresNoValue: (operator: FilterOperator) => boolean;

package/dist/cjs/core/src/types/FlattenedHeader.d.ts

@@ -0,0 +1,10 @@
+import HeaderObject from "./HeaderObject";
+import type { PanelSection } from "./PanelSection";
+export type FlattenedHeader = {
+    header: HeaderObject;
+    visualIndex: number;
+    depth: number;
+    parent: HeaderObject | null;
+    indexPath: number[];
+    panelSection?: PanelSection;
+};

package/dist/cjs/core/src/types/FooterRendererProps.d.ts

@@ -0,0 +1,17 @@
+import type { IconElement } from "./IconsConfig";
+interface FooterRendererProps {
+    currentPage: number;
+    endRow: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+    nextIcon?: IconElement;
+    onNextPage: () => Promise<void>;
+    onPageChange: (page: number) => void;
+    onPrevPage: () => void;
+    prevIcon?: IconElement;
+    rowsPerPage: number;
+    startRow: number;
+    totalPages: number;
+    totalRows: number;
+}
+export default FooterRendererProps;

package/dist/cjs/core/src/types/GenerateRowIdParams.d.ts

@@ -0,0 +1,11 @@
+import Row from "./Row";
+import { GetRowId } from "./GetRowId";
+export interface GenerateRowIdParams {
+    row: Row;
+    getRowId?: GetRowId;
+    depth: number;
+    index: number;
+    rowPath: (string | number)[];
+    rowIndexPath: number[];
+    groupingKey?: string;
+}

package/dist/cjs/core/src/types/GetRowId.d.ts

@@ -0,0 +1,10 @@
+import Row from "./Row";
+export interface GetRowIdParams {
+    row: Row;
+    depth: number;
+    index: number;
+    rowPath: (string | number)[];
+    rowIndexPath: number[];
+    groupingKey?: string;
+}
+export type GetRowId = (params: GetRowIdParams) => string | number;

package/dist/cjs/core/src/types/HandleResizeStartProps.d.ts

@@ -0,0 +1,21 @@
+import { HeaderObject, Accessor } from "..";
+export interface RefObject<T> {
+    current: T | null;
+}
+export type HandleResizeStartProps = {
+    autoExpandColumns: boolean;
+    collapsedHeaders: Set<Accessor>;
+    containerWidth: number;
+    event: MouseEvent | TouchEvent;
+    forceUpdate: () => void;
+    header: HeaderObject;
+    headers: HeaderObject[];
+    mainBodyRef: RefObject<HTMLDivElement>;
+    onColumnWidthChange?: (headers: HeaderObject[]) => void;
+    pinnedLeftRef: RefObject<HTMLDivElement>;
+    pinnedRightRef: RefObject<HTMLDivElement>;
+    reverse: boolean;
+    setHeaders: (headers: HeaderObject[] | ((prev: HeaderObject[]) => HeaderObject[])) => void;
+    setIsResizing: (isResizing: boolean | ((prev: boolean) => boolean)) => void;
+    startWidth: number;
+};

package/dist/cjs/core/src/types/HeaderDropdownProps.d.ts

@@ -0,0 +1,14 @@
+import HeaderRendererProps from "./HeaderRendererProps";
+interface HeaderDropdownProps extends HeaderRendererProps {
+    isOpen: boolean;
+    onClose: () => void;
+    position: {
+        top?: number;
+        left?: number;
+        right?: number;
+        bottom?: number;
+    };
+}
+export type VanillaHeaderDropdown = (props: HeaderDropdownProps) => HTMLElement | string | null;
+export type HeaderDropdown = (props: HeaderDropdownProps) => HTMLElement | string | null;
+export default HeaderDropdownProps;

package/dist/cjs/core/src/types/HeaderObject.d.ts

@@ -0,0 +1,98 @@
+import Row from "./Row";
+import { Pinned } from "./Pinned";
+import EnumOption from "./EnumOption";
+import { AggregationConfig } from "./AggregationTypes";
+import { CellRenderer } from "./CellRendererProps";
+import { HeaderRenderer } from "./HeaderRendererProps";
+import CellValue from "./CellValue";
+import { SimpleTableProps } from "./SimpleTableProps";
+import { QuickFilterGetter } from "./QuickFilterTypes";
+export type Accessor = keyof Row | string;
+export type ColumnType = "string" | "number" | "boolean" | "date" | "enum" | "lineAreaChart" | "barChart" | "other";
+export type ShowWhen = "parentCollapsed" | "parentExpanded" | "always";
+export interface ChartOptions {
+    min?: number;
+    max?: number;
+    width?: number;
+    height?: number;
+    color?: string;
+    fillColor?: string;
+    fillOpacity?: number;
+    strokeWidth?: number;
+    gap?: number;
+}
+export interface ValueFormatterProps {
+    accessor: Accessor;
+    colIndex: number;
+    row: Row;
+    rowIndex: number;
+    value: CellValue;
+}
+export type ValueFormatter = (props: ValueFormatterProps) => string | number | string[] | number[];
+export interface ValueGetterProps {
+    accessor: Accessor;
+    row: Row;
+    rowIndex: number;
+}
+export type ValueGetter = (props: ValueGetterProps) => CellValue;
+export interface ComparatorProps {
+    rowA: Row;
+    rowB: Row;
+    valueA: CellValue;
+    valueB: CellValue;
+    direction: "asc" | "desc";
+}
+export type Comparator = (props: ComparatorProps) => number;
+export interface ExportValueProps {
+    accessor: Accessor;
+    colIndex: number;
+    row: Row;
+    rowIndex: number;
+    value: CellValue;
+    formattedValue?: string | number | string[] | number[];
+}
+export type ExportValueGetter = (props: ExportValueProps) => string | number;
+export declare const DEFAULT_SHOW_WHEN: ShowWhen;
+type HeaderObject = {
+    accessor: Accessor;
+    aggregation?: AggregationConfig;
+    align?: "left" | "center" | "right";
+    cellRenderer?: CellRenderer;
+    chartOptions?: ChartOptions;
+    children?: HeaderObject[];
+    collapsible?: boolean;
+    collapseDefault?: boolean;
+    comparator?: Comparator;
+    disableReorder?: boolean;
+    enumOptions?: EnumOption[];
+    expandable?: boolean;
+    exportValueGetter?: ExportValueGetter;
+    filterable?: boolean;
+    headerRenderer?: HeaderRenderer;
+    hide?: boolean;
+    isEditable?: boolean;
+    excludeFromRender?: boolean;
+    excludeFromCsv?: boolean;
+    isSelectionColumn?: boolean;
+    /** When true, column stays visible, cannot be unpinned from a pinned side, cannot reorder above non-essentials in its section */
+    isEssential?: boolean;
+    isSortable?: boolean;
+    label: string;
+    minWidth?: number | string;
+    sortingOrder?: ("asc" | "desc" | null)[];
+    nestedTable?: Omit<SimpleTableProps, "rows" | "loadingStateRenderer" | "errorStateRenderer" | "emptyStateRenderer" | "tableEmptyStateRenderer" | "expandIcon" | "filterIcon" | "sortUpIcon" | "sortDownIcon" | "nextIcon" | "prevIcon" | "headerCollapseIcon" | "headerExpandIcon">;
+    pinned?: Pinned;
+    quickFilterable?: boolean;
+    quickFilterGetter?: QuickFilterGetter;
+    singleRowChildren?: boolean;
+    tooltip?: string;
+    type?: ColumnType;
+    useFormattedValueForClipboard?: boolean;
+    useFormattedValueForCSV?: boolean;
+    valueFormatter?: ValueFormatter;
+    valueGetter?: ValueGetter;
+    showWhen?: ShowWhen;
+    width: number | string;
+    maxWidth?: number | string;
+};
+export default HeaderObject;

package/dist/cjs/core/src/types/HeaderRendererProps.d.ts

@@ -0,0 +1,17 @@
+import type { Accessor } from "./HeaderObject";
+import type HeaderObject from "./HeaderObject";
+import type { IconElement } from "./IconsConfig";
+export interface HeaderRendererComponents {
+    sortIcon?: IconElement;
+    filterIcon?: IconElement;
+    collapseIcon?: IconElement;
+    labelContent?: string | HTMLElement;
+}
+interface HeaderRendererProps {
+    accessor: Accessor;
+    colIndex: number;
+    header: HeaderObject;
+    components?: HeaderRendererComponents;
+}
+export type HeaderRenderer = (props: HeaderRendererProps) => HTMLElement | string | null;
+export default HeaderRendererProps;

package/dist/cjs/core/src/types/IconsConfig.d.ts

@@ -0,0 +1,19 @@
+/** Single icon value used across header, footer, and column editor props */
+export type IconElement = SVGSVGElement | HTMLElement | string;
+export interface VanillaIconsConfig {
+    drag?: IconElement;
+    expand?: IconElement;
+    filter?: IconElement;
+    headerCollapse?: IconElement;
+    headerExpand?: IconElement;
+    next?: IconElement;
+    prev?: IconElement;
+    sortDown?: IconElement;
+    sortUp?: IconElement;
+    /** Label for pin-to-left control in column editor (default: "L") */
+    pinnedLeftIcon?: IconElement;
+    /** Label for pin-to-right control in column editor (default: "R") */
+    pinnedRightIcon?: IconElement;
+}
+export interface IconsConfig extends VanillaIconsConfig {
+}

package/dist/cjs/core/src/types/OnNextPage.d.ts

@@ -0,0 +1,2 @@
+type OnNextPage = (page: number) => Promise<boolean>;
+export default OnNextPage;

package/dist/cjs/core/src/types/OnRowGroupExpandProps.d.ts

@@ -0,0 +1,16 @@
+import Row from "./Row";
+import { Accessor } from "./HeaderObject";
+interface OnRowGroupExpandProps {
+    row: Row;
+    depth: number;
+    event: MouseEvent | KeyboardEvent;
+    groupingKey?: string;
+    isExpanded: boolean;
+    rowIndexPath: number[];
+    rowIdPath?: (string | number)[];
+    groupingKeys: Accessor[];
+    setLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    setEmpty: (isEmpty: boolean, message?: string) => void;
+}
+export default OnRowGroupExpandProps;

package/dist/cjs/core/src/types/OnSortProps.d.ts

@@ -0,0 +1,3 @@
+import { Accessor } from "./HeaderObject";
+type OnSortProps = (accessor: Accessor) => void;
+export default OnSortProps;

package/dist/cjs/core/src/types/PanelSection.d.ts

@@ -0,0 +1 @@
+export type PanelSection = "left" | "main" | "right";

package/dist/cjs/core/src/types/Pinned.d.ts

@@ -0,0 +1 @@
+export type Pinned = "left" | "right";

package/dist/cjs/core/src/types/PinnedSectionsState.d.ts

@@ -0,0 +1,6 @@
+import { Accessor } from "./HeaderObject";
+export type PinnedSectionsState = {
+    left: Accessor[];
+    main: Accessor[];
+    right: Accessor[];
+};

package/dist/cjs/core/src/types/QuickFilterTypes.d.ts

@@ -0,0 +1,21 @@
+import { Accessor } from "./HeaderObject";
+import Row from "./Row";
+export type QuickFilterMode = "simple" | "smart";
+export interface QuickFilterConfig {
+    text: string;
+    columns?: Accessor[];
+    caseSensitive?: boolean;
+    mode?: QuickFilterMode;
+    useFormattedValue?: boolean;
+    onChange?: (text: string) => void;
+}
+export interface QuickFilterGetterProps {
+    row: Row;
+    accessor: Accessor;
+}
+export type QuickFilterGetter = (props: QuickFilterGetterProps) => string;
+export interface SmartFilterToken {
+    type: "word" | "phrase" | "negation" | "columnSpecific";
+    value: string;
+    column?: Accessor;
+}

package/dist/cjs/core/src/types/Row.d.ts

@@ -0,0 +1,3 @@
+import CellValue from "./CellValue";
+type Row = Record<string, CellValue | Row[] | Record<string, any>>;
+export default Row;

package/dist/cjs/core/src/types/RowButton.d.ts

@@ -0,0 +1,6 @@
+import Row from "./Row";
+export interface RowButtonProps {
+    row: Row;
+    rowIndex: number;
+}
+export type RowButton = (props: RowButtonProps) => HTMLElement | null;

package/dist/cjs/core/src/types/RowId.d.ts

@@ -0,0 +1 @@
+export type RowId = string | number;

package/dist/cjs/core/src/types/RowSelectionChangeProps.d.ts

@@ -0,0 +1,7 @@
+import Row from "./Row";
+type RowSelectionChangeProps = {
+    row: Row;
+    isSelected: boolean;
+    selectedRows: Set<string>;
+};
+export default RowSelectionChangeProps;