@superblocksteam/library 1.99.99-next.2

package/dist-types/lib/user-facing/components/table/props.d.ts

@@ -0,0 +1,259 @@
+import { Section, Prop } from "../../properties-panel/props-builder.js";
+import { PaginationTypes } from "./types.js";
+import { CompactMode } from "./types.js";
+import type { UnknownRow } from "./types.js";
+export declare const propertiesDefinition: {
+    general: Section<Record<string, Prop<any, any>> & {
+        tableHeader: Prop<string, true>;
+        tableData: Prop<UnknownRow[], false>;
+        columns: import("../../properties-panel/props-builder.js").RecordProp<{
+            general: Section<(Record<string, Prop<any, any>> & ({
+                label: Prop<string, false>;
+            } & (Omit<{
+                columnType: Prop<import("./types.js").ColumnType, true>;
+            }, "columnType"> & ({
+                computedValue: Prop<string, false>;
+                displayedValue: Prop<string, false>;
+                columnType: Prop<"text", true>;
+            } | {
+                computedValue: Prop<string, false>;
+                notation: Prop<"compact" | "standard" | "scientific" | "engineering" | "unformatted", false>;
+                minimumFractionDigits: Prop<number, false>;
+                maximumFractionDigits: Prop<number, false>;
+                columnType: Prop<"number", true>;
+            } | {
+                computedValue: Prop<string, false>;
+                notation: Prop<"compact" | "standard" | "scientific" | "engineering" | "unformatted", false>;
+                minimumFractionDigits: Prop<number, false>;
+                maximumFractionDigits: Prop<number, false>;
+                currency: Prop<string, false>;
+                columnType: Prop<"currency", true>;
+            } | {
+                computedValue: Prop<string, false>;
+                minimumFractionDigits: Prop<number, false>;
+                maximumFractionDigits: Prop<number, false>;
+                columnType: Prop<"percentage", true>;
+            } | {
+                openImageUrl: Prop<boolean, false>;
+                columnType: Prop<"image", true>;
+            } | {
+                computedValue: Prop<string, false>;
+                columnType: Prop<"video", true>;
+            } | {
+                valueFormat: Prop<string, false>;
+                displayFormat: Prop<string, false>;
+                manageTimezone: Prop<boolean, false>;
+                valueTimezone: Prop<string, false>;
+                displayTimezone: Prop<string, false>;
+                columnType: Prop<"date", true>;
+            } | {
+                buttonLabel: Prop<string, false>;
+                isDisabled: Prop<boolean, false>;
+                columnType: Prop<"button", true>;
+            } | {
+                linkUrl: Prop<string, false>;
+                linkLabel: Prop<string, false>;
+                openInNewTab: Prop<boolean, false>;
+                columnType: Prop<"link", true>;
+            } | {
+                computedValue: Prop<string, false>;
+                columnType: Prop<"boolean", true>;
+            } | {
+                computedValue: Prop<string, false>;
+                columnType: Prop<"tags", true>;
+            } | {
+                computedValue: Prop<string, false>;
+                displayedValue: Prop<string, false>;
+                columnType: Prop<"email", true>;
+            })))) & {
+                isVisible: Prop<boolean, true>;
+            }>;
+            presentation: Section<(Record<string, Prop<any, any>> & ({
+                headerIcon: Prop<string, false>;
+                headerIconPosition: Prop<import("../../icons/constants.js").IconPosition, false>;
+            } & (Omit<{
+                columnType: Prop<import("./types.js").ColumnType, false>;
+            }, "columnType"> & ({
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                textWrap: Prop<boolean, false>;
+                cellIcon: Prop<string, false>;
+                cellIconPosition: Prop<import("../../icons/constants.js").IconPosition, false>;
+                columnType: Prop<"text", true>;
+            } | {
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                textWrap: Prop<boolean, false>;
+                cellIcon: Prop<string, false>;
+                cellIconPosition: Prop<import("../../icons/constants.js").IconPosition, false>;
+                columnType: Prop<"number", true>;
+            } | {
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                textWrap: Prop<boolean, false>;
+                cellIcon: Prop<string, false>;
+                cellIconPosition: Prop<import("../../icons/constants.js").IconPosition, false>;
+                columnType: Prop<"currency", true>;
+            } | {
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                textWrap: Prop<boolean, false>;
+                cellIcon: Prop<string, false>;
+                cellIconPosition: Prop<import("../../icons/constants.js").IconPosition, false>;
+                columnType: Prop<"percentage", true>;
+            } | {
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                imageSize: Prop<import("./types.js").ImageSize, false>;
+                imageBorderRadius: Prop<import("@superblocksteam/library-shared").Dim, false>;
+                columnType: Prop<"image", true>;
+            } | {
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                columnType: Prop<"video", true>;
+            } | {
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                textWrap: Prop<boolean, false>;
+                cellIcon: Prop<string, false>;
+                cellIconPosition: Prop<import("../../icons/constants.js").IconPosition, false>;
+                columnType: Prop<"date", true>;
+            } | {
+                buttonVariant: Prop<import("../button/props.js").ButtonVariant, false>;
+                buttonBackgroundColor: Prop<string, false>;
+                buttonLabelColor: Prop<string, false>;
+                backgroundColor: Prop<string, false>;
+                cellIcon: Prop<string, false>;
+                cellIconPosition: Prop<import("../../icons/constants.js").IconPosition, false>;
+                columnType: Prop<"button", true>;
+            } | {
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                columnType: Prop<"link", true>;
+            } | {
+                booleanStyleFalse: Prop<import("./types.js").BooleanStyleFalse, false>;
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                columnType: Prop<"boolean", true>;
+            } | {
+                tagDisplayConfig: Prop<any, false>;
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                columnType: Prop<"tags", true>;
+            } | {
+                horizontalAlign: Prop<"center" | "left" | "right", false>;
+                verticalAlign: Prop<"center" | "bottom" | "top", false>;
+                "cellProps.textStyle": Prop<any, false>;
+                cellBackground: Prop<string, false>;
+                textWrap: Prop<boolean, false>;
+                cellIcon: Prop<string, false>;
+                cellIconPosition: Prop<import("../../icons/constants.js").IconPosition, false>;
+                columnType: Prop<"email", true>;
+            })))) & {
+                frozen: Prop<boolean, false>;
+            }>;
+            interaction: Section<Record<string, Prop<any, any>> & Omit<{
+                columnType: Prop<import("./types.js").ColumnType, false>;
+            }, "onClick" | "columnType"> & {
+                columnType: Prop<"button", true>;
+                onClick: Prop<import("../../sb-event-flow.js").SbEventFlow, false>;
+            }>;
+        }>;
+    }>;
+    layout: Section<Record<string, Prop<any, any>> & {
+        maxHeight?: Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false> | undefined;
+        minHeight?: Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false> | undefined;
+        maxWidth?: Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false> | undefined;
+        minWidth?: Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false> | undefined;
+        width: Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false>;
+        height: Prop<import("@superblocksteam/library-shared").Dim<import("@superblocksteam/library-shared").DimModes>, false>;
+    } & {
+        margin: Prop<unknown, true>;
+    } & {
+        isVisible: Prop<boolean, true>;
+        collapseWhenInvisible: Prop<boolean, false>;
+    }>;
+    interaction: Section<Record<string, Prop<any, any>> & {
+        isFilterable: Prop<boolean, true>;
+        defaultFilters: Prop<any, false>;
+        multiRowSelection: Prop<boolean, true>;
+        isSearchable: Prop<boolean, true>;
+        isDownloadable: Prop<boolean, true>;
+        pageType: Prop<PaginationTypes, true>;
+        configuredPageSize: Prop<number, false>;
+        defaultSort: import("../../properties-panel/props-builder.js").CompositeProp<{
+            column: Prop<string, true>;
+            asc: Prop<boolean, true>;
+        }>;
+        defaultSearchText: Prop<string, false>;
+        searchPlaceholder: Prop<string, false>;
+    }>;
+    appearance: Section<Record<string, Prop<any, any>> & {
+        defaultSelectedRow: Prop<number, false>;
+        showColumnBorders: Prop<boolean, false>;
+        "headerProps.textStyle": Prop<any, false>;
+        "columnHeaderProps.textStyle": Prop<any, false>;
+        "cellProps.textStyle": Prop<any, false>;
+        backgroundColor: Prop<string, false>;
+        selectedRowBackgroundColor: Prop<string, false>;
+        border: Prop<import("@superblocksteam/library-shared/types").PerSideBorder, true>;
+        borderRadius: Prop<import("@superblocksteam/library-shared/types").PerCornerBorderRadius, true>;
+        compactMode: Prop<CompactMode, false>;
+        maxLinesPerRow: Prop<number, false>;
+        animateLoading: Prop<boolean, false>;
+        isVisible: Prop<boolean, false>;
+        collapseWhenHidden: Prop<boolean, false>;
+        "searchProps.textStyle": Prop<any, false>;
+        "searchProps.backgroundColor": Prop<string, false>;
+        "searchProps.border": Prop<import("@superblocksteam/library-shared/types").PerSideBorder, true>;
+        "searchProps.borderRadius": Prop<import("@superblocksteam/library-shared/types").PerCornerBorderRadius, true>;
+    }>;
+    events: Section<Record<string, Prop<any, any>> & {
+        onRowClick: Prop<import("../../sb-event-flow.js").SbEventFlow, false>;
+        onRowSelected: Prop<import("../../sb-event-flow.js").SbEventFlow, false>;
+        onPageChange: Prop<import("../../sb-event-flow.js").SbEventFlow, false>;
+        onFiltersChanged: Prop<import("../../sb-event-flow.js").SbEventFlow, false>;
+        onSearchTextChanged: Prop<import("../../sb-event-flow.js").SbEventFlow, false>;
+    }>;
+    derived: Section<Record<string, Prop<any, any>> & {
+        tableDataWithInserts: Prop<any[], true>;
+        tableDataWithInsertsOrderMap: Prop<number[], true>;
+        selectedRow: Prop<any, true>;
+        selectedRowSchema: Prop<any, true>;
+        selectedRows: Prop<any, true>;
+        pageSize: Prop<number, true>;
+        filteredTableData: Prop<any[], true>;
+        filteredOrderMap: Prop<number[], true>;
+    }>;
+    meta: Section<Record<string, Prop<any, any>> & {
+        selectedRowIndex: Prop<number, false>;
+        selectedRowIndices: Prop<any, false>;
+        pageNo: Prop<number, true>;
+        sortedColumn: Prop<any, false>;
+        searchText: Prop<string, false>;
+        filters: Prop<any, false>;
+        hiddenColumns: Prop<any, false>;
+        columnFreezes: Prop<any, false>;
+        tagsColorAssignment: Prop<any, false>;
+    }>;
+};

