@veeqo/ui 0.0.4 → 0.0.7

package/dist/esm/types/components/DataTable/cells/styled.d.ts

@@ -0,0 +1 @@
+export declare const CellButton: import("styled-components").StyledComponent<"button", any, {}, never>;

package/dist/esm/types/components/DataTable/styled.d.ts

@@ -0,0 +1,46 @@
+import { NoWrapType, StripedType } from './utils/types';
+import { ScrollPosition } from './utils/constants';
+type WrapperPropTypes = {
+    scrollDisabled: boolean;
+    scrollPosition?: ScrollPosition;
+    lastStartFixedColumnsIndex?: number;
+    firstEndFixedColumnsIndex?: number;
+    showScrollbar?: boolean;
+};
+export declare const TooltipContent: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Wrapper: import("styled-components").StyledComponent<"div", any, WrapperPropTypes, never>;
+export declare const WrapperBordered: import("styled-components").StyledComponent<"div", any, WrapperPropTypes, never>;
+export declare const Head: import("styled-components").StyledComponent<"thead", any, {}, never>;
+export declare const Body: import("styled-components").StyledComponent<"tbody", any, {
+    fixedColumnsStyle?: string | undefined;
+}, never>;
+export declare const Foot: import("styled-components").StyledComponent<"tfoot", any, {}, never>;
+export interface RowProps {
+    accentColor?: string;
+}
+export declare const Row: import("styled-components").StyledComponent<"tr", any, RowProps, never>;
+export interface CellProps {
+    align?: 'left' | 'center' | 'right';
+    grow?: boolean;
+}
+export declare const Cell: import("styled-components").StyledComponent<"td", any, CellProps, never>;
+export declare const HeaderCell: import("styled-components").StyledComponent<"td", any, CellProps & {
+    as: string;
+}, "as">;
+export interface HeaderCellLayoutProps {
+    align?: 'left' | 'center' | 'right';
+}
+export declare const HeaderCellLayout: import("styled-components").StyledComponent<"div", any, HeaderCellLayoutProps, never>;
+type TablePropTypes = {
+    striped?: StripedType;
+    noWrap?: NoWrapType;
+    tableLoading?: boolean;
+    isFixedLayout?: boolean;
+};
+export declare const Table: import("styled-components").StyledComponent<"table", any, TablePropTypes, never>;
+export declare const Footer: import("styled-components").StyledComponent<"tfoot", any, {
+    fixedColumnsStyle?: string | undefined;
+}, never>;
+export declare const StickyHeaderWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const FakeHeaderTable: import("styled-components").StyledComponent<"table", any, TablePropTypes, never>;
+export {};

package/dist/esm/types/components/DataTable/utils/constants.d.ts

@@ -0,0 +1,9 @@
+import { SpecificStateType } from './types';
+export declare const defaultEmptyState: SpecificStateType;
+export declare const defaultErrorState: SpecificStateType;
+export declare enum ScrollPosition {
+    start = "start",
+    middle = "middle",
+    end = "End",
+    none = "none"
+}

package/dist/esm/types/components/DataTable/utils/hooks.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+export declare const useStickyHeader: (tableRef: React.RefObject<HTMLTableElement | null>, topOffset?: number) => {
+    isSticky: boolean;
+};

package/dist/esm/types/components/DataTable/utils/index.d.ts

@@ -0,0 +1,2 @@
+import { FixedColumnInlineStyle } from './types';
+export declare const convertFixedColumnInlineStyleToStyled: (fixedColumnsStyle: FixedColumnInlineStyle[]) => string;

package/dist/esm/types/components/DataTable/utils/types.d.ts

