@layers-app/shared 0.0.36 → 0.0.37-0

package/dist/components/FlowEditor/hooks/useFlow.d.ts

@@ -0,0 +1,35 @@
+import { Connection, NodeChange, OnEdgesChange, XYPosition } from '@xyflow/react';
+import { ApiFlowLight } from '../../../../../flow/src/api/flowLight/types.ts';
+interface Props {
+    value: {
+        nodes: string;
+        edges: string;
+    };
+    flowId: string;
+    onChange?: (flow: Props['value']) => void;
+}
+export declare const useFlow: ({ value, onChange, flowId }: Props) => {
+    nodes: ApiFlowLight.FlowNodeItem[];
+    edges: ApiFlowLight.FlowEdgeItem[];
+    onNodesChange: (changes: NodeChange<ApiFlowLight.FlowNodeItem>[]) => Promise<void>;
+    onEdgesChange: OnEdgesChange<ApiFlowLight.FlowEdgeItem>;
+    onConnect: (params: Connection) => void;
+    addNode: (type: ApiFlowLight.NodeType, position: XYPosition, data?: Partial<ApiFlowLight.FlowNodeItem["data"]>, measured?: Partial<ApiFlowLight.FlowNodeItem["measured"]>) => void;
+    updateNodeData: (nodeId: string, data: Partial<ApiFlowLight.FlowNodeItem["data"]>) => void;
+    updateEdge: (edgeId: string, data: Partial<ApiFlowLight.FlowEdgeItem>) => void;
+    updateEdgeData: (edgeId: string, data: Partial<Required<ApiFlowLight.FlowEdgeItem>["data"]>) => void;
+};
+export interface UseFlowResult {
+    nodes: ApiFlowLight.FlowNodeItem[];
+    edges: ApiFlowLight.FlowEdgeItem[];
+    onNodesChange: (changes: NodeChange<ApiFlowLight.FlowNodeItem>[], selectedNode?: ApiFlowLight.FlowNodeItem | null) => void;
+    onEdgesChange: OnEdgesChange<ApiFlowLight.FlowEdgeItem>;
+    onConnect: (params: Connection) => void;
+    addNode: (type: ApiFlowLight.NodeType, position: XYPosition, data?: Partial<ApiFlowLight.FlowNodeItem['data']>, measured?: Partial<ApiFlowLight.FlowNodeItem['measured']>) => void;
+    updateNodeData: (nodeId: string, data: Partial<ApiFlowLight.FlowNodeItem['data']>) => void;
+    updateEdge: (edgeId: string, data: Partial<ApiFlowLight.FlowEdgeItem>) => void;
+    updateEdgeData: (edgeId: string, data: Partial<Required<ApiFlowLight.FlowEdgeItem>['data']>) => void;
+    returnNode: (node: ApiFlowLight.FlowNodeItem) => void;
+    returnEdge: (edge: ApiFlowLight.FlowEdgeItem) => void;
+}
+export {};

package/dist/components/FlowEditor/hooks/usePngExport.d.ts

@@ -0,0 +1 @@
+export declare const usePngExport: () => (flowName: string) => void;

package/dist/components/FlowEditor/index.d.ts

@@ -0,0 +1,10 @@
+interface Props {
+    value: {
+        nodes: string;
+        edges: string;
+    };
+    flowId: string;
+    onChange?: (data: Props['value']) => void;
+}
+export declare const FlowEditor: import('react').ForwardRefExoticComponent<Props & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/components/FlowEditor/store/useFlowStore.d.ts

@@ -0,0 +1,9 @@
+export interface FlowState {
+    snapToGrid: boolean;
+    showGrid: boolean;
+    autoLayout: {
+        active: boolean;
+        direction: 'right' | 'down' | null;
+    };
+}
+export declare const useFlowStore: import('zustand').UseBoundStore<import('zustand').StoreApi<FlowState>>;

package/dist/components/FlowEditor/store/useUndoRedoStore.d.ts

