@vibe/core 3.81.1-alpha-635d8.0 → 3.81.1

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

@@ -0,0 +1,79 @@
+import React, { type ReactElement } from "react";
+import { type VibeComponentProps } from "../../../types";
+import { type TableHeaderProps } from "../TableHeader/TableHeader";
+import { type TableBodyProps } from "../TableBody/TableBody";
+import { RowSizes as RowSizesEnum } from "./TableConsts";
+import { type RowSizes } from "./Table.types";
+import { type SubIcon } from "@vibe/icon";
+export type TableLoadingStateType = "long-text" | "medium-text" | "circle" | "rectangle";
+type Width = number | `${number}%` | `${number}px` | `${number}fr`;
+export interface TableColumn {
+    /**
+     * Unique identifier for the column.
+     */
+    id: string;
+    /**
+     * Column title displayed in the header.
+     */
+    title: string;
+    /**
+     * Additional information displayed as a tooltip.
+     */
+    infoContent?: string;
+    /**
+     * Column width configuration.
+     */
+    width?: Width | {
+        min: Width;
+        max: Width;
+    };
+    /**
+     * Icon displayed next to the column title.
+     */
+    icon?: SubIcon;
+    /**
+     * Loading state type for the column when data is being fetched.
+     */
+    loadingStateType?: TableLoadingStateType;
+}
+export interface TableProps extends VibeComponentProps {
+    /**
+     * Defines the columns of the table.
+     */
+    columns: TableColumn[];
+    /**
+     * State of the data being displayed (loading or error).
+     */
+    dataState?: {
+        isLoading?: boolean;
+        isError?: boolean;
+    };
+    /**
+     * React element displayed when there is an error state.
+     */
+    errorState: ReactElement;
+    /**
+     * React element displayed when there is no data.
+     */
+    emptyState: ReactElement;
+    /**
+     * Custom styles for the table.
+     */
+    style?: React.CSSProperties;
+    /**
+     * The child components inside the table, such as `<TableHeader />` and `<TableBody />`.
+     */
+    children?: ReactElement<TableHeaderProps> | ReactElement<TableBodyProps> | Array<ReactElement<TableHeaderProps> | ReactElement<TableBodyProps>>;
+    /**
+     * The row size of the table.
+     */
+    size?: RowSizes;
+    /**
+     * If true, removes the table's outer border.
+     */
+    withoutBorder?: boolean;
+}
+declare const _default: React.ForwardRefExoticComponent<TableProps & React.RefAttributes<HTMLElement>> & {
+    sizes: typeof RowSizesEnum;
+};
+export default _default;

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

@@ -0,0 +1 @@
+export type RowSizes = "small" | "medium" | "large";

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

@@ -0,0 +1,14 @@
+export declare const SKELETON_ROWS_AMOUNT = 5;
+/**
+ * @deprecated
+ */
+export declare enum RowSizes {
+    SMALL = "small",
+    MEDIUM = "medium",
+    LARGE = "large"
+}
+export declare const RowHeights: {
+    small: number;
+    medium: number;
+    large: number;
+};

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

@@ -0,0 +1,12 @@
+import { type AriaAttributes } from "react";
+import type React from "react";
+import { type TableColumn, type TableLoadingStateType } from "./Table";
+import { type TableHeaderCellProps } from "../TableHeaderCell/TableHeaderCell";
+import { SkeletonType } from "../../Skeleton/SkeletonConstants";
+export declare function generateWidth(width: TableColumn["width"]): string;
+export declare function getTableRowLayoutStyles(columns: TableColumn[], style?: React.CSSProperties): React.CSSProperties;
+export declare function getSortIcon(sortState: TableHeaderCellProps["sortState"]): React.FC<import("@vibe/icons/dist/react/SortAscending").SortAscendingProps>;
+export declare function getNextSortState(sortState: TableHeaderCellProps["sortState"]): TableHeaderCellProps["sortState"];
+export declare function getAriaSort(sortState: TableHeaderCellProps["sortState"]): AriaAttributes["aria-sort"];
+export declare function getSkeletonType(loadingStateType: TableLoadingStateType): SkeletonType;
+export declare function getLoadingTypeForCell(loadingStateType: TableLoadingStateType, rowIndex: number): TableLoadingStateType;

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

