@veeqo/ui 0.0.1 → 0.0.4

package/lib/components/Button/types.d.ts

@@ -0,0 +1,18 @@
+import { ReactNode, ButtonHTMLAttributes } from 'react';
+export type ButtonVariant = 'default' | 'destructive' | 'primary' | 'primaryDestructive' | 'flat' | 'link' | 'unstyled';
+/**
+ * Button properties.
+ */
+export type ButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & {
+    children?: ReactNode;
+    /** Variant styles */
+    variant?: ButtonVariant;
+    /** Button sizes */
+    size?: 'sm' | 'base';
+    /** Icon */
+    icon?: ReactNode;
+    /** Renders a dropdown indicator inside the button */
+    dropdown?: boolean;
+    /** Renders a loading indicator inside the button */
+    loading?: boolean;
+};

package/lib/components/Card/Card.d.ts

@@ -0,0 +1,28 @@
+import React, { ReactNode } from 'react';
+import { CardElevation } from './styled';
+type CardAction = {
+    title: string;
+    onClick: () => void;
+};
+export type CardProps = {
+    className?: string;
+    style?: React.CSSProperties;
+    title?: string;
+    subtitle?: string;
+    HeaderActionSlot?: React.ReactNode;
+    action?: CardAction;
+    collapsable?: boolean;
+    elevation?: CardElevation;
+    accent?: 'info' | 'success' | 'error';
+    children: ReactNode;
+    onClose?: () => void;
+    renderFooter?: () => ReactNode;
+};
+export declare const Card: {
+    ({ className, style, title, subtitle, HeaderActionSlot, action, collapsable, elevation, accent, children, onClose, renderFooter, }: CardProps): React.JSX.Element;
+    Surface: import("styled-components").StyledComponent<"div", any, import("./styled").SurfaceProps, never>;
+    Section: import("styled-components").StyledComponent<"section", any, {}, never>;
+    FullBleed: import("styled-components").StyledComponent<"div", any, {}, never>;
+    Footer: import("styled-components").StyledComponent<"footer", any, {}, never>;
+};
+export {};

package/lib/components/Card/index.d.ts

@@ -0,0 +1 @@
+export { Card } from './Card';

package/lib/components/Card/styled.d.ts

@@ -0,0 +1,16 @@
+export type CardElevation = 0 | 1 | 2 | 3 | 4;
+declare const accents: {
+    info: string;
+    success: string;
+    error: string;
+};
+export declare const Footer: import("styled-components").StyledComponent<"footer", any, {}, never>;
+export declare const Section: import("styled-components").StyledComponent<"section", any, {}, never>;
+export declare const FullBleed: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Body: import("styled-components").StyledComponent<import("framer-motion").ForwardRefComponent<HTMLDivElement, import("framer-motion").HTMLMotionProps<"div">>, any, {}, never>;
+export interface SurfaceProps {
+    elevation?: CardElevation;
+    accent?: keyof typeof accents;
+}
+export declare const Surface: import("styled-components").StyledComponent<"div", any, SurfaceProps, never>;
+export {};

package/lib/components/CardHeader/CardHeader.d.ts

@@ -0,0 +1,19 @@
+import React from 'react';
+import { HeaderVariant } from '../Text/types';
+type CardHeaderAction = {
+    title: string;
+    onClick: () => void;
+};
+export interface CardHeaderProps {
+    id?: string;
+    title?: string;
+    subtitle?: string;
+    headerVariant?: HeaderVariant;
+    action?: CardHeaderAction;
+    ActionSlot?: React.ReactNode;
+    isCollapsed?: boolean;
+    onClickCollapse?: () => void;
+    onClickClose?: () => void;
+}
+export declare const CardHeader: ({ id, title, subtitle, headerVariant, action, ActionSlot, isCollapsed, onClickCollapse, onClickClose, }: CardHeaderProps) => React.JSX.Element;
+export {};

package/lib/components/CardHeader/index.d.ts