@@ -0,0 +1,24 @@
+import { ApiFlowLight } from '../../../../../flow/src/api/flowLight/types.ts';
+interface FlowStateSnapshot {
+    nodes: ApiFlowLight.FlowNodeItem[];
+    edges: ApiFlowLight.FlowEdgeItem[];
+}
+interface PerFlowUndoRedoState {
+    undoStack: FlowStateSnapshot[];
+    redoStack: FlowStateSnapshot[];
+    current: FlowStateSnapshot;
+}
+interface UndoRedoState {
+    flows: Record<string, PerFlowUndoRedoState>;
+    initFlow: (flowId: string, initialState?: FlowStateSnapshot) => void;
+    setSnapshot: (flowId: string, snapshot: FlowStateSnapshot) => void;
+    undo: (flowId: string) => void;
+    redo: (flowId: string) => void;
+    getCurrent: (flowId: string) => FlowStateSnapshot | undefined;
+    canUndo: (flowId: string) => boolean;
+    canRedo: (flowId: string) => boolean;
+    clearHistory: (flowId: string) => void;
+    setCurrent: (flowId: string, snapshot: FlowStateSnapshot) => void;
+}
+export declare const useFlowUndoRedoStore: import('zustand').UseBoundStore<import('zustand').StoreApi<UndoRedoState>>;
+export {};

package/dist/components/FlowEditor/utils/index.d.ts

@@ -0,0 +1 @@
+export declare const truncate: (text: string, maxLength?: number) => string;

package/dist/components/Logotype.d.ts

@@ -1,8 +1,10 @@
 import { FlexProps } from '@mantine/core';
 import { default as LayersLogoIcon } from '../assets/layers-logo-icon.svg?react';