package/dist-types/lib/user-facing/components/table/table-component.d.ts

@@ -0,0 +1,100 @@
+import React from "react";
+import type { InsertRowOptions } from "./constants.js";
+import type { ColumnFilter, CompactMode, Pagination, ReactTableColumnProps, TableFilters } from "./types.js";
+import type { Dim, DimModes } from "@superblocksteam/library-shared";
+import type { TextStyleWithVariant, UserAccessibleTheme, PerCornerBorderRadius, PerSideBorder } from "@superblocksteam/library-shared/types";
+export interface TableProps {
+    backgroundColor?: string;
+    borderRadius?: PerCornerBorderRadius;
+    border?: PerSideBorder;
+    selectedRowBackgroundColor?: string;
+    sourceId: string;
+    widgetName: string;
+    searchKey: string;
+    isDisabled?: boolean;
+    isVisible?: boolean;
+    isLoading: boolean;
+    height?: Dim<DimModes>;
+    minHeight?: number;
+    maxHeight?: number;
+    tableCellTextStyle?: TextStyleWithVariant;
+    tableHeaderTextStyle?: TextStyleWithVariant;
+    columnHeaderTextStyle?: TextStyleWithVariant;
+    searchProps?: {
+        textStyle?: TextStyleWithVariant;
+        border?: PerSideBorder;
+        borderRadius?: PerCornerBorderRadius;
+        backgroundColor?: string;
+    };
+    rawTableData: Array<Record<string, unknown>>;
+    filteredOrderMap: number[] | undefined;
+    tableData: Array<Record<string, unknown>>;
+    columnOrder?: string[];
+    disableDrag: (disable: boolean) => void;
+    onRowClick: (rowData: Record<string, unknown>, rowIndex: number) => void;
+    onRowSelect: (rowIndex: number, shiftKey?: boolean) => void;
+    selectRows: (rows?: "ALL" | "NONE") => void;
+    updatePageNo: (pageNo: number) => void;
+    sortTableColumn: (column: string, asc: boolean) => void;
+    nextPageClick: () => void;
+    prevPageClick: () => void;
+    pageNo: number;
+    pageSize: number;
+    pageType: Pagination;
+    selectedRowIndex: number;
+    selectedRowIndices: number[];
+    multiRowSelection?: boolean;
+    columnSizeMap?: {
+        [key: string]: number;
+    };
+    handleResizeColumn: (columnSizeMap: {
+        [key: string]: number;
+    }) => void;
+    handleReorderColumn: (columnOrder: string[]) => void;
+    searchTableData: (searchKey: any) => void;
+    filters?: TableFilters;
+    setColumnFilter: (columnId: string, filter: ColumnFilter) => void;
+    columns: ReactTableColumnProps[];
+    compactMode?: CompactMode;
+    isDownloadable: boolean;
+    isFilterable: boolean;
+    showColumnBorders: boolean;
+    isSortable: boolean;
+    isSearchable: boolean;
+    tableHeader: string;
+    hiddenColumns?: string[];
+    numEdits: number;
+    numEditErrors: number;
+    validationMessages?: string[];
+    onEditSave: () => void;
+    onEditCancel: () => void;
+    searchPlaceholder: string;
+    columnFreezes?: Record<string, boolean>;
+    handleClickOutsideCells: () => void;
+    onRowInsertion: (options?: InsertRowOptions) => void;
+    onRowDeletion: (rowIndices: number[]) => void;
+    getIsRowDeleted: (rowIndex: number, isOriginalIndex?: boolean) => boolean;
+    getIsRowInserted: (rowIndex: number, isOriginalIndex?: boolean) => boolean;
+    getIsRowEdited: (rowIndex: number, isOriginalIndex?: boolean) => boolean;
+    isDeletionEnabled: boolean;
+    isInsertionEnabled: boolean;
+    isSaving: boolean;
+    getCellBackground: (currentRowIndex: number, columnId: string) => string | undefined;
+    onKeyDown: (e: React.KeyboardEvent<HTMLDivElement>) => void;
+    disableNudge: (disable: boolean) => void;
+    setCurrentCellFocus: (focus: {
+        row: number;
+        columnId: string;
+    }[]) => void;
+    currentEditFocus: {
+        row: number;
+        columnId: string;
+    } | undefined;
+    handleCopy: (event: Event) => void;
+    handlePaste: (event: Event) => void;
+    theme: UserAccessibleTheme;
+    appMode: "EDIT" | "DEPLOYED";
+    updateProperty: (property: string, value: any) => void;
+}
+declare const Table: (props: TableProps) => React.JSX.Element;
+export default Table;

