@lavalogic/scoria 0.0.1

package/dist/Components/Table/Types/Columns/Definitions/Expand/ExpandDef.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { IconProps } from '../../../../../Icon.svelte';
+import type { ITableInitOptions } from '../../../Context/TableInitOptions.js';
+import { ColumnType } from '../../ColumnType.js';
+import type { DefsWrapper } from '../../DefsWrapper.js';
+import { ColumnDef, type ColumnDefProps } from '../ColumnDef.svelte.js';
+export interface ExpandDefProps<T extends object, R extends object> extends ColumnDefProps<T> {
+    isEnabled: (item: T, index: number) => boolean | Promise<boolean>;
+    getInnerColumnDefs: (item: T, index: number) => DefsWrapper<R>;
+    headerIcon: IconProps['name'];
+    innerTableName: string;
+    innerTableOptions: ITableInitOptions<R>;
+}
+export declare class ExpandDef<T extends object, R extends object = object> extends ColumnDef<T> {
+    readonly columnType = ColumnType.Expand;
+    constructor(props: ExpandDefProps<T, R>);
+    readonly innerTableName: string;
+    readonly getInnerColumnDefs: (item: T, index: number) => DefsWrapper<R>;
+    readonly headerIcon: IconProps['name'];
+    readonly isEnabled: (item: T, index: number) => boolean | Promise<boolean>;
+    readonly innerTableOptions: ITableInitOptions<R>;
+}

package/dist/Components/Table/Types/Columns/Definitions/Expand/ExpandDef.svelte.js

@@ -0,0 +1,18 @@
+import { ColumnType } from '../../ColumnType.js';
+import { ColumnDef } from '../ColumnDef.svelte.js';
+export class ExpandDef extends ColumnDef {
+    columnType = ColumnType.Expand;
+    constructor(props) {
+        super(props);
+        this.isEnabled = $derived(props.isEnabled);
+        this.headerIcon = $derived(props.headerIcon);
+        this.getInnerColumnDefs = $derived(props.getInnerColumnDefs);
+        this.innerTableName = $derived(props.innerTableName);
+        this.innerTableOptions = $derived(props.innerTableOptions);
+    }
+    innerTableName;
+    getInnerColumnDefs;
+    headerIcon;
+    isEnabled;
+    innerTableOptions;
+}

package/dist/Components/Table/Types/Columns/Definitions/FilterOnly/FilterOnlyDef.d.ts

@@ -0,0 +1,6 @@
+import type { StringFilterValueType } from '../../../Filtering/FilterFn.js';
+import { ColumnType } from '../../ColumnType.js';
+import { ColumnDef } from '../ColumnDef.svelte.js';
+export declare class FilterOnlyDef<T extends object> extends ColumnDef<T, StringFilterValueType> {
+    readonly columnType: ColumnType;
+}

package/dist/Components/Table/Types/Columns/Definitions/FilterOnly/FilterOnlyDef.js

@@ -0,0 +1,5 @@
+import { ColumnType } from '../../ColumnType.js';
+import { ColumnDef } from '../ColumnDef.svelte.js';
+export class FilterOnlyDef extends ColumnDef {
+    columnType = ColumnType.FilterOnly;
+}

package/dist/Components/Table/Types/Columns/Definitions/RowSelection/RowSelectionDef.svelte.d.ts

@@ -0,0 +1,7 @@
+import { ColumnType } from '../../ColumnType.js';
+import { ColumnDef } from '../ColumnDef.svelte.js';
+export declare class RowSelectionDef<T extends object> extends ColumnDef<T> {
+    readonly isSelectable: (item: T, index: number) => boolean | Promise<boolean>;
+    readonly columnType: ColumnType;
+    constructor(isSelectable: (item: T, index: number) => boolean | Promise<boolean>);
+}

package/dist/Components/Table/Types/Columns/Definitions/RowSelection/RowSelectionDef.svelte.js

@@ -0,0 +1,15 @@
+import { generateUUID } from '../../../../../../Helpers/Helpers.svelte.js';
+import { ColumnType } from '../../ColumnType.js';
+import { ColumnDef } from '../ColumnDef.svelte.js';
+export class RowSelectionDef extends ColumnDef {
+    isSelectable;
+    columnType = ColumnType.RowSelect;
+    constructor(isSelectable) {
+        super({
+            id: `is-selectable-${generateUUID()}`,
+            header: 'Row Selected',
+            enableSorting: false
+        });
+        this.isSelectable = isSelectable;
+    }
+}