@@ -0,0 +1,106 @@
+import { ReactNode, CSSProperties } from 'react';
+export type DataTableId = string | number;
+export type RowData = any;
+export type DataTableHeader = {
+    id: DataTableId;
+    title?: string;
+    icon?: ReactNode;
+    tooltip?: string;
+    align?: 'left' | 'center' | 'right';
+    sortable?: boolean;
+    grow?: boolean;
+    width?: number | string;
+    skeleton?: string;
+    skeletonStyle?: CSSProperties;
+};
+export type DataTableRow = {
+    id: DataTableId;
+    data: RowData;
+    nestedRows?: DataTableNestedRow[];
+    accentColor?: string;
+};
+export type DataTableNestedRow = {
+    id: DataTableId;
+    data: RowData;
+};
+export type DataTableSortDirection = 'ascending' | 'descending';
+export type DataTableSelectionMode = 'multiple' | 'single';
+export type SpecificStates = '' | 'empty' | 'emptyWithSearch' | 'error';
+export type SpecificStateType = {
+    icon: ReactNode;
+    title: string;
+    subTitle?: string;
+};
+export type StripedType = boolean;
+export type NoWrapType = boolean;
+export type ShowScrollbarType = boolean;
+/**
+ * DataTable properties.
+ */
+export interface DataTableProps {
+    /** Removes the outer border */
+    borderless?: boolean;
+    /** Enables row zebra striping */
+    striped?: StripedType;
+    /** Disables text wrapping in header cells */
+    noWrap?: NoWrapType;
+    /** Forces OSX to render scrollbars */
+    showScrollbar?: ShowScrollbarType;
+    /** Configure column headers */
+    headers?: DataTableHeader[];
+    /** Configure content rows */
+    rows: DataTableRow[];
+    /** Render a content row */
+    renderRow: (row: DataTableRow) => ReactNode;
+    /** Render a nested content row */
+    renderNestedRow?: (nestedRow: DataTableNestedRow) => ReactNode;
+    /** List of row IDs that are expanded - their nested rows will be rendered */
+    expandedRowIds?: DataTableId[];
+    /** Render a content row when in the LOADING state */
+    renderLoadingRow?: () => ReactNode;
+    /** Render a footer row */
+    renderFooterRow?: (rows: DataTableRow[]) => ReactNode;
+    /** Render a footer row when in the LOADING state */
+    renderFooterLoadingRow?: () => ReactNode;
+    /** Hides the extra first cell added to the footer when row selection is enabled */
+    omitFooterSelectionCell?: boolean;
+    /** List of selected row IDs */
+    selectedRowIds?: Array<DataTableId>;
+    /** Sets the mode of row selection */
+    selectionMode?: DataTableSelectionMode;
+    /** Disable ability to select specified rows */
+    disabledSelectionInputRowIds?: DataTableId[];
+    /** Event triggered when rows are selected/deselected */
+    onChangeSelectedRowIds?: (selectedRowIds: Array<DataTableId>) => void;
+    /** Current sorted column ID (see headers config) */
+    sortColumnId?: DataTableId;
+    /** Current sort direction */
+    sortDirection?: DataTableSortDirection;
+    /** Event triggered when sortable column headers are clicked */
+    onChangeSort?: (columnId: DataTableId, direction: DataTableSortDirection) => void;
+    /** Shows the ERROR state */
+    isError: boolean;
+    /** Shows the LOADING state */
+    isLoading: boolean;
+    /** Default number of rows shown in LOADING state */
+    skeletonRowsNumber?: number;
+    /** Enables sticky headers row */
+    isHeaderSticky?: boolean;
+    /** Custom styles for stick header container - e.g. adding `top` offset */
+    stickyHeaderStyle?: CSSProperties;
+    /**
+     * Config object to show custom content when in ERROR or EMPTY states.
+     * Accepts `title`, `subTitle` and `icon`.
+     * */
+    customSpecificState?: SpecificStateType;
+    /** Override the table content height when using customSpecificState */
+    bodyHeightInSpecificStates?: number;
+    /** Number of fixed columns at the start of the table */
+    startFixedColumnsNumber?: number;
+    /** Number of fixed columns at the end of the table */
+    endFixedColumnsNumber?: number;
+}
+export type FixedColumnInlineStyle = {
+    index: number;
+    style: CSSProperties;
+};

