@economic/taco 2.15.0 → 2.17.0

package/dist/components/Drawer/Drawer.d.ts

@@ -36,8 +36,12 @@ export declare type DrawerProps = Omit<DialogProps, 'draggable' | 'size'> & {
     focusTrap?: boolean;
     /** When 'true' renders close button in topr right cornenr of drawer content */
     showCloseButton?: boolean;
+    /** Target specific named outlet allowing you to render a drawer to a specific outlet */
+    outletName?: string;
+};
+export declare type OutletProps = React.HTMLAttributes<HTMLDivElement> & {
+    name?: string;
 };
-export declare type OutletProps = React.HTMLAttributes<HTMLDivElement>;
 export declare type ForwardedDrawerWithStatics = React.ForwardRefExoticComponent<DrawerProps & React.RefAttributes<HTMLElement>> & {
     Trigger: React.ForwardRefExoticComponent<DrawerTriggerProps & React.RefAttributes<HTMLButtonElement>>;
     Content: React.ForwardRefExoticComponent<DrawerContentProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/Provider/Localization.d.ts

@@ -202,6 +202,12 @@ export declare const defaultLocalisationTexts: {
                 progress: string;
                 complete: string;
             };
+            clearChangesConfirmationDialog: {
+                title: string;
+                description: string;
+                cancel: string;
+                confirm: string;
+            };
         };
         filters: {
             button: string;
@@ -302,6 +308,19 @@ export declare const defaultLocalisationTexts: {
         otherOptions: {
             tooltip: string;
         };
+        validation: {
+            index: string;
+            alert: {
+                unsavedEntries: (count?: number) => "unsaved entry:" | "unsaved entries:";
+                incompleteAndHavntBeenSaved: (count?: number) => "is incomplete and haven’t been saved." | "are incomplete and haven’t been saved.";
+            };
+            resetFiltersDialog: {
+                title: string;
+                description: string;
+                cancel: string;
+                confirm: string;
+            };
+        };
     };
     searchInput: {
         button: string;

package/dist/components/SearchInput2/SearchInput2.d.ts

@@ -3,6 +3,7 @@ import { KeyDownHandlerOptions } from '../../utils/keyboard';
 interface CommonSearchInput2Props extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'defaultValue' | 'onChange' | 'value'> {
     loading?: boolean;
     onChange: (value: string) => void;
+    onClear?: () => void;
     settingsContent?: JSX.Element;
     shortcut?: string | KeyDownHandlerOptions;
     value?: string;

package/dist/components/Table3/Table3.d.ts

@@ -9,8 +9,6 @@ declare function Group(_: Table3GroupProps): null;
 declare namespace Group {
     var displayName: string;
 }
-declare type FixedForwardRef = <T, P = {}>(render: (props: P, ref: React.Ref<T>) => JSX.Element) => (props: P & React.RefAttributes<T>) => JSX.Element;
-export declare const fixedForwardRef: FixedForwardRef;
 declare type Table3WithStatics = (<TType = unknown>(props: Table3Props<TType> & React.RefAttributes<Table3Ref>) => JSX.Element) & {
     Column: typeof Column;
     Group: typeof Group;

package/dist/components/Table3/components/alert/ErrorAlert.d.ts

@@ -0,0 +1,10 @@
+import { Table as RTable } from '@tanstack/react-table';
+import { TableStrategy } from '../../types';
+import React from 'react';
+export declare type ErrorAlertProps<TType = unknown> = {
+    table: RTable<TType>;
+    tableRef: React.RefObject<HTMLDivElement>;
+    scrollToIndex: TableStrategy['scrollToIndex'];
+    rowIdentifier?: string;
+};
+export declare function ErrorAlert<TType = unknown>(props: ErrorAlertProps<TType>): JSX.Element;

package/dist/components/Table3/components/columns/cell/DisplayCell.d.ts

@@ -2,8 +2,11 @@ import React from 'react';
 import { CellContext } from '@tanstack/react-table';
 import { Table3ColumnAlignment } from '../../../types';
 export declare type DisplayCellProps<TType = unknown> = CellContext<TType, unknown> & {
+    highlighted?: boolean;
+    highlightedAsCurrent?: boolean;
     children?: string | JSX.Element;
     className?: string;
+    value?: any;
 };
 export declare function DisplayCell<TType = unknown>(props: DisplayCellProps<TType>): JSX.Element;
 export declare type MemoedDisplayCellProps<TType = unknown> = {
@@ -14,8 +17,8 @@ export declare type MemoedDisplayCellProps<TType = unknown> = {
     debug?: boolean;
     enableTruncate?: boolean;
     frozenColumnIndex?: number;
-    highlighted: boolean;
-    highlightedAsCurrent: boolean;
+    highlighted?: boolean;
+    highlightedAsCurrent?: boolean;
     id: string;
     index: number;
     tableRef: React.RefObject<HTMLDivElement>;

package/dist/components/Table3/components/columns/cell/EditingCell.d.ts

@@ -1,10 +1,13 @@
 /// <reference types="react" />
 import { TableMeta, CellContext } from '@tanstack/react-table';
 export declare type EditingCellProps<TType = unknown> = CellContext<TType, unknown> & {
+    highlighted?: boolean;
+    highlightedAsCurrent?: boolean;
     children?: string | JSX.Element;
 };
 export declare function EditingCell<TType = unknown>(props: EditingCellProps<TType>): JSX.Element;
 export declare type MemoedEditingCellProps<TType = unknown> = EditingCellProps<TType> & {
     isHovered: boolean;
     tableMeta: TableMeta<TType>;
+    error?: string;
 };

package/dist/components/Table3/components/columns/cell/EditingControl.d.ts

@@ -16,6 +16,6 @@ export declare type EditingControlProps<TType = unknown> = {
     cell: RTCell<TType, unknown>;
     error?: string;
     tabIndex?: number;
-    isCurrentRow?: boolean;
+    isActiveRow?: boolean;
 };
 export declare const EditingControl: React.ForwardRefExoticComponent<Pick<any, string | number | symbol> & React.RefAttributes<HTMLElement>>;

package/dist/components/Table3/components/columns/cell/Highlight.d.ts

@@ -0,0 +1,2 @@
+/// <reference types="react" />
+export declare const Highlight: (props: any) => JSX.Element;

package/dist/components/Table3/components/columns/header/Header.d.ts

@@ -9,7 +9,7 @@ export declare type HeaderProps<TType = unknown> = HeaderContext<TType, unknown>
     hasSeparator?: boolean;
 };
 export declare function Header<TType = unknown>(props: HeaderProps<TType>): JSX.Element;
-export declare type MemoedHeaderProps<TType = unknown> = Omit<HeaderProps<TType>, 'column' | 'header'> & {
+export declare type HeaderContentProps<TType = unknown> = Omit<HeaderProps<TType>, 'column' | 'header'> & {
     align?: Table3ColumnAlignment;
     canFreeze: boolean;
     canHide: boolean;

package/dist/components/Table3/components/columns/internal/EditingActions.d.ts

@@ -5,4 +5,4 @@ export declare type EditingActionsProps<TType = unknown> = CellContext<TType, un
 };
 export declare const COLUMN_ID = "__editing_actions";
 export declare const EDITING_ACTIONS_WIDTH = 60;
-export declare function createRowEditingActionsColumn<TType = unknown>(): DisplayColumnDef<TType, unknown>;
+export declare function createRowEditingActionsColumn<TType = unknown>(rowIdentifier?: string): DisplayColumnDef<TType, unknown>;

package/dist/components/Table3/components/columns/styles.d.ts

@@ -1,5 +1,5 @@
-import { Table3ColumnAlignment, Table3FontSize } from '../../types';
+import { Table3ColumnAlignment } from '../../types';
 export declare const PRINT_MIN_COLUMN_SIZE = 20;
 export declare const getCellAlignmentClasses: (alignment?: Table3ColumnAlignment) => string;
-export declare const getFontBasedMinColumnSize: (fontSize: Table3FontSize | undefined) => 57 | 83 | 72;
+export declare const getFontBasedMinColumnSize: (fontSize?: "small" | "medium" | "large") => 57 | 83 | 72;
 export declare const getInputAppearanceClassnames: () => string;

package/dist/components/Table3/components/rows/Row.d.ts

@@ -1,6 +1,7 @@
 import React from 'react';
 import { Row as RTRow, Table as RTable } from '@tanstack/react-table';
 import { Table3RowClickHandler, Table3RowDropHandler } from '../../types';
+import { LastCellIndex } from '../../util/editing';
 declare type RowProps<TType = unknown> = Omit<React.HTMLAttributes<HTMLDivElement>, 'onClick' | 'onDrop'> & {
     index: number;
     isLastRow: boolean;
@@ -12,11 +13,14 @@ declare type RowProps<TType = unknown> = Omit<React.HTMLAttributes<HTMLDivElemen
     tableRef: React.RefObject<HTMLDivElement>;
 };
 export declare function Row<TType = unknown>(props: RowProps<TType>): JSX.Element;
-export declare type MemoedRowProps<TType = unknown> = RowProps<TType> & {
+export declare const lastCellIndex: LastCellIndex;
+export declare type MemoedRowProps<TType = unknown> = Omit<RowProps<TType>, 'onClick'> & {
+    data: TType;
     'aria-grabbed'?: boolean;
     'data-current': boolean;
     'data-selected': boolean;
     draggable: boolean;
     index: number;
+    onClick: (event: React.MouseEvent<HTMLDivElement>, data: unknown) => void;
 };
 export {};

package/dist/components/Table3/components/rows/RowContext.d.ts

@@ -3,6 +3,7 @@ declare type RowContextValue = {
     isHovered: boolean;
     setIsHovered: (value: boolean) => void;
     rowIndex: number;
+    hasError: boolean;
 };
 export declare const RowContext: React.Context<RowContextValue>;
 export declare const useRowContext: () => RowContextValue;

package/dist/components/Table3/hooks/features/useEditing.d.ts

@@ -1,30 +1,31 @@
 import React from 'react';
 import { Cell as RTCell } from '@tanstack/react-table';
+import { Table3SaveHandler } from '../../types';
 import { IndicatorReason } from '../../components/columns/cell/Indicator';
-export declare enum SavingStateValue {
+import { Table3Validation } from './useValidation';
+export declare enum SavingStatusValue {
     Saving = "saving",
     Saved = "saved",
     Error = "error"
 }
-export declare type SavingState = {
-    state: SavingStateValue;
-};
-export declare function useEditing<TType = unknown>(isEnabled: boolean, onSave?: (row: TType) => void): {
+export declare function useEditing<TType = unknown>(isEnabled: boolean, validation: Table3Validation<TType>, onSave?: Table3SaveHandler<TType>): {
     isEnabled: boolean;
     isEditing: boolean;
     toggleEditing: React.Dispatch<React.SetStateAction<boolean>>;
-    changes: Record<string, TType> | null;
+    changes: EditingState<TType>;
     getCellValue: <T extends TType>(cell: RTCell<T, unknown>) => any;
     setCellValue: <T_1 extends TType>(cell: RTCell<T_1, unknown>, value: unknown) => void;
     saveChangesIfNeeded: () => Promise<void>;
     detailModeEditing: boolean;
     setDetailModeEditing: React.Dispatch<React.SetStateAction<boolean>>;
-    rowMoveReason: Record<string, IndicatorReason | null>;
-    setRowMoveReason: React.Dispatch<React.SetStateAction<Record<string, IndicatorReason | null>>>;
-    removeRowMoveReason: (columnId: string) => void;
+    rowMoveReason: Record<string, IndicatorReason | null> | null;
+    setRowMoveReason: React.Dispatch<React.SetStateAction<Record<string, IndicatorReason | null> | null>>;
+    removeRowMoveReason: () => void;
     handleKeyDown: (event: KeyboardEvent) => void;
     handleBlur: (event: React.FocusEvent) => void;
     resetChange: (rowId: string) => void;
-    savingStates: Record<string, SavingState> | null;
-    removeSavingState: (rowId: string) => void;
+    getSavingStatus: (rowId: string) => SavingStatusValue | null;
+    resetSavingStatus: (rowId: string) => void;
 };
+declare type EditingState<TType = unknown> = Record<string, TType> | null;
+export {};

package/dist/components/Table3/hooks/features/{usePauseHoverState.d.ts → usePauseShortcuts.d.ts}

@@ -1,6 +1,5 @@
 import React from 'react';
-export declare function usePauseHoverState(): {
+export declare function usePauseShortcuts(): {
     isPaused: boolean;
     pause: React.Dispatch<React.SetStateAction<boolean>>;
-    handleKeyDown: (event: KeyboardEvent) => void;
 };

package/dist/components/Table3/hooks/features/useSearch.d.ts

@@ -1,6 +1,5 @@
 import React from 'react';
-import { Table3LoadAllHandler } from '../../types';
-export declare function useSearch(isEnabled: boolean, excludeUnmatchedResultsInSearch?: boolean, loadAll?: Table3LoadAllHandler): {
+export declare function useSearch(isEnabled: boolean, excludeUnmatchedResultsInSearch?: boolean): {
     isEnabled: boolean;
     isHighlightingEnabled: boolean;
     toggleHighlighting: React.Dispatch<React.SetStateAction<boolean>>;
@@ -12,5 +11,6 @@ export declare function useSearch(isEnabled: boolean, excludeUnmatchedResultsInS
     setHighlightedColumnIndexes: React.Dispatch<React.SetStateAction<number[][]>>;
     currentHighlightColumnIndex: number | undefined;
     setCurrentHighlightColumnIndex: React.Dispatch<React.SetStateAction<number | undefined>>;
-    loadAll: Table3LoadAllHandler | undefined;
+    isSearching: boolean;
+    setIsSearching: React.Dispatch<React.SetStateAction<boolean>>;
 };

package/dist/components/Table3/hooks/features/useValidation.d.ts

@@ -0,0 +1,13 @@
+import { Cell as RTCell } from '@tanstack/react-table';
+import { RowErrors, Table3CellValidationHandler, Table3RowValidationHandler } from '../../types';
+export declare type Table3Validation<TType = unknown> = {
+    validate: (rowId: string, row: TType, cellId?: string) => Promise<void | RowErrors>;
+    setCellError: (rowId: string, cellId: string, error: string) => void;
+    setRowErrors: (rowId: string, errors: Record<string, string>) => void;
+    confirmErrors: (rowId: string) => void;
+    getCellError: <T extends TType>(cell: RTCell<T, unknown>) => string | undefined;
+    resetErrors: (rowId: string, cellId?: string) => void;
+    errors: Record<string, RowErrors> | null;
+    draftErrors: Record<string, RowErrors> | null;
+};
+export declare function useValidation<TType = unknown>(onCellValidate?: Table3CellValidationHandler<TType>, onRowValidate?: Table3RowValidationHandler<TType>): Table3Validation<TType>;

package/dist/components/Table3/hooks/useTable.d.ts

@@ -1,42 +1,47 @@
 import React from 'react';
 import { RowData } from '@tanstack/react-table';
-import { Table3ColumnAlignment, Table3ColumnRenderer, Table3Props, Table3ColumnHeaderMenu, Table3ColumnControlRenderer, Table3ColumnDataType, Table3ColumnClassNameHandler, Table3ColumnFooterRenderer, TableStrategy, Table3FilterComparator, Table3Settings } from '../types';
-import { useCurrentRow } from './features/useCurrentRow';
-import { usePauseHoverState } from './features/usePauseHoverState';
-import { useRowHeight } from './features/useRowHeight';
-import { useFontSize } from './features/useFontSize';
+import { Table3ColumnAlignment, Table3ColumnRenderer, Table3Props, Table3ColumnHeaderMenu, Table3ColumnControlRenderer, Table3ColumnDataType, Table3ColumnClassNameHandler, Table3ColumnFooterRenderer, TableStrategy, Table3FilterComparator, Table3Settings, Table3Ref } from '../types';
+import { useTableRowActive } from '../../../primitives/Table/useTable/features/useTableRowActive';
+import { useTableRowHeight } from '../../../primitives/Table/useTable/features/useTableRowHeight';
+import { useTableFontSize } from '../../../primitives/Table/useTable/features/useTableFontSize';
 import { useRowDrag } from './features/useRowDrag';
 import { useColumnFreezing } from './features/useColumnFreezing';
-import { useRowSelection } from './features/useRowSelection';
-import { useRowClick } from './features/useRowClick';
-import { useColumnOrdering } from './features/useColumnOrdering';
+import { useTableRowSelection } from '../../../primitives/Table/useTable/features/useTableRowSelection';
+import { useTableServerLoading } from '../../../primitives/Table/useTable/features/useTableServerLoading';
+import { useTableRowClick } from '../../../primitives/Table/useTable/features/useTableRowClick';
+import { useTableColumnOrdering } from '../../../primitives/Table/useTable/features/useTableColumnOrdering';
 import { useRowDrop } from './features/useRowDrop';
 import { useEditing } from './features/useEditing';
-import { usePrinting } from './features/usePrinting';
-import { useRowGoto } from './features/useRowGoto';
+import { useTablePrinting } from '../../../primitives/Table/useTable/features/useTablePrinting';
+import { useTableRowGoto } from '../../../primitives/Table/useTable/features/useTableRowGoto';
 import { useSearch } from './features/useSearch';
 import { useRowActions } from './features/useRowActions';
+import { Table3Validation } from './features/useValidation';
+import { usePauseShortcuts } from './features/usePauseShortcuts';
 declare module '@tanstack/table-core' {
     interface TableMeta<TData extends RowData> {
         columnFreezing: ReturnType<typeof useColumnFreezing>;
-        columnOrdering: ReturnType<typeof useColumnOrdering>;
-        currentRow: ReturnType<typeof useCurrentRow>;
+        columnOrdering: ReturnType<typeof useTableColumnOrdering>;
         editing: ReturnType<typeof useEditing>;
         enableFooter: boolean;
-        fontSize: ReturnType<typeof useFontSize>;
+        fontSize: ReturnType<typeof useTableFontSize>;
         getSettings: () => Table3Settings;
-        hoverState: ReturnType<typeof usePauseHoverState>;
         isPrinting: boolean;
         isUsingServer: boolean;
-        printing: ReturnType<typeof usePrinting>;
+        printing: ReturnType<typeof useTablePrinting>;
         rowActions: ReturnType<typeof useRowActions>;
-        rowClick: ReturnType<typeof useRowClick>;
+        rowActive: ReturnType<typeof useTableRowActive>;
+        rowClick: ReturnType<typeof useTableRowClick>;
         rowDrag: ReturnType<typeof useRowDrag>;
         rowDrop: ReturnType<typeof useRowDrop>;
-        rowGoto: ReturnType<typeof useRowGoto>;
-        rowHeight: ReturnType<typeof useRowHeight>;
-        rowSelection: ReturnType<typeof useRowSelection>;
+        rowGoto: ReturnType<typeof useTableRowGoto>;
+        rowHeight: ReturnType<typeof useTableRowHeight>;
+        rowSelection: ReturnType<typeof useTableRowSelection>;
         search: ReturnType<typeof useSearch>;
+        server: ReturnType<typeof useTableServerLoading>;
+        shortcutsState: ReturnType<typeof usePauseShortcuts>;
+        tableRef: React.RefObject<Table3Ref>;
+        validation: Table3Validation<TData>;
     }
     interface ColumnMeta<TData extends RowData, TValue> {
         align?: Table3ColumnAlignment;
@@ -63,7 +68,7 @@ declare module '@tanstack/table-core' {
         scrollToIndex: TableStrategy['scrollToIndex'];
     }
 }
-export declare function useTable<TType = unknown>(props: Table3Props<TType>): {
+export declare function useTable<TType = unknown>(props: Table3Props<TType>, ref: React.RefObject<Table3Ref>): {
     table: any;
     length: number;
 };

package/dist/components/Table3/types.d.ts

@@ -1,7 +1,9 @@
 /// <reference types="react" />
-import { ColumnFilter as RTColumnFilter, ColumnOrderState, ColumnSizingState, ColumnSort as RTTableColumnSort, SortingState, VisibilityState, BuiltInSortingFn } from '@tanstack/react-table';
+import { ColumnOrderState, ColumnSizingState, SortingState, VisibilityState, BuiltInSortingFn } from '@tanstack/react-table';
 import { MenuProps } from '../Menu/Menu';
 import { MenuItemProps } from '../Menu/components/Item';
+import { TableColumnFilter, TableColumnSort, TableFilterHandler, TableFontSize, TableRef, TableRowClickHandler, TableRowGotoHandler, TableRowHeight, TableRowSelectHandler, TableServerLoadAllHandler, TableServerLoadPageHandler, TableSortHandler } from '../../primitives/Table/types';
+import { ValueOf } from '../../types';
 export declare type Table3SortDirection = 'asc' | 'desc';
 export declare type Table3SortFn<TType = unknown> = ((rowA: TType, rowB: TType, columnId: string) => -1 | 0 | 1) | BuiltInSortingFn | 'auto';
 export declare type Table3ColumnRenderer<TValue = unknown, TType = unknown> = (value: TValue, row: TType) => JSX.Element | string | number | null;
@@ -17,12 +19,11 @@ export declare type Table3ColumnControlProps = {
     onBlur?: (value: any) => void;
     onFocus?: React.FocusEventHandler;
     readOnly?: boolean;
-    ref: React.RefObject<HTMLElement>;
+    ref: React.RefObject<HTMLElement> | ((instance: HTMLElement | null | undefined) => void);
     setValue: (value: any) => void;
     value: any;
 };
 export declare type Table3ColumnControlRenderer<TType = unknown> = ((props: Table3ColumnControlProps, row?: TType) => JSX.Element) | 'datepicker' | 'input' | 'switch' | 'textarea';
-declare type ValueOf<T> = T[keyof T];
 export declare type Table3ColumnProps<TType = unknown> = ValueOf<{
     [K in keyof TType]: {
         accessor: K;
@@ -60,13 +61,13 @@ export declare type Table3GroupProps = {
     children: (JSX.Element | boolean | null | undefined)[];
 };
 export declare type DeprecatedRowDensity = 'compact' | 'normal' | 'comfortable' | 'spacious';
-export declare type Table3RowHeight = 'short' | 'medium' | 'tall' | 'extra-tall';
-export declare type Table3FontSize = 'small' | 'medium' | 'large';
-export declare type Table3RowClickHandler<TType = unknown> = (row: TType) => void;
+export declare type Table3RowHeight = TableRowHeight;
+export declare type Table3FontSize = TableFontSize;
+export declare type Table3RowClickHandler<TType = unknown> = TableRowClickHandler<TType>;
 export declare type Table3RowDragHandler<TType = unknown> = (rows: TType[], showPlaceholder: (string: any) => void, setDataTransfer: (data: string) => void) => void;
 export declare type Table3RowDropHandler<TType = any> = (event: React.DragEvent, row: TType) => void;
 export declare type Table3RowExpansionRenderer<TType = unknown> = (row: TType) => (() => JSX.Element) | null;
-export declare type Table3RowSelectionHandler<TType = unknown> = (rows: TType[]) => void;
+export declare type Table3RowSelectionHandler<TType = unknown> = TableRowSelectHandler<TType>;
 export declare type Table3RowActionRenderer<TType = unknown> = (row: TType) => JSX.Element | null;
 export declare type Table3Preset = 'display' | 'editable';
 export declare type Table3Settings = {
@@ -105,13 +106,16 @@ export declare type Table3Filter = {
     id: string | null;
     value: Table3FilterValue;
 };
-export declare type ColumnFilter = RTColumnFilter;
-export declare type Table3FilterHandler = (filters: ColumnFilter[]) => void;
-export declare type Table3LoadPageHandler = (pageIndex: number, sorting: Table3ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<void>;
-export declare type Table3LoadAllHandler = (sorting: Table3ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<void>;
-export declare type Table3RowGotoHandler = (column: string, query: string, sorting: Table3ColumnSort[], filters: ColumnFilter[], search: string | undefined) => Promise<number>;
-export declare type Table3ColumnSort = RTTableColumnSort;
-export declare type Table3SortHandler = (sorting: Table3ColumnSort[]) => void;
+export declare type ColumnFilter = TableColumnFilter;
+export declare type Table3FilterHandler = TableFilterHandler;
+export declare type Table3LoadPageHandler = TableServerLoadPageHandler;
+export declare type Table3LoadAllHandler = TableServerLoadAllHandler;
+export declare type Table3RowGotoHandler = TableRowGotoHandler;
+export declare type Table3ColumnSort = TableColumnSort;
+export declare type Table3SortHandler = TableSortHandler;
+export declare type RowErrors = Record<string, string>;
+export declare type Table3CellValidationHandler<TType = unknown> = (cellValue: any, cellId: string, row: TType) => Promise<RowErrors | undefined | void>;
+export declare type Table3RowValidationHandler<TType = unknown> = (row: TType) => Promise<RowErrors | undefined | void>;
 export declare type TableStrategy = {
     renderBody: () => JSX.Element | JSX.Element[] | null;
     scrollToIndex: (index: number, options?: {
@@ -169,10 +173,13 @@ export declare type Table3CommonProps<TType = unknown> = Partial<Table3Options>
     onFilter?: Table3FilterHandler;
     onSave?: Table3SaveHandler<TType>;
     onSort?: Table3SortHandler;
+    onCellValidate?: Table3CellValidationHandler<TType>;
+    onRowValidate?: Table3RowValidationHandler<TType>;
     preset?: Table3Preset;
     shortcuts?: Table3Shortcuts<TType>;
     toolbarLeft?: JSX.Element;
     toolbarRight?: JSX.Element;
+    rowIdentifier?: string;
 };
 interface Table3ClientProps<TType = unknown> extends Table3CommonProps<TType> {
     length?: never;
@@ -187,12 +194,8 @@ interface Table3ServerProps<TType = unknown> extends Table3CommonProps<TType> {
     pageSize?: number;
 }
 export declare type Table3Props<TType = unknown> = Table3ClientProps<TType> | Table3ServerProps<TType>;
-export declare type Table3Ref = HTMLDivElement & {
+export declare type Table3Ref = TableRef & {
     instance: {
-        resetFiltering: () => void;
-        resetRowExpansion: () => void;
-        resetRowSelection: () => void;
-        resetSorting: () => void;
         toggleEditing: (enabled: boolean | undefined) => void;
     };
 };
@@ -262,6 +265,12 @@ export declare type Table3Texts = {
             progress: string;
             complete: string;
         };
+        clearChangesConfirmationDialog: {
+            title: string;
+            description: string;
+            cancel: string;
+            confirm: string;
+        };
     };
     filters: {
         button: string;
@@ -344,5 +353,18 @@ export declare type Table3Texts = {
     otherOptions: {
         tooltip: string;
     };
+    validation: {
+        index: string;
+        alert: {
+            unsavedEntries: (count?: number) => string;
+            incompleteAndHavntBeenSaved: (count?: number) => string;
+        };
+        resetFiltersDialog: {
+            title: string;
+            description: string;
+            cancel: string;
+            confirm: string;
+        };
+    };
 };
 export {};

package/dist/components/Table3/util/editing.d.ts

@@ -2,3 +2,9 @@ export declare const focussableNodeNames: string[];
 export declare const focusableSelector: string;
 export declare const hasChanged: (value: any, newValue: any) => boolean;
 export declare const willRowMoveAfterSorting: (value: any, cell: any, rowIndex: any, rows: any, desc: any) => boolean;
+export declare class LastCellIndex {
+    _value: string | null | undefined;
+    get value(): string | null | undefined;
+    set value(val: string | null | undefined);
+}
+export declare function getColumnIndex(element: Element): string | null | undefined;

package/dist/components/Table3/util/scrolling.d.ts

@@ -0,0 +1,2 @@
+import { Table3Ref } from '../types';
+export declare function getTableLeftScrollDistance(tableElement: Table3Ref, cell: Element, frozenColumnIndex: number, isEditing?: boolean): number | null;