@@ -0,0 +1 @@
+export { CardHeader } from './CardHeader';

package/lib/components/CardHeader/styled.d.ts

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

package/lib/components/Checkbox/Checkbox.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { ForwardedChoiceProps } from '../Choice';
+export type CheckboxValue = string | number;
+export interface CheckboxProps extends ForwardedChoiceProps {
+    checked: boolean;
+    indeterminate?: boolean;
+    value?: CheckboxValue;
+    name?: string;
+    disabled?: boolean;
+    ariaLabel?: string;
+    onChange: (checked: boolean, value?: CheckboxValue) => void;
+}
+export declare const Checkbox: ({ checked, indeterminate, value, name, disabled, ariaLabel, onChange, ...otherProps }: CheckboxProps) => React.JSX.Element;

package/lib/components/Checkbox/index.d.ts

@@ -0,0 +1 @@
+export { Checkbox } from './Checkbox';

package/lib/components/Checkbox/styled.d.ts

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

package/lib/components/Choice/Choice.d.ts

@@ -0,0 +1,17 @@
+import React, { ReactNode } from 'react';
+export interface ForwardedChoiceProps {
+    disabled?: boolean;
+    label?: string;
+    hint?: string;
+    tooltip?: string;
+    error?: string;
+    bordered?: boolean;
+    Badge?: ReactNode;
+    Accessory?: ReactNode;
+    Footer?: ReactNode;
+}
+export interface ChoiceProps extends ForwardedChoiceProps {
+    id: string;
+    children: ReactNode;
+}
+export declare const Choice: ({ id, label, hint, tooltip, error, bordered, Badge, Accessory, Footer, children, disabled, }: ChoiceProps) => React.JSX.Element;

package/lib/components/Choice/components/styled.d.ts

@@ -0,0 +1,17 @@
+export declare const RootLayout: import("styled-components").StyledComponent<"div", any, {}, never>;
+export interface InputLayoutProps {
+    align: 'top' | 'center';
+}
+export declare const InputLayout: import("styled-components").StyledComponent<"div", any, InputLayoutProps, never>;
+export declare const AccessoryLayout: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const TextLayout: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const LabelText: import("styled-components").StyledComponent<"span", any, {}, never>;
+export declare const HintText: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const ErrorText: import("styled-components").StyledComponent<"div", any, {}, never>;
+export declare const Wrapper: import("styled-components").StyledComponent<"label", any, {
+    disabled: boolean;
+}, never>;
+export declare const BorderedWrapper: import("styled-components").StyledComponent<"label", any, {
+    disabled: boolean;
+}, never>;
+export declare const BlockTooltip: import("styled-components").StyledComponent<({ children, text, content, config, reversed, className, withTriangle, initialShouldShow, useReactPortal, }: import("../../Tooltip/types").TooltipProps) => JSX.Element | null, any, {}, never>;

package/lib/components/Choice/index.d.ts

@@ -0,0 +1 @@
+export * from './Choice';

package/lib/components/ChoiceList/ChoiceList.d.ts

@@ -0,0 +1,29 @@
+import React, { Component, ReactNode } from 'react';
+type ChoiceListOptionValue = string | number;
+export interface ChoiceListOption {
+    value: ChoiceListOptionValue;
+    name?: string;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+    Badge?: ReactNode;
+    Accessory?: ReactNode;
+    Footer?: ReactNode;
+}
+export interface ChoiceListProps {
+    options: ChoiceListOption[];
+    selected: ChoiceListOptionValue[];
+    title?: string;
+    allowMultiple?: boolean;
+    disabled?: boolean;
+    bordered?: boolean;
+    error?: string;
+    onChange: (selected: ChoiceListOptionValue[]) => void;
+}
+export declare class ChoiceList extends Component<ChoiceListProps> {
+    handleChange: (value: ChoiceListOptionValue, checked: boolean) => void;
+    handleChangeSingle: (value: ChoiceListOptionValue, checked: boolean) => void;
+    handleChangeMultiple: (value: ChoiceListOptionValue, checked: boolean) => void;
+    render(): React.JSX.Element;
+}
+export {};