package/dist/esm/types/components/DataTableExp/DataTable.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { DataTableProps } from './types';
+import { ColumnMenu } from './components/ColumnMenu';
+import { SelectionCell } from './components/SelectionCell';
+import { SelectionHeader } from './components/SelectionHeader';
+export declare const DataTableExp: {
+    ({ ActionBarSlot, borderMode, columns, emptyState, expandedRowIds, loading, loadingRowCount, onChangeSort, rows, disabledRowIds, selectionMode, selectionState, setExpanded, sortState, stripingMode, enableStickyHeader, }: DataTableProps): React.JSX.Element;
+    defaultProps: {
+        loading: boolean;
+        loadingRowCount: number;
+        selectionMode: string;
+        stripingMode: string;
+        enableStickyHeader: boolean;
+    };
+    Cell: import("styled-components").StyledComponent<"td", any, import("./components/Cell").CellProps, never>;
+    ColumnMenu: typeof ColumnMenu;
+    SelectionCell: typeof SelectionCell;
+    SelectionHeader: typeof SelectionHeader;
+    Header: import("styled-components").StyledComponent<"th", any, import("./types").HeaderProps, never>;
+    Truncate: import("styled-components").StyledComponent<"div", any, {}, never>;
+    NoWrap: import("styled-components").StyledComponent<"div", any, {}, never>;
+};

package/dist/esm/types/components/DataTableExp/components/ActionBar.d.ts

@@ -0,0 +1,9 @@
+import React, { RefObject, ReactNode } from 'react';
+import { ColumnConfig } from '../types';
+export interface ActionBarProps {
+    children: ReactNode;
+    selectionColumn: ColumnConfig;
+    intersectionTargetRef: RefObject<HTMLElement>;
+    containerRef: RefObject<HTMLElement>;
+}
+export declare function ActionBar({ selectionColumn, intersectionTargetRef, containerRef, children, }: ActionBarProps): React.JSX.Element;

package/dist/esm/types/components/DataTableExp/components/Cell.d.ts

@@ -0,0 +1,7 @@
+import { ColumnAlignment, ColumnSpacing } from '../types';
+export interface CellProps {
+    align?: ColumnAlignment;
+    spacing?: ColumnSpacing;
+    span?: number;
+}
+export declare const Cell: import("styled-components").StyledComponent<"td", any, CellProps, never>;

package/dist/esm/types/components/DataTableExp/components/ColumnHeader.d.ts

@@ -0,0 +1,6 @@
+export declare const SortIndicator: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const HeaderContent: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const ClickableHeaderContent: import("styled-components").StyledComponent<"span", any, {
+    as: string;
+    type: string;
+}, "type" | "as">;

package/dist/esm/types/components/DataTableExp/components/ColumnMenu.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ColumnConfigs, ColumnId } from '../types';
+export interface ColumnMenuProps {
+    columns: ColumnConfigs;
+    columnGroups: ColumnId[][];
+    setColumns: (columns: ColumnConfigs) => void;
+}
+export declare function ColumnMenu({ columns, columnGroups, setColumns }: ColumnMenuProps): React.JSX.Element;

package/dist/esm/types/components/DataTableExp/components/EmptyBodyContent.d.ts

@@ -0,0 +1,5 @@
+export interface EmptyBodyContentProps {
+    columnCount: number;
+}
+export declare const EmptyBodyContent: import("styled-components").StyledComponent<"div", any, EmptyBodyContentProps, never>;
+export declare const EmptyBodyGlyphWrapper: import("styled-components").StyledComponent<"div", any, {}, never>;

package/dist/esm/types/components/DataTableExp/components/Header.d.ts

@@ -0,0 +1,2 @@
+import { HeaderProps } from '../types';
+export declare const Header: import("styled-components").StyledComponent<"th", any, HeaderProps, never>;

package/dist/esm/types/components/DataTableExp/components/LoadingCellContent.d.ts

@@ -0,0 +1 @@
+export declare const LoadingCellContent: import("styled-components").StyledComponent<"div", any, {}, never>;

package/dist/esm/types/components/DataTableExp/components/NoWrap.d.ts

@@ -0,0 +1 @@
+export declare const NoWrap: import("styled-components").StyledComponent<"div", any, {}, never>;

package/dist/esm/types/components/DataTableExp/components/Row.d.ts