@@ -0,0 +1,12 @@
+import React, { type ReactElement, type ComponentProps } from "react";
+import { type VibeComponentProps } from "../../../types";
+import { type TableRowProps } from "../TableRow/TableRow";
+import type VirtualizedList from "../../VirtualizedList/VirtualizedList";
+export interface TableBodyProps extends VibeComponentProps {
+    /**
+     * The child components inside the table body, such as `<TableRow />` elements.
+     */
+    children?: ReactElement<TableRowProps> | ReactElement<TableRowProps>[] | ReactElement<ComponentProps<typeof VirtualizedList>>;
+}
+declare const TableBody: React.ForwardRefExoticComponent<TableBodyProps & React.RefAttributes<HTMLDivElement>>;
+export default TableBody;

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

@@ -0,0 +1,14 @@
+import React from "react";
+import { type VibeComponentProps } from "../../../types";
+export interface TableCellProps extends VibeComponentProps {
+    /**
+     * The content inside the table cell.
+     */
+    children?: React.ReactNode;
+    /**
+     * If true, makes the cell sticky (typically used for frozen columns).
+     */
+    sticky?: boolean;
+}
+declare const TableCell: React.ForwardRefExoticComponent<TableCellProps & React.RefAttributes<HTMLDivElement>>;
+export default TableCell;

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

@@ -0,0 +1,15 @@
+import React from "react";
+import { type VibeComponentProps } from "../../../types";
+import { type TableLoadingStateType } from "../Table/Table";
+export interface TableCellSkeletonProps extends VibeComponentProps {
+    /**
+     * The type of loading state for the skeleton.
+     */
+    type?: TableLoadingStateType;
+    /**
+     * If true, renders a shorter skeleton for text-based loading states.
+     */
+    short?: boolean;
+}
+declare const TableCellSkeleton: React.FC<TableCellSkeletonProps>;
+export default TableCellSkeleton;

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

@@ -0,0 +1,4 @@
+import React from "react";
+import { type TableContainerProps } from "./TableContainer.types";
+declare const TableContainer: React.ForwardRefExoticComponent<TableContainerProps & React.RefAttributes<HTMLDivElement>>;
+export default TableContainer;

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

@@ -0,0 +1,12 @@
+import type React from "react";
+import { type VibeComponentProps } from "../../../types";
+export interface TableContainerProps extends VibeComponentProps {
+    /**
+     * Custom styles for the table container.
+     */
+    style?: React.CSSProperties;
+    /**
+     * The child elements inside the table container.
+     */
+    children: React.ReactNode;
+}

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

@@ -0,0 +1,11 @@
+import React from "react";
+import { type VibeComponentProps } from "../../../types";
+import { type TableHeaderCellProps } from "../TableHeaderCell/TableHeaderCell";
+export interface TableHeaderProps extends VibeComponentProps {
+    /**
+     * The child elements inside the table header, typically `<TableHeaderCell />` components.
+     */
+    children?: React.ReactElement<TableHeaderCellProps> | React.ReactElement<TableHeaderCellProps>[];
+}
+declare const TableHeader: React.ForwardRefExoticComponent<TableHeaderProps & React.RefAttributes<HTMLDivElement>>;
+export default TableHeader;

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