package/dist-types/lib/user-facing/components/table/table-manager.d.ts

@@ -0,0 +1,23 @@
+export declare class TableManager {
+    focusedCellIndices: boolean[][];
+    originCell: {
+        rowIndex: number;
+        columnId: string;
+    } | null;
+    private focusedCellIndicesChangeListeners;
+    private originCellListeners;
+    private focusedCellListeners;
+    setFocusedCellIndices(focusedCellIndices: boolean[][]): void;
+    changeCellFocus(row: number, column: number, focus: boolean): void;
+    setOriginCell(rowIndex: number, columnId: string): void;
+    clearOriginCell(): void;
+    clearFocusedCells(clearOrigin?: boolean): void;
+    onFocusedCellIndicesChange: (listener: () => void) => () => void;
+    onFocusedCellChange: (row: number, column: number, listener: () => void) => () => void;
+    onOriginCellChange: (rowIndex: number, columnId: string, listener: () => void) => () => void;
+    private getRowColumnKey;
+}
+export declare const TableManagerContext: import("react").Context<TableManager>;
+export declare function useTableManager(): TableManager;
+export declare function useIsOriginCell(rowIndex: number, columnId: string): boolean;
+export declare function useIsCellFocused(row: number, column: number): boolean;

package/dist-types/lib/user-facing/components/table/table-styles.d.ts