@@ -0,0 +1,7 @@
+export interface RowProps {
+    accentColor?: string;
+    selected?: boolean;
+    expanded?: boolean;
+    disabled?: boolean;
+}
+export declare const Row: import("styled-components").StyledComponent<"tr", any, RowProps, never>;

package/dist/esm/types/components/DataTableExp/components/ScrollContainer.d.ts

@@ -0,0 +1 @@
+export declare const ScrollContainer: import("styled-components").StyledComponent<"div", any, {}, never>;

package/dist/esm/types/components/DataTableExp/components/SelectionCell.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { CellProps } from './Cell';
+import { RowId, SelectionMode } from '../types';
+export interface SelectionCellProps extends CellProps {
+    rowId: RowId;
+    selected: boolean;
+    onChange: (selected: boolean, value: RowId | undefined) => void;
+    selectionMode: SelectionMode;
+    disabled: boolean;
+}
+export declare function SelectionCell({ selected, rowId, onChange, selectionMode, disabled, ...cellProps }: SelectionCellProps): React.JSX.Element;

package/dist/esm/types/components/DataTableExp/components/SelectionHeader.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { SelectionHeaderProps } from '../types';
+export declare function SelectionHeader({ selected, indeterminate, onChange, selectionMode, ...headerProps }: SelectionHeaderProps): React.JSX.Element;

package/dist/esm/types/components/DataTableExp/components/StickyHead.d.ts

@@ -0,0 +1,9 @@
+import React, { ReactNode, RefObject } from 'react';
+export interface StickyHeadProps {
+    tableCss: string;
+    children?: ReactNode;
+    intersectionTargetRef: RefObject<HTMLElement>;
+    containerRef: RefObject<HTMLElement>;
+    cellWidths: number[];
+}
+export declare function StickyHead({ children, intersectionTargetRef, containerRef, cellWidths, tableCss, }: StickyHeadProps): React.JSX.Element | null;

package/dist/esm/types/components/DataTableExp/components/TableGrid.d.ts

@@ -0,0 +1,4 @@
+export interface TableGridProps {
+    css: string;
+}
+export declare const TableGrid: import("styled-components").StyledComponent<"table", any, TableGridProps, never>;

package/dist/esm/types/components/DataTableExp/components/Truncate.d.ts

@@ -0,0 +1 @@
+export declare const Truncate: import("styled-components").StyledComponent<"div", any, {}, never>;

package/dist/esm/types/components/DataTableExp/components/Wrapper.d.ts

@@ -0,0 +1,5 @@
+import { BorderMode } from '../types';
+export interface WrapperProps {
+    borderMode?: BorderMode;
+}
+export declare const Wrapper: import("styled-components").StyledComponent<"div", any, WrapperProps, never>;

package/dist/esm/types/components/DataTableExp/constants.d.ts

@@ -0,0 +1,3 @@
+export declare const defaultCellSpacing = 3;
+export declare const headerCellHeight = "56px";
+export declare const footerCellHeight = "56px";

package/dist/esm/types/components/DataTableExp/hooks/useCellWidths.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useCellWidths(tableRef: RefObject<HTMLElement>, containerRef: RefObject<HTMLElement>): number[];

package/dist/esm/types/components/DataTableExp/hooks/useColumns.d.ts

@@ -0,0 +1,6 @@
+import { ColumnConfigs } from '../types';
+export declare function useColumns(columns: ColumnConfigs): {
+    visible: import("../types").ColumnConfig[];
+    pinnedLeft: import("../types").ColumnConfig[];
+    pinnedRight: import("../types").ColumnConfig[];
+};

package/dist/esm/types/components/DataTableExp/hooks/useDragToScroll.d.ts

@@ -0,0 +1,2 @@
+import { RefObject } from 'react';
+export declare function useDragToScroll(targetRef: RefObject<HTMLElement>): void;

package/dist/esm/types/components/DataTableExp/hooks/useNested.d.ts

@@ -0,0 +1,7 @@
+import { RowId, SetExpandedAction } from '../types';
+export declare function useNested(): {
+    nestedTableProps: {
+        expandedRowIds: RowId[];
+        setExpanded: SetExpandedAction;
+    };
+};