@@ -0,0 +1,35 @@
+import React from "react";
+import { type VibeComponentProps } from "../../../types";
+import { type SubIcon } from "@vibe/icon";
+export interface TableHeaderCellProps extends VibeComponentProps {
+    /**
+     * The title of the column, displayed inside the header cell.
+     */
+    title: string | React.ReactNode;
+    /**
+     * Icon displayed next to the column title.
+     */
+    icon?: SubIcon;
+    /**
+     * Tooltip content for additional information about the column.
+     */
+    infoContent?: string;
+    /**
+     * Current sorting state of the column.
+     */
+    sortState?: "asc" | "desc" | "none";
+    /**
+     * Callback fired when the column header is clicked to change sorting.
+     */
+    onSortClicked?: (direction: "asc" | "desc" | "none") => void;
+    /**
+     * ARIA label for the sort button.
+     */
+    sortButtonAriaLabel?: string;
+    /**
+     * If true, the header cell remains visible while scrolling horizontally.
+     */
+    sticky?: boolean;
+}
+declare const TableHeaderCell: React.ForwardRefExoticComponent<TableHeaderCellProps & React.RefAttributes<HTMLDivElement>>;
+export default TableHeaderCell;

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

@@ -0,0 +1,19 @@
+import React from "react";
+import { type VibeComponentProps } from "../../../types";
+import { type TableCellProps } from "../TableCell/TableCell";
+export interface TableRowProps extends VibeComponentProps {
+    /**
+     * If true, applies a highlighted style to the row.
+     */
+    highlighted?: boolean;
+    /**
+     * The child components inside the table row, typically `<TableCell />` elements.
+     */
+    children?: React.ReactElement<TableCellProps> | React.ReactElement<TableCellProps>[];
+    /**
+     * Custom styles applied to the table row.
+     */
+    style?: React.CSSProperties;
+}
+declare const TableRow: React.ForwardRefExoticComponent<TableRowProps & React.RefAttributes<HTMLDivElement>>;
+export default TableRow;

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

@@ -0,0 +1,4 @@
+import React from "react";
+import { type TableMenuProps } from "./TableRowMenu.types";
+declare const TableRowMenu: React.ForwardRefExoticComponent<TableMenuProps & React.RefAttributes<HTMLDivElement>>;
+export default TableRowMenu;

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

@@ -0,0 +1,12 @@
+import { type VibeComponentProps } from "../../../types";
+import type React from "react";
+export interface TableMenuProps extends VibeComponentProps {
+    /**
+     * The ID of the row that the menu is associated with.
+     */
+    rowId: string;
+    /**
+     * The child elements inside the table menu.
+     */
+    children?: React.ReactNode;
+}

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

@@ -0,0 +1,35 @@
+import React from "react";
+import { type VibeComponentProps } from "../../../types";
+import { type ScrollDirection } from "react-window";
+import { type TableColumn } from "../Table/Table";
+export type TableVirtualizedRow = Record<string, unknown> & {
+    id: string;
+};
+export interface TableVirtualizedBodyProps<T extends TableVirtualizedRow = TableVirtualizedRow> extends VibeComponentProps {
+    /**
+     * The list of items to render in the virtualized table.
+     */
+    items: T[];
+    /**
+     * Function to render a row in the table.
+     */
+    rowRenderer: (item: T) => JSX.Element;
+    /**
+     * Callback function triggered on scroll.
+     */
+    onScroll?: (horizontalScrollDirection: ScrollDirection, scrollTop: number, scrollUpdateWasRequested: boolean) => void;
+    /**
+     * The columns configuration for the table.
+     */
+    columns?: TableColumn[];
+    /**
+     * Function to render the table header.
+     */
+    headerRenderer?: (columns: TableColumn[]) => JSX.Element;
+    /**
+     * Number of rows to render above/below the visible area.
+     */
+    overscanCount?: number;
+}
+declare const TableVirtualizedBody: React.ForwardRefExoticComponent<TableVirtualizedBodyProps<TableVirtualizedRow> & React.RefAttributes<HTMLDivElement>>;
+export default TableVirtualizedBody;

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

@@ -0,0 +1,4 @@
+import React from "react";
+import { type TableContainerProviderProps } from "./TableContainerContext.types";
+export declare const TableContainerProvider: ({ value, children }: TableContainerProviderProps) => React.JSX.Element;
+export declare const useTableContainer: () => import("./TableContainerContext.types").TableContainerProviderValue;

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

@@ -0,0 +1,9 @@
+import type React from "react";
+export type TableContainerContext = TableContainerProviderValue;
+export interface TableContainerProviderValue {
+    menuContainerRef: React.RefObject<HTMLDivElement>;
+}
+export interface TableContainerProviderProps {
+    value: TableContainerProviderValue;
+    children: React.ReactNode;
+}

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