package/lib/components/ChoiceList/index.d.ts

@@ -0,0 +1 @@
+export { ChoiceList } from './ChoiceList';

package/lib/components/ChoiceList/styled.d.ts

@@ -0,0 +1,2 @@
+export declare const Fieldset: import("styled-components").StyledComponent<"fieldset", any, {}, never>;
+export declare const Legend: import("styled-components").StyledComponent<"legend", any, {}, never>;

package/lib/components/CopyToClipboard/CopyToClipboard.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+export interface CopyToClipboardProps {
+    className?: string;
+    text: string;
+    onCopy?: () => void;
+}
+/**
+ * A dynamic button to facilitate copying text to a users' keyboard when clicked.
+ */
+export declare const CopyToClipboard: ({ className, text, onCopy }: CopyToClipboardProps) => React.JSX.Element;

package/lib/components/CopyToClipboard/index.d.ts

@@ -0,0 +1 @@
+export { CopyToClipboard } from './CopyToClipboard';

package/lib/components/DataTable/DataTable.d.ts

@@ -0,0 +1,21 @@
+import React from 'react';
+import { DataTableProps } from './utils/types';
+export declare const IconUnsorted: () => React.JSX.Element;
+export declare const IconSortAsc: () => React.JSX.Element;
+export declare const IconSortDesc: () => React.JSX.Element;
+export declare const DataTable: {
+    ({ borderless, striped, noWrap, showScrollbar, headers, rows, renderRow, renderNestedRow, expandedRowIds, renderLoadingRow, renderFooterRow, renderFooterLoadingRow, omitFooterSelectionCell, selectedRowIds, disabledSelectionInputRowIds, selectionMode, onChangeSelectedRowIds, sortColumnId, sortDirection, onChangeSort, isError, isLoading, skeletonRowsNumber, isHeaderSticky, stickyHeaderStyle, customSpecificState, bodyHeightInSpecificStates, startFixedColumnsNumber, endFixedColumnsNumber, }: DataTableProps): React.JSX.Element;
+    Cell: import("styled-components").StyledComponent<"td", any, import("./styled").CellProps, never>;
+    ClickableCell: ({ onClick, children, ...otherProps }: import("./cells/ClickableCell").ClickableCellProps) => React.JSX.Element;
+    EditableCell: ({ onClick, children, ...otherProps }: import("./cells/EditableCell").EditableCellProps) => React.JSX.Element;
+    SkeletonCell: {
+        ({ style, ...otherProps }: import("./cells/SkeletonCell").SkeletonCellProps): React.JSX.Element;
+        defaultProps: {
+            style: {};
+        };
+    };
+    SkeletonContent: ({ isLoading, style }: {
+        isLoading?: boolean | undefined;
+        style?: React.CSSProperties | undefined;
+    }) => React.JSX.Element;
+};

package/lib/components/DataTable/SkeletonContent/SkeletonContent.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+type SkeletonContentPropTypes = {
+    isLoading?: boolean;
+    style?: React.CSSProperties;
+};
+export declare const SkeletonContent: ({ isLoading, style }: SkeletonContentPropTypes) => React.JSX.Element;
+export {};

package/lib/components/DataTable/SkeletonContent/index.d.ts

@@ -0,0 +1 @@
+export { SkeletonContent } from './SkeletonContent';

package/lib/components/DataTable/SpecificState/SpecificState.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { SpecificStateType } from '../utils/types';
+type SpecificStatePropTypes = SpecificStateType & {
+    height: number;
+};
+export declare const SpecificState: ({ height, icon, title, subTitle }: SpecificStatePropTypes) => React.JSX.Element;
+export {};

package/lib/components/DataTable/SpecificState/index.d.ts