package/dist/esm/types/components/DataTableExp/hooks/useScrollPosition.d.ts

@@ -0,0 +1,6 @@
+import { RefObject } from 'react';
+import { ScrollPosition } from '../types';
+export declare function useScrollPosition(containerRef: RefObject<HTMLElement>): {
+    scrollPosition: ScrollPosition;
+    containerRef: RefObject<HTMLElement>;
+};

package/dist/esm/types/components/DataTableExp/hooks/useSelection.d.ts

@@ -0,0 +1,12 @@
+import { ColumnConfig, RowId, SelectionState, SelectionMode, SetSelectedAction } from '../types';
+export type UseSelectionConfig = {
+    selectionMode?: SelectionMode;
+    selectionState?: SelectionState;
+    enabledRowIds: RowId[];
+};
+export declare function useSelection({ selectionMode, selectionState, enabledRowIds, }: UseSelectionConfig): {
+    selectionEnabled: boolean;
+    selectedRowIds: RowId[];
+    selectionColumn: ColumnConfig;
+    setSelected: SetSelectedAction;
+};

package/dist/esm/types/components/DataTableExp/renderers/renderCell.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { TableRow, ColumnConfig, TableActions, RowState } from '../types';
+/**
+ * Default renderer for table cells
+ *
+ * @param row
+ * @param column
+ * @returns
+ */
+export declare function renderCell(row: TableRow, column: ColumnConfig, actions: TableActions, rowState: RowState): ReactNode;

package/dist/esm/types/components/DataTableExp/renderers/renderFooter.d.ts

@@ -0,0 +1,13 @@
+import { ReactNode } from 'react';
+import { ColumnConfig } from '../types';
+type RenderFooterParameters = {
+    column: ColumnConfig;
+};
+/**
+ * Default renderer for table footer cells
+ *
+ * @param column Column configuration object
+ * @returns Footer cell instance
+ */
+export declare function renderFooter({ column }: RenderFooterParameters): ReactNode;
+export {};

package/dist/esm/types/components/DataTableExp/renderers/renderHeader.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+import { ColumnConfig, SortState, SortChangeHandler } from '../types';
+type RenderHeaderParameters = {
+    column: ColumnConfig;
+    sortState?: SortState;
+    onChangeSort?: SortChangeHandler;
+};
+/**
+ * Default renderer for table header cells
+ *
+ * @param column Column configuration object
+ * @returns Header cell instance
+ */
+export declare function renderHeader({ column, sortState, onChangeSort, }: RenderHeaderParameters): ReactNode;
+export {};

package/dist/esm/types/components/DataTableExp/renderers/renderLoadingCell.d.ts

@@ -0,0 +1,9 @@
+import { ReactNode } from 'react';
+import { TableRow, ColumnConfig } from '../types';
+/**
+ * Default renderer for loading cells
+ * @param row
+ * @param column
+ * @returns
+ */
+export declare function renderLoadingCell(row: TableRow, column: ColumnConfig): ReactNode;

package/dist/esm/types/components/DataTableExp/renderers/renderNestedCell.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { NestedTableRow, ColumnConfig, RowState } from '../types';
+/**
+ * Default renderer for table cells in nested rows
+ *
+ * @param nestedRow
+ * @param column
+ * @returns
+ */
+export declare function renderNestedCell(nestedRow: NestedTableRow, column: ColumnConfig, rowState: RowState): ReactNode;

package/dist/esm/types/components/DataTableExp/types.d.ts