@@ -0,0 +1,4 @@
+import React from "react";
+import { type TableContext as ITableContext, type TableProviderProps } from "./TableContext.types";
+export declare const TableProvider: ({ value, children }: TableProviderProps) => React.JSX.Element;
+export declare const useTable: () => ITableContext;

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

@@ -0,0 +1,27 @@
+import { type TableProps } from "../../Table/Table";
+import { type UIEventHandler } from "react";
+import type React from "react";
+export interface TableContext extends TableProviderValue {
+    headRef: React.MutableRefObject<HTMLDivElement>;
+    onHeadScroll: UIEventHandler<HTMLDivElement>;
+    virtualizedListRef: React.MutableRefObject<HTMLDivElement>;
+    onVirtualizedListScroll: UIEventHandler<HTMLDivElement>;
+}
+export interface TableProviderForwardedProps {
+    columns: TableProps["columns"];
+    dataState?: TableProps["dataState"];
+    emptyState: TableProps["emptyState"];
+    errorState: TableProps["errorState"];
+    size: TableProps["size"];
+}
+export interface TableProviderValue extends TableProviderForwardedProps {
+    tableRootRef: React.MutableRefObject<HTMLDivElement>;
+    isVirtualized: boolean;
+    markTableAsVirtualized: () => void;
+    isScrolled: boolean;
+    setIsScrolled: React.Dispatch<React.SetStateAction<boolean>>;
+}
+export type TableProviderProps = {
+    value: TableProviderValue;
+    children: React.ReactNode;
+};

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

@@ -0,0 +1,4 @@
+import React from "react";
+import { type TableRowMenuContext as ITableRowMenuContext, type TableRowMenuProviderProps } from "./TableRowMenuContext.types";
+export declare const TableRowMenuProvider: ({ value, children }: TableRowMenuProviderProps) => React.JSX.Element;
+export declare const useTableRowMenu: () => ITableRowMenuContext;

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

@@ -0,0 +1,23 @@
+import type React from "react";
+export interface TableRowMenuContext extends Pick<TableRowMenuProviderValue, "resetHoveredRow"> {
+    hoveredRowId: string;
+    onMouseOverRow: (rowRef: React.MutableRefObject<HTMLDivElement>) => void;
+    onMouseLeaveRow: () => void;
+    onMouseOverRowMenu: () => void;
+    onMouseLeaveRowMenu: () => void;
+    menuButtonPosition: number;
+    setTableMenuShown: () => void;
+    setTableMenuHidden: () => void;
+}
+export interface TableRowMenuProviderValue {
+    tableRootRef: React.RefObject<HTMLDivElement>;
+    hoveredRowRef: React.RefObject<HTMLDivElement>;
+    isMenuOpen: boolean;
+    resetHoveredRow: () => void;
+    setHoveredRowRef: (rowRef: React.RefObject<HTMLDivElement>) => void;
+    setIsMenuOpen: (isOpen: boolean) => void;
+}
+export type TableRowMenuProviderProps = {
+    value: TableRowMenuProviderValue;
+    children: React.ReactNode;
+};

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

@@ -0,0 +1,12 @@
+export { default as Table, type TableProps, type TableColumn } from "./Table/Table";
+export { default as TableContainer } from "./TableContainer/TableContainer";
+export * from "./TableContainer/TableContainer.types";
+export { default as TableHeader, type TableHeaderProps } from "./TableHeader/TableHeader";
+export { default as TableHeaderCell, type TableHeaderCellProps } from "./TableHeaderCell/TableHeaderCell";
+export { default as TableBody, type TableBodyProps } from "./TableBody/TableBody";
+export { default as TableVirtualizedBody, type TableVirtualizedBodyProps, type TableVirtualizedRow } from "./TableVirtualizedBody/TableVirtualizedBody";
+export { default as TableRow, type TableRowProps } from "./TableRow/TableRow";
+export { default as TableRowMenu } from "./TableRowMenu/TableRowMenu";
+export * from "./TableRowMenu/TableRowMenu.types";
+export { default as TableCell, type TableCellProps } from "./TableCell/TableCell";
+export * from "./Table/Table.types";

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