@@ -0,0 +1,78 @@
+import { CompactMode } from "./types.js";
+import type { TableSizes } from "./constants.js";
+import type { SingleCellProperties, ColumnProperties } from "./types.js";
+import type { UserAccessibleTheme } from "@superblocksteam/library-shared/types";
+import type { CSSProperties } from "react";
+interface TableWrapperProps {
+    tableSizes: TableSizes;
+    backgroundColor?: string;
+    selectedRowBackgroundColor?: string;
+    showColumnBorders: boolean;
+    showFrozenColShadow?: boolean;
+    colors: UserAccessibleTheme["colors"];
+}
+export declare const getRowBorderColor: (backgroundColor: string | undefined, colors: UserAccessibleTheme["colors"]) => string;
+export declare const getHoverRowBackgroundColor: (backgroundColor: string | undefined, colors: UserAccessibleTheme["colors"]) => string;
+export declare const TableCSSVariables: {
+    rowHoverBgColor: string;
+};
+export declare const TableWrapper: import("styled-components").StyledComponent<"div", any, TableWrapperProps, never>;
+export declare const buildCellStyles: ({ cellTextStyle, fontStyle, textColor, horizontalAlign, verticalAlign, textSize, compactMode, }: {
+    cellTextStyle?: SingleCellProperties["cellTextStyle"];
+    fontStyle?: SingleCellProperties["fontStyle"];
+    textColor?: SingleCellProperties["textColor"];
+    horizontalAlign?: SingleCellProperties["horizontalAlign"];
+    verticalAlign?: SingleCellProperties["verticalAlign"];
+    textSize?: SingleCellProperties["textSize"];
+    compactMode: CompactMode;
+}) => CSSProperties;
+export declare const CELL_WRAPPER_HOR_MARGIN = 8;
+interface CellWrapperProps {
+    cellProperties: SingleCellProperties;
+    compactMode: CompactMode;
+    hasLeftIcon?: boolean;
+    hasRightIcon?: boolean;
+    isDropdownType?: boolean;
+    isHidden?: boolean;
+    maxWidth?: number;
+}
+type CellOverflowOptions = {
+    canWrap?: boolean;
+    maxLines?: number;
+    isTags?: boolean;
+};
+export declare const getCellWrapStyles: (options: CellOverflowOptions) => {
+    maxHeight: string;
+    WebkitLineClamp?: undefined;
+} | {
+    WebkitLineClamp: number;
+    maxHeight?: undefined;
+} | undefined;
+export declare const getCellClass: (options: CellOverflowOptions) => string | undefined;
+export declare const TextIconWrapper: import("styled-components").StyledComponent<"div", any, {
+    cellProperties: SingleCellProperties;
+    hasLeftIcon?: boolean;
+    hasRightIcon?: boolean;
+}, never>;
+export declare const CellWrapper: import("styled-components").StyledComponent<"div", any, CellWrapperProps, never>;
+export declare const ColumnHeaderWrapper: import("styled-components").StyledComponent<"div", any, {
+    columnProperties: ColumnProperties;
+}, never>;
+export declare const ColumnHeaderTitleWrapper: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const HeaderCellContentWrapper: import("styled-components").StyledComponent<"div", any, {
+    columnProperties: ColumnProperties;
+    shouldCapitalize: boolean;
+}, never>;
+interface TableIconWrapperProps {
+    selected?: boolean;
+    disabled?: boolean;
+    tableSizes: TableSizes;
+}
+export declare const TableIconWrapper: import("styled-components").StyledComponent<"div", any, TableIconWrapperProps, never>;
+export declare const SortIconWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const DefaultValueWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const getTableCellTextStyleClassName: ({ tableCellTextStyleVariant, cellTextStyleVariant, }: {
+    tableCellTextStyleVariant?: string;
+    cellTextStyleVariant?: string;
+}) => string | undefined;
+export {};

