@loadsmart/loadsmart-ui 8.0.0 → 8.0.2

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

@@ -29,20 +29,20 @@ export type PaginationProps = Omit<HTMLAttributes<HTMLElement>, 'onChange'> & {
     siblingCount?: number;
 };
 export type usePaginationProps = Pick<PaginationProps, 'boundaryCount' | 'count' | 'disabled' | 'onChange' | 'page' | 'siblingCount'>;
-export type usePaginationReturn = {
+export interface usePaginationReturn {
     'aria-current'?: boolean | undefined;
     disabled: boolean;
     itemType: string;
     onClick: () => void;
     page: number | null;
-};
+}
 export type PaginationItemProps = ButtonProps & {
     itemType: string;
     page: number | null;
 };
-export type PaginationHelperArgs = {
+export interface PaginationHelperArgs {
     boundaryCount: number;
     count: number;
     page: number;
     siblingCount: number;
-};
+}

package/dist/components/Pagination/PaginationItem.d.ts

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 import { PaginationItemProps } from './Pagination.types';
-declare function PaginationItem(props: PaginationItemProps): JSX.Element;
+declare function PaginationItem(props: PaginationItemProps): React.JSX.Element;
 export default PaginationItem;

package/dist/components/Popover/Popover.d.ts

@@ -1,10 +1,11 @@
+import { default as React } from 'react';
 import { PopoverFloatingProps, PopoverProps, PopoverReferenceProps, UsePopoverReturn } from './Popover.types';
 export declare function usePopover(): UsePopoverReturn;
-declare function Popover(props: PopoverProps): JSX.Element;
+declare function Popover(props: PopoverProps): React.JSX.Element;
 declare namespace Popover {
     var Floating: typeof PopoverFloating;
     var Reference: typeof PopoverReference;
 }
-declare function PopoverReference({ children, ...others }: PopoverReferenceProps): JSX.Element;
-declare function PopoverFloating({ children, style, ...others }: PopoverFloatingProps): JSX.Element;
+declare function PopoverReference({ children, ...others }: PopoverReferenceProps): React.JSX.Element;
+declare function PopoverFloating({ children, style, ...others }: PopoverFloatingProps): React.JSX.Element;
 export default Popover;

package/dist/components/ProgressBar/ProgressBar.d.ts

@@ -1,9 +1,9 @@
-import { BaseHTMLAttributes } from 'react';
+import { BaseHTMLAttributes, default as React } from 'react';
 export interface ProgressBarProps extends BaseHTMLAttributes<HTMLDivElement> {
-    value?: number;
-    status?: string;
-    rounded?: boolean;
-    showLine?: boolean;
+    readonly value?: number;
+    readonly status?: string;
+    readonly rounded?: boolean;
+    readonly showLine?: boolean;
 }
-export declare function ProgressBar({ value, status, rounded, showLine, ...extra }: ProgressBarProps): JSX.Element;
+export declare function ProgressBar({ value, status, rounded, showLine, ...extra }: ProgressBarProps): React.JSX.Element;
 export default ProgressBar;

package/dist/components/Radio/Radio.d.ts

@@ -1,10 +1,10 @@
-import { InputHTMLAttributes, ReactNode } from 'react';
-import { default as ColorScheme } from '../../utils/types/ColorScheme';
+import { InputHTMLAttributes, ReactNode, default as React } from 'react';
+import { ColorScheme } from '../../utils/types/ColorScheme';
 import { SelectionStyleProps } from '../../common/SelectionWrapper';
