@loadsmart/loadsmart-ui 8.0.0 → 8.0.2

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

@@ -3,10 +3,10 @@ import { TableRowGroup, SortableColumn, ColumnGroup } from './useSortBy.types';
  * A hook that receives columns and table rows to sort them when sortByColumn function is called.
  * Exposes columnData, tableData and sortByColumn to be consumed by the Table component.
  *
- * @param {ColumnGroup} columnGroup a group of table columns
- * @param {TableRowGroup} tableRowGroup a group of table rows
+ * @param columnGroup a group of table columns
+ * @param tableRowGroup a group of table rows
  *
- * @returns {TableRowGroup} sorted table rows
+ * @returns sorted table rows
  */
 declare function useSortBy(columnGroup: ColumnGroup, tableRowGroup: TableRowGroup): {
     tableData: TableRowGroup;

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

@@ -1,3 +1,4 @@
+import { default as React } from 'react';
 import { RowsPerPageProps } from './TablePagination.types';
-declare function RowsPerPage({ page, rowsPerPage, onRowsPerPageChange, labelRowsPerPage, count, rowsPerPageOptions, disabled, position, align, }: RowsPerPageProps): JSX.Element;
+declare function RowsPerPage({ page, rowsPerPage, onRowsPerPageChange, labelRowsPerPage, count, rowsPerPageOptions, disabled, position, align, }: RowsPerPageProps): React.JSX.Element;
 export default RowsPerPage;

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

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

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

@@ -1,4 +1,2 @@
-export declare const NoPaddingButton: import('styled-components').StyledComponent<import('react').ForwardRefExoticComponent<import('../Button').ButtonProps & import('react').RefAttributes<HTMLButtonElement>>, any, {
-    variant: "tertiary";
-    scale: "small";
-}, "scale" | "variant">;
+import { StyledComponent } from 'styled-components';
+export declare const NoPaddingButton: StyledComponent<any, any, any, any>;

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

@@ -1,11 +1,6 @@
 import { default as React } from 'react';
 import { TablePaginationActionsProps } from './TablePagination.types';
-import { IconProps } from '../Icon';
-export declare const ActionIcon: import('styled-components').StyledComponent<React.ComponentType<import('../IconFactory').IconProps<import('../IconFactory').IconMapping>>, any, {
-    color: "neutral-darker";
-    size: "16";
-} & IconProps & {
-    rotate?: number;
-}, "size" | "color">;
-declare function TablePaginationActions({ variant, disabled, onPageChange, page, count, rowsPerPage, }: TablePaginationActionsProps): JSX.Element;
+import { StyledComponent } from 'styled-components';
+export declare const ActionIcon: StyledComponent<any, any, any, any>;
+declare function TablePaginationActions({ variant, disabled, onPageChange, page, count, rowsPerPage, }: TablePaginationActionsProps): React.JSX.Element;
 export default TablePaginationActions;

package/dist/components/Tabs/Tabs.d.ts

@@ -1,28 +1,28 @@
-import { default as React, HTMLAttributes, ReactNode } from 'react';
+import { HTMLAttributes, ReactNode, default as React } from 'react';
 import { WithDirectionProps } from './Tabs.types';
 type TabsItemsProps = HTMLAttributes<HTMLUListElement>;
 declare function TabsItems({ children, ...props }: TabsItemsProps): React.JSX.Element;
 interface TabsItemProps extends HTMLAttributes<HTMLInputElement> {
-    name: string;
-    default?: boolean;
-    leading?: ReactNode;
-    disabled?: boolean;
+    readonly name: string;
+    readonly default?: boolean;
+    readonly leading?: ReactNode;
+    readonly disabled?: boolean;
 }
 declare function TabsItem({ children, name, default: isDefault, className, onChange, leading, disabled, ...props }: TabsItemProps): React.JSX.Element;
 type PanelsItemsProps = HTMLAttributes<HTMLDivElement>;
 declare function PanelsItems({ children, ...props }: PanelsItemsProps): React.JSX.Element;
 interface PanelsItemProps extends HTMLAttributes<HTMLElement> {
-    name: string;
+    readonly name: string;
     /**
      * Renders the Panel.Item only when is visible
      * @default false
      */
-    lazy?: boolean;
+    readonly lazy?: boolean;
 }
 declare function PanelsItem({ children, name, lazy, ...props }: PanelsItemProps): React.JSX.Element;
 export interface TabsProps extends HTMLAttributes<HTMLElement>, WithDirectionProps {
-    activeTab?: string;
-    onTabChange?: (tab: string) => void;
+    readonly activeTab?: string;
+    readonly onTabChange?: (tab: string) => void;
 }
 /**
  * @example
@@ -39,7 +39,7 @@ export interface TabsProps extends HTMLAttributes<HTMLElement>, WithDirectionPro
     </Tabs.Panels>
  * </Tabs>
  */
-declare function Tabs({ children, direction, id: propId, activeTab: propTab, onTabChange, ...props }: TabsProps): JSX.Element;
+declare function Tabs({ children, direction, id: propId, activeTab: propTab, onTabChange, ...props }: TabsProps): React.JSX.Element;
 declare namespace Tabs {
     var Items: typeof TabsItems;
     var Item: typeof TabsItem;

package/dist/components/Tabs/TabsContext.d.ts

@@ -1,8 +1,9 @@
+import { Context } from 'react';
 interface TabContextValue {
     id: string;
     activeTab: string;
     setActiveTab: (name: string) => void;
     direction?: 'horizontal' | 'vertical';
 }
-export declare const TabContext: import('react').Context<TabContextValue>;
+export declare const TabContext: Context<TabContextValue>;
 export {};

package/dist/components/Tag/Tag.d.ts

@@ -1,18 +1,18 @@
-import { default as React, ReactNode, ButtonHTMLAttributes } from 'react';
+import { default as React, ButtonHTMLAttributes, ReactNode } from 'react';
 interface WithSizeProps {
-    size?: 'small' | 'default' | 'large';
+    readonly size?: 'small' | 'default' | 'large';
 }
 export interface TagProps extends React.HTMLAttributes<HTMLElement>, WithSizeProps {
-    className?: string;
-    children?: ReactNode;
-    disabled?: boolean;
-    leading?: ReactNode;
-    removable?: boolean;
-    variant?: 'accent' | 'danger' | 'default' | 'outlined' | 'success' | 'warning';
-    onRemove?: () => void;
-    getRemoveButtonProps?: () => Partial<ButtonHTMLAttributes<HTMLButtonElement>> & {
+    readonly className?: string;
+    readonly children?: ReactNode;
+    readonly disabled?: boolean;
+    readonly leading?: ReactNode;
+    readonly removable?: boolean;
+    readonly variant?: 'accent' | 'danger' | 'default' | 'outlined' | 'success' | 'warning';
+    readonly onRemove?: () => void;
+    readonly getRemoveButtonProps?: () => Partial<ButtonHTMLAttributes<HTMLButtonElement>> & {
         'data-testid'?: string;
     };
 }
-declare function Tag(props: TagProps): JSX.Element;
+declare function Tag(props: TagProps): React.JSX.Element;
 export default Tag;

package/dist/components/Text/Text.d.ts

@@ -1,9 +1,10 @@
 import { PropsWithChildren } from 'react';
 import { TypographyOptions, TypographyVariants } from '../../styles/typography';
+import { StyledComponent } from 'styled-components';
 export type TextProps = PropsWithChildren<{
     variant?: TypographyVariants;
     italic?: TypographyOptions['italic'];
     color?: TypographyOptions['color'];
 }>;
-declare const _default: import('styled-components').StyledComponent<"span", any, TextProps, never>;
+declare const _default: StyledComponent<"span", any, TextProps, never>;
 export default _default;

package/dist/components/TextField/TextField.d.ts

@@ -1,18 +1,19 @@
 import { default as React, InputHTMLAttributes, ReactNode } from 'react';
-import { default as ColorScheme } from '../../utils/types/ColorScheme';
+import { ColorScheme } from '../../utils/types/ColorScheme';
 import { default as Status } from '../../utils/types/Status';
+import { StyledComponent } from 'styled-components';
 interface WithAdditionalProps {
-    scale?: 'small' | 'default' | 'large';
-    status?: Status;
-    scheme?: ColorScheme;
-    leading?: ReactNode;
-    trailing?: ReactNode;
+    readonly scale?: 'small' | 'default' | 'large';
+    readonly status?: Status;
+    readonly scheme?: ColorScheme;
+    readonly leading?: ReactNode;
+    readonly trailing?: ReactNode;
 }
 export interface TextFieldProps extends InputHTMLAttributes<HTMLInputElement>, WithAdditionalProps {
-    className?: string;
-    children?: ReactNode;
+    readonly className?: string;
+    readonly children?: ReactNode;
 }
-export declare const Leading: import('styled-components').StyledComponent<"span", any, WithAdditionalProps, never>;
-export declare const Trailing: import('styled-components').StyledComponent<"span", any, WithAdditionalProps, never>;
+export declare const Leading: StyledComponent<"span", any, WithAdditionalProps, never>;
+export declare const Trailing: StyledComponent<"span", any, WithAdditionalProps, never>;
 declare const TextField: React.ForwardRefExoticComponent<TextFieldProps & React.RefAttributes<HTMLInputElement>>;
 export default TextField;

package/dist/components/Textarea/Textarea.d.ts

@@ -1,16 +1,16 @@
 import { default as React, TextareaHTMLAttributes, ReactNode } from 'react';
-import { default as ColorScheme } from '../../utils/types/ColorScheme';
+import { ColorScheme } from '../../utils/types/ColorScheme';
 import { default as Status } from '../../utils/types/Status';
 interface WithAdditionalProps {
-    scale?: 'small' | 'default' | 'large';
-    status?: Status;
-    scheme?: ColorScheme;
-    leading?: ReactNode;
-    trailing?: ReactNode;
+    readonly scale?: 'small' | 'default' | 'large';
+    readonly status?: Status;
+    readonly scheme?: ColorScheme;
+    readonly leading?: ReactNode;
+    readonly trailing?: ReactNode;
 }
 export interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement>, WithAdditionalProps {
-    className?: string;
-    children?: ReactNode;
+    readonly className?: string;
+    readonly children?: ReactNode;
 }
 declare const Textarea: React.ForwardRefExoticComponent<TextareaProps & React.RefAttributes<HTMLTextAreaElement>>;
 export default Textarea;

package/dist/components/Toast/Toast.d.ts

@@ -1,11 +1,11 @@
-import { BaseHTMLAttributes } from 'react';
+import { BaseHTMLAttributes, default as React } from 'react';
 import { default as Status } from '../../utils/types/Status';
 export interface ToastProps extends BaseHTMLAttributes<HTMLDivElement> {
-    message: string;
-    status?: Status;
-    timeout?: number;
-    showIcon?: boolean;
-    onClose: () => void;
+    readonly message: string;
+    readonly status?: Status;
+    readonly timeout?: number;
+    readonly showIcon?: boolean;
+    readonly onClose: () => void;
 }
-declare function Toast({ message, onClose, timeout, showIcon, status, }: ToastProps): JSX.Element;
+declare function Toast({ message, onClose, timeout, showIcon, status, }: ToastProps): React.JSX.Element;
 export default Toast;

package/dist/components/ToggleGroup/Toggle.d.ts

@@ -1,4 +1,6 @@
+import { default as React } from 'react';
 import { ToggleGroupOptionProps } from './ToggleGroup.types';
-declare function Toggle({ value, children, disabled, ...others }: ToggleGroupOptionProps): JSX.Element;
-declare const _default: import('styled-components').StyledComponent<typeof Toggle, any, {}, never>;
+import { StyledComponent } from 'styled-components';
+declare function Toggle({ value, children, disabled, ...others }: ToggleGroupOptionProps): React.JSX.Element;
+declare const _default: StyledComponent<typeof Toggle, any, {}, never>;
 export default _default;

package/dist/components/ToggleGroup/ToggleGroup.d.ts

@@ -1,6 +1,7 @@
+import { default as React } from 'react';
 import { ToggleGroupOptionProps, ToggleGroupProps } from './ToggleGroup.types';
-declare function ToggleGroup(props: ToggleGroupProps): JSX.Element;
+declare function ToggleGroup(props: ToggleGroupProps): React.JSX.Element;
 declare namespace ToggleGroup {
-    var Option: import("styled-components").StyledComponent<({ value, children, disabled, ...others }: ToggleGroupOptionProps) => JSX.Element, any, {}, never>;
+    var Option: import("styled-components").StyledComponent<({ value, children, disabled, ...others }: ToggleGroupOptionProps) => React.JSX.Element, any, {}, never>;
 }
 export default ToggleGroup;

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

@@ -1,7 +1,7 @@
 import { ButtonProps } from '../Button';
 import { HTMLAttributes } from 'react';
 import { Selectable, SelectableState, SelectableType } from '../../hooks/useSelectable';
-import { default as ColorScheme } from '../../utils/types/ColorScheme';
+import { ColorScheme } from '../../utils/types/ColorScheme';
 import { default as EventLike } from '../../utils/types/EventLike';
 export type ToggleGroupType = SelectableType;
 export type ToggleGroupOptionValue = string | number | boolean;

package/dist/components/ToggleGroup/ToggleGroupContext.d.ts

@@ -1,5 +1,5 @@
 import { default as React } from 'react';
-import { ToggleGroupProps, ToggleOption } from './ToggleGroup.types';
+import { ToggleGroupProps } from './ToggleGroup.types';
 declare const ToggleGroupContext: React.Context<Pick<ToggleGroupProps, "scale" | "disabled">>;
-export declare const SelectableContext: React.Context<import('../../hooks/useSelectable/useSelectable.types').useSelectableReturn<ToggleOption>>, useSelectable: (props: import('../../hooks/useSelectable/useSelectable.types').useSelectableProps<ToggleOption>) => import('../../hooks/useSelectable/useSelectable.types').useSelectableReturn<ToggleOption>;
+export declare const SelectableContext: any, useSelectable: any;
 export default ToggleGroupContext;

package/dist/components/Tooltip/Tooltip.d.ts

@@ -1,5 +1,5 @@
-import { HTMLAttributes, ReactNode, PropsWithChildren } from 'react';
-import { default as ColorScheme } from '../../utils/types/ColorScheme';
+import { default as React, PropsWithChildren, HTMLAttributes, ReactNode } from 'react';
+import { ColorScheme } from '../../utils/types/ColorScheme';
 import { PopoverAlign, PopoverPosition } from '../Popover';
 export declare enum TooltipPosition {
     Top = "top",
@@ -13,10 +13,10 @@ export declare enum TooltipAlign {
     End = "end"
 }
 export interface TooltipProps extends HTMLAttributes<HTMLDivElement> {
-    message: ReactNode;
-    scheme?: ColorScheme;
-    position?: TooltipPosition | PopoverPosition;
-    align?: TooltipAlign | PopoverAlign;
+    readonly message: ReactNode;
+    readonly scheme?: ColorScheme;
+    readonly position?: TooltipPosition | PopoverPosition;
+    readonly align?: TooltipAlign | PopoverAlign;
 }
-declare function Tooltip({ children, message, scheme, position, align, ...rest }: PropsWithChildren<TooltipProps>): JSX.Element;
+declare function Tooltip({ children, message, scheme, position, align, ...rest }: PropsWithChildren<TooltipProps>): React.JSX.Element;
 export default Tooltip;

package/dist/components/TopNavigation/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({ url, className, children }: LogoProps): JSX.Element;
-declare const _default: import('styled-components').StyledComponent<typeof Logo, any, LogoProps, never>;
+declare function Logo({ url, className, children }: LogoProps): React.JSX.Element;
+declare const _default: StyledComponent<typeof Logo, any, LogoProps, never>;
 export default _default;

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

@@ -1,15 +1,15 @@
-import { PropsWithChildren, ReactNode, HTMLAttributes } from 'react';
+import { default as React, PropsWithChildren, ReactNode, HTMLAttributes } from 'react';
 import { MenuDropdownSubItem } from './MenuItemDropdown';
 type MenuItemProps = HTMLAttributes<HTMLElement> & PropsWithChildren<{
-    label: string;
-    icon?: ReactNode;
-    url?: string;
+    readonly label: string;
+    readonly icon?: ReactNode;
+    readonly url?: string;
 }>;
 export type MenuProps = PropsWithChildren<{
-    align?: 'left' | 'right';
+    readonly align?: 'left' | 'right';
 }>;
-declare function MenuItem(props: MenuItemProps): JSX.Element;
-declare function Menu(props: MenuProps): JSX.Element;
+declare function MenuItem({ children, ...props }: MenuItemProps): React.JSX.Element;
+declare function Menu({ align, children }: MenuProps): React.JSX.Element;
 declare namespace Menu {
     var Item: typeof MenuItem;
     var SubItem: typeof MenuDropdownSubItem;

package/dist/components/TopNavigation/Menu/MenuItemDropdown.d.ts

@@ -1,17 +1,17 @@
-import { PropsWithChildren, ReactNode, HTMLAttributes } from 'react';
-import { Dropdown } from '../../Dropdown';
-export declare const MenuDropdown: import('styled-components').StyledComponent<typeof Dropdown, any, {}, never>;
-export declare const MenuDropdownSeparator: import('styled-components').StyledComponent<"hr", any, {}, never>;
-export declare const MenuDropdownLabel: import('styled-components').StyledComponent<"label", any, import('../../../theming').ThemedProps, never>;
+import { default as React, PropsWithChildren, ReactNode, HTMLAttributes } from 'react';
+import { StyledComponent } from 'styled-components';
+export declare const MenuDropdown: StyledComponent<any, any, any, any>;
+export declare const MenuDropdownSeparator: StyledComponent<"hr", any, {}, never>;
+export declare const MenuDropdownLabel: StyledComponent<"label", any, {}, never>;
 type MenuDropdownSubItemProps = HTMLAttributes<HTMLElement> & {
-    label: string;
-    url?: string;
-    icon?: ReactNode;
-    separator?: boolean;
+    readonly label: string;
+    readonly url?: string;
+    readonly icon?: ReactNode;
+    readonly separator?: boolean;
 };
-export declare function MenuDropdownSubItem({ icon, label, url, ...rest }: MenuDropdownSubItemProps): JSX.Element;
+export declare function MenuDropdownSubItem({ icon, label, url, ...rest }: MenuDropdownSubItemProps): React.JSX.Element;
 export type MenuItemDropdownProps = PropsWithChildren<{
-    label: string;
+    readonly label: string;
 }>;
-declare function MenuItemDropdown(props: MenuItemDropdownProps): JSX.Element;
+declare function MenuItemDropdown(props: MenuItemDropdownProps): React.JSX.Element;
 export { MenuItemDropdown };

package/dist/components/TopNavigation/Menu/MenuItemIcon.d.ts

@@ -1,8 +1,8 @@
-import { ReactNode } from 'react';
-type MenuItemIconProps = {
-    label: string;
-    icon?: ReactNode;
-    url?: string;
-};
-export declare function MenuItemIcon({ url, icon, label, ...rest }: MenuItemIconProps): JSX.Element;
+import { default as React, ReactNode } from 'react';
+interface MenuItemIconProps {
+    readonly label: string;
+    readonly icon?: ReactNode;
+    readonly url?: string;
+}
+export declare function MenuItemIcon({ url, icon, label, ...rest }: MenuItemIconProps): React.JSX.Element;
 export {};

package/dist/components/TopNavigation/OpenSideNavButton/OpenSideNavButton.d.ts

@@ -1,7 +1,9 @@
-export type OpenSideNavButtonProps = {
-    className?: string;
-    onClick: () => void;
-};
-declare function OpenSideNavButton({ className, onClick }: OpenSideNavButtonProps): JSX.Element;
-declare const _default: import('styled-components').StyledComponent<typeof OpenSideNavButton, any, OpenSideNavButtonProps, never>;
+import { default as React } from 'react';
+import { StyledComponent } from 'styled-components';
+export interface OpenSideNavButtonProps {
+    readonly className?: string;
+    readonly onClick: () => void;
+}
+declare function OpenSideNavButton({ className, onClick }: OpenSideNavButtonProps): React.JSX.Element;
+declare const _default: StyledComponent<typeof OpenSideNavButton, any, OpenSideNavButtonProps, never>;
 export default _default;

package/dist/components/TopNavigation/TopNavigation.d.ts

@@ -1,11 +1,11 @@
-import { ReactNode } from 'react';
+import { default as React, ReactNode } from 'react';
 export interface TopNavigationProps {
-    children?: ReactNode;
+    readonly children?: ReactNode;
 }
-declare function TopNavigation({ children }: TopNavigationProps): JSX.Element;
+declare function TopNavigation({ children }: TopNavigationProps): React.JSX.Element;
 declare namespace TopNavigation {
-    var Logo: import("styled-components").StyledComponent<({ url, className, children }: import("./Logo/Logo").LogoProps) => JSX.Element, any, import("./Logo/Logo").LogoProps, never>;
+    var Logo: import("styled-components").StyledComponent<({ url, className, children }: import("./Logo/Logo").LogoProps) => React.JSX.Element, any, import("./Logo/Logo").LogoProps, never>;
     var Menu: typeof import("./Menu").Menu;
-    var OpenSideNavButton: import("styled-components").StyledComponent<({ className, onClick }: import("./OpenSideNavButton/OpenSideNavButton").OpenSideNavButtonProps) => JSX.Element, any, import("./OpenSideNavButton/OpenSideNavButton").OpenSideNavButtonProps, never>;
+    var OpenSideNavButton: import("styled-components").StyledComponent<({ className, onClick }: import("./OpenSideNavButton/OpenSideNavButton").OpenSideNavButtonProps) => React.JSX.Element, any, import("./OpenSideNavButton/OpenSideNavButton").OpenSideNavButtonProps, never>;
 }
 export default TopNavigation;

package/dist/components/VisuallyHidden/VisuallyHidden.d.ts

@@ -1 +1,2 @@
-export declare const VisuallyHidden: import('styled-components').StyledComponent<"span", any, {}, never>;
+import { StyledComponent } from 'styled-components';
+export declare const VisuallyHidden: StyledComponent<"span", any, {}, never>;

package/dist/hooks/useDidMount/useDidMount.d.ts

@@ -3,7 +3,7 @@
  * on if the component is mounted.
  * Be aware that your effect, callback, memo, etc cannot list is
  * as a dependency, otherwise it will be triggered at the wrong moment.
- * @returns {boolean} Whether the component is mounted or not.
+ * @returns Whether the component is mounted or not.
  */
 declare function useDidMount(): boolean;
 export default useDidMount;

package/dist/hooks/useFingerprint/useFingerprint.d.ts

@@ -7,7 +7,6 @@ type FingerprintAdapter<T> = (item: T) => string;
  *
  * @param adapter - adapter function that gets a unique identifier for each item in the `items` prop
  * @param items - list of items whose fingerprint should be checked.
- * @returns
  */
 declare function useFingerprint<T>(adapter: FingerprintAdapter<T>, items: T[]): {
     fingerprint: string;

package/dist/hooks/useFocusTrap/useFocusTrap.d.ts

@@ -9,17 +9,16 @@ export interface useFocusTrapProps {
  *
  * Based on https://developer.mozilla.org/en-US/docs/Web/Accessibility/Keyboard-navigable_JavaScript_widgets.
  *
- * @param {useFocusTrapProps} props
- * @param {RefObject} props.containerRef - Ref to the container that will be the boundary for the focus trap.
- * @param {() => void} props.onActivate - Called when the focus trap is activated.
- * @param {() => void} props.onDeactivate - Called when the focus trap is deactivated.
- * @param {(KeyboardEvent['key'])[]} props.keys - Keys that will move the focus inside
+ * @param props
+ * @param props.containerRef - Ref to the container that will be the boundary for the focus trap.
+ * @param props.onActivate - Called when the focus trap is activated.
+ * @param props.onDeactivate - Called when the focus trap is deactivated.
+ * @param props.keys - Keys that will move the focus inside
  * the container (The current implementation only track focus for button elements). We current
  * support `Tab`, `ArrowUp`, and `ArrowDown` keys. If not provided, only the `Tab` key will be used.
- * @returns {Object}
  */
-declare function useFocusTrap<T extends HTMLElement>(props: useFocusTrapProps): {
-    containerRef: (container: T | null) => void;
+declare function useFocusTrap(props: useFocusTrapProps): {
+    containerRef: (container: HTMLElement | null) => void;
     active: boolean;
     activate: () => void;
     deactivate: () => void;

package/dist/hooks/useFocusWithin/useFocusWithin.d.ts

@@ -6,7 +6,7 @@ export interface useFocusWithinProps {
 /**
  * As CSS's focus-within is not fully supported, this hook
  * helps with identifying focus within elements.
- * @param {Object} props - Hook props
+ * @param props - Hook props
  */
 declare function useFocusWithin<T>(props?: useFocusWithinProps): {
     ref: RefObject<T>;

package/dist/hooks/useHeightExpansionToggler/useHeightExpansionToggler.d.ts

@@ -1,14 +1,14 @@
 import { RefObject } from 'react';
 import { CSSProperties } from 'styled-components';
-export type HeightExpansionToggler = {
+export interface HeightExpansionToggler {
     expanded: boolean;
     toggle: () => void;
     height: CSSProperties['height'];
-};
+}
 /**
  * A React Hook to help you expand or collapse an element by
  * checking its total height and controlling a boolean flag
- * @param {React.RefObject} targetElRef - Ref of the wrapper element
+ * @param targetElRef - Ref of the wrapper element
  */
 declare function useHeightExpansionToggler(targetElRef: RefObject<HTMLElement>): HeightExpansionToggler;
 export default useHeightExpansionToggler;

package/dist/hooks/useSelectable/SelectableStrategy.d.ts

@@ -1,11 +1,11 @@
 import { Selectable, SelectableAdapter, SelectableStrategy } from './useSelectable.types';
-export type SelectableStrategyContext<T extends Selectable> = {
+export interface SelectableStrategyContext<T extends Selectable> {
     getAdapter: (type?: string) => SelectableAdapter<T>;
-};
+}
+export declare function SingleSelectionStrategy<T extends Selectable>(context: SelectableStrategyContext<T>): SelectableStrategy<T>;
+export declare function MultipleSelectionStrategy<T extends Selectable>(context: SelectableStrategyContext<T>): SelectableStrategy<T>;
 declare function createSelectionStrategy<T extends Selectable>(props: {
     multiple?: boolean;
     adapters: Record<string, SelectableAdapter<T>>;
 }): SelectableStrategy<T>;
-export declare function SingleSelectionStrategy<T extends Selectable>(context: SelectableStrategyContext<T>): SelectableStrategy<T>;
-export declare function MultipleSelectionStrategy<T extends Selectable>(context: SelectableStrategyContext<T>): SelectableStrategy<T>;
 export default createSelectionStrategy;

package/dist/hooks/useSelectable/useSelectable.types.d.ts

@@ -7,14 +7,14 @@ export interface SelectableAdapter<T> {
 }
 export type SelectableState<T extends Selectable> = Map<SelectableKeyType, T>;
 export type SelectableType = 'single' | 'multiple';
-export type SelectableStrategy<T extends Selectable> = {
+export interface SelectableStrategy<T extends Selectable> {
     type: () => SelectableType;
     init: (items: T[]) => SelectableState<T>;
     select: (items: T[], selection: SelectableState<T>) => SelectableState<T>;
     unselect: (keys: SelectableKeyType[], selection: SelectableState<T>) => SelectableState<T>;
     toggle: (items: T[], selection: SelectableState<T>) => SelectableState<T>;
     clear: (selection: SelectableState<T>) => SelectableState<T>;
-};
+}
 export type SelectableAction<T extends Selectable> = {
     type: 'select';
     payload: T[];