package/dist/Components/Table/Types/Columns/Definitions/ValidationFn.d.ts

@@ -0,0 +1,3 @@
+import type { Validity } from '../../../../../Types/Internal/Validity.js';
+import type { ValidityWrapper } from '../../../../../Types/Internal/ValidityWrapper.js';
+export type ValidationFn<T> = (item: T, isSelected: boolean) => Validity | Promise<Validity> | ValidityWrapper | Promise<ValidityWrapper>;

package/dist/Components/Table/Types/Columns/Definitions/ValidationFn.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Columns/DefsWrapper.d.ts

@@ -0,0 +1,6 @@
+import type { CustomRemoteFilters } from '../Filtering/CustomRemoteFilters.js';
+import type { ColumnDef } from './Definitions/ColumnDef.svelte.js';
+export interface DefsWrapper<T extends object> {
+    defs: ColumnDef<T>[];
+    remoteFilters?: CustomRemoteFilters;
+}

package/dist/Components/Table/Types/Columns/DefsWrapper.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Columns/DisplayType.d.ts

@@ -0,0 +1,7 @@
+export declare const enum DisplayType {
+    Normal = "Normal",
+    Bubbles = "Bubbles",
+    Progress = "Progress",
+    Icon = "Icon",
+    Validity = "Validity"
+}

package/dist/Components/Table/Types/Columns/DisplayType.js

@@ -0,0 +1,8 @@
+export var DisplayType;
+(function (DisplayType) {
+    DisplayType["Normal"] = "Normal";
+    DisplayType["Bubbles"] = "Bubbles";
+    DisplayType["Progress"] = "Progress";
+    DisplayType["Icon"] = "Icon";
+    DisplayType["Validity"] = "Validity";
+})(DisplayType || (DisplayType = {}));

package/dist/Components/Table/Types/Columns/ExpandColumn.d.ts

@@ -0,0 +1,10 @@
+import type { ExpandDef } from './Definitions/Expand/ExpandDef.svelte.js';
+export interface ExpandColumn<T extends object & object> {
+    id: string;
+    columnDef: ExpandDef<T, any>;
+    getCanSort: () => boolean;
+    getToggleSortingHandler: () => (e: MouseEvent) => void;
+    getIsSorted: () => 'asc' | 'desc' | 'none';
+    getIsResizing: () => boolean;
+    getIsVisible: () => boolean;
+}

package/dist/Components/Table/Types/Columns/ExpandColumn.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Columns/ExpandTableCell.d.ts

@@ -0,0 +1,8 @@
+import type { Row } from '../Context/Row.js';
+import type { ExpandColumn } from './ExpandColumn.js';
+export interface ExpandTableCell<T extends object> {
+    column: ExpandColumn<T>;
+    row: Row<T>;
+    id: string;
+    getValue: () => unknown;
+}

package/dist/Components/Table/Types/Columns/ExpandTableCell.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Columns/ProgressBarColumn.d.ts

@@ -0,0 +1,10 @@
+import type { ProgressBarDef } from './Definitions/Display/ProgressBarDef.svelte.js';
+export interface ProgressBarColumn<T extends object & object> {
+    id: string;
+    columnDef: ProgressBarDef<T>;
+    getCanSort: () => boolean;
+    getToggleSortingHandler: () => (e: MouseEvent) => void;
+    getIsSorted: () => 'asc' | 'desc' | 'none';
+    getIsResizing: () => boolean;
+    getIsVisible: () => boolean;
+}

package/dist/Components/Table/Types/Columns/ProgressBarColumn.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Columns/ProgressBarTableCell.d.ts

@@ -0,0 +1,8 @@
+import type { Row } from '../Context/Row.js';
+import type { ProgressBarColumn } from './ProgressBarColumn.js';
+export interface ProgressBarTableCell<T extends object> {
+    column: ProgressBarColumn<T>;
+    row: Row<T>;
+    id: string;
+    getValue: () => unknown;
+}

package/dist/Components/Table/Types/Columns/ProgressBarTableCell.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Columns/TableActionButton.d.ts

