@fattureincloud/fic-design-system 0.4.2 → 0.4.6-expenses.1

package/dist/components/select/hooks/useCustomSelectStyle.d.ts

@@ -0,0 +1,4 @@
+import { Styles } from 'react-select/src/styles';
+declare type sizeType = 'medium' | 'large';
+declare const useCustomSelectStyle: (size?: sizeType) => Partial<Styles>;
+export default useCustomSelectStyle;

package/dist/components/select/index.d.ts

@@ -0,0 +1,4 @@
+import { TSelect, TSelectAsync, TSelectCreatable } from './typings/select';
+export declare const Select: TSelect;
+export declare const SelectCreatable: TSelectCreatable;
+export declare const SelectAsync: TSelectAsync;

package/dist/components/select/select.stories.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/select/typings/select.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="react" />
+import { default as Select } from 'react-select';
+import { default as AsyncSelect } from 'react-select/async';
+import CreatableSelect from 'react-select/creatable';
+import { InputActionMeta } from 'react-select/src/types';
+export interface Props {
+    label?: string;
+    size?: 'medium' | 'large' | undefined;
+    inputChange?: (newValue: string, actionMeta: InputActionMeta) => void;
+    getRef?: (node: any) => any;
+}
+export declare type TSelectProps = React.ComponentProps<typeof Select & Props>;
+export declare type TAsyncSelectProps = React.ComponentProps<typeof AsyncSelect & Props>;
+export declare type TSelectPropsCreatable = React.ComponentProps<typeof CreatableSelect> & {
+    label?: string;
+    size?: 'medium' | 'large' | undefined;
+    inputChange?: (newValue: string, actionMeta: InputActionMeta) => void;
+    createOption?: (inputValue: string) => void;
+};
+export declare type TSelect = React.FunctionComponent<TSelectProps>;
+export declare type TSelectCreatable = React.FunctionComponent<TSelectPropsCreatable>;
+export declare type TSelectAsync = React.FunctionComponent<TAsyncSelectProps>;

package/dist/components/select/utils.d.ts

@@ -0,0 +1 @@
+export declare const getRenderComponents: (size: string, isDisabled?: boolean | undefined, isSearchable?: boolean | undefined, menuIsOpen?: boolean | undefined) => {};

package/dist/components/stepBar/components/singleStep.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+import { StepProps } from '../types';
+export declare const SingleStep: (props: StepProps) => JSX.Element;

package/dist/components/stepBar/components/styledStepBarWrapper.d.ts

@@ -0,0 +1,2 @@
+import { UnstyledStepBarPropsInterface } from '../types';
+export declare const StyledStepBarWrapper: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, UnstyledStepBarPropsInterface, never>;

package/dist/components/stepBar/index.d.ts

@@ -0,0 +1,2 @@
+import StepBar from './stepBar';
+export { StepBar };

package/dist/components/stepBar/stepBar.d.ts

@@ -0,0 +1,7 @@
+import { Component } from 'react';
+import { TStepBar, UnstyledStepBarPropsInterface, UnstyledStepBarStateInterface } from './types';
+export declare class UnstyledStepBar extends Component<UnstyledStepBarPropsInterface, UnstyledStepBarStateInterface> {
+    render(): JSX.Element;
+}
+declare const StepBar: TStepBar;
+export default StepBar;

package/dist/components/stepBar/stepBar.stories.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,15 @@
+/// <reference types="react" />
+export interface StepProps {
+    title: string;
+    type: 'standard' | 'current' | 'completed';
+    number: number;
+}
+interface Props {
+    stepList: Array<StepProps>;
+}
+export declare type TStepBar = React.FunctionComponent<Props>;
+export interface UnstyledStepBarPropsInterface extends Props {
+}
+export interface UnstyledStepBarStateInterface {
+}
+export {};

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

@@ -0,0 +1,10 @@
+/// <reference types="react" />
+import { Row } from 'react-table';
+import { RowActions, TableData } from '../types';
+interface Props<T extends TableData> {
+    row: Row<T>;
+    actions?: RowActions<T>;
+    renderActions?: () => JSX.Element;
+}
+declare const ActionsCell: <T extends TableData>({ row, actions, renderActions }: Props<T>) => JSX.Element;
+export default ActionsCell;

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

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+export interface EmptyTablePageProps {
+    columnsCount: number;
+    EmptyPage?: JSX.Element;
+}
+declare const EmptyState: ({ columnsCount, EmptyPage }: EmptyTablePageProps) => JSX.Element;
+export default EmptyState;

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