@@ -0,0 +1 @@
+export { SpecificState } from './SpecificState';

package/lib/components/DataTable/SpecificState/styled.d.ts

@@ -0,0 +1,8 @@
+type SpecificStateContainerPropTypes = {
+    height: number;
+};
+declare const SpecificStateContainer: import("styled-components").StyledComponent<"div", any, SpecificStateContainerPropTypes, never>;
+declare const EllipseContainer: import("styled-components").StyledComponent<"div", any, {}, never>;
+declare const TitleText: import("styled-components").StyledComponent<"span", any, {} & import("../../Text/types").TextProps, never>;
+declare const SubTitleText: import("styled-components").StyledComponent<"span", any, {} & import("../../Text/types").TextProps, never>;
+export { SpecificStateContainer, EllipseContainer, TitleText, SubTitleText };

package/lib/components/DataTable/StickyHeader.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+type StickyHeaderPropTypes = {
+    tableRef: React.RefObject<HTMLTableElement>;
+    wrapperRef: React.RefObject<HTMLDivElement>;
+    isFixedLayout: boolean;
+    renderHeader: (offset?: number) => React.ReactNode;
+    wrapperStyle?: React.CSSProperties;
+};
+export declare const StickyHeader: ({ renderHeader, tableRef, wrapperRef, isFixedLayout, wrapperStyle, }: StickyHeaderPropTypes) => React.JSX.Element | null;
+export {};

package/lib/components/DataTable/cells/ClickableCell.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { CellProps } from '../styled';
+export interface ClickableCellProps extends CellProps {
+    onClick: React.MouseEventHandler<HTMLButtonElement>;
+    children: React.ReactNode;
+}
+export declare const ClickableCell: ({ onClick, children, ...otherProps }: ClickableCellProps) => React.JSX.Element;

package/lib/components/DataTable/cells/EditableCell.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { CellProps } from '../styled';
+export interface EditableCellProps extends CellProps {
+    onClick: React.MouseEventHandler<HTMLButtonElement>;
+    children: React.ReactNode;
+}
+export declare const EditableCell: ({ onClick, children, ...otherProps }: EditableCellProps) => React.JSX.Element;

package/lib/components/DataTable/cells/SkeletonCell.d.ts

@@ -0,0 +1,11 @@
+import React, { CSSProperties } from 'react';
+import { CellProps } from '../styled';
+export interface SkeletonCellProps extends CellProps {
+    style?: CSSProperties;
+}
+export declare const SkeletonCell: {
+    ({ style, ...otherProps }: SkeletonCellProps): React.JSX.Element;
+    defaultProps: {
+        style: {};
+    };
+};

package/lib/components/DataTable/cells/SkeletonHeaderCell.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { SkeletonCellProps } from './SkeletonCell';
+type SkeletonHeaderCellPropTypes = SkeletonCellProps & {
+    width: string | number;
+    isLoading: boolean;
+};
+export declare const SkeletonHeaderCell: ({ style, width, isLoading, ...otherProps }: SkeletonHeaderCellPropTypes) => React.JSX.Element;
+export {};

package/lib/components/DataTable/cells/index.d.ts

@@ -0,0 +1,3 @@
+export { ClickableCell } from './ClickableCell';
+export { EditableCell } from './EditableCell';
+export { SkeletonCell } from './SkeletonCell';

package/lib/components/DataTable/cells/styled.d.ts

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

package/lib/components/DataTable/index.d.ts

@@ -0,0 +1 @@
+export { DataTable } from './DataTable';

package/lib/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/lib/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/lib/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/lib/components/DataTable/utils/index.d.ts

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

package/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/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/lib/components/DataTableExp/components/LoadingCellContent.d.ts

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

package/lib/components/DataTableExp/components/NoWrap.d.ts

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

package/lib/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/lib/components/DataTableExp/components/ScrollContainer.d.ts

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

package/lib/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/lib/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/lib/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;