@@ -0,0 +1,8 @@
+import type { ColourSet } from '../../../../scss/colours.js';
+export interface TableActionButton<T> {
+    getLabel: (item: T, index: number) => string | Promise<string>;
+    callback: (item: T, index: number) => void;
+    colourSet?: ColourSet;
+    disabled?: boolean;
+    isDisabled?: (item: T, index: number) => boolean | Promise<boolean>;
+}

package/dist/Components/Table/Types/Columns/TableActionButton.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Columns/TableCell.d.ts

@@ -0,0 +1,8 @@
+import type { Row } from '../Context/Row.js';
+import type { Column } from './Column.js';
+export interface TableCell<T extends object> {
+    column: Column<T>;
+    row: Row<T>;
+    id: string;
+    getValue: () => unknown;
+}

package/dist/Components/Table/Types/Columns/TableCell.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Columns/VisibilityState.d.ts

@@ -0,0 +1 @@
+export type VisibilityState = Record<string, boolean>;

package/dist/Components/Table/Types/Columns/VisibilityState.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Context/ReadonlyRowModel.d.ts

@@ -0,0 +1,6 @@
+import type { SvelteMap } from 'svelte/reactivity';
+import type { Row } from './Row.js';
+export interface ReadonlyRowModel<T extends object> {
+    readonly rows: Row<T>[];
+    readonly rowsById: SvelteMap<string, Row<T>>;
+}

package/dist/Components/Table/Types/Context/ReadonlyRowModel.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Context/Row.d.ts

@@ -0,0 +1,10 @@
+import type { TableCell } from '../Columns/TableCell.js';
+export interface Row<T extends object> {
+    getValue: (columnId: string) => any;
+    original: T;
+    index: number;
+    id: string;
+    getLeftVisibleCells: () => TableCell<T>[];
+    getRightVisibleCells: () => TableCell<T>[];
+    getCenterVisibleCells: () => TableCell<T>[];
+}

package/dist/Components/Table/Types/Context/Row.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Context/RowModel.d.ts

@@ -0,0 +1,5 @@
+import type { Row } from './Row.js';
+export interface RowModel<T extends object> {
+    rows: Row<T>[];
+    rowsById: Map<string, Row<T>>;
+}

package/dist/Components/Table/Types/Context/RowModel.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Context/Table.d.ts

@@ -0,0 +1,33 @@
+import type { Column } from '../Columns/Column.js';
+import type { ColumnPinningState } from '../Columns/ColumnPinningState.js';
+import type { ColumnSizingState } from '../Columns/ColumnSizingState.js';
+import type { ColumnDef } from '../Columns/Definitions/ColumnDef.svelte.js';
+import type { VisibilityState } from '../Columns/VisibilityState.js';
+import type { SortingState } from '../DataRepository/SortingState.js';
+import type { ColumnFiltersState } from '../Filtering/ColumnFiltersState.js';
+import type { HeaderGroup } from '../HeaderGroup.js';
+import type { OnChangeFn } from '../OnChangeFn.js';
+import type { PaginationState } from '../Pagination/PaginationState.js';
+export interface Table<T extends object> {
+    data: T[];
+    columns: ColumnDef<T>[];
+    columnSizing: ColumnSizingState;
+    columnVisibility: VisibilityState;
+    sorting: SortingState | undefined;
+    pagination: PaginationState | undefined;
+    columnPinning: ColumnPinningState;
+    columnFilters: ColumnFiltersState | undefined;
+    enableMultiSort: boolean;
+    getLeftTotalSize: () => number;
+    getCenterTotalSize: () => number;
+    getRightTotalSize: () => number;
+    getLeftHeaderGroups: () => HeaderGroup<T>[];
+    getRightHeaderGroups: () => HeaderGroup<T>[];
+    getCenterHeaderGroups: () => HeaderGroup<T>[];
+    getLeftVisibleLeafColumns: () => Column<T>[];
+    getRightVisibleLeafColumns: () => Column<T>[];
+    getCenterVisibleLeafColumns: () => Column<T>[];
+    onColumnVisibilityChange: OnChangeFn<VisibilityState>;
+    onColumnSizingChange: OnChangeFn<ColumnSizingState>;
+    onColumnFiltersChange: OnChangeFn<ColumnFiltersState> | undefined;
+}

package/dist/Components/Table/Types/Context/Table.js

@@ -0,0 +1 @@
+export {};

package/dist/Components/Table/Types/Context/TableContext.svelte.d.ts