@@ -0,0 +1,64 @@
+import { type FC, type ReactElement } from "react";
+import { type IconType, type SubIcon } from "@vibe/icon";
+import type VibeComponentProps from "../../../types/VibeComponentProps";
+import { type TooltipProps } from "../../Tooltip/Tooltip";
+export interface TabProps extends VibeComponentProps {
+    /**
+     * Class name applied to the inner tab content.
+     */
+    tabInnerClassName?: string;
+    /**
+     * The index value of the tab.
+     */
+    value?: number;
+    /**
+     * If true, disables the tab.
+     */
+    disabled?: boolean;
+    /**
+     * If true, marks the tab as active.
+     */
+    active?: boolean;
+    /**
+     * If true, applies focus styles to the tab.
+     */
+    focus?: boolean;
+    /**
+     * If true, hides the individual tab border when using stretched underline.
+     */
+    stretchedUnderline?: boolean;
+    /**
+     * The icon displayed in the tab.
+     */
+    icon?: SubIcon;
+    /**
+     * The type of icon.
+     */
+    iconType?: IconType;
+    /**
+     * The position of the icon relative to the text.
+     */
+    iconSide?: string;
+    /**
+     * Callback fired when the tab is clicked.
+     */
+    onClick?: (value: number) => void;
+    /**
+     * Props passed to the tab's tooltip.
+     */
+    tooltipProps?: Partial<TooltipProps>;
+    /**
+     * The content displayed inside the tab.
+     */
+    children?: string | ReactElement | ReactElement[];
+    /**
+     * Tab index for focus management.
+     */
+    tabIndex?: number;
+    /**
+     * The id of the associated TabPanel for aria-controls attribute.
+     */
+    ariaControls?: string;
+}
+declare const Tab: FC<TabProps>;
+export default Tab;

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

@@ -0,0 +1,35 @@
+import { type FC, type ReactElement } from "react";
+import type VibeComponentProps from "../../../types/VibeComponentProps";
+import { type TabProps } from "../Tab/Tab";
+export interface TabListProps extends VibeComponentProps {
+    /**
+     * Callback fired when the active tab changes.
+     */
+    onTabChange?: (tabId: number) => void;
+    /**
+     * The index of the currently active tab.
+     */
+    activeTabId?: number;
+    /**
+     * The type of tab style.
+     */
+    tabType?: string;
+    /**
+     * The size of the tab list.
+     */
+    size?: string;
+    /**
+     * If true, Sets an E2E underline under the whole tabs component.
+     */
+    stretchedUnderline?: boolean;
+    /**
+     * Array of corresponding TabPanel ids for aria-controls relationship.
+     */
+    tabPanelIds?: string[];
+    /**
+     * The child elements representing tabs.
+     */
+    children?: ReactElement<TabProps>[];
+}
+declare const TabList: FC<TabListProps>;
+export default TabList;

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

@@ -0,0 +1,14 @@
+import { type FC, type ReactElement } from "react";
+import type VibeComponentProps from "../../../types/VibeComponentProps";
+export interface TabPanelProps extends VibeComponentProps {
+    /**
+     * The content inside the tab panel.
+     */
+    children?: ReactElement | ReactElement[] | string;
+    /**
+     * The index of the tab panel.
+     */
+    index?: number;
+}
+declare const TabPanel: FC<TabPanelProps>;
+export default TabPanel;

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