@@ -0,0 +1,116 @@
+import { ReactNode } from 'react';
+import { Size } from '../Stack/types';
+export type BorderType = 'all' | 'vertical' | 'none';
+export type ScrollPosition = 'none' | 'start' | 'middle' | 'end';
+export type RowState = {
+    selected: boolean;
+    expanded: boolean;
+    disabled: boolean;
+};
+export type ColumnId = string | number;
+export type ColumnAlignment = 'left' | 'center' | 'right';
+export type ColumnOverflow = 'none' | 'wrap' | 'truncate';
+export type ColumnPinned = 'left' | 'right' | 'none';
+export type ColumnSpacing = Size;
+export type ColumnWidth = number | string;
+export type ColumnWidthFixed = ColumnWidth;
+export type ColumnWidthBounded = {
+    min?: ColumnWidth;
+    max?: ColumnWidth;
+};
+export type ColumnConfig = {
+    id: ColumnId;
+    align?: ColumnAlignment;
+    hidden?: boolean;
+    icon?: Omit<ReactNode, string>;
+    pinned?: ColumnPinned;
+    sortable?: boolean;
+    spacing?: ColumnSpacing;
+    span?: number;
+    title?: string;
+    tooltip?: string;
+    width?: ColumnWidthFixed | ColumnWidthBounded;
+    renderCell: CellRenderer;
+    renderFooter?: FooterRenderer;
+    renderHeader?: HeaderRenderer;
+    renderNestedCell?: NestedCellRenderer;
+};
+export type ColumnConfigs = Array<ColumnConfig>;
+export declare enum SortDirection {
+    ascending = "ascending",
+    descending = "descending"
+}
+export type SortDirectionType = keyof typeof SortDirection;
+export type SortState = {
+    columnId: ColumnId;
+    direction: SortDirection;
+};
+export type SortChangeHandler = (sortState: SortState) => void;
+export type RowId = number | string;
+export interface NestedTableRow {
+    id: RowId;
+    data: any;
+}
+export type NestedTableRows = Array<NestedTableRow>;
+export interface TableRow {
+    id: RowId;
+    data: any;
+    nestedRows?: NestedTableRows;
+    accentColor?: string;
+    e2eClassName?: string;
+}
+export type TableRows = Array<TableRow>;
+export interface HeaderProps extends React.HtmlHTMLAttributes<HTMLTableCellElement> {
+    id: string;
+    align?: ColumnAlignment;
+    spacing?: ColumnSpacing;
+    span?: number;
+}
+export interface RendererHeaderProps extends HeaderProps {
+    key: string;
+}
+export interface SelectionHeaderProps extends Omit<HeaderProps, 'onChange'> {
+    selected: boolean;
+    indeterminate: boolean;
+    onChange: (selected: boolean, value: RowId | undefined) => void;
+    selectionMode: SelectionMode;
+}
+export type HeaderRenderer = (column: ColumnConfig, headerProps: RendererHeaderProps) => ReactNode;
+export type FooterRenderer = (column: ColumnConfig, footerProps: object) => ReactNode;
+export type CellRenderer = (row: TableRow, cellProps: object, actions: TableActions, rowState: RowState) => ReactNode;
+type ParentRowState = RowState;
+export type NestedCellRenderer = (nestedRow: NestedTableRow, cellProps: object, parentRowState: ParentRowState) => ReactNode;
+export type SetSelectedAction = (selected: boolean, rowId: RowId | undefined) => void;
+export type SetExpandedAction = (expanded: boolean, rowId: RowId | undefined) => void;
+export type TableActions = {
+    setSelected: SetSelectedAction;
+    setExpanded: SetExpandedAction;
+};
+export type BorderMode = 'full' | 'vertical' | 'none';
+export type CustomState = {
+    icon: ReactNode;
+    heading: string;
+    subheading?: string;
+};
+export type SelectionMode = 'single' | 'multiple';
+export type SelectionState = [RowId[], (rowIds: RowId[]) => void];
+export type StripingMode = 'row' | 'nested';
+export interface DataTableProps {
+    ActionBarSlot?: ReactNode;
+    borderMode?: BorderMode;
+    columns: ColumnConfigs;
+    disabledRowIds?: Array<RowId>;
+    enableStickyHeader?: boolean;
+    emptyState?: CustomState;
+    expandedRowIds?: Array<RowId>;
+    loading?: boolean;
+    loadingRowCount?: number;
+    onChangeSort?: SortChangeHandler;
+    rows: TableRows;
+    selectionMode?: SelectionMode;
+    selectionState?: SelectionState;
+    setExpanded?: SetExpandedAction;
+    sortState?: SortState;
+    stripingMode?: StripingMode;
+}
+export {};