package/dist-types/lib/user-facing/components/table/table-utilities.d.ts

@@ -0,0 +1,147 @@
+import { Dim } from "@superblocksteam/library-shared";
+import React from "react";
+import { BooleanStyleFalse } from "./types.js";
+import type { CompactMode } from "./types.js";
+import type { ColumnProperties, TableWidgetProps, EditProps, SingleCellProperties, TableStyles, TagDisplayConfig, TagsColorAssignment, ColumnPropertyFunctionArgs } from "./types.js";
+import type { IconPosition } from "../../icons/constants.js";
+import type { ButtonVariant } from "../button/props.js";
+import type { DimModes } from "@superblocksteam/library-shared";
+import type { TextStyleWithVariant, UserAccessibleTheme } from "@superblocksteam/library-shared/types";
+export declare const getAllTableColumnKeys: (tableData: Readonly<Array<Record<string, unknown>>>, additionalColumnKeys?: string[]) => string[];
+interface TableTagsProps {
+    theme: UserAccessibleTheme;
+    isHidden: boolean;
+    cellProperties: SingleCellProperties;
+    tagValues: unknown[];
+    tagsColorAssignment?: TagsColorAssignment;
+    tagsCustomColorAssignment?: Record<string, TagDisplayConfig>;
+    compactMode: CompactMode;
+    handleCellFocus?: () => void;
+    maxWidth?: number;
+    maxLinesPerRow?: number;
+}
+export type TableCellProps = SingleCellProperties & {
+    isHidden: boolean;
+    cellProperties: SingleCellProperties;
+    tagsColorAssignment?: TagsColorAssignment;
+    tagsCustomColorAssignment?: Record<string, TagDisplayConfig>;
+    booleanStyleFalse?: BooleanStyleFalse;
+    compactMode: CompactMode;
+    isFocused: boolean;
+    isMultiselecting: boolean;
+};
+interface CellPosition {
+    currentRowIndex: number;
+    originalRowIndex: number;
+    columnId: string;
+}
+export declare const sanitizeCellValue: (cellValue: any) => string;
+export declare const TagsCell: ({ isHidden, cellProperties, tagValues, tagsColorAssignment, tagsCustomColorAssignment, compactMode, handleCellFocus, maxWidth, maxLinesPerRow, theme, }: TableTagsProps) => React.JSX.Element;
+interface ColumnAction {
+    label: string;
+    id: string;
+    actions: (args: ColumnPropertyFunctionArgs) => void;
+}
+export declare const formatByType: (value: unknown, type: string, options: {
+    maxLen?: number;
+    displayedValue?: string;
+    notation?: Intl.NumberFormatOptions["notation"] | "unformatted";
+    currency?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+    inputFormat?: string;
+    outputFormat?: string;
+    manageTimezone?: boolean;
+    timezone?: string;
+    displayTimezone?: string;
+}) => string;
+export declare const EditableCell: (props: {
+    value: any;
+    rawValue: any;
+    columnType: string;
+    cellProps: TableCellProps;
+    editProps: EditProps;
+    tableName: string;
+    compactMode: CompactMode;
+    position: CellPosition;
+    isInserted: boolean;
+    columnName: string;
+    maxLinesPerRow?: number;
+    theme: UserAccessibleTheme;
+}) => React.JSX.Element;
+export declare function getCellProperties(tableCellTextStyle: TextStyleWithVariant | undefined, columnProperties: ColumnProperties, rowIndex: number): SingleCellProperties;
+export declare function getPropertyValue(value: any, index: number, preserveCase?: boolean, preserveDataType?: boolean): any;
+export declare function getFirstPropertyValue(value: string | string[] | undefined): string | undefined;
+export declare const renderCell: ({ value, columnType, editInputType, cellProps, defaultValue, maxLinesPerRow, tableCellTextStyle, typographies, theme, }: {
+    value: any;
+    columnType: string;
+    editInputType?: string;
+    cellProps: TableCellProps;
+    position: CellPosition;
+    defaultValue?: string;
+    maxLinesPerRow?: number;
+    tableCellTextStyle?: TextStyleWithVariant;
+    typographies?: UserAccessibleTheme["typographies"];
+    theme: UserAccessibleTheme;
+}) => React.JSX.Element;
+interface RenderActionProps {
+    rowIndex: number;
+    isSelected: boolean;
+    isDisabled?: boolean;
+    columnActions?: ColumnAction[];
+    backgroundColor?: string;
+    buttonVariant: ButtonVariant;
+    buttonLabelColor: string | undefined;
+    cellIcon?: string;
+    cellIconPosition: IconPosition;
+    onCommandClick: (args: ColumnPropertyFunctionArgs) => void;
+    handleRowSelect: (rowIndex: number) => void;
+    compactMode: CompactMode;
+}
+export declare const renderActions: (props: RenderActionProps, isHidden: boolean, cellProperties: SingleCellProperties, compactMode: CompactMode, theme: UserAccessibleTheme) => React.JSX.Element;
+export declare const renderLink: (props: {
+    isHidden: boolean;
+    cellProperties: SingleCellProperties;
+    compactMode: CompactMode;
+    position: CellPosition;
+    maxLinesPerRow?: number;
+    tableCellTextStyle?: TextStyleWithVariant;
+}) => React.JSX.Element;
+export declare const renderEmptyRow: (columns: any, page: any, prepareRow: any, index: number, columnSizeMap: undefined | {
+    [key: string]: number;
+}, resizingColumnIdRef: React.MutableRefObject<string>) => React.JSX.Element;
+export declare const getIsColumnFrozen: (columnId: string, columnFreezes: undefined | Record<string, boolean>, defaultFrozen: undefined | boolean) => boolean | undefined;
+export declare const getMergedColumnOrder: (originalColumnOrder: string[], newColumnIds: string[]) => string[];
+export declare const TABLE_MULTISELECT_COLID = "SB_$$_MULTISELECT";
+export declare const getVisibleOrderedColumnIds: (columns: Record<string, ColumnProperties>, columnOrder: string[], columnFreezes: undefined | Record<string, boolean>, isMultiSelect: boolean | undefined, hiddenColumns: undefined | string[]) => string[];
+export declare const reorderColumns: (columns: Record<string, ColumnProperties>, columnOrder: string[], columnFreezes?: Record<string, boolean>) => Record<string, ColumnProperties>;
+export declare function getDefaultColumnProperties(accessor: string, index: number, widgetName: string, isDerived?: boolean): ColumnProperties;
+export declare function getDefaultComputedValue(accessor: string, widgetName: string, isDerived: boolean): string;
+export declare function columnHasNonDefaultProps(columnProperties: ColumnProperties, widgetName: string): boolean;
+export declare function getTableStyles(props: any): TableStyles;
+export declare const getColumnWidthStyle: ({ column, columnSizeMap, resizingColumnIdRef, canvasScaleFactor, }: {
+    column: any;
+    columnSizeMap: {
+        [key: string]: number;
+    } | undefined;
+    resizingColumnIdRef: React.MutableRefObject<string>;
+    canvasScaleFactor: number;
+}) => {
+    flex: string;
+    width: string;
+} | undefined;
+export declare const getFluidColumnWidth: (componentWidth: Dim<DimModes>, allColumns: Record<string, ColumnProperties>, columnSizeMap: {
+    [key: string]: number;
+} | undefined) => number;
+export declare const getColumnWidth: (colId: string, columnSizeMap: {
+    [key: string]: number;
+} | undefined, fluidColumnWidth: number) => {
+    width: number;
+    actualFlexWidth?: undefined;
+} | {
+    width: number;
+    actualFlexWidth: number;
+};
+export declare function collapseTableData(data: unknown[][], largestRow?: number): unknown[][];
+export declare function createTableColumns(props: TableWidgetProps): Record<string, ColumnProperties> | undefined;
+export {};