@@ -0,0 +1,6 @@
+interface Props {
+    count: number;
+    resetSelection: () => void;
+}
+declare const SelectedRowsCount: ({ count, resetSelection }: Props) => JSX.Element;
+export default SelectedRowsCount;

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

@@ -0,0 +1,6 @@
+interface Props {
+    isSorted: boolean;
+    isSortedDesc?: boolean;
+}
+declare const SortIndicator: ({ isSorted, isSortedDesc }: Props) => JSX.Element;
+export default SortIndicator;

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

@@ -0,0 +1,13 @@
+import { Row, UseTableInstanceProps } from 'react-table';
+import { TableData } from '../types';
+interface Props<T extends TableData> {
+    rows: Row<T>[];
+    prepareRow: UseTableInstanceProps<T>['prepareRow'];
+    selectedRowsIds: string[];
+}
+declare const TableBody: <T extends TableData>({ rows, prepareRow, selectedRowsIds }: Props<T>) => JSX.Element;
+export interface TableBodyTrProps {
+    isSelected?: boolean;
+    isDisabled?: boolean;
+}
+export default TableBody;

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

@@ -0,0 +1,2 @@
+declare const TableFoot: import("styled-components").StyledComponent<"tfoot", import("styled-components").DefaultTheme, {}, never>;
+export default TableFoot;

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

@@ -0,0 +1,7 @@
+import { HeaderGroup } from 'react-table';
+import { TableData } from '../types';
+interface Props<T extends TableData> {
+    headerGroups: HeaderGroup<T>[];
+}
+declare const TableHeader: <T extends TableData>({ headerGroups }: Props<T>) => JSX.Element;
+export default TableHeader;

package/dist/components/table/components/actions/DropdownActions.d.ts

@@ -0,0 +1,9 @@
+import { Row } from 'react-table';
+import { RowAction, TableData } from '../../types';
+interface Props<T extends TableData> {
+    row: Row<T>;
+    actions: RowAction<T>[];
+    rowIsDisabled?: boolean;
+}
+declare const DropdownActions: <T extends TableData>({ row, actions, rowIsDisabled }: Props<T>) => JSX.Element;
+export default DropdownActions;

package/dist/components/table/components/actions/PrimaryAction.d.ts

@@ -0,0 +1,11 @@
+import { Row } from 'react-table';
+import { DropdownItemType } from '../../../dropdown/types';
+import { RowAction, TableData } from '../../types';
+interface Props<T extends TableData> {
+    action: RowAction<T>;
+    row: Row<T>;
+    rowIsDisabled?: boolean;
+    type?: DropdownItemType;
+}
+declare const PrimaryAction: <T extends TableData>({ action, row, rowIsDisabled, type, }: Props<T>) => JSX.Element | null;
+export default PrimaryAction;

package/dist/components/table/components/checkboxes/Cell.d.ts

@@ -0,0 +1,4 @@
+import { CellProps } from 'react-table';
+import { TableData } from '../../types';
+declare const Cell: <T extends TableData>({ row }: CellProps<T, any>) => JSX.Element;
+export default Cell;

package/dist/components/table/components/checkboxes/Header.d.ts

@@ -0,0 +1,4 @@
+import { HeaderProps } from 'react-table';
+import { TableData } from '../../types';
+declare const Header: <T extends TableData>(props: HeaderProps<T>) => JSX.Element;
+export default Header;

package/dist/components/table/components/checkboxes/useHeaderCheckboxProps.d.ts

@@ -0,0 +1,12 @@
+import { PropsWithChildren } from 'react';
+import { HeaderProps, TableToggleAllRowsSelectedProps } from 'react-table';
+import { TableData } from '../../types';
+interface Props<T extends TableData> {
+    headerProps: PropsWithChildren<HeaderProps<T>>;
+    selectSinglePage?: boolean;
+}
+interface ReturnType extends TableToggleAllRowsSelectedProps {
+    disabled: boolean;
+}
+declare const useHeaderCheckboxProps: <T extends TableData>({ headerProps, selectSinglePage, }: Props<T>) => ReturnType;
+export default useHeaderCheckboxProps;

package/dist/components/table/components/customizationModal/customizationsModal.d.ts