@@ -0,0 +1,23 @@
+import React, { type ReactElement } from "react";
+import { TabPanelsAnimationDirection as TabPanelsAnimationDirectionEnum } from "./TabPanelsConstants";
+import { type TabPanelsAnimationDirection } from "./TabPanels.types";
+import { type TabPanelProps } from "../TabPanel/TabPanel";
+import { type VibeComponentProps } from "../../../types";
+export interface TabPanelsProps extends VibeComponentProps {
+    /**
+     * The index of the currently active tab panel.
+     */
+    activeTabId?: number;
+    /**
+     * The animation direction when switching between tab panels.
+     */
+    animationDirection?: TabPanelsAnimationDirection;
+    /**
+     * The child elements representing tab panels.
+     */
+    children?: ReactElement<TabPanelProps> | ReactElement<TabPanelProps>[];
+}
+declare const _default: React.ForwardRefExoticComponent<TabPanelsProps & React.RefAttributes<HTMLElement>> & {
+    animationDirections: typeof TabPanelsAnimationDirectionEnum;
+};
+export default _default;

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

@@ -0,0 +1 @@
+export type TabPanelsAnimationDirection = "rtl" | "ltr";

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

@@ -0,0 +1,7 @@
+/**
+ * @deprecated
+ */
+export declare enum TabPanelsAnimationDirection {
+    RTL = "rtl",
+    LTR = "ltr"
+}

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

@@ -0,0 +1,14 @@
+import { type FC, type ReactElement } from "react";
+import type VibeComponentProps from "../../../types/VibeComponentProps";
+export interface TabsContextProps extends VibeComponentProps {
+    /**
+     * The index of the currently active tab.
+     */
+    activeTabId?: number;
+    /**
+     * The child elements representing the tab list and tab panels.
+     */
+    children?: ReactElement | ReactElement[];
+}
+declare const TabsContext: FC<TabsContextProps>;
+export default TabsContext;

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

@@ -0,0 +1,6 @@
+export { default as Tab, type TabProps } from "./Tab/Tab";
+export { default as TabList, type TabListProps } from "./TabList/TabList";
+export { default as TabPanel, type TabPanelProps } from "./TabPanel/TabPanel";
+export { default as TabsContext, type TabsContextProps } from "./TabsContext/TabsContext";
+export { default as TabPanels, type TabPanelsProps } from "./TabPanels/TabPanels";
+export * from "./TabPanels/TabPanels.types";

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

@@ -0,0 +1,26 @@
+import React, { type ReactNode } from "react";
+import { TextType as TextTypeEnum, TextWeight as TextWeightEnum } from "./TextConstants";
+import { type TypographyProps } from "../Typography/Typography";
+import { TypographyAlign as TypographyAlignEnum, TypographyColor as TypographyColorEnum } from "../Typography/TypographyConstants";
+import { type TextType, type TextWeight } from "./Text.types";
+export interface TextProps extends TypographyProps {
+    /**
+     * The text style variant.
+     */
+    type?: TextType;
+    /**
+     * The font weight of the text.
+     */
+    weight?: TextWeight;
+    /**
+     * The content inside the text component.
+     */
+    children: ReactNode;
+}
+declare const _default: React.ForwardRefExoticComponent<TextProps & React.RefAttributes<HTMLElement>> & {
+    types: typeof TextTypeEnum;
+    weights: typeof TextWeightEnum;
+    colors: typeof TypographyColorEnum;
+    align: typeof TypographyAlignEnum;
+};
+export default _default;

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

@@ -0,0 +1,2 @@
+export type TextType = "text1" | "text2" | "text3";
+export type TextWeight = "bold" | "medium" | "normal";

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

@@ -0,0 +1,16 @@
+/**
+ * @deprecated
+ */
+export declare enum TextType {
+    TEXT1 = "text1",
+    TEXT2 = "text2",
+    TEXT3 = "text3"
+}
+/**
+ * @deprecated
+ */
+export declare enum TextWeight {
+    BOLD = "bold",
+    MEDIUM = "medium",
+    NORMAL = "normal"
+}

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

@@ -0,0 +1,2 @@
+export { default as Text, type TextProps } from "./Text";
+export * from "./Text.types";

package/dist/components/TextArea/TextArea.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { type TextAreaProps } from "./TextArea.types";
+declare const TextArea: React.ForwardRefExoticComponent<TextAreaProps & React.RefAttributes<HTMLTextAreaElement>>;
+export default TextArea;