@coreui/react-pro 4.0.0-rc.1

package/dist/components/sidebar/CSidebar.d.ts

@@ -0,0 +1,49 @@
+import React, { HTMLAttributes } from 'react';
+export interface CSidebarProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+    /**
+     * Sets if the color of text should be colored for a light or dark dark background. [docs]
+     *
+     * @type 'dark' | 'light'
+     */
+    colorScheme?: 'dark' | 'light';
+    /**
+     * Make sidebar narrow. [docs]
+     */
+    narrow?: boolean;
+    /**
+     * Event emitted after visibility of component changed. [docs]
+     */
+    onVisibleChange?: (visible: boolean) => void;
+    /**
+     * Set sidebar to narrow variant. [docs]
+     */
+    overlaid?: boolean;
+    /**
+     * Components placement, there’s no default placement. [docs]
+     * @type 'start' | 'end'
+     */
+    placement?: 'start' | 'end';
+    /**
+     * Place sidebar in non-static positions. [docs]
+     */
+    position?: 'fixed' | 'sticky';
+    /**
+     * Size the component small, large, or extra large. [docs]
+     */
+    size?: 'sm' | 'lg' | 'xl';
+    /**
+     * Expand narrowed sidebar on hover. [docs]
+     */
+    unfoldable?: boolean;
+    /**
+     * Toggle the visibility of sidebar component. [docs]
+     *
+     * @default true
+     */
+    visible?: boolean;
+}
+export declare const CSidebar: React.ForwardRefExoticComponent<CSidebarProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/sidebar/CSidebarBrand.d.ts

@@ -0,0 +1,8 @@
+import React, { HTMLAttributes } from 'react';
+export interface CSidebarBrandProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+}
+export declare const CSidebarBrand: React.ForwardRefExoticComponent<CSidebarBrandProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/sidebar/CSidebarFooter.d.ts

@@ -0,0 +1,8 @@
+import React, { HTMLAttributes } from 'react';
+export interface CSidebarFooterProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+}
+export declare const CSidebarFooter: React.ForwardRefExoticComponent<CSidebarFooterProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/sidebar/CSidebarHeader.d.ts

@@ -0,0 +1,8 @@
+import React, { HTMLAttributes } from 'react';
+export interface CSidebarHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+}
+export declare const CSidebarHeader: React.ForwardRefExoticComponent<CSidebarHeaderProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/sidebar/CSidebarNav.d.ts

@@ -0,0 +1,14 @@
+import React, { HTMLAttributes } from 'react';
+export interface CSidebarNavProps extends HTMLAttributes<HTMLUListElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+}
+interface ContextProps {
+    visibleGroup: string;
+    setVisibleGroup: React.Dispatch<React.SetStateAction<string | undefined>>;
+}
+export declare const CNavContext: React.Context<ContextProps>;
+export declare const CSidebarNav: React.ForwardRefExoticComponent<CSidebarNavProps & React.RefAttributes<HTMLUListElement>>;
+export {};

package/dist/components/sidebar/CSidebarToggler.d.ts

@@ -0,0 +1,8 @@
+import React, { HTMLAttributes } from 'react';
+export interface CSidebarTogglerProps extends HTMLAttributes<HTMLButtonElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+}
+export declare const CSidebarToggler: React.ForwardRefExoticComponent<CSidebarTogglerProps & React.RefAttributes<HTMLButtonElement>>;

package/dist/components/smart-table/CSmartTable.d.ts

@@ -0,0 +1,3 @@
+import React from 'react';
+import { CSmartTableProps } from './CSmartTableInterface';
+export declare const CSmartTable: React.ForwardRefExoticComponent<CSmartTableProps & React.RefAttributes<HTMLDivElement>>;

package/dist/components/smart-table/CSmartTableBody.d.ts