@@ -1,10 +1,9 @@
 import { Component } from 'react';
-import { DropResult, ResponderProvided } from 'react-beautiful-dnd';
 import { CustomizationsModalPropsInterface, CustomizationsModalStateInterface } from '../../typings/main';
 export declare class CustomizationsModal extends Component<CustomizationsModalPropsInterface, CustomizationsModalStateInterface> {
     constructor(props: CustomizationsModalPropsInterface);
     propertiesDisplayHandler: (id: string) => void;
-    onDragEnd: (result: DropResult, provided: ResponderProvided) => void;
+    onDragEnd: (result: any, provided: any) => void;
     resetProperties: () => void;
     render(): JSX.Element;
 }

package/dist/components/table/components/customizationModal/utils.d.ts

@@ -1,6 +1,6 @@
 import { CSSProperties } from 'react';
-import { DraggableStateSnapshot, DraggingStyle, NotDraggingStyle } from 'react-beautiful-dnd';
+import { DraggingStyle, NotDraggingStyle } from 'react-beautiful-dnd';
 import { TControlledProperties } from '../../typings/main';
-export declare const getItemStyle: (snapshot: DraggableStateSnapshot, draggableStyle?: DraggingStyle | NotDraggingStyle | undefined) => React.CSSProperties;
+export declare const getItemStyle: (snapshot: any, draggableStyle?: DraggingStyle | NotDraggingStyle) => React.CSSProperties;
 export declare const getListStyle: (isDraggingOver: boolean) => CSSProperties;
 export declare const reorder: (list: TControlledProperties, startIndex: number, endIndex: number) => import("../../typings/main").TControlledProperty[];

package/dist/components/table/components/pagination/PageButton.d.ts

@@ -0,0 +1,10 @@
+import { ReactText } from 'react';
+interface Props extends PageButtonWrapperProps {
+    text: ReactText;
+    onClick: () => void;
+}
+declare const PageButton: ({ text, onClick, isActive }: Props) => JSX.Element;
+export interface PageButtonWrapperProps {
+    isActive: boolean;
+}
+export default PageButton;

package/dist/components/table/components/pagination/PaginationButtons.d.ts

@@ -0,0 +1,9 @@
+import { UsePaginationInstanceProps } from 'react-table';
+import { TableData } from '../../types';
+interface Props<T extends TableData> {
+    pageCount: number;
+    pageIndex: number;
+    gotoPage: UsePaginationInstanceProps<T>['gotoPage'];
+}
+declare const PaginationButtons: <T extends TableData>({ pageCount, pageIndex, gotoPage }: Props<T>) => JSX.Element;
+export default PaginationButtons;

package/dist/components/table/components/pagination/utils.d.ts

@@ -0,0 +1,14 @@
+import { DefaultTheme } from 'styled-components';
+import { paletteColor } from '../../../../styles/types';
+import { PageButtonWrapperProps } from './PageButton';
+interface GetPageButtonParams extends PageButtonWrapperProps {
+    theme: DefaultTheme;
+}
+export interface PageButtonStyles {
+    color: paletteColor;
+    background: paletteColor;
+    hoverColor: paletteColor;
+    hoverBackground: paletteColor;
+}
+export declare const getPageButtonStyles: ({ theme, isActive }: GetPageButtonParams) => PageButtonStyles;
+export {};

package/dist/components/table/components/tableParts/TableTd.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+declare type alignType = 'left' | 'center' | 'right';
+interface Props extends React.HTMLAttributes<HTMLTableDataCellElement> {
+    align?: alignType;
+}
+export declare const TableTd: import("styled-components").StyledComponent<({ children, align, ...rest }: Props) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export default TableTd;

package/dist/components/table/components/tableParts/TableTh.d.ts

@@ -0,0 +1,4 @@
+import React from 'react';
+declare type Props = React.HTMLAttributes<HTMLTableHeaderCellElement>;
+export declare const TableTh: import("styled-components").StyledComponent<({ children, ...rest }: Props) => JSX.Element, import("styled-components").DefaultTheme, {}, never>;
+export default TableTh;

package/dist/components/table/components/tableParts/styled.d.ts

@@ -0,0 +1,2 @@
+export declare const TableWrapper: import("styled-components").StyledComponent<"table", import("styled-components").DefaultTheme, {}, never>;
+export declare const TableTr: import("styled-components").StyledComponent<"tr", import("styled-components").DefaultTheme, {}, never>;