-export declare const Logotype: ({ minified, isLink, to, ...props }: FlexProps & {
+import { default as LayersLogoCopyright } from '../assets/logo-copyright.svg?react';
+export declare const Logotype: ({ minified, isLink, to, variant, ...props }: FlexProps & {
     minified?: boolean;
     isLink?: boolean;
     to?: string;
+    variant?: "default" | "copyright";
 }) => import("react/jsx-runtime").JSX.Element;
-export { LayersLogoIcon };
+export { LayersLogoIcon, LayersLogoCopyright };

package/dist/components/NotPublicPanel/NotPublicPanel.d.ts

@@ -5,7 +5,6 @@ type Props = {
     PreviewComponent?: React.FC<{
         data: any;
     }>;
-    zoom?: boolean;
 };
-export declare const NotPublicPanel: ({ entityData, handlePublish, isPublishing, PreviewComponent, zoom, }: Props) => import("react/jsx-runtime").JSX.Element;
+export declare const NotPublicPanel: ({ entityData, handlePublish, isPublishing, PreviewComponent, }: Props) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/SearchFilters/SearchFilters.d.ts

@@ -1,7 +1,9 @@
-import { SelectedFilter, setSelectedFilterType } from './types';
+import { FilterType, SelectedFilter, setSelectedFilterType } from './types';
 interface IProps {
+    allowedTypes?: FilterType[];
+    allowedFilters?: string[];
     setSelectedFilter?: setSelectedFilterType;
     selectedFilter?: SelectedFilter;
 }
-export declare const SearchFilters: ({ setSelectedFilter, selectedFilter, }: IProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SearchFilters: ({ setSelectedFilter, selectedFilter, allowedTypes, allowedFilters, }: IProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/SearchFilters/components/Type.d.ts

@@ -1,7 +1,8 @@
-import { SelectedFilter } from '../types';
+import { FilterType, SelectedFilter } from '../types';
 interface IProps {
     setSelectedFilter: (value: (prev: SelectedFilter) => SelectedFilter) => void;
     selectedFilter?: SelectedFilter;
+    allowedTypes?: FilterType[];
 }
-export declare const Type: ({ setSelectedFilter, selectedFilter }: IProps) => import("react/jsx-runtime").JSX.Element;
+export declare const Type: ({ setSelectedFilter, selectedFilter, allowedTypes, }: IProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -1,5 +1,5 @@
 export type SortOrder = 'asc' | 'desc';
-export type FilterType = 'Page' | 'Project' | 'Flow' | 'Form' | 'Cloud' | null;
+export type FilterType = 'PAGE' | 'PROJECT' | 'FLOW' | 'FORM' | 'FOLDER' | null;
 export type SortFilter = {
     [key: string]: {
         order: SortOrder;

package/dist/components/TemplatesModal/components/SelectedTemplate.d.ts

@@ -0,0 +1,7 @@
+import { Template } from '../types.ts';
+interface Props {
+    selectedTemplate: Template;
+    closeSelectedTemplateContent: VoidFunction;
+}
+export declare const SelectedTemplate: ({ selectedTemplate, closeSelectedTemplateContent, }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/TemplatesModal/components/Template.d.ts

@@ -0,0 +1,9 @@
+import { templates } from '../data.ts';
+import { Template as TemplateType } from '../types.ts';
+interface Props {
+    template: (typeof templates)[number];
+    setSelectedTemplate: (template: TemplateType) => void;
+    index: number;
+}
+export declare const Template: ({ template, setSelectedTemplate, index }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/TemplatesModal/components/Templates.d.ts

@@ -0,0 +1,7 @@
+import { Template as TemplateType } from '../types.ts';
+interface Props {
+    title?: string;
+    setSelectedTemplate: (template: TemplateType) => void;
+}
+export declare const Templates: ({ title, setSelectedTemplate }: Props) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/TemplatesModal/data.d.ts

@@ -0,0 +1,13 @@
+import { Template } from './types.ts';
+export declare const templateCategories: string[];
+export declare const appTypeConfig: readonly [{
+    readonly type: "Pages";
+    readonly icon: import('react').ForwardRefExoticComponent<import('@tabler/icons-react').IconProps & import('react').RefAttributes<import('@tabler/icons-react').Icon>>;
+}, {
+    readonly type: "Flow";
+    readonly icon: import('react').ForwardRefExoticComponent<import('@tabler/icons-react').IconProps & import('react').RefAttributes<import('@tabler/icons-react').Icon>>;
+}, ...{
+    type: string;
+    icon: import('react').ForwardRefExoticComponent<import('@tabler/icons-react').IconProps & import('react').RefAttributes<import('@tabler/icons-react').Icon>>;
+}[]];
+export declare const templates: Template[];

package/dist/components/TemplatesModal/index.d.ts

@@ -0,0 +1,7 @@
+import { FC } from 'react';
+export declare const openTemplatesModal: () => void;
+export declare const closeTemplatesModal: () => void;
+export declare const TemplatesModal: FC;
+export declare const TemplatesLayout: ({ title }: {
+    title?: string;
+}) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,16 @@
+export type AppType = 'Pages' | 'Forms' | 'Flow';
+export interface Template {
+    id: string;
+    title: string;
+    description: string;
+    category: string;
+    appType: AppType;
+    author: string;
+    views?: number;
+    isBlocked?: boolean;
+    pageId: string;
+    wsId: string;
+    createdAt?: string;
+    tags?: string[];
+    longDescription?: string;
+}

package/dist/components/table/FrontTable.d.ts

@@ -0,0 +1,35 @@
+export declare const FrontTable: import('react').NamedExoticComponent<unknown> & {
+    readonly type: () => import("react/jsx-runtime").JSX.Element;
+} & {
+    Header: import('@emotion/styled').StyledComponent<{
+        theme?: import('@emotion/react').Theme;
+        as?: React.ElementType;
+    }, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+    Title: import('@emotion/styled').StyledComponent<{
+        theme?: import('@emotion/react').Theme;
+        as?: React.ElementType;
+    }, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+    Desc: import('@emotion/styled').StyledComponent<{
+        theme?: import('@emotion/react').Theme;
+        as?: React.ElementType;
+    }, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+    Pagination: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+    Search: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;
+    Root: import('@emotion/styled').StyledComponent<{
+        theme?: import('@emotion/react').Theme;
+        as?: React.ElementType;
+    }, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+    Provider: <ITEM extends import('./types').TableRowModel>({ children, store, rows, columns, loading, pageSizeOptions, rowHeight, headerHeight, rowCount, exportFileName, pagination, virtualization, searching, selection, sorting, expanding, }: import('react').PropsWithChildren<{
+        store: import('./store').CreateTableReturn;
+    } & import('./types').TableProps<ITEM>>) => import("react/jsx-runtime").JSX.Element;
+    Menu: import('react').MemoExoticComponent<({ onExport, isLoading, }: {
+        onExport?: (format: "csv" | "xlsx") => void;
+        isLoading?: boolean;
+    }) => import("react/jsx-runtime").JSX.Element>;
+};
+export * from './hooks/useCreateTable';
+export * from './hooks/useSaveRowCount';
+export * from './types';
+export * from './helpers/columns';
+export * from './components/TableSearch';
+export * from './components/TablePagination';

package/dist/components/table/api.d.ts

@@ -0,0 +1,31 @@
+import { UseStore } from './store';
+import { TableSortModel } from './types';
+export type TableAPI = ReturnType<typeof createApi>;
+export declare const createApi: (store: UseStore) => {
+    setPageSize: (v: number) => void;
+    setPage: (v: number) => void;
+    setSort: (v: TableSortModel | null) => void;
+    downloadCSV: () => void;
+    downloadExcel: () => void;
+    setSelected: (selected: string[]) => void;
+    toggleColumn: (v: string) => void;
+    setVisibleColumns: (v: string[]) => void;
+    setSearch: (v: string) => void;
+    setPrevPage: () => void;
+    setNextPage: () => void;
+    setColumnWidth: (field: string, setWidth: number) => void;
+    toggleRowExpand: (id: string) => void;
+    setRootRef: (rootRef: HTMLDivElement) => void;
+    setScrollRef: (scrollRef: HTMLDivElement) => void;
+    calculateColumnWidths: (clear?: boolean) => void;
+    selectVisibleRows: () => void;
+    unselectVisibleRows: () => void;
+    unselectRow: (id: string) => void;
+    selectRow: (id: string) => void;
+    setAutosize: () => void;
+    removeAutosize: () => void;
+    setColumnsOrder: (columnsOrder: string[]) => void;
+    setColumnOrder: (columnId: string, index: number) => void;
+    moveColumnLeft: (columnId: string) => void;
+    moveColumnRight: (columnId: string) => void;
+};

package/dist/components/table/components/Table.d.ts

@@ -0,0 +1 @@
+export declare const Table: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TableAggregation.d.ts

@@ -0,0 +1 @@
+export declare const TableAggregation: () => import("react/jsx-runtime").JSX.Element | null;

package/dist/components/table/components/TableCell.d.ts

@@ -0,0 +1,11 @@
+import { TableColumnDef, TableRowModel } from '../types';
+interface TableCellProps {
+    column: TableColumnDef;
+    row: TableRowModel;
+}
+export declare const TableCell: import('react').MemoExoticComponent<({ column, row }: TableCellProps) => import("react/jsx-runtime").JSX.Element>;
+export declare const CellRoot: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export {};

package/dist/components/table/components/TableHeaderCell.d.ts

@@ -0,0 +1,17 @@
+import { CSSProperties } from 'react';
+import { TableColumnDef, TableSortModel } from '../types';
+interface TableHeaderCellProps {
+    column: TableColumnDef;
+    sort?: TableSortModel | null;
+    style?: CSSProperties;
+}
+export declare const TableHeaderCell: ({ column, sort, style, }: TableHeaderCellProps) => import("react/jsx-runtime").JSX.Element;
+export declare const HeaderCellRoot: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const HeaderCellContent: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export {};

package/dist/components/table/components/TableHeaders.d.ts

@@ -0,0 +1 @@
+export declare const TableHeaders: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TableMenu.d.ts

@@ -0,0 +1,4 @@
+export declare const TableMenu: import('react').MemoExoticComponent<({ onExport, isLoading, }: {
+    onExport?: (format: "csv" | "xlsx") => void;
+    isLoading?: boolean;
+}) => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TablePagination.d.ts

@@ -0,0 +1 @@
+export declare const TablePagination: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TablePanel.d.ts

@@ -0,0 +1 @@
+export declare const TablePanel: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element | null>;

package/dist/components/table/components/TableRow.d.ts

@@ -0,0 +1,14 @@
+import { RowMeta, TableColumnDef, TableRowModel } from '../types';
+interface TableRowProps {
+    start: number;
+    row: TableRowModel;
+    selected: string[];
+    meta: Partial<Record<string, RowMeta>>;
+    columns: {
+        left: TableColumnDef[];
+        base: TableColumnDef[];
+        right: TableColumnDef[];
+    };
+}
+export declare const TableRow: import('react').MemoExoticComponent<({ row, meta, columns, selected, start }: TableRowProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/table/components/TableRows.d.ts

@@ -0,0 +1,14 @@
+import { RowMeta, TableColumnDef, TableRowModel } from '../types';
+type RenderRowsProps = {
+    rows: TableRowModel[];
+    meta: Partial<Record<string, RowMeta>>;
+    selected: string[];
+    virtual?: boolean;
+    columns: {
+        left: TableColumnDef[];
+        base: TableColumnDef[];
+        right: TableColumnDef[];
+    };
+};
+export declare const TableRows: import('react').MemoExoticComponent<({ rows, meta, columns, selected, virtual }: RenderRowsProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/table/components/TableSearch.d.ts

@@ -0,0 +1 @@
+export declare const TableSearch: import('react').MemoExoticComponent<() => import("react/jsx-runtime").JSX.Element>;

package/dist/components/table/components/TableSkeleton.d.ts

@@ -0,0 +1,11 @@
+import { TableColumnDef } from '../types';
+type TableSkeletonProps = {
+    count: number;
+    columns: {
+        left: TableColumnDef[];
+        base: TableColumnDef[];
+        right: TableColumnDef[];
+    };
+};
+export declare const TableSkeleton: import('react').MemoExoticComponent<({ count, columns }: TableSkeletonProps) => import("react/jsx-runtime").JSX.Element>;
+export {};

package/dist/components/table/components/TableTitle.d.ts

@@ -0,0 +1,16 @@
+export declare const TableTitle: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const TableHeader: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const TableRoot: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+export declare const TableDesc: import('@emotion/styled').StyledComponent<{
+    theme?: import('@emotion/react').Theme;
+    as?: React.ElementType;
+}, import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;

package/dist/components/table/constants.d.ts

@@ -0,0 +1,25 @@
+export declare const TABLE_ATTRIBUTES: {
+    readonly ROW: "data-row";
+    readonly CELL: "data-cell";
+    readonly ROOT: "data-root";
+    readonly COLUMN_ALIGN: "data-al";
+    readonly SCROLLED: "data-scrolled";
+    readonly SORTABLE: "data-sortable";
+    readonly RESIZER: "data-resizer";
+    readonly RESIZER_SIDE: "data-side";
+    readonly ROW_SELECTED: "data-sel";
+    readonly ROW_CHILD: "data-child";
+    readonly SORTED: "data-sorted";
+    readonly HEADER_CELL: "data-header";
+    readonly INNER: "data-inner";
+    readonly AUTOSIZE: "data-autosize";
+    readonly PANEL_SIDE: "data-side";
+    readonly HEADER_GRID: "data-header-grid";
+    readonly VIRTUAL_CONTAINER: "data-virtual";
+    readonly BASE: "data-base";
+    readonly HEADERS: "data-headers";
+    readonly HEADER_GROUP: "data-header-group";
+};
+export declare const SELECT_COLUMN_FIELD = "__checkbox__";
+export declare const EXPAND_COLUMN_FIELD = "__expand__";
+export declare const TABLE_AGGREGATION_ROW_ID = "__aggregation__";

package/dist/components/table/export.d.ts

@@ -0,0 +1,9 @@
+import { TableColumnDef, TableRowModel } from './types';
+type ExportProps<T extends TableRowModel> = {
+    rows: T[];
+    columns: TableColumnDef<T>[];
+    fileName: string;
+};
+export declare const exportToExcel: <T extends TableRowModel>({ rows, columns, fileName, }: ExportProps<T>) => Promise<void>;
+export declare const exportToCSV: <T extends TableRowModel>({ rows, columns, fileName, }: ExportProps<T>) => Promise<void>;
+export {};

package/dist/components/table/helpers/columns.d.ts

@@ -0,0 +1,28 @@
+import { CSSProperties } from 'react';
+import { TableAPI } from '../api';
+import { DateColumnProps, TableColumnDef, TableColumnPin, TableColumnState, TableColumnsProp, TableRowModel } from '../types';
+import { Numbers } from './formatters';
+export declare const getDateColumn: (props?: DateColumnProps) => Partial<TableColumnDef>;
+export declare const getNumberColumn: (props?: Numbers.FormatterProps) => Partial<TableColumnDef>;
+export declare const getRatioColumn: (props?: Numbers.FormatterProps) => Partial<TableColumnDef>;
+export declare const getPercentColumn: (props?: Omit<Numbers.FormatterProps, "value">) => Partial<TableColumnDef>;
+export declare const getCurrencyColumn: (props?: Omit<Numbers.FormatterProps, "value">) => Partial<TableColumnDef>;
+export declare const getColumnId: (str: string) => string;
+export declare const getColumnsProps: <T extends TableRowModel>(type: TableColumnDef<T>["type"]) => Partial<TableColumnDef>;
+export declare const isTechnicalColumn: (col: string) => col is "__checkbox__" | "__expand__";
+export type GridAreaMap = Record<string, string>;
+export declare function filterPinnedColumns(columns: TableColumnsProp, pinnedSide?: TableColumnPin): TableColumnsProp;
+export declare const mergeColumn: (current: TableColumnDef, update?: Partial<TableColumnState>) => TableColumnState;
+export declare const getHeaderStyles: (columns: TableColumnDef[]) => CSSProperties;
+export declare const getExpandingColumn: ({ expanded, api, pinned, }: {
+    expanded: string[];
+    api: TableAPI;
+    pinned: boolean;
+}) => TableColumnState;
+export declare const getSelectionColumn: ({ selected, api, pinned, }: {
+    selected: string[];
+    api: TableAPI;
+    pinned: boolean;
+}) => TableColumnState;
+export declare const getAggregationColumns: (columns: TableColumnDef[], aggregatedRow: TableRowModel, rows: TableRowModel[]) => TableColumnDef[];
+export declare const getAggregateValue: (column: TableColumnDef, rows: TableRowModel[]) => number | null;

package/dist/components/table/helpers/formatters.d.ts

@@ -0,0 +1,76 @@
+/**
+ * A namespace containing utility functions for number parsing, validation, and formatting
+ */
+export declare namespace Numbers {
+    type AcceptableValue = number | string | null | undefined;
+    /**
+     * Parses a value into a number, handling various input types
+     * @param value - The value to parse (can be number, string, or null/undefined)
+     * @returns The parsed number or NaN if parsing fails
+     */
+    const parse: (value: AcceptableValue) => number;
+    /**
+     * Checks if a value is a positive number
+     * @param value - The value to check
+     * @returns True if the value is a positive number, false otherwise
+     */
+    const isPositive: (value: AcceptableValue) => boolean;
+    /**
+     * Checks if a value is a negative number
+     * @param v - The value to check
+     * @returns True if the value is a negative number, false otherwise
+     */
+    const isNegative: (value: AcceptableValue) => boolean;
+    const getDynamic: (v: AcceptableValue, invert?: boolean) => DynamicType | null;
+    /**
+     * Checks if a value is a valid number
+     * @param v - The value to check
+     * @returns True if the value is a valid number, false otherwise
+     */
+    const isNumber: (value: AcceptableValue) => value is number;
+    /**
+     * Type definition for number formatting styles
+     */
+    type NumberType = 'number' | 'percent' | 'currency';
+    /**
+     * Configuration options for number formatting
+     */
+    type FormatterProps = Intl.NumberFormatOptions & {
+        /** The locale to use for formatting */
+        locale?: Intl.LocalesArgument;
+        /** Whether to force decimal places */
+        decimal?: boolean;
+        /** The value to return when formatting fails */
+        invalidValue?: string;
+        /** Whether to divide the value by 100 */
+        divide?: boolean;
+        /** Whether to use short formatting */
+        short?: boolean;
+    };
+    /**
+     * Formats a number according to the specified options
+     * @param v - The value to format
+     * @param _options
+     * @returns The formatted string or the invalidValue if formatting fails
+     */
+    const format: (v: AcceptableValue, _options?: FormatterProps) => string;
+    /**
+     * Formats a number as currency
+     * @param v - The value to format
+     * @param options - Formatting options including locale and currency
+     * @returns The formatted currency string
+     */
+    const formatCurrency: (v: AcceptableValue, options?: FormatterProps) => string;
+    /**
+     * Formats a number as a percentage
+     * @param v - The value to format
+     * @param options - Formatting options including locale
+     * @returns The formatted percentage string
+     */
+    const formatPercents: (v: AcceptableValue, options?: FormatterProps) => string;
+    const dynamicTypesList: readonly ["positive", "negative", "neutral"];
+    type DynamicType = (typeof dynamicTypesList)[number];
+    const round: (value: string | number, exp?: number, type?: "round" | "floor" | "ceil") => number;
+    const formatByType: (type: NumberType, v: AcceptableValue, options?: FormatterProps) => string;
+    const getCurrencySymbol: (currency: Intl.NumberFormatOptions["currency"], locale?: Intl.LocalesArgument) => string;
+}

package/dist/components/table/hooks/TableProvider.d.ts

@@ -0,0 +1,57 @@
+import { PropsWithChildren } from 'react';
+import { CreateTableReturn } from '../store';
+import { TableProps, TableRowModel } from '../types';
+export declare const TableContext: import('react').Context<{
+    useStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<import('../store').Store>, "persist"> & {
+        persist: {
+            setOptions: (options: Partial<import('zustand/middleware').PersistOptions<import('../store').Store, {
+                sort: import('../types').TableSortModel | null;
+                search: string;
+                pageSize: number;
+                columnsOrder: string[];
+            }>>) => void;
+            clearStorage: () => void;
+            rehydrate: () => Promise<void> | void;
+            hasHydrated: () => boolean;
+            onHydrate: (fn: (state: import('../store').Store) => void) => () => void;
+            onFinishHydration: (fn: (state: import('../store').Store) => void) => () => void;
+            getOptions: () => Partial<import('zustand/middleware').PersistOptions<import('../store').Store, {
+                sort: import('../types').TableSortModel | null;
+                search: string;
+                pageSize: number;
+                columnsOrder: string[];
+            }>>;
+        };
+    }>;
+    api: {
+        setPageSize: (v: number) => void;
+        setPage: (v: number) => void;
+        setSort: (v: import('../types').TableSortModel | null) => void;
+        downloadCSV: () => void;
+        downloadExcel: () => void;
+        setSelected: (selected: string[]) => void;
+        toggleColumn: (v: string) => void;
+        setVisibleColumns: (v: string[]) => void;
+        setSearch: (v: string) => void;
+        setPrevPage: () => void;
+        setNextPage: () => void;
+        setColumnWidth: (field: string, setWidth: number) => void;
+        toggleRowExpand: (id: string) => void;
+        setRootRef: (rootRef: HTMLDivElement) => void;
+        setScrollRef: (scrollRef: HTMLDivElement) => void;
+        calculateColumnWidths: (clear?: boolean) => void;
+        selectVisibleRows: () => void;
+        unselectVisibleRows: () => void;
+        unselectRow: (id: string) => void;
+        selectRow: (id: string) => void;
+        setAutosize: () => void;
+        removeAutosize: () => void;
+        setColumnsOrder: (columnsOrder: string[]) => void;
+        setColumnOrder: (columnId: string, index: number) => void;
+        moveColumnLeft: (columnId: string) => void;
+        moveColumnRight: (columnId: string) => void;
+    };
+}>;
+export declare const TableProvider: <ITEM extends TableRowModel>({ children, store, rows, columns, loading, pageSizeOptions, rowHeight, headerHeight, rowCount, exportFileName, pagination, virtualization, searching, selection, sorting, expanding, }: PropsWithChildren<{
+    store: CreateTableReturn;
+} & TableProps<ITEM>>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/table/hooks/useColumnsResizing.d.ts

@@ -0,0 +1,5 @@
+import { MutableRefObject } from 'react';
+export declare const useColumnsResizing: (resizing: MutableRefObject<boolean>) => {
+    onPointerDown: (...args: any) => any;
+    onDragStart: import('react').DragEventHandler;
+};