@@ -0,0 +1,13 @@
+import React, { MouseEvent, ReactNode } from 'react';
+import { CTableBodyProps } from '../table/CTableBody';
+import { Item, ScopedColumns } from './CSmartTableInterface';
+export interface CSmartTableBodyProps extends CTableBodyProps {
+    clickableRows?: boolean;
+    currentItems: Item[];
+    firstItemOnActivePageIndex: number;
+    noItemsLabel?: string | ReactNode;
+    onRowClick?: (item: Item, index: number, columnName: string, event: MouseEvent | boolean) => void;
+    rawColumnNames: string[];
+    scopedColumns?: ScopedColumns;
+}
+export declare const CSmartTableBody: React.ForwardRefExoticComponent<CSmartTableBodyProps & React.RefAttributes<HTMLTableSectionElement>>;

package/dist/components/smart-table/CSmartTableCleaner.d.ts

@@ -0,0 +1,7 @@
+import React, { HTMLAttributes, ReactNode } from 'react';
+interface CSmartTableCleanerProps extends HTMLAttributes<HTMLButtonElement> {
+    content?: string | ReactNode;
+    isFiltered?: string;
+}
+export declare const CSmartTableCleaner: React.ForwardRefExoticComponent<CSmartTableCleanerProps & React.RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/components/smart-table/CSmartTableFilter.d.ts

@@ -0,0 +1,8 @@
+import React, { HTMLAttributes } from 'react';
+interface CSmartTableFilterProps extends HTMLAttributes<HTMLInputElement> {
+    filterLabel?: string;
+    filterPlaceholder?: string;
+    value?: string | number;
+}
+export declare const CSmartTableFilter: React.ForwardRefExoticComponent<CSmartTableFilterProps & React.RefAttributes<HTMLInputElement>>;
+export {};

package/dist/components/smart-table/CSmartTableHead.d.ts

@@ -0,0 +1,17 @@
+import React, { ElementType, ReactNode } from 'react';
+import { ColumnFilter, Column, Sorter, SorterValue } from './CSmartTableInterface';
+import { CTableHeadProps } from '../table/CTableHead';
+export interface CSmartTableHeadProps extends CTableHeadProps {
+    columnFilter?: boolean | ColumnFilter;
+    columnSorter?: boolean | Sorter;
+    component?: string | ElementType;
+    columns: (Column | string)[];
+    handleFilterOnChange?: (key: string, value: string) => void;
+    handleFilterOnInput?: (key: string, value: string) => void;
+    handleSort?: (key: string, index: number) => void;
+    sorterState?: SorterValue;
+    sortingIcon?: ReactNode;
+    sortingIconAscending?: ReactNode;
+    sortingIconDescending?: ReactNode;
+}
+export declare const CSmartTableHead: React.ForwardRefExoticComponent<CSmartTableHeadProps & React.RefAttributes<HTMLTableSectionElement>>;

package/dist/components/smart-table/CSmartTableInterface.d.ts