package/dist/components/table/hooks/useCheckboxesComponents.d.ts

@@ -0,0 +1,4 @@
+import { Hooks } from 'react-table';
+import { TableData } from '../types';
+declare const useCheckboxesComponents: <T extends TableData>(hooks: Hooks<T>) => void;
+export default useCheckboxesComponents;

package/dist/components/table/hooks/useTableHooks.d.ts

@@ -0,0 +1,6 @@
+import { PluginHook } from 'react-table';
+import { TableProps } from '../Table';
+import { TableData } from '../types';
+declare type Props<T extends TableData> = Pick<TableProps<T>, 'actions' | 'withCheckbox' | 'renderActions'>;
+declare const useTableHooks: <T extends TableData>({ actions, renderActions, withCheckbox }: Props<T>) => PluginHook<T>[];
+export default useTableHooks;

package/dist/components/table/hooks/useTableValues.d.ts

@@ -0,0 +1,14 @@
+import { Dispatch, SetStateAction } from 'react';
+import { Row } from 'react-table';
+import { TableData } from '../types';
+interface Props {
+    initialFilter?: string;
+}
+interface ReturnType<DataType extends TableData> {
+    filter: string;
+    setFilter: Dispatch<SetStateAction<string>>;
+    selection: Row<DataType>[];
+    setSelection: Dispatch<SetStateAction<Row<DataType>[]>>;
+}
+declare const useTableValues: <DataType extends TableData>({ initialFilter }?: Props) => ReturnType<DataType>;
+export default useTableValues;

package/dist/components/table/stories/columns.d.ts

@@ -0,0 +1,3 @@
+import { Column } from 'react-table';
+import { DataType } from './components/types';
+export declare const columns: Column<DataType>[];

package/dist/components/table/stories/components/CustomPerson.d.ts

@@ -0,0 +1,6 @@
+import { CustomPersonData } from './types';
+interface Props {
+    value: CustomPersonData;
+}
+declare const CustomPerson: ({ value: { img, name, role } }: Props) => JSX.Element;
+export default CustomPerson;

package/dist/components/table/stories/components/Role.d.ts

@@ -0,0 +1,7 @@
+export declare const rolesArray: readonly ["master", "admin", undefined];
+export declare type roleType = typeof rolesArray[number];
+interface Props {
+    role: roleType;
+}
+declare const Role: ({ role }: Props) => JSX.Element | null;
+export default Role;

package/dist/components/table/stories/components/types.d.ts

@@ -0,0 +1,14 @@
+import { roleType } from './Role';
+export interface CustomPersonData {
+    img: string;
+    name: string;
+    role?: roleType;
+}
+export interface DataType {
+    person: CustomPersonData;
+    name: string;
+    address: string;
+    date: string;
+    order: number;
+    isDisabled?: boolean;
+}

package/dist/components/table/stories/data.d.ts

@@ -0,0 +1,2 @@
+import { DataType } from './components/types';
+export declare const getRandomUsers: (n: number) => DataType[];

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

@@ -0,0 +1,33 @@
+import { colorsPalette } from '../../common/types/colorsPalette';
+import { ButtonProps, IconButtonProps } from '../buttons';
+import { DropdownItemType } from '../dropdown/types';
+declare type TableHeaderPalette = colorsPalette;
+declare type rowStatus = 'normal' | 'hover' | 'selected' | 'disabled';
+declare type TableRowsPalette = {
+    [k in rowStatus]: colorsPalette;
+};
+interface SelectedRowsCountPalette extends colorsPalette {
+    resetButtonColor: ButtonProps['color'];
+}
+declare type paginationItemStatus = 'normal' | 'hover' | 'active';
+declare type PaginationPalette = {
+    numbers: {
+        [k in paginationItemStatus]: colorsPalette;
+    };
+    buttons: ButtonProps['color'];
+};
+declare type ActionsPalette = {
+    colors: {
+        [k in DropdownItemType]: ButtonProps['color'];
+    };
+    dropdownTriggerColor: IconButtonProps['color'];
+};
+export interface TablePalette {
+    header: TableHeaderPalette;
+    rows: TableRowsPalette;
+    selectedRowsCount: SelectedRowsCountPalette;
+    actions: ActionsPalette;
+    pagination: PaginationPalette;
+}
+declare const tablePalette: TablePalette;
+export default tablePalette;

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