@@ -0,0 +1,232 @@
+import { SvelteMap, SvelteSet } from 'svelte/reactivity';
+import type { ColumnDef } from '../Columns/Definitions/ColumnDef.svelte.js';
+import type { DefsWrapper } from '../Columns/DefsWrapper.js';
+import type { DataRepository } from '../DataRepository/DataRepository.js';
+import { ToolbarPosition } from '../Toolbar/ToolbarPosition.js';
+import type { ITableInitOptions } from './TableInitOptions.js';
+import type { CustomRemoteFilters } from '../Filtering/CustomRemoteFilters.js';
+import type { BoolFilterValueType, DateFilterValueType, FilterFn, NumberFilterValueType, SelectFilterValueType, StringFilterValueType } from '../Filtering/FilterFn.js';
+import type { ColumnDefSet } from '../Columns/Definitions/ColumnDefSet.js';
+import type { CellCoordinates } from '../Coordinates/CellCoordinates.js';
+import type { ColumnSizingState } from '../Columns/ColumnSizingState.js';
+import type { ColumnPinningState } from '../Columns/ColumnPinningState.js';
+import type { VisibilityState } from '../Columns/VisibilityState.js';
+import type { CellCoordinatesWithoutColumn } from '../Coordinates/CellCoordinatesWithoutColumn.js';
+import type { Updater } from 'svelte/store';
+import type { OnChangeFn } from '../OnChangeFn.js';
+import type { ColumnFiltersState } from '../Filtering/ColumnFiltersState.js';
+import type { Table } from './Table.js';
+import type { HasCustomFilterFunction } from '../Filtering/HasCustomFilterFunction.js';
+import type { RowModel } from './RowModel.js';
+export declare class TableContext<T extends object> {
+    readonly defaultColumnDefs: DefsWrapper<T>;
+    readonly tableName: string;
+    allowCopy: boolean;
+    enableResize: boolean;
+    allowColumnReordering: boolean;
+    allowQuickFiltering: boolean;
+    allowAdvancedFiltering: boolean;
+    toolbarPosition: ToolbarPosition;
+    displayFooter: boolean;
+    selectionExtractor: ITableInitOptions<T>['selectionExtractor'];
+    getUserId: () => string | undefined;
+    private _onEditCell;
+    static readonly identifier: unique symbol;
+    static init<T extends object>(defaultColumnDefs: DefsWrapper<T>, tableName: string, dataRepo: DataRepository<T>, options: ITableInitOptions<T>): TableContext<T>;
+    constructor(INTERNAL_ONLY: symbol, defaultColumnDefs: DefsWrapper<T>, tableName: string, dataRepo: DataRepository<T>, allowCopy: boolean, enableResize: boolean, allowColumnReordering: boolean, allowQuickFiltering: boolean, allowAdvancedFiltering: boolean, toolbarPosition: ToolbarPosition, displayFooter: boolean, selectionExtractor: ITableInitOptions<T>['selectionExtractor'], getUserId: () => string | undefined, _onEditCell?: ITableInitOptions<T>['onEditCell']);
+    private readonly userId;
+    private isSelectable;
+    __queryValues: SvelteMap<string, unknown>;
+    private _paginationRepo;
+    get paginationRepo(): DataRepository<T> | undefined;
+    set paginationRepo(v: DataRepository<T> | undefined);
+    private _showQuickFiltering;
+    get showQuickFiltering(): boolean;
+    set showQuickFiltering(v: boolean);
+    private _dataRepo;
+    get dataRepo(): DataRepository<T> | undefined;
+    private set dataRepo(value);
+    private _remoteFilters;
+    get remoteFilters(): CustomRemoteFilters | undefined;
+    private set remoteFilters(value);
+    private _showSelectedOnly;
+    get showSelectedOnly(): boolean;
+    set showSelectedOnly(v: boolean);
+    private readonly _dateFilter;
+    get dateFilter(): FilterFn<T, DateFilterValueType> | undefined;
+    private readonly _numberFilter;
+    get numberFilter(): FilterFn<T, NumberFilterValueType> | undefined;
+    private readonly _selectFilter;
+    get selectFilter(): FilterFn<T, SelectFilterValueType<T>> | undefined;
+    private readonly _boolFilter;
+    get boolFilter(): FilterFn<T, BoolFilterValueType> | undefined;
+    private readonly _stringFilter;
+    get stringFilter(): FilterFn<T, StringFilterValueType> | undefined;
+    private _limitFooter;
+    get limitFooter(): boolean;
+    set limitFooter(v: boolean);
+    private _dragTarget;
+    get dragTarget(): ColumnDef<T> | null;
+    set dragTarget(v: ColumnDef<T> | null);
+    private _columnDefs;
+    get columnDefs(): Array<ColumnDef<T>>;
+    set columnDefs(v: Array<ColumnDef<T>>);
+    private _columnPresets;
+    get columnPresets(): readonly ColumnDefSet<T>[];
+    private set columnPresets(value);
+    private _selectedPreset;
+    get selectedPreset(): ColumnDefSet<T> | undefined;
+    set selectedPreset(v: ColumnDefSet<T> | undefined);
+    private _focusedRowIndexIds;
+    get focusedRowIndexIds(): SvelteSet<number>;
+    set focusedRowIndexIds(v: SvelteSet<number>);
+    private readonly _highlightedItems;
+    get highlightedItems(): SvelteMap<unknown, T>;
+    private _focusedColumnIds;
+    get focusedColumnIds(): SvelteSet<string>;
+    set focusedColumnIds(v: SvelteSet<string>);
+    private _isMousingDown;
+    get isMousingDown(): boolean;
+    set isMousingDown(v: boolean);
+    private _focusStart;
+    get focusStart(): CellCoordinates | null;
+    private set focusStart(value);
+    private _focusStartIsBeingEdited;
+    get focusStartIsBeingEdited(): boolean;
+    set focusStartIsBeingEdited(v: boolean);
+    private _focusEnd;
+    get focusEnd(): CellCoordinates | null;
+    set focusEnd(v: CellCoordinates | null);
+    private _singleClickEditing;
+    get singleClickEditing(): boolean;
+    set singleClickEditing(v: boolean);
+    private _changeColourOnHover;
+    get changeColourOnHover(): boolean;
+    set changeColourOnHover(v: boolean);
+    private _isCompact;
+    get isCompact(): boolean;
+    set isCompact(v: boolean);
+    private _alternateRowColours;
+    get alternateRowColours(): boolean;
+    set alternateRowColours(v: boolean);
+    private _copyWithHeaders;
+    get copyWithHeaders(): boolean;
+    set copyWithHeaders(v: boolean);
+    private _commaSeparatedCopy;
+    get commaSeparatedCopy(): boolean;
+    set commaSeparatedCopy(v: boolean);
+    private _columnSizing;
+    get columnSizing(): ColumnSizingState;
+    set columnSizing(v: ColumnSizingState);
+    private _columnPinning;
+    get columnPinning(): ColumnPinningState;
+    set columnPinning(v: ColumnPinningState);
+    private _columnVisibility;
+    get columnVisibility(): VisibilityState;
+    set columnVisibility(v: VisibilityState);
+    private _openModalCoordinates;
+    get openModalCoordinates(): CellCoordinatesWithoutColumn | null;
+    set openModalCoordinates(v: CellCoordinatesWithoutColumn | null);
+    private _allSelectedInCurrentPage;
+    get allSelectedInCurrentPage(): Promise<boolean>;
+    private allSelectedBySelectableMethod;
+    private _areAllHighlighted;
+    private _allHighlighted;
+    get allHighlighted(): Promise<boolean>;
+    private _hasHighlightedItems;
+    get hasHighlightedItems(): boolean;
+    private _selectedItems;
+    get selectedItems(): SvelteMap<unknown, T>;
+    private set selectedItems(value);
+    private _invalidValues;
+    get invalidValues(): SvelteMap<unknown, T>;
+    set invalidValues(v: SvelteMap<unknown, T>);
+    private _hasInvalidSelectedItems;
+    get hasInvalidSelectedItems(): boolean;
+    private set hasInvalidSelectedItems(value);
+    private columnDefsById;
+    private readonly getSortingFn;
+    readonly originalRowIndices: Map<T, number>;
+    readonly sortedData: T[];
+    readonly sortedRowModel: RowModel<T>;
+    _currentPageData: T[];
+    readonly paginationRowModel: RowModel<T>;
+    get currentPageData(): T[];
+    readonly selectionContains: (item: T) => boolean;
+    readonly addInvalidValue: (item: T) => void;
+    readonly removeInvalidValue: (item: T) => void;
+    readonly setOpenModalCoordinates: (coordinates: CellCoordinatesWithoutColumn | null) => void;
+    readonly toggleHighlightedRow: (item: T) => void;
+    readonly resetHighlightedRows: () => void;
+    readonly toggleSelected: (item: T, selected: boolean) => void;
+    setSelectionMap: (set: SvelteMap<unknown, T>) => void;
+    readonly updateSelectedItems: () => Promise<void>;
+    readonly resetSelectedItems: () => void;
+    readonly recalculateAllSelectedInCurrentPage: () => void;
+    readonly onSelectAllInCurrentPage: () => Promise<void>;
+    readonly onHighlightAll: () => void;
+    readonly onEditCell: (item: T, coords: CellCoordinates, value: unknown) => Promise<void>;
+    readonly handleTdKeydown: (e: KeyboardEvent) => void;
+    readonly toggleQuickFiltering: () => void;
+    readonly setColumnPinning: (updater: Updater<ColumnPinningState>) => void;
+    updateFilters: OnChangeFn<ColumnFiltersState> | undefined;
+    updateVisibility: OnChangeFn<VisibilityState>;
+    updateColumnSizing: OnChangeFn<ColumnSizingState>;
+    readonly table: Table<T>;
+    readonly lastPage: number;
+    readonly measureHeaderWidth: (columnDef: ColumnDef<T>) => number;
+    readonly autoResize: (columnDef: ColumnDef<T>) => Promise<void>;
+    reorderColumn: (dropTarget: HTMLLIElement | HTMLTableCellElement | null) => ColumnDef<T, unknown>[] | undefined;
+    copyHighlightedRowsToClipboard: () => Promise<void>;
+    copyDataToClipboard: () => Promise<void>;
+    private _performRowCopy;
+    readonly startFocus: (coords: CellCoordinates) => void;
+    readonly moveFocus: (coords: CellCoordinates, startEditing?: boolean) => void;
+    readonly unfocus: () => void;
+    readonly focusToTop: () => void;
+    readonly focusToBottom: () => void;
+    readonly moveToBottom: () => void;
+    readonly moveToTop: () => void;
+    readonly moveFocusUp: () => void;
+    readonly setFocusUp: () => void;
+    readonly tabForward: () => void;
+    readonly tabBackward: () => void;
+    readonly focusToStart: () => null | undefined;
+    readonly moveToStart: () => void;
+    readonly focusToEnd: () => null | undefined;
+    readonly moveToEnd: () => void;
+    readonly moveFocusDown: () => void;
+    readonly setFocusDown: () => void;
+    readonly moveFocusLeft: () => void;
+    readonly setFocusLeft: () => void;
+    readonly moveFocusRight: () => void;
+    readonly setFocusRight: () => void;
+    readonly endFocus: (coords: CellCoordinates) => void;
+    readonly setIsCompact: (value: boolean) => void;
+    readonly setAlternateRowColours: (value: boolean) => void;
+    readonly setSingleClickEditing: (value: boolean) => void;
+    readonly setChangeColourOnHover: (value: boolean) => void;
+    readonly setCopyWithHeaders: (value: boolean) => void;
+    readonly setCommaSeparatedCopy: (value: boolean) => void;
+    readonly setSelectedPreset: (preset: ColumnDefSet<T>) => void;
+    readonly saveColumnPreset: (name: string) => void;
+    /**
+     * This listener should be added and removed based on isMousingDown
+     */
+    readonly setFocusEnd: (coords: CellCoordinates) => void;
+    private columnDefReturnsTextValue;
+    private _updateLocalStorageSettings;
+    private _moveFocusEndRow;
+    private _moveFocusRow;
+    private _recalculateFocusedElements;
+    private getHighlightedRowData;
+    private getFocusElementData;
+    private updateDefsBasedOnPinning;
+    private assertNoDuplicateIds;
+    private setupDefaultColumnDefs;
+    private _getUserDefaults;
+    private _setNewPinningState;
+    readonly getToggleSortingHandler: (def: ColumnDef<T>) => (e: MouseEvent) => void;
+    private reassignDefsToPresets;
+}
+export declare function isSearchable<T extends object, CD extends ColumnDef<T> | ColumnDef<T>>(def: CD): def is CD & HasCustomFilterFunction;