@@ -0,0 +1,289 @@
+import { HTMLAttributes, MouseEvent, ReactNode } from 'react';
+import { CSmartPaginationProps } from '../pagination/CSmartPagination';
+import { CTableProps } from '../table/CTable';
+import { CTableBodyProps } from '../table/CTableBody';
+import { CTableFootProps } from '../table/CTableFoot';
+import { CTableHeaderCellProps } from '../table/CTableHeaderCell';
+import { CTableRowProps } from '../table/CTableRow';
+import { CTableHeadProps } from '../table/CTableHead';
+export interface Column {
+    sorter?: boolean;
+    key: string;
+    label?: string;
+    filter?: boolean;
+    _style?: any;
+    _props?: CTableHeaderCellProps;
+}
+export interface ColumnFilter {
+    lazy?: boolean;
+    external?: boolean;
+}
+export interface ColumnFilterValue {
+    [key: string]: any;
+}
+export interface Item {
+    [key: string]: number | string | any;
+    _props: CTableRowProps;
+}
+export interface ItemsPerPageSelect {
+    external?: boolean;
+    label?: string;
+    values?: Array<number>;
+}
+export interface Sorter {
+    resetable?: boolean;
+    external?: boolean;
+}
+export interface ScopedColumns {
+    details?: (a: Item, b: number) => ReactNode;
+}
+export interface SorterValue {
+    column?: string;
+    state?: number | string;
+}
+export interface TableFilter {
+    lazy?: boolean;
+    external?: boolean;
+    label?: string;
+    placeholder?: string;
+}
+export interface NoItemsView {
+    noResults?: string;
+    noItems?: string;
+}
+export interface CSmartTableProps extends HTMLAttributes<HTMLDivElement> {
+    /**
+     * Sets active page. If 'pagination' prop is enabled, activePage is set only initially. [docs]
+     *
+     * @default 1
+     */
+    activePage?: number;
+    /**
+     * A string of all className you want applied to the base component. [docs]
+     */
+    className?: string;
+    /**
+     * When set, displays table cleaner above table, next to the table filter (or in place of table filter if `tableFilter` prop is not set)
+     * Cleaner resets `tableFilterValue`, `columnFilterValue`, `sorterValue`. If clean is possible it is clickable (`tabIndex="0"` `role="button"`, `color="danger"`), otherwise it is not clickable and transparent. Cleaner can be customized through the `cleaner` slot. [docs]
+     *
+     */
+    cleaner?: boolean;
+    /**
+     * Style table items as clickable. [docs]
+     *
+     * @type boolean
+     */
+    clickableRows?: boolean;
+    /**
+     * When set, displays additional filter row between table header and items, allowing filtering by specific column.
+     * Column filter can be customized, by passing prop as object with additional options as keys. Available options:
+     * - external (Boolean) - Disables automatic filtering inside component.
+     * - lazy (Boolean) - Set to true to trigger filter updates only on change event. [docs]
+     *
+     * @type boolean | ColumnFilter
+     */
+    columnFilter?: boolean | ColumnFilter;
+    /**
+     * Value of table filter. To set pass object where keys are column names and values are filter strings e.g.:
+     * { user: 'John', age: 12 }
+     * You can track state of this prop by setting .sync modifier. [docs]
+     */
+    columnFilterValue?: ColumnFilterValue;
+    /**
+     * Prop for table columns configuration. If prop is not defined, table will display columns based on the first item keys, omitting keys that begins with underscore (e.g. '_classes')
+     *
+     * In columns prop each array item represents one column. Item might be specified in two ways:
+     * String: each item define column name equal to item value.
+     * Object: item is object with following keys available as column configuration:
+     * - key (required)(String) - define column name equal to item key.
+     * - label (String) - define visible label of column. If not defined, label will be generated automatically based on column name, by converting kebab-case and snake_case to individual words and capitalization of each word.
+     * - _classes (String/Array/Object) - adds classes to all cels in column
+     * - _style (String/Array/Object) - adds styles to the column header (useful for defining widths)
+     * - sorter (Boolean) - disables sorting of the column when set to false
+     * - filter (Boolean) - removes filter from column when set to false. [docs]
+     */
+    columns?: Column[] | string[];
+    /**
+     * Enables table sorting by column value. Sorting will be performed corectly only if values in column are of one type: string (case insensitive) or number.
+     *
+     * Sorter can be customized, by passing prop as object with additional options as keys. Available options:
+     * - external (Boolean) - Disables automatic sorting inside component.
+     * - resetable (Boolean) - If set to true clicking on sorter have three states: ascending, descending and null. That means that third click on sorter will reset sorting, and restore table to original order. [docs]
+     *
+     * @type boolean | Sorter
+     */
+    columnSorter?: boolean | Sorter;
+    /**
+     * Displays table footer, which mirrors table header. (without column filter). [docs]
+     */
+    footer?: boolean;
+    /**
+     * Set to false to remove table header. [docs]
+     *
+     * @default true
+     */
+    header?: boolean;
+    /**
+     * Array of objects, where each object represents one item - row in table. Additionally, you can add style classes to each row by passing them by '_classes' key and to single cell by '_cellClasses'.
+     *
+     * Example item:
+     * { name: 'John' , age: 12, _props: { color: 'success' }, _cellProps: { age: { className: 'fw-bold'}}}
+     * For column generation description watch columns prop. [docs]
+     *
+     * @type Array<string>
+     */
+    items?: Item[];
+    /**
+     * Number of items per site, when pagination is enabled. [docs]
+     *
+     * @default 10
+     */
+    itemsPerPage?: number;
+    /**
+     * Label for items per page selector. [docs]
+     *
+     * @default 'Items per page:'
+     */
+    itemsPerPageLabel?: string;
+    /**
+     * Items per page selector options. [docs]
+     *
+     * @default [5, 10, 20, 50]
+     */
+    itemsPerPageOptions?: number[];
+    /**
+     * Adds select element over table, which is used for control items per page in pagination. If you want to customize this element, pass object with optional values:
+     * - label (String) - replaces default label text
+     * - values (Array) - custom array of pagination values
+     * - external (Boolean) - disables automatic 'itemsPerPage' change (use to change pages externaly by 'pagination-change' event). [docs]
+     */
+    itemsPerPageSelect?: boolean | ItemsPerPageSelect;
+    /**
+     * When set, table will have loading style: loading spinner and reduced opacity. When 'small' prop is enabled spinner will be also smaller. [docs]
+     */
+    loading?: boolean;
+    /**
+     * ReactNode or string for passing custom noItemsLabel texts. [docs]
+     * @default 'No items found'
+     */
+    noItemsLabel?: string | ReactNode;
+    /**
+     * Page change callback. [docs]
+     */
+    onActivePageChange?: (value: number) => void;
+    /**
+     * Column filter change callback. [docs]
+     */
+    onColumnFilterChange?: (value: ColumnFilterValue) => void;
+    /**
+     * Filtered items change callback. [docs]
+     */
+    onFilteredItemsChange?: (items: Item[]) => void;
+    /**
+     * Pagination change callback. [docs]
+     */
+    onItemsPerPageChange?: (value: number) => void;
+    /**
+     * Row click callback. [docs]
+     */
+    onRowClick?: (item: Item, index: number, columnName: string, event: MouseEvent | boolean) => void;
+    /**
+     * Sorter value change callback. [docs]
+     */
+    onSorterChange?: (value: SorterValue) => void;
+    /**
+     * Table filter change callback. [docs]
+     */
+    onTableFilterChange?: (value?: string) => void;
+    /**
+     * Enables default pagination. Set to true for default setup or pass an object with additional CPagination props. Default pagination will always have the computed number of pages that cannot be changed. The number of pages is generated based on the number of passed items and 'itemsPerPage' prop. If this restriction is an obstacle, you can make external CPagination instead. [docs]
+     */
+    pagination?: boolean;
+    /**
+     * Properties to `CSmartPagination` component. [docs]
+     *
+     * @link https://coreui.io/react/docs/4.0/components/smart-pagination#csmartpagination
+     */
+    paginationProps?: CSmartPaginationProps;
+    /**
+     * Scoped columns. [docs]
+     *
+     * @type scopedColumns
+     */
+    scopedColumns?: ScopedColumns;
+    /**
+     * State of the sorter. Name key is column name, direction can be 'asc' or 'desc'. Set .sync modifier to track changes. [docs]
+     *
+     * @type SorterValue
+     */
+    sorterValue?: SorterValue;
+    /**
+     * Sorter icon when items are unsorted. [docs]
+     *
+     * @default '<CIcon width="18" content={cilArrowTop} />
+     */
+    sortingIcon?: ReactNode;
+    /**
+     * Sorter icon when items are sorted ascending. [docs]
+     *
+     * @default '<CIcon width="18" content={cilArrowTop} />
+     */
+    sortingIconAscending?: ReactNode;
+    /**
+     * Sorter icon when items are sorted descending. [docs]
+     *
+     * @default '<CIcon width="18" content={cilArrowBottom} />'
+     */
+    sortingIconDescending?: ReactNode;
+    /**
+     * Properties to `CTableBody` component. [docs]
+     *
+     * @link https://coreui.io/react/docs/4.0/components/table/#ctablebody
+     */
+    tableBodyProps?: CTableBodyProps;
+    /**
+     * Properties to `CTableFoot` component. [docs]
+     *
+     * @link https://coreui.io/react/docs/4.0/components/table/#ctablefoot
+     */
+    tableFootProps?: CTableFootProps;
+    /**
+     * When set, displays table filter above table, allowing filtering by specific column.
+     *
+     * Column filter can be customized, by passing prop as object with additional options as keys. Available options:
+     * - placeholder (String) - Sets custom table filter placeholder.
+     * - label (String) - Sets custom table filter label.
+     * - external (Boolean) - Disables automatic filtering inside component.
+     * - lazy (Boolean) - Set to true to trigger filter updates only on change event. [docs]
+     */
+    tableFilter?: boolean | TableFilter;
+    /**
+     * The element represents a caption for a component. [docs]
+     *
+     * @default 'Filter:'
+     */
+    tableFilterLabel?: string;
+    /**
+     * Specifies a short hint that is visible in the search input. [docs]
+     *
+     * @default 'type string...'
+     */
+    tableFilterPlaceholder?: string;
+    /**
+     * Value of table filter. Set .sync modifier to track changes. [docs]
+     *
+     */
+    tableFilterValue?: string;
+    /**
+     * Properties to `CTableHead` component. [docs]
+     *
+     * @link https://coreui.io/react/docs/4.0/components/table/#ctablehead
+     */
+    tableHeadProps?: CTableHeadProps;
+    /**
+     * Properties to `CTable` component. [docs]
+     *
+     * @link https://coreui.io/react/docs/4.0/components/table/#ctable
+     */
+    tableProps?: CTableProps;
+}