package/dist/esm/types/components/DataTableExp/utils/GetSortIcon.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { ColumnId, SortState } from '../types';
+type GetSortIconPropsParameters = {
+    sortState?: SortState;
+    columnId: ColumnId;
+    size: string;
+};
+export declare const GetSortIcon: ({ sortState, columnId, size }: GetSortIconPropsParameters) => React.JSX.Element;
+export {};

package/dist/esm/types/components/DataTableExp/utils/alignmentToFlex.d.ts

@@ -0,0 +1,2 @@
+import { ColumnAlignment } from '../types';
+export declare function alignmentToFlex(align: ColumnAlignment): "center" | "flex-end" | "flex-start";

package/dist/esm/types/components/DataTableExp/utils/generateTableCss.d.ts

@@ -0,0 +1,10 @@
+import { ColumnConfigs, ScrollPosition, StripingMode } from '../types';
+export type GenerateTableCssArgs = {
+    pinnedLeft: ColumnConfigs;
+    pinnedRight: ColumnConfigs;
+    cellWidths: Array<number>;
+    scrollPosition: ScrollPosition;
+    visible: ColumnConfigs;
+    stripingMode?: StripingMode;
+};
+export declare function generateTableCss({ pinnedLeft, pinnedRight, cellWidths, scrollPosition, visible, stripingMode, }: GenerateTableCssArgs): string;

package/dist/esm/types/components/DataTableExp/utils/getNextSortState.d.ts

@@ -0,0 +1,7 @@
+import { ColumnId, SortState } from '../types';
+type GetNewSortValuesParameters = {
+    sortState: SortState;
+    columnId: ColumnId;
+};
+export declare function getNextSortState({ sortState, columnId }: GetNewSortValuesParameters): SortState;
+export {};

package/dist/esm/types/components/DataTableExp/utils/getRowState.d.ts

@@ -0,0 +1,10 @@
+import type { RowId } from '../types';
+export declare const getRowState: (rowId: RowId, { selectedRowIds, expandedRowIds, disabledRowIds, }: Partial<{
+    selectedRowIds: RowId[];
+    expandedRowIds: RowId[];
+    disabledRowIds: RowId[];
+}>) => {
+    selected: boolean;
+    expanded: boolean;
+    disabled: boolean;
+};

package/dist/esm/types/components/DataTableExp/utils/parseWidth.d.ts

@@ -0,0 +1 @@
+export declare function parseWidth(width: any, fallback?: string): string;

package/dist/esm/types/components/DataTableExp/utils/sumAll.d.ts

@@ -0,0 +1,2 @@
+export declare function sumAllBeforeIndex(array: Array<any>, index: number): any;
+export declare function sumAllAfterIndex(array: Array<any>, index: number): any;

package/dist/esm/types/components/DescriptionList/DescriptionList.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+type DescriptionListItem = {
+    term: string;
+    description: string | string[];
+};
+export interface DescriptionListProps {
+    items: DescriptionListItem[];
+    horizontal?: boolean;
+}
+export declare const DescriptionList: ({ items, horizontal }: DescriptionListProps) => React.JSX.Element;
+export {};

package/dist/esm/types/components/DetailPage/DetailPage.d.ts

@@ -0,0 +1,6 @@
+import React, { ReactNode } from 'react';
+export interface PageHeaderProps {
+    renderHeader: (toggleSidebar: () => void, shouldShowSidebar?: boolean) => ReactNode;
+    children: ReactNode;
+}
+export declare const DetailPage: ({ renderHeader, children }: PageHeaderProps) => React.JSX.Element;

package/dist/esm/types/components/DetailPage/styled.d.ts

@@ -0,0 +1,2 @@
+export declare const ColumnGrid: import("styled-components").StyledComponent<"div", any, any, never>;
+export declare const ContentContainer: import("styled-components").StyledComponent<"div", any, {}, never>;

package/dist/esm/types/components/DimensionsInput/DimensionsInput.d.ts

@@ -0,0 +1,3 @@
+import { FC } from 'react';
+import { DimensionsProps } from './types';
+export declare const DimensionsInput: FC<DimensionsProps>;