-export interface RadioProps extends InputHTMLAttributes<HTMLInputElement>, SelectionStyleProps {
-    leading?: ReactNode;
-    scheme?: ColorScheme;
-    trailing?: ReactNode;
+export interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'disabled'>, SelectionStyleProps {
+    readonly leading?: ReactNode;
+    readonly scheme?: ColorScheme;
+    readonly trailing?: ReactNode;
 }
-declare function Radio({ className, disabled, children, leading, trailing, scheme, ...others }: RadioProps): JSX.Element;
+declare function Radio({ className, disabled, children, leading, trailing, scheme, ...others }: RadioProps): React.JSX.Element;
 export default Radio;

package/dist/components/Section/Section.d.ts

@@ -1,11 +1,11 @@
-import { default as React, HTMLAttributes, ReactNode } from 'react';
+import { HTMLAttributes, ReactNode, default as React } from 'react';
 export type SectionProps = HTMLAttributes<HTMLElement>;
 export interface SectionTitleProps extends HTMLAttributes<HTMLElement> {
-    children: ReactNode;
-    leading?: ReactNode;
+    readonly children: ReactNode;
+    readonly leading?: ReactNode;
 }
 declare function SectionTitle({ children, leading, ...others }: SectionTitleProps): React.JSX.Element;
-declare function Section({ children, ...others }: SectionProps): JSX.Element;
+declare function Section({ children, ...others }: SectionProps): React.JSX.Element;
 declare namespace Section {
     var Title: typeof SectionTitle;
 }

package/dist/components/Select/Select.context.d.ts

@@ -1,5 +1,6 @@
 import { useSelectReturn } from './Select.types';
-declare const SelectableContext: import('react').Context<import('../../hooks/useSelectable/useSelectable.types').useSelectableReturn<import('../../hooks/useSelectable').Selectable>>, useSelectable: (props: import('../../hooks/useSelectable/useSelectable.types').useSelectableProps<import('../../hooks/useSelectable').Selectable>) => import('../../hooks/useSelectable/useSelectable.types').useSelectableReturn<import('../../hooks/useSelectable').Selectable>;
+import { Context } from 'react';
+declare const SelectableContext: any, useSelectable: any;
 export { SelectableContext, useSelectable };
-declare const SelectContext: import('react').Context<useSelectReturn | null>;
+declare const SelectContext: Context<useSelectReturn | null>;
 export { SelectContext };

package/dist/components/Select/Select.d.ts

@@ -3,9 +3,9 @@ import { default as SelectOption } from './SelectOption';
 import { default as SelectEmpty } from './SelectEmpty';
 import { default as SelectCreatableOption } from './SelectCreatableOption';
 import { SelectProps } from './Select.types';
-declare function Select(props: SelectProps): JSX.Element;
+declare function Select(props: SelectProps): React.JSX.Element;
 declare namespace Select {
-    var Trigger: React.ForwardRefExoticComponent<import("../TextField").TextFieldProps & React.RefAttributes<HTMLInputElement>>;
+    var Trigger: React.ForwardRefExoticComponent<Omit<TextFieldProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
     var Option: typeof SelectOption;
     var Empty: typeof SelectEmpty;
     var CreatableOption: typeof SelectCreatableOption;

package/dist/components/Select/Select.fixtures.d.ts

@@ -1,14 +1,14 @@
 import { SelectableKeyType } from '../../hooks/useSelectable';
 import { SelectDatasource } from './Select.types';
-export type Fruit = {
+export interface Fruit {
     label: string;
     value: string;
     family: string;
-};
-export type User = {
+}
+export interface User {
     uuid: string;
     name: string;
-};
+}
 export type Customer = User;
 export declare const SelectableKeyTypeOptions: {
     label: string;

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

@@ -3,7 +3,7 @@ import { DropdownMenuItemProps, DropdownProps } from '../Dropdown';
 import { TextFieldProps } from '../TextField';
 import { Selectable, SelectableAdapter, SelectableKeyType, SelectableState } from '../../hooks/useSelectable';
 import { useSelectableReturn } from '../../hooks/useSelectable/useSelectable.types';
-import { ChangeEvent, ComponentType, FocusEvent, HTMLAttributes } from 'react';
+import { ChangeEvent, ComponentType, FocusEvent, HTMLAttributes, ReactNode } from 'react';
 export type Option = Selectable;
 export interface GenericOption {
     label: string;
@@ -29,27 +29,27 @@ export interface SelectAdapter<T> extends SelectableAdapter<T> {
     getLabel: (o: T) => string;
 }
 export type Adapters = Record<string, SelectAdapter<any>>;
-export type SelectDatasource<T> = {
+export interface SelectDatasource<T> {
     type: string;
     adapter: SelectAdapter<T>;
     fetch: ({ query, regex }: {
         query: string;
         regex: RegExp;
     }) => T[] | Promise<T[]>;
-};
+}
 export type SelectDatasourceFunction<T> = () => SelectDatasource<T>;
-export type SelectComponentsOptionProps = {
+export interface SelectComponentsOptionProps {
     value: SelectOptionProps['value'];
-};
-export type SelectComponentsEmptyProps = {
+}
+export interface SelectComponentsEmptyProps {
     children: SelectEmptyProps['children'];
-};
-export type CreatableOptionType = () => React.ReactElement<any, any> | null;
-export type Components = {
+}
+export type CreatableOptionType = () => ReactNode | null;
+export interface Components {
     Option?: ComponentType<SelectComponentsOptionProps>;
     Empty?: ComponentType<SelectComponentsEmptyProps>;
     CreatableOption?: CreatableOptionType;
-};
+}
 export type CreateOptionPosition = 'first' | 'last';
 export type OnChange = (event: EventLike<Option | Option[] | null>) => void;
 export type OnCreate = (query: string) => Promise<void | Option> | void | Option;
@@ -81,7 +81,7 @@ export type SelectEmptyProps = HTMLAttributes<HTMLDivElement>;
 export type SelectCreatableOptionProps = Omit<DropdownMenuItemProps, keyof CreatableProps>;
 export type SelectStatus = 'idle' | 'querying' | 'pending-query' | 'queried';
 export type SelectTriggerProps = TextFieldProps;
-export type useSelectReturn = {
+export interface useSelectReturn {
     status: SelectStatus;
     options: Option[];
     value: Selectable | Selectable[] | null;
@@ -114,9 +114,9 @@ export type useSelectReturn = {
     getCreatebleProps: () => CreatableProps;
     isCreatable: () => boolean;
     createOptionPosition?: CreateOptionPosition;
-};
-export type useSelectExternalReturn = {
+}
+export interface useSelectExternalReturn {
     getOption: useSelectReturn['getOption'];
     query: useSelectReturn['query'];
     isChecked: (option: Option) => boolean;
-};
+}

package/dist/components/Select/SelectCreatableOption.d.ts

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 import { SelectCreatableOptionProps } from './Select.types';
-declare function SelectCreatableOption({ children, ...rest }: SelectCreatableOptionProps): JSX.Element;
+declare function SelectCreatableOption({ children, ...rest }: SelectCreatableOptionProps): React.JSX.Element;
 export default SelectCreatableOption;

package/dist/components/Select/SelectEmpty.d.ts

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 import { SelectEmptyProps } from './Select.types';
-declare function SelectEmpty({ children, ...others }: SelectEmptyProps): JSX.Element;
+declare function SelectEmpty({ children, ...others }: SelectEmptyProps): React.JSX.Element;
 export default SelectEmpty;

package/dist/components/Select/SelectOption.d.ts

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 import { SelectOptionProps } from './Select.types';
-declare function SelectOption({ children, value, leading, trailing, ...rest }: SelectOptionProps): JSX.Element;
+declare function SelectOption({ children, value, leading, trailing, ...rest }: SelectOptionProps): React.JSX.Element;
 export default SelectOption;

package/dist/components/Select/SelectTrigger.d.ts

@@ -1,3 +1,3 @@
 import { default as React } from 'react';
-declare const SelectTrigger: React.ForwardRefExoticComponent<import('../TextField').TextFieldProps & React.RefAttributes<HTMLInputElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<TextFieldProps, "ref"> & React.RefAttributes<HTMLInputElement>>;
 export default SelectTrigger;

package/dist/components/Select/useSelect.d.ts

@@ -1,8 +1,6 @@
 import { SelectProps, useSelectReturn } from './Select.types';
 /**
  * Based on https://www.w3.org/TR/wai-aria-practices-1.1/examples/combobox/aria1.1pattern/listbox-combo.html
- * @param props
- * @returns
  */
 declare function useSelect(props: SelectProps): useSelectReturn;
 export default useSelect;

package/dist/components/SideNavigation/Logo/Logo.d.ts

@@ -1,8 +1,9 @@
-import { PropsWithChildren } from 'react';
+import { default as React, PropsWithChildren } from 'react';
+import { StyledComponent } from 'styled-components';
 export type LogoProps = PropsWithChildren<{
-    url: string;
-    className?: string;
+    readonly url: string;
+    readonly className?: string;
 }>;
-declare function Logo({ className, url, children }: LogoProps): JSX.Element;
-declare const _default: import('styled-components').StyledComponent<typeof Logo, any, LogoProps, never>;
+declare function Logo({ className, url, children }: LogoProps): React.JSX.Element;
+declare const _default: StyledComponent<typeof Logo, any, LogoProps, never>;
 export default _default;

package/dist/components/SideNavigation/Menu/Menu.d.ts

@@ -1,16 +1,6 @@
-import { default as React, PropsWithChildren } from 'react';
-import { MenuExpandableProps } from './MenuExpandable';
-import { MenuLinkProps } from './MenuLink';
+import { default as React } from 'react';
 export interface MenuProps extends React.HTMLAttributes<HTMLDivElement> {
-    label?: string;
+    readonly label?: string;
 }
-declare function Menu({ label, children, ...props }: MenuProps): JSX.Element;
-type MenuItemProps = {
-    active?: boolean;
-} & PropsWithChildren<MenuLinkProps & MenuExpandableProps>;
-declare function MenuItem(props: MenuItemProps): React.JSX.Element;
-declare const _default: string & import('styled-components').StyledComponentBase<typeof Menu, any, {}, never> & import('hoist-non-react-statics').NonReactStatics<typeof Menu, {}> & {
-    Item: typeof MenuItem;
-    SubItem: import('styled-components').StyledComponent<({ url, ...props }: MenuLinkProps) => JSX.Element, any, {}, never>;
-};
+declare const _default: any;
 export default _default;

package/dist/components/SideNavigation/Menu/MenuBaseItem.d.ts

@@ -1,11 +1,11 @@
-import { ReactNode, HTMLAttributes } from 'react';
+import { default as React, ReactNode, HTMLAttributes } from 'react';
 import { MenuLinkProps } from './MenuLink';
 export type MenuBaseItemProps = HTMLAttributes<HTMLElement> & {
-    label: string;
-    leading?: ReactNode;
-    trailing?: ReactNode;
-    url?: string;
-    subItems?: MenuLinkProps[];
+    readonly label: string;
+    readonly leading?: ReactNode;
+    readonly trailing?: ReactNode;
+    readonly url?: string;
+    readonly subItems?: MenuLinkProps[];
 };
-declare function MenuBaseItem({ label, leading, trailing, ...props }: MenuBaseItemProps): JSX.Element;
+declare function MenuBaseItem({ label, leading, trailing, ...props }: MenuBaseItemProps): React.JSX.Element;
 export default MenuBaseItem;

package/dist/components/SideNavigation/Menu/MenuExpandable.d.ts

@@ -1,6 +1,6 @@
-import { PropsWithChildren, HTMLAttributes } from 'react';
+import { default as React, PropsWithChildren, HTMLAttributes } from 'react';
 export type MenuExpandableProps = HTMLAttributes<HTMLDivElement> & PropsWithChildren<{
-    label: string;
+    readonly label: string;
 }>;
-declare function MenuExpandable({ label, children, ...props }: MenuExpandableProps): JSX.Element;
+declare function MenuExpandable({ label, children, ...props }: MenuExpandableProps): React.JSX.Element;
 export default MenuExpandable;

package/dist/components/SideNavigation/Menu/MenuLink.d.ts

@@ -1,10 +1,11 @@
 import { default as React, ReactNode } from 'react';
+import { StyledComponent } from 'styled-components';
 export type MenuLinkProps = React.HTMLAttributes<HTMLAnchorElement> & {
-    label: string;
-    leading?: ReactNode;
-    trailing?: ReactNode;
-    url?: string;
+    readonly label: string;
+    readonly leading?: ReactNode;
+    readonly trailing?: ReactNode;
+    readonly url?: string;
 };
-declare function MenuLink({ url, ...props }: MenuLinkProps): JSX.Element;
-declare const _default: import('styled-components').StyledComponent<typeof MenuLink, any, {}, never>;
+declare function MenuLink({ url, ...props }: MenuLinkProps): React.JSX.Element;
+declare const _default: StyledComponent<typeof MenuLink, any, {}, never>;
 export default _default;

package/dist/components/SideNavigation/Separator/Separator.d.ts

@@ -1,5 +1,6 @@
+import { default as React } from 'react';
 export interface SeparatorProps {
-    className?: string;
+    readonly className?: string;
 }
-declare function Separator(props: SeparatorProps): JSX.Element;
+declare function Separator(props: SeparatorProps): React.JSX.Element;
 export default Separator;

package/dist/components/SideNavigation/SideNavigation.d.ts

@@ -1,28 +1,13 @@
-import { CloseButtonProps } from '../../common/CloseButton';
-import { default as React, ReactNode } from 'react';
+import { ReactNode, default as React } from 'react';
 export interface SideNavigationProps {
-    className?: string;
-    children: ReactNode;
+    readonly className?: string;
+    readonly children: ReactNode;
 }
-declare function SideNavigation({ className, children }: SideNavigationProps): JSX.Element;
+declare function SideNavigation({ className, children }: SideNavigationProps): React.JSX.Element;
 declare namespace SideNavigation {
-    var Logo: import("styled-components").StyledComponent<({ className, url, children }: import("./Logo/Logo").LogoProps) => JSX.Element, any, import("./Logo/Logo").LogoProps, never>;
-    var Menu: string & import("styled-components").StyledComponentBase<({ label, children, ...props }: import("./Menu/Menu").MenuProps) => JSX.Element, any, {}, never> & import("hoist-non-react-statics").NonReactStatics<({ label, children, ...props }: import("./Menu/Menu").MenuProps) => JSX.Element, {}> & {
-        Item: (props: {
-            active?: boolean;
-        } & React.HTMLAttributes<HTMLAnchorElement> & {
-            label: string;
-            leading?: ReactNode;
-            trailing?: ReactNode;
-            url?: string;
-        } & React.HTMLAttributes<HTMLDivElement> & {
-            label: string;
-        } & {
-            children?: ReactNode | undefined;
-        }) => React.JSX.Element;
-        SubItem: import("styled-components").StyledComponent<({ url, ...props }: import("./Menu/MenuLink").MenuLinkProps) => JSX.Element, any, {}, never>;
-    };
+    var Logo: import("styled-components").StyledComponent<({ className, url, children }: import("./Logo/Logo").LogoProps) => React.JSX.Element, any, import("./Logo/Logo").LogoProps, never>;
+    var Menu: any;
     var Separator: typeof import("./Separator").Separator;
-    var CloseButton: import("styled-components").StyledComponent<typeof import("common/CloseButton").default, any, CloseButtonProps, never>;
+    var CloseButton: import("styled-components").StyledComponent<any, any, any, any>;
 }
 export default SideNavigation;

package/dist/components/Steps/ProgressSteps/ProgressStep.d.ts

@@ -1,12 +1,12 @@
-import { ReactNode } from 'react';
+import { ReactNode, default as React } from 'react';
 import { Step } from '../Steps.types';
 export interface StepsProgressProps {
     steps: Array<Step>;
     current: number | string;
 }
 declare function ProgressStep(props: {
-    step: Step;
-    current: boolean;
-    indicator: ReactNode;
-}): JSX.Element;
+    readonly step: Step;
+    readonly current: boolean;
+    readonly indicator: ReactNode;
+}): React.JSX.Element;
 export default ProgressStep;

package/dist/components/Steps/ProgressSteps/ProgressSteps.d.ts

@@ -1,7 +1,8 @@
+import { default as React } from 'react';
 import { Step } from '../Steps.types';
 export interface StepsProgressProps {
-    steps: Array<Step>;
-    current: number | string;
+    readonly steps: Array<Step>;
+    readonly current: number | string;
 }
-declare function StepsProgress(props: StepsProgressProps): JSX.Element;
+declare function StepsProgress(props: StepsProgressProps): React.JSX.Element;
 export default StepsProgress;

package/dist/components/Steps/Steps.d.ts

@@ -1,15 +1,15 @@
-import { PropsWithChildren } from 'react';
+import { default as React, PropsWithChildren } from 'react';
 import { default as StepsStep } from './StepsStep';
-import { default as ColorScheme } from '../../utils/types/ColorScheme';
+import { ColorScheme } from '../../utils/types/ColorScheme';
 import { Step } from './Steps.types';
 export interface StepsProps {
-    current: number | string;
-    id: number | string;
-    steps: Array<Step>;
-    className?: string;
-    scheme?: ColorScheme;
+    readonly current: number | string;
+    readonly id: number | string;
+    readonly steps: Array<Step>;
+    readonly className?: string;
+    readonly scheme?: ColorScheme;
 }
-declare function Steps({ id, children, current, steps, ...others }: PropsWithChildren<StepsProps>): JSX.Element;
+declare function Steps({ id, children, current, steps, ...others }: PropsWithChildren<StepsProps>): React.JSX.Element;
 declare namespace Steps {
     var Step: typeof StepsStep;
 }

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

@@ -1,5 +1,5 @@
-export type Step = {
+export interface Step {
     id: number | string;
     label: string;
     complete: boolean;
-};
+}

package/dist/components/Steps/StepsStep.d.ts

@@ -1,8 +1,9 @@
-import { PropsWithChildren } from 'react';
+import { default as React, PropsWithChildren } from 'react';
+import { StyledComponent } from 'styled-components';
 export interface StepsStepProps {
-    id: number | string;
-    className?: string;
+    readonly id: number | string;
+    readonly className?: string;
 }
-export declare const StepWrapper: import('styled-components').StyledComponent<"article", any, import('../../theming').ThemedProps, never>;
-declare function StepsStep({ children, id, ...others }: PropsWithChildren<StepsStepProps>): JSX.Element;
+export declare const StepWrapper: StyledComponent<"article", any, {}, never>;
+declare function StepsStep({ children, id, ...others }: PropsWithChildren<StepsStepProps>): React.JSX.Element;
 export default StepsStep;

package/dist/components/Steps/useSteps.d.ts

@@ -4,10 +4,10 @@ export interface useStepsProps {
     steps: Array<Step>;
     current?: number | string;
 }
-type State = {
+interface State {
     current: number | string;
     steps: Array<Step>;
-};
+}
 type Action = {
     type: 'navigate';
     payload: {

package/dist/components/Switch/Switch.d.ts

@@ -1,11 +1,11 @@
-import { ChangeEvent, InputHTMLAttributes } from 'react';
+import { ChangeEvent, InputHTMLAttributes, default as React } from 'react';
 interface WithAdditionalProps {
-    active?: boolean;
-    onToggle?: (event: ChangeEvent<HTMLInputElement>) => void;
-    scale?: 'default' | 'large';
+    readonly active?: boolean;
+    readonly onToggle?: (event: ChangeEvent<HTMLInputElement>) => void;
+    readonly scale?: 'default' | 'large';
 }
 export interface SwitchProps extends InputHTMLAttributes<HTMLInputElement>, WithAdditionalProps {
-    className?: string;
+    readonly className?: string;
 }
-declare function Switch({ active, className, disabled, name, onToggle, scale, ...others }: SwitchProps): JSX.Element;
+declare function Switch({ active, className, disabled, name, onToggle, scale, ...others }: SwitchProps): React.JSX.Element;
 export default Switch;

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

@@ -18,17 +18,17 @@ export interface TableSelectionCore<T extends Selectable = TableSelectableRow> {
     register: (key?: T) => void;
 }
 export declare function useTableSelectionCore<T extends Selectable>(config?: TableSelectionConfig<T>): TableSelectionCore<T>;
-export declare const TableSelectionContext: React.Context<TableSelectionCore<TableSelectableRow>>;
+export declare const TableSelectionContext: React.Context<TableSelectionCore<any>>;
 type TableSelectionProviderProps = PropsWithChildren<{
-    selection?: TableSelectionConfig;
+    readonly selection?: TableSelectionConfig;
 }>;
-export declare function TableSelectionProvider({ children, selection, }: TableSelectionProviderProps): JSX.Element;
+export declare function TableSelectionProvider({ children, selection }: TableSelectionProviderProps): React.JSX.Element;
 export declare function useTableSelection<T extends Selectable = TableSelectableRow>(): TableSelectionCore<T>;
-type TableSelectionHook<T extends Selectable = TableSelectableRow> = {
+interface TableSelectionHook<T extends Selectable = TableSelectableRow> {
     values: T[];
     clear: TableSelectionCore<T>['clear'];
-};
+}
 export declare function useSelection<T extends Selectable = TableSelectableRow>(): TableSelectionHook<T>;
 export declare function isCellSelected<T extends Selectable>(value: T, selectedRows: SelectableState<T>, config: TableSelectionSelectable<T>): boolean;
-export declare function useIsCellSelected<T extends Selectable = TableSelectableRow>(value?: T): boolean;
+export declare function useIsCellSelected(value?: Selectable): boolean;
 export {};

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

@@ -1,7 +1,8 @@
+import { default as React } from 'react';
 import { useSelection, TableSelectableRow } from './Selection';
 import { default as TableSortHandle } from './TableSortHandle';
 import { TableProps, TableSectionProps, TableRowProps, TableCellProps, TableCaptionProps, TableSelectionProps, SelectionCellProps, TablePickerItemProps, TablePickerProps, ExpandableTableRowProps } from './Table.types';
-declare function Table<T extends TableSelectableRow>({ children, selection, scale, ...others }: TableProps<T>): JSX.Element;
+declare function Table<T extends TableSelectableRow>({ children, selection, scale, ...others }: TableProps<T>): React.JSX.Element;
 declare namespace Table {
     var Head: typeof TableHead;
     var Body: typeof TableBody;
@@ -19,18 +20,18 @@ declare namespace Table {
     var SortHandle: typeof TableSortHandle;
     var Picker: typeof TablePicker;
 }
-declare function TableCaption({ children, position, height }: TableCaptionProps): JSX.Element;
-declare function TableHead({ children, ...others }: TableSectionProps): JSX.Element;
-declare function TableBody({ children, ...others }: TableSectionProps): JSX.Element;
-declare function TableCell({ children, alignment, format, ...others }: TableCellProps): JSX.Element;
-declare function SelectionCell<T extends TableSelectableRow>({ value, ...props }: SelectionCellProps<T>): JSX.Element;
-declare function SelectionHeadCell<T extends TableSelectableRow>(props: SelectionCellProps<T>): JSX.Element;
-declare function TableRow({ children, ...others }: TableRowProps): JSX.Element;
-declare function ExpandableTableRow({ expandableContent, expanded, leading: propsLeading, children, onExpandedChange, initialExpanded, ...others }: ExpandableTableRowProps): JSX.Element;
-declare function TableHeadCell({ alignment, children, onClick, ...others }: TableCellProps): JSX.Element;
-declare function TableSelectionActions({ buttons, children, ...others }: TableSelectionProps): JSX.Element;
-declare function TablePickerItem<T>({ option, checked, children, ...props }: TablePickerItemProps<T>): JSX.Element;
-declare function TablePicker<T>({ value, onChange, options, align, children, trigger: propsTrigger, ...props }: TablePickerProps<T>): JSX.Element;
+declare function TableCaption({ children, position, height }: TableCaptionProps): React.JSX.Element;
+declare function TableHead({ children, ...others }: TableSectionProps): React.JSX.Element;
+declare function TableBody({ children, ...others }: TableSectionProps): React.JSX.Element;
+declare function TableCell({ children, alignment, format, ...others }: TableCellProps): React.JSX.Element;
+declare function SelectionCell<T extends TableSelectableRow>({ value, ...props }: SelectionCellProps<T>): React.JSX.Element;
+declare function SelectionHeadCell<T extends TableSelectableRow>({ children, ...props }: SelectionCellProps<T>): React.JSX.Element;
+declare function TableRow({ children, ...others }: TableRowProps): React.JSX.Element;
+declare function ExpandableTableRow({ expandableContent, expanded, leading: propsLeading, children, onExpandedChange, initialExpanded, ...others }: ExpandableTableRowProps): React.JSX.Element;
+declare function TableHeadCell({ alignment, children, onClick, ...others }: TableCellProps): React.JSX.Element;
+declare function TableSelectionActions({ buttons, children, ...others }: TableSelectionProps): React.JSX.Element;
+declare function TablePickerItem<T>({ option, checked, children, ...props }: TablePickerItemProps<T>): React.JSX.Element;
+declare function TablePicker<T>({ value, onChange, options, align, children, trigger: propsTrigger, ...props }: TablePickerProps<T>): React.JSX.Element;
 declare namespace TablePicker {
     var Item: typeof TablePickerItem;
 }

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

@@ -1,5 +1,5 @@
 import { Selectable } from '../../hooks/useSelectable';
-import { ComponentType, HTMLAttributes, PropsWithChildren, ReactNode, ReactElement } from 'react';
+import { ComponentType, HTMLAttributes, PropsWithChildren, ReactNode } from 'react';
 import { DropdownMenuItemProps, DropdownMenuProps } from '../Dropdown';
 import { DropdownTriggerButtonProps } from '../Dropdown/DropdownTrigger';
 import { TableSelectableRow, TableSelectionConfig } from './Selection';
@@ -22,7 +22,7 @@ export interface SelectionCellProps<T extends TableSelectableRow = TableSelectab
     children?: (props: {
         selected: boolean;
         toggle: () => void;
-    }) => ReactElement;
+    }) => ReactNode;
 }
 export interface TableSectionProps extends HTMLAttributes<HTMLTableSectionElement> {
     scale?: Scale;
@@ -42,11 +42,11 @@ export interface TableCellProps extends HTMLAttributes<HTMLTableCellElement> {
     scale?: Scale;
     selected?: boolean;
 }
-export type TableColumn<T = Record<string, unknown>> = {
+export interface TableColumn<T = Record<string, unknown>> {
     /**
      * The accessor of you entry interface
      */
-    key: keyof T;
+    key: Exclude<keyof T, symbol>;
     /**
      * The label that should go in the Header cell
      */
@@ -56,7 +56,7 @@ export type TableColumn<T = Record<string, unknown>> = {
      * If omitted, `title` is used
      */
     option?: string;
-};
+}
 export type TableColumns<T> = Array<TableColumn<T>>;
 export interface TablePickerItemProps<T> extends DropdownMenuItemProps {
     option?: TableColumn<T>;

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

@@ -1,7 +1,8 @@
+import { default as React } from 'react';
 import { SortDirection } from './useSortBy.types';
 import { BoxProps } from '../Layout/Box';
 interface TableSortHandleProps extends BoxProps {
-    order?: SortDirection | null;
+    readonly order?: SortDirection | null;
 }
-declare function TableSortHandle({ order, ...rest }: TableSortHandleProps): JSX.Element | null;
+declare function TableSortHandle({ order, ...rest }: TableSortHandleProps): React.JSX.Element;
 export default TableSortHandle;