package/dist/components/smart-table/CSmartTableItemsPerPageSelector.d.ts

@@ -0,0 +1,8 @@
+import React, { HTMLAttributes } from 'react';
+interface CSmartTableItemsPerPageSelectorProps extends HTMLAttributes<HTMLSelectElement> {
+    itemsPerPage?: number;
+    itemsPerPageLabel?: string;
+    itemsPerPageOptions?: number[];
+}
+export declare const CSmartTableItemsPerPageSelector: React.ForwardRefExoticComponent<CSmartTableItemsPerPageSelectorProps & React.RefAttributes<HTMLSelectElement>>;
+export {};

package/dist/components/spinner/CSpinner.d.ts

@@ -0,0 +1,37 @@
+import React, { ElementType, HTMLAttributes } from 'react';
+import { Colors } from '../Types';
+export interface CSpinnerProps extends HTMLAttributes<HTMLDivElement | HTMLSpanElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+    /**
+     * Sets the color context of the component to one of CoreUI’s themed colors. [docs]
+     *
+     * @type {'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string }
+     */
+    color?: Colors;
+    /**
+     * Component used for the root node. Either a string to use a HTML element or a component. [docs]
+     *
+     * @default 'div'
+     */
+    component?: string | ElementType;
+    /**
+     * Size the component small. [docs]
+     */
+    size?: 'sm';
+    /**
+     * Set the button variant to an outlined button or a ghost button. [docs]
+     *
+     * @default 'border'
+     */
+    variant?: 'border' | 'grow';
+    /**
+     * Set visually hidden label for accessibility purposes. [docs]
+     *
+     * @default 'Loading...'
+     */
+    visuallyHiddenLabel?: string;
+}
+export declare const CSpinner: React.ForwardRefExoticComponent<CSpinnerProps & React.RefAttributes<HTMLDivElement | HTMLSpanElement>>;

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