@@ -0,0 +1,27 @@
+import { Row, SortingRule } from 'react-table';
+import { DropdownItemType } from '../dropdown/types';
+import { IconProps } from '../icon';
+export interface TableData {
+    isDisabled?: boolean;
+}
+export interface CustomColumn {
+    align?: 'left' | 'center' | 'right';
+}
+export interface RowActions<T extends TableData> {
+    primary?: RowAction<T>;
+    dropdown?: RowAction<T>[];
+}
+export interface RowAction<T extends TableData> {
+    icon?: IconProps;
+    type?: DropdownItemType;
+    text: string;
+    onClick: (row: Row<T>) => void;
+    isDisabled?: boolean;
+}
+interface ManualPaginationConfig {
+    pageCount: number;
+    setCurrentPage: (page: number) => void;
+}
+export declare type ManualPagination = ManualPaginationConfig | undefined;
+export declare type OnSort<T extends TableData> = (sortBy: Array<SortingRule<T>>) => void;
+export {};

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

@@ -0,0 +1,14 @@
+import { DefaultTheme } from 'styled-components';
+import { paletteColor } from '../../styles/types';
+import { TableBodyTrProps } from './components/TableBody';
+interface GetTableBodyTrStylesParams extends TableBodyTrProps {
+    theme: DefaultTheme;
+}
+export interface TableBodyTrStyles {
+    background: paletteColor;
+    color: paletteColor;
+    hoverColor: paletteColor;
+    hoverBackground: paletteColor;
+}
+export declare const getTableBodyTrStyles: ({ theme, isDisabled, isSelected, }: GetTableBodyTrStylesParams) => TableBodyTrStyles;
+export {};

package/dist/components/tabs/components/item/Item.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { TabsItem } from '../../types';
+interface Props extends TabsItem {
+    tabRef?: React.RefObject<HTMLDivElement>;
+}
+declare const Item: ({ handleClick, active, text, tabRef }: Props) => JSX.Element;
+export { Props as TabsItemProps };
+export default Item;

package/dist/components/tabs/components/item/components/ActiveTag.d.ts

@@ -0,0 +1,6 @@
+import { TabsItem } from '../../../types';
+interface ActiveTagType {
+    active: TabsItem['active'];
+}
+declare const ActiveTag: import("styled-components").StyledComponent<"span", any, ActiveTagType, never>;
+export default ActiveTag;

package/dist/components/tabs/components/item/components/Tab.d.ts

@@ -0,0 +1,6 @@
+import { TabsItem } from '../../../types';
+interface TabTypes {
+    active: TabsItem['active'];
+}
+declare const Tab: import("styled-components").StyledComponent<"span", any, TabTypes, never>;
+export default Tab;

package/dist/components/tabs/components/tabsDropdown/TabsDropdown.d.ts

@@ -0,0 +1,8 @@
+/// <reference types="react" />
+import { TabsItem } from '../../types';
+interface Props {
+    active: TabsItem['active'];
+    items: TabsItem[];
+}
+declare const TabsDropdown: ({ active, items }: Props) => JSX.Element;
+export default TabsDropdown;

package/dist/components/tabs/components/tabsDropdown/components/TabsDropdownTrigger.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="react" />
+import { TabsItem } from '../../../types';
+interface Props {
+    active: TabsItem['active'];
+}
+declare const TabsDropdownTrigger: ({ active }: Props) => JSX.Element;
+export default TabsDropdownTrigger;

package/dist/components/tabs/hooks/useResizedWidth.d.ts

@@ -0,0 +1,7 @@
+import { UseMeasureRef } from 'react-use/lib/useMeasure';
+interface ReturnType {
+    elementsWrapperRef: UseMeasureRef<HTMLDivElement>;
+    wrapperWidth: number;
+}
+declare const useResizedWidth: () => ReturnType;
+export default useResizedWidth;

package/dist/components/tabs/hooks/useTabItemsCount.d.ts

@@ -0,0 +1,12 @@
+import { RefObject } from 'react';
+import { TabsProps } from '../tabs';
+interface Params extends Required<Pick<TabsProps, 'distance' | 'lateralPadding' | 'scrollable'>> {
+    tabsLength: number;
+    wrapperWidth: number;
+    tabsRefs: RefObject<HTMLDivElement>[];
+}
+interface ReturnType {
+    visibleCount: number;
+}
+declare const useTabItemsCount: ({ scrollable, distance, tabsLength, wrapperWidth, tabsRefs, lateralPadding }: Params) => ReturnType;
+export default useTabItemsCount;

package/dist/components/tabs/tabs.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+import { TabsItem } from './types';
+interface Props {
+    className?: string;
+    tabs: TabsItem[];
+    distance?: number;
+    lateralPadding?: number;
+    scrollable?: boolean;
+}
+declare const Tabs: ({ tabs, className, scrollable, distance, lateralPadding }: Props) => JSX.Element;
+export { Props as TabsProps };
+export default Tabs;

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

@@ -0,0 +1,5 @@
+export interface TabsItem {
+    text: string;
+    active?: boolean;
+    handleClick?: () => void;
+}

package/dist/components/tag/components/StyledTag.d.ts

@@ -0,0 +1,10 @@
+import { IconProps } from '../../../index';
+import { TagStyle, TagType } from '../types';
+export declare const StyledTag: import("styled-components").StyledComponent<"div", any, {
+    type: TagType;
+    tagStyle: TagStyle;
+}, never>;
+export declare const TagText: import("styled-components").StyledComponent<"div", any, {
+    leftIcon: IconProps | undefined;
+    rightIcon: IconProps | undefined;
+}, never>;

package/dist/components/tag/index.d.ts

@@ -1,3 +1,4 @@
 import { Tag } from './Tag';
 import tagPalette, { TagPalette } from './tagPalette';
-export { Tag, tagPalette, TagPalette };
+import { TagProps } from './types';
+export { Tag, TagProps, tagPalette, TagPalette };

package/dist/components/test/index.d.ts

@@ -0,0 +1,2 @@
+import test from './test';
+export { test };

package/dist/components/test/test.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+export default class Test extends React.Component<{}, {}> {
+    static variabileStatica: string;
+    render(): JSX.Element;
+}

package/dist/components/textButton/TextButton.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="react" />
+interface Props extends WrapperProps {
+    text: string;
+}
+declare const TextButton: ({ isDisabled, onClick, text, ...rest }: Props) => JSX.Element;
+interface WrapperProps {
+    color?: 'blue' | 'red' | 'green' | 'yellow' | 'white';
+    isDisabled?: boolean;
+    onClick: () => void;
+    className?: string;
+}
+export default TextButton;

package/dist/components/textButton/index.d.ts

@@ -0,0 +1,2 @@
+import TextButton from './TextButton';
+export { TextButton };

package/dist/components/textButton/textButton.stories.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/tooltips/components/message.d.ts

@@ -0,0 +1,12 @@
+import { TPlacement } from '../types';
+interface MessageInterface {
+    messageHeight: number;
+    messageWidth: number;
+    placement: TPlacement;
+    triggerDimension: {
+        width: number;
+        height: number;
+    };
+}
+export declare const Message: import("styled-components").StyledComponent<"div", import("styled-components").DefaultTheme, MessageInterface, never>;
+export {};

package/dist/components/tooltips/components/styledTooltipWrapper.d.ts

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

package/dist/components/tooltips/index.d.ts

@@ -0,0 +1,2 @@
+import Tooltip from './tooltips';
+export { Tooltip };

package/dist/components/tooltips/tooltips.d.ts

@@ -0,0 +1,15 @@
+import React, { Component } from 'react';
+import { UnstyledTooltipPropsInterface, UnstyledTooltipStateInterface, TTooltip } from './types';
+export declare class UnstyledTooltip extends Component<UnstyledTooltipPropsInterface, UnstyledTooltipStateInterface> {
+    constructor(props: UnstyledTooltipPropsInterface);
+    messageRef: React.RefObject<HTMLDivElement>;
+    triggerRef: React.RefObject<HTMLDivElement>;
+    componentDidMount(): void;
+    componentDidUpdate(prevProps: UnstyledTooltipPropsInterface): void;
+    handleMouseLeave: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    handleMouseEnter: (e: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    updateStateDimensions: (width: number, height: number) => void;
+    render(): JSX.Element;
+}
+declare const Tooltip: TTooltip;
+export default Tooltip;

package/dist/components/tooltips/tooltips.stories.d.ts

@@ -0,0 +1 @@
+export {};