@@ -0,0 +1,53 @@
+import React, { TableHTMLAttributes } from 'react';
+import { Colors } from '../Types';
+export interface CTableProps extends TableHTMLAttributes<HTMLTableElement> {
+    /**
+     * Set the vertical aligment. [docs]
+     */
+    align?: 'bottom' | 'middle' | 'top';
+    /**
+     * Sets the border color of the component to one of CoreUI’s themed colors. [docs]
+     *
+     * @type 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string
+     */
+    borderColor?: Colors;
+    /**
+     * Add borders on all sides of the table and cells. [docs]
+     */
+    bordered?: boolean;
+    /**
+     * Remove borders on all sides of the table and cells. [docs]
+     */
+    borderless?: boolean;
+    /**
+     * Put the `<caption>` on the top of the table. [docs]
+     */
+    caption?: 'top';
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+    /**
+     * Sets the color context of the component to one of CoreUI’s themed colors. [docs]
+     *
+     * @type 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string
+     */
+    color?: Colors;
+    /**
+     * Enable a hover state on table rows within a `<CTableBody>`. [docs]
+     */
+    hover?: boolean;
+    /**
+     * Make any table responsive across all viewports or pick a maximum breakpoint with which to have a responsive table up to. [docs]
+     */
+    responsive?: boolean | 'sm' | 'md' | 'lg' | 'xl' | 'xxl';
+    /**
+     * Make table more compact by cutting all cell `padding` in half. [docs]
+     */
+    small?: boolean;
+    /**
+     * Add zebra-striping to any table row within the `<CTableBody>`. [docs]
+     */
+    striped?: boolean;
+}
+export declare const CTable: React.ForwardRefExoticComponent<CTableProps & React.RefAttributes<HTMLTableElement>>;

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

@@ -0,0 +1,15 @@
+import React, { HTMLAttributes } from 'react';
+import { Colors } from '../Types';
+export interface CTableBodyProps extends HTMLAttributes<HTMLTableSectionElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+    /**
+     * Sets the color context of the component to one of CoreUI’s themed colors. [docs]
+     *
+     * @type 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string
+     */
+    color?: Colors;
+}
+export declare const CTableBody: React.ForwardRefExoticComponent<CTableBodyProps & React.RefAttributes<HTMLTableSectionElement>>;

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

@@ -0,0 +1,2 @@
+import React from 'react';
+export declare const CTableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;

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

@@ -0,0 +1,27 @@
+import React, { TdHTMLAttributes } from 'react';
+import { Colors } from '../Types';
+export interface CTableDataCellProps extends Omit<TdHTMLAttributes<HTMLTableDataCellElement>, 'align'> {
+    /**
+     * Highlight a table row or cell. [docs]
+     */
+    active?: boolean;
+    /**
+     * Set the vertical aligment. [docs]
+     */
+    align?: 'bottom' | 'middle' | 'top';
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+    /**
+     * Sets the color context of the component to one of CoreUI’s themed colors. [docs]
+     *
+     * @type 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string
+     */
+    color?: Colors;
+    /**
+     * @ignore
+     */
+    colSpan?: number;
+}
+export declare const CTableDataCell: React.ForwardRefExoticComponent<CTableDataCellProps & React.RefAttributes<HTMLTableDataCellElement>>;

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

@@ -0,0 +1,15 @@
+import React, { HTMLAttributes } from 'react';
+import { Colors } from '../Types';
+export interface CTableFootProps extends HTMLAttributes<HTMLTableSectionElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+    /**
+     * Sets the color context of the component to one of CoreUI’s themed colors. [docs]
+     *
+     * @type 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string
+     */
+    color?: Colors;
+}
+export declare const CTableFoot: React.ForwardRefExoticComponent<CTableFootProps & React.RefAttributes<HTMLTableSectionElement>>;

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

@@ -0,0 +1,15 @@
+import React, { HTMLAttributes } from 'react';
+import { Colors } from '../Types';
+export interface CTableHeadProps extends HTMLAttributes<HTMLTableSectionElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+    /**
+     * Sets the color context of the component to one of CoreUI’s themed colors. [docs]
+     *
+     * @type 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string
+     */
+    color?: Colors;
+}
+export declare const CTableHead: React.ForwardRefExoticComponent<CTableHeadProps & React.RefAttributes<HTMLTableSectionElement>>;

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

@@ -0,0 +1,15 @@
+import React, { ThHTMLAttributes } from 'react';
+import { Colors } from '../Types';
+export interface CTableHeaderCellProps extends ThHTMLAttributes<HTMLTableHeaderCellElement> {
+    /**
+     * A string of all className you want applied to the component. [docs]
+     */
+    className?: string;
+    /**
+     * Sets the color context of the component to one of CoreUI’s themed colors. [docs]
+     *
+     * @type 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'dark' | 'light' | string
+     */
+    color?: Colors;
+}
+export declare const CTableHeaderCell: React.ForwardRefExoticComponent<CTableHeaderCellProps & React.RefAttributes<HTMLTableHeaderCellElement>>;