@murabei-data-science/pumpwood-ui 1.3.0

package/dist/types/components/Filters/DateRangeFilter.d.ts

@@ -0,0 +1,23 @@
+export interface DateRangeFilterProps {
+    startDate?: Date;
+    endDate?: Date;
+    onStartDateChange: (date: Date | undefined) => void;
+    onEndDateChange: (date: Date | undefined) => void;
+    startLabel?: string;
+    endLabel?: string;
+    className?: string;
+}
+/**
+ * A date range picker filter component.
+ *
+ * @example
+ * ```tsx
+ * <DateRangeFilter
+ *   startDate={startDate}
+ *   endDate={endDate}
+ *   onStartDateChange={setStartDate}
+ *   onEndDateChange={setEndDate}
+ * />
+ * ```
+ */
+export declare const DateRangeFilter: ({ startDate, endDate, onStartDateChange, onEndDateChange, startLabel, endLabel, className, }: DateRangeFilterProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/KeyValueContent/index.d.ts

@@ -0,0 +1,3 @@
+export declare function KeyValueContent({ data }: {
+    data: Record<string, any>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Loading/index.d.ts

@@ -0,0 +1,2 @@
+export default function Loading(): import("react/jsx-runtime").JSX.Element;
+export { Loading };

package/dist/types/components/M2MTable/index.d.ts

@@ -0,0 +1,35 @@
+import { type ComponentPropsWithoutRef } from "react";
+import { type FKFetcherParams } from "../FKSelect";
+export type M2MListFn = (modelClass: string, filterDict: Record<string, any>, fields: string[]) => Promise<[
+    Record<string, any>[] | null,
+    {
+        message?: string;
+    } | null
+]>;
+export declare const M2MCreateDialog: ({ open, onOpenChange, targetModelClass, relationName, handleCreateNew, mutate, fkFetcher, }: {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    targetModelClass: string;
+    relationName: string;
+    handleCreateNew: (id: string) => void;
+    mutate: () => void;
+    fkFetcher: (params: FKFetcherParams) => Promise<any[]>;
+}) => import("react/jsx-runtime").JSX.Element;
+interface IM2MTableProps extends Omit<ComponentPropsWithoutRef<"div">, "onChange"> {
+    modelClass: string;
+    targetModelClass: string;
+    filterDict: Record<string, any>;
+    targetField: string;
+    relationName: string;
+    displayFields: {
+        name: string;
+        field: string;
+    }[];
+    handleCreateNew: (id: string) => void;
+    handleDeleteItem: (id: string) => void;
+    fields: string[];
+    listFn: M2MListFn;
+    fkFetcher: (params: FKFetcherParams) => Promise<any[]>;
+}
+export declare const M2MTable: ({ modelClass, targetModelClass, targetField, filterDict, relationName, fields, displayFields, handleCreateNew, handleDeleteItem, listFn, fkFetcher, }: IM2MTableProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/MarkdownEditor/index.d.ts

@@ -0,0 +1,12 @@
+export interface IMarkdownEditorProps {
+    value: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    error?: string;
+    disabled?: boolean;
+    className?: string;
+}
+/**
+ * WYSIWYG markdown editor wrapper around Toast UI Editor.
+ */
+export declare function MarkdownEditor({ value, onChange, placeholder, error, disabled, className, }: IMarkdownEditorProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/MultiSelectDropdown/index.d.ts

@@ -0,0 +1,14 @@
+export interface IMultiSelectOption {
+    label: string;
+    value: string;
+}
+interface IMultiSelectDropdownProps {
+    options: IMultiSelectOption[];
+    selected: string[];
+    onChange: (selected: string[]) => void;
+    placeholder?: string;
+    className?: string;
+    maxDisplay?: number;
+}
+export declare function MultiSelectDropdown({ options, selected, onChange, placeholder, className, maxDisplay, }: IMultiSelectDropdownProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/NoResult/index.d.ts

@@ -0,0 +1,15 @@
+export interface INoResultProps {
+    /** Title shown in the empty state. */
+    title?: string;
+    /** Description shown in the empty state. */
+    description?: string;
+}
+/**
+ * Default empty state for tables and lists with no data.
+ *
+ * @example
+ * ```tsx
+ * <NoResult />
+ * ```
+ */
+export declare function NoResult({ title, description, }: INoResultProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,12 @@
+type PaginationProps = {
+    startRecord: number;
+    endRecord: number;
+    hasValidSearchValues: boolean;
+    tabCount: number;
+    disabledLoadBackButton: boolean;
+    disabledLoadMoreButton: boolean;
+    loadBack: () => void;
+    loadMore: () => void;
+};
+export declare const Pagination: ({ startRecord, endRecord, hasValidSearchValues, tabCount, disabledLoadBackButton, disabledLoadMoreButton, loadBack, loadMore, }: PaginationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,52 @@
+/**
+ * Parameters passed to the FK fetcher function.
+ */
+export type FKFetcherParams = {
+    search: string;
+    modelClass: string;
+    labelName: string;
+    additionalFilters?: Record<string, any>;
+    fields?: string[];
+    limit?: number;
+    offset?: number;
+};
+/**
+ * Props for the FK variant of the Select component.
+ */
+export interface IFKSelectVariantProps {
+    /** Optional id used as data-testid on the trigger. */
+    id?: string;
+    /** Function to fetch data from the API. */
+    fetcher: (params: FKFetcherParams) => Promise<any[]>;
+    /** Optional function to resolve a value not present in the list. */
+    resolveValue?: (params: {
+        modelClass: string;
+        value: string | number;
+    }) => Promise<any>;
+    /** The model class name to identify the resource. */
+    modelClass: string;
+    /** The field name to use as the display label. */
+    labelName: string;
+    /** The field name to use as the value (ID). Defaults to 'pk'. */
+    valueField?: string;
+    /** Placeholder text for the search input. */
+    placeholder?: string;
+    /** Message to show when no items are found. */
+    emptyMessage?: string;
+    /** The currently selected value. */
+    value: string | number | null;
+    /** Callback when an item is selected. */
+    onChange: (value: string | number, item?: any) => void;
+    /** Additional filters to apply to the API request. */
+    additionalFilters?: Record<string, any>;
+    /** Extra fields to include in search. */
+    fields?: string[];
+    /** Optional class names for the wrapper. */
+    className?: string;
+    /** Debounce time in ms. Defaults to 300. */
+    debounceWait?: number;
+}
+/**
+ * FK variant of Select — async searchable combobox for foreign keys.
+ */
+export declare const FKSelectVariant: ({ id, fetcher, resolveValue, modelClass, labelName, valueField, placeholder, emptyMessage, value, onChange, additionalFilters, fields, className, debounceWait, }: IFKSelectVariantProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,70 @@
+import { type IFKSelectProps } from "@/components/FKSelect";
+type Option = {
+    value: string;
+    label: string;
+};
+type SharedSelectProps = {
+    /** Optional id used as data-testid on the trigger. */
+    id?: string;
+    /** Optional class names for the select wrapper (width, layout). */
+    className?: string;
+};
+/**
+ * Props for the static (default) Select variant.
+ */
+export interface IStaticSelectProps extends SharedSelectProps {
+    variant?: "static";
+    /** Placeholder text when no value is selected. */
+    placeholder: string;
+    /** Static options with value and label. */
+    options: Option[];
+    /** Controlled selected value. */
+    value?: string;
+    /** Callback when the selected value changes. */
+    onValueChange?: (value: string) => void;
+    /** Marks the field as required in HTML forms. */
+    required?: boolean;
+    /** Name attribute for HTML form submission. */
+    name?: string;
+}
+/**
+ * Props for the FK variant of Select.
+ */
+export interface ISelectFKProps extends IFKSelectProps {
+    variant: "fk";
+}
+/**
+ * Props for the Select component (static or FK variant).
+ */
+export type ISelectProps = IStaticSelectProps | ISelectFKProps;
+/**
+ * A reusable dropdown component built with shadcn/ui.
+ *
+ * Supports a static variant (Radix Select) and an FK variant (async
+ * Combobox) for foreign-key fields.
+ *
+ * @example
+ * ```tsx
+ * <Select
+ *   placeholder="Choose an option"
+ *   options={[
+ *     { value: "a", label: "Option A" },
+ *     { value: "b", label: "Option B" },
+ *   ]}
+ *   value={selected}
+ *   onValueChange={setSelected}
+ * />
+ *
+ * <Select
+ *   variant="fk"
+ *   fetcher={fetchUsers}
+ *   modelClass="user"
+ *   labelName="username"
+ *   placeholder="Select user"
+ *   value={userId}
+ *   onChange={(id, item) => setUserId(id)}
+ * />
+ * ```
+ */
+export declare const Select: (props: ISelectProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/types/components/Sidebar/NavigationSidebar.d.ts

@@ -0,0 +1,45 @@
+import { type LucideIcon } from "lucide-react";
+import { type ComponentType, type ReactNode } from "react";
+export interface INavigationSidebarSubLink {
+    title: string;
+    href: string;
+}
+export interface INavigationSidebarLink {
+    title: string;
+    href?: string;
+    icon: string;
+    subItems?: INavigationSidebarSubLink[];
+}
+export interface INavigationSidebarLogo {
+    src: string;
+    alt: string;
+    width?: number;
+    height?: number;
+}
+export interface INavigationSidebarProps {
+    links: INavigationSidebarLink[];
+    iconMap: Record<string, LucideIcon>;
+    pathname: string;
+    isSidebarCollapsedFromQuery?: boolean;
+    logo: INavigationSidebarLogo;
+    onLogout: () => void | Promise<void>;
+    logoutIcon?: LucideIcon;
+    logoutLabel?: string;
+    LinkComponent?: ComponentType<{
+        href: any;
+        className?: string;
+        children: ReactNode;
+        title?: string;
+    }>;
+    ImageComponent?: ComponentType<{
+        src: string;
+        alt: string;
+        width: number;
+        height: number;
+        className?: string;
+    }>;
+}
+/**
+ * Configurable navigation sidebar with collapse, groups and logout.
+ */
+export declare function NavigationSidebar({ links, iconMap, pathname, isSidebarCollapsedFromQuery, logo, onLogout, logoutIcon, logoutLabel, LinkComponent, ImageComponent, }: INavigationSidebarProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Sidebar/index.d.ts

@@ -0,0 +1,157 @@
+import { type LucideIcon } from "lucide-react";
+import { type ComponentType, type ReactNode } from "react";
+/**
+ * Props for the Sidebar Root component.
+ */
+export interface SidebarRootProps {
+    /** The content of the sidebar. */
+    children: ReactNode;
+    /** Whether the sidebar is currently collapsed. */
+    isCollapsed: boolean;
+    /** Whether the sidebar is mid-collapse transition. */
+    isCollapsing?: boolean;
+    /** Callback to toggle the collapsed state. */
+    onToggleCollapse: () => void;
+    /** Callback when width transition ends. */
+    onTransitionEnd?: () => void;
+    /** Additional CSS classes. */
+    className?: string;
+}
+declare function Root({ children, isCollapsed, isCollapsing, onToggleCollapse, onTransitionEnd, className, }: SidebarRootProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props for the Sidebar Header component.
+ */
+export interface SidebarHeaderProps {
+    children: ReactNode;
+    className?: string;
+}
+declare function Header({ children, className }: SidebarHeaderProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props for the Sidebar Content component.
+ */
+export interface SidebarContentProps {
+    children: ReactNode;
+    className?: string;
+}
+declare function Content({ children, className }: SidebarContentProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props for the Sidebar Footer component.
+ */
+export interface SidebarFooterProps {
+    children: ReactNode;
+    className?: string;
+}
+declare function Footer({ children, className }: SidebarFooterProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props for the Sidebar Toggle component.
+ */
+export interface SidebarToggleProps {
+    className?: string;
+}
+declare function Toggle({ className }: SidebarToggleProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props for the Sidebar Logo component.
+ */
+export interface SidebarLogoProps {
+    src: string;
+    alt: string;
+    width?: number;
+    height?: number;
+    /** Logo width when the sidebar is collapsed. Defaults to 48. */
+    collapsedWidth?: number;
+    /** Logo height when the sidebar is collapsed. */
+    collapsedHeight?: number;
+    className?: string;
+    ImageComponent?: ComponentType<{
+        src: string;
+        alt: string;
+        width: number;
+        height: number;
+        className?: string;
+    }>;
+}
+declare function Logo({ src, alt, width, height, collapsedWidth, collapsedHeight, className, ImageComponent, }: SidebarLogoProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Props for the Sidebar Link component.
+ */
+export interface SidebarLinkProps {
+    icon: LucideIcon;
+    children: ReactNode;
+    href: any;
+    active?: boolean;
+    className?: string;
+    LinkComponent?: ComponentType<{
+        href: any;
+        className?: string;
+        children: ReactNode;
+        title?: string;
+    }>;
+}
+declare function Link({ icon: Icon, children, href, active, className, LinkComponent, }: SidebarLinkProps): import("react/jsx-runtime").JSX.Element;
+export interface SidebarNavGroupProps {
+    icon: LucideIcon;
+    title: string;
+    isExpanded: boolean;
+    isActive?: boolean;
+    onToggle: () => void;
+    children: ReactNode;
+    className?: string;
+}
+declare function NavGroup({ icon: Icon, title, isExpanded, isActive, onToggle, children, className, }: SidebarNavGroupProps): import("react/jsx-runtime").JSX.Element;
+export interface SidebarNavSubLinkProps {
+    title: string;
+    href: string | Record<string, unknown>;
+    active?: boolean;
+    className?: string;
+    LinkComponent?: ComponentType<{
+        href: any;
+        className?: string;
+        children: ReactNode;
+        title?: string;
+    }>;
+}
+declare function NavSubLink({ title, href, active, className, LinkComponent, }: SidebarNavSubLinkProps): import("react/jsx-runtime").JSX.Element;
+export interface SidebarActionProps {
+    icon: LucideIcon;
+    label: string;
+    onClick: () => void;
+    className?: string;
+}
+declare function Action({ icon: Icon, label, onClick, className }: SidebarActionProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * A composable Sidebar component.
+ *
+ * @example
+ * ```tsx
+ * const [collapsed, setCollapsed] = useState(false);
+ *
+ * return (
+ *   <Sidebar.Root isCollapsed={collapsed} onToggleCollapse={() => setCollapsed(!collapsed)}>
+ *     <Sidebar.Header>
+ *       <Sidebar.Logo src="/logo.png" alt="Logo" />
+ *       <Sidebar.Toggle />
+ *     </Sidebar.Header>
+ *     <Sidebar.Content>
+ *       <Sidebar.Link icon={HomeIcon} href="/">Home</Sidebar.Link>
+ *     </Sidebar.Content>
+ *     <Sidebar.Footer>
+ *        User Info
+ *     </Sidebar.Footer>
+ *   </Sidebar.Root>
+ * )
+ * ```
+ */
+export declare const Sidebar: {
+    Root: typeof Root;
+    Header: typeof Header;
+    Content: typeof Content;
+    Footer: typeof Footer;
+    Toggle: typeof Toggle;
+    Logo: typeof Logo;
+    Link: typeof Link;
+    NavGroup: typeof NavGroup;
+    NavSubLink: typeof NavSubLink;
+    Action: typeof Action;
+};
+export { useSidebarCollapse } from "./useSidebarCollapse";
+export type { IUseSidebarCollapseOptions } from "./useSidebarCollapse";

package/dist/types/components/Sidebar/useSidebarCollapse.d.ts

@@ -0,0 +1,18 @@
+export interface IUseSidebarCollapseOptions {
+    initialCollapsed?: boolean;
+    onPersist?: (collapsed: boolean) => void;
+}
+/**
+ * Hook for sidebar collapse state with optional persistence callback.
+ */
+export declare function useSidebarCollapse({ initialCollapsed, onPersist, }?: IUseSidebarCollapseOptions): {
+    isCollapsed: boolean;
+    isCollapsing: boolean;
+    expandedItems: Record<string, boolean>;
+    setExpandedItems: import("react").Dispatch<import("react").SetStateAction<Record<string, boolean>>>;
+    toggleCollapse: () => void;
+    expand: () => void;
+    handleTransitionEnd: () => void;
+    toggleExpanded: (title: string) => void;
+    setExpandedOnCollapse: () => void;
+};

package/dist/types/components/Stack/index.d.ts

@@ -0,0 +1,28 @@
+import type { HTMLAttributes, ReactNode } from "react";
+type StackProps = HTMLAttributes<HTMLDivElement> & {
+    children: ReactNode;
+    /** The direction of the stack. Defaults to 'col'. */
+    direction?: "row" | "col";
+    /** The gap between elements. Maps to Tailwind gap utility (e.g. 4 -> gap-4). */
+    gap?: number;
+    /** Click handler. When set, the stack becomes keyboard-accessible (role="button"). */
+    onClick?: () => void;
+    className?: string;
+};
+/**
+ * A layout component that arranges children in a stack (vertical or horizontal).
+ *
+ * When `onClick` is provided, the stack receives `role="button"`, `tabIndex={0}`,
+ * and responds to Enter and Space keys. Provide visible text or pass `aria-label`
+ * via props for accessibility.
+ *
+ * @example
+ * ```tsx
+ * <Stack direction="row" gap={4}>
+ *   <Button>Btn 1</Button>
+ *   <Button>Btn 2</Button>
+ * </Stack>
+ * ```
+ */
+declare function Stack({ children, onClick, direction, gap, className, ...props }: StackProps): import("react/jsx-runtime").JSX.Element;
+export default Stack;

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

@@ -0,0 +1,92 @@
+import type { ReactNode } from "react";
+/**
+ * Column definition for Table.
+ */
+export interface ITableColumn<T> {
+    /** Row field key used to read cell value. */
+    key: keyof T & string;
+    /** Header label. */
+    label: string;
+    /** Tailwind width classes for head and cell. */
+    width?: string;
+    /** Extra classes for the header cell. */
+    className?: string;
+    /** Extra classes for the body cell. */
+    cellClassName?: string;
+    /** Whether the column supports sorting. */
+    sortable?: boolean;
+    /** Custom cell renderer. */
+    render?: (value: unknown, row: T) => ReactNode;
+}
+/**
+ * Props for the Table component.
+ */
+export interface ITableProps<T> {
+    /** Rows to display. */
+    data: T[];
+    /** Column configuration. */
+    columns: ITableColumn<T>[];
+    /** Returns a stable key for each row. */
+    getRowKey: (row: T) => string | number;
+    /** Current sort field; prefix with '-' for descending. */
+    ordering?: string;
+    /** Called when a sortable column header is clicked. */
+    onSort?: (columnKey: string) => void;
+    /** Called when a row is clicked. */
+    onRowClick?: (row: T) => void;
+    /** Whether a data request is in progress. */
+    isLoading?: boolean;
+    /** Whether more rows can be loaded. */
+    hasMore?: boolean;
+    /** Called when the load-more button is clicked. */
+    onLoadMore?: () => void;
+    /** Extra classes for the scroll wrapper. */
+    className?: string;
+}
+/**
+ * A comprehensive Table component system.
+ *
+ * @example
+ * ```tsx
+ * <PumpwoodTable.Root>
+ *   <PumpwoodTable.Header>
+ *     <PumpwoodTable.Row>
+ *       <PumpwoodTable.Head>ID</PumpwoodTable.Head>
+ *       <PumpwoodTable.Head>Name</PumpwoodTable.Head>
+ *     </PumpwoodTable.Row>
+ *   </PumpwoodTable.Header>
+ *   <PumpwoodTable.Body>
+ *     <PumpwoodTable.Row>
+ *       <PumpwoodTable.Cell>1</PumpwoodTable.Cell>
+ *       <PumpwoodTable.Cell>John Doe</PumpwoodTable.Cell>
+ *     </PumpwoodTable.Row>
+ *   </PumpwoodTable.Body>
+ * </PumpwoodTable.Root>
+ * ```
+ */
+export declare const PumpwoodTable: {
+    Root: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLTableElement> & import("react").RefAttributes<HTMLTableElement>>;
+    Body: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLTableSectionElement> & import("react").RefAttributes<HTMLTableSectionElement>>;
+    Cell: import("react").ForwardRefExoticComponent<import("react").TdHTMLAttributes<HTMLTableCellElement> & import("react").RefAttributes<HTMLTableCellElement>>;
+    Head: import("react").ForwardRefExoticComponent<import("react").ThHTMLAttributes<HTMLTableCellElement> & import("react").RefAttributes<HTMLTableCellElement>>;
+    Header: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLTableSectionElement> & import("react").RefAttributes<HTMLTableSectionElement>>;
+    Row: import("react").ForwardRefExoticComponent<import("react").HTMLAttributes<HTMLTableRowElement> & import("react").RefAttributes<HTMLTableRowElement>>;
+};
+/**
+ * Generic data table with loading, empty, sort, and load-more states.
+ *
+ * @example
+ * ```tsx
+ * <Table
+ *   data={items}
+ *   columns={columns}
+ *   getRowKey={(row) => row.pk}
+ *   ordering={ordering}
+ *   onSort={handleSort}
+ *   isLoading={isLoading}
+ *   hasMore={hasMore}
+ *   onLoadMore={handleLoadMore}
+ * />
+ * ```
+ */
+export declare function Table<T extends Record<string, unknown>>({ data, columns, getRowKey, ordering, onSort, onRowClick, isLoading, hasMore, onLoadMore, className, }: ITableProps<T>): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/TableSkeleton/index.d.ts

@@ -0,0 +1,23 @@
+export interface ITableSkeletonColumn {
+    /** Tailwind width classes matching the table column. */
+    width?: string;
+    /** Extra classes for the skeleton cell. */
+    cellClassName?: string;
+}
+export interface ITableSkeletonProps {
+    /** Column layout or column count. */
+    columns: ITableSkeletonColumn[] | number;
+    /** Number of skeleton rows. Defaults to 5. */
+    rows?: number;
+}
+/**
+ * Skeleton rows rendered inside TableBody while data is loading.
+ *
+ * @example
+ * ```tsx
+ * <TableBody>
+ *   <TableSkeleton columns={columns} rows={5} />
+ * </TableBody>
+ * ```
+ */
+export declare function TableSkeleton({ columns, rows, }: ITableSkeletonProps): import("react/jsx-runtime").JSX.Element;

package/dist/types/components/TagInput/index.d.ts

@@ -0,0 +1,13 @@
+export interface ITagItem {
+    key: string;
+    value: string;
+}
+interface ITagInputProps {
+    value: ITagItem[];
+    onChange: (tags: ITagItem[]) => void;
+    keyPlaceholder?: string;
+    valuePlaceholder?: string;
+    disabled?: boolean;
+}
+export default function TagInput({ value, onChange, keyPlaceholder, valuePlaceholder, disabled, }: ITagInputProps): import("react/jsx-runtime").JSX.Element;
+export { TagInput };

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

@@ -0,0 +1,21 @@
+import type { HTMLAttributes, ReactNode } from "react";
+type TypographyProps = HTMLAttributes<HTMLParagraphElement> & {
+    children: ReactNode;
+    className?: string;
+};
+declare function H1({ children, className, ...props }: TypographyProps): import("react/jsx-runtime").JSX.Element;
+declare function Muted({ children, className, ...props }: TypographyProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Typography components for consistent text styling.
+ *
+ * @example
+ * ```tsx
+ * <Typography.H1>Main Title</Typography.H1>
+ * <Typography.Muted>Subtitle text</Typography.Muted>
+ * ```
+ */
+export declare const Typography: {
+    H1: typeof H1;
+    Muted: typeof Muted;
+};
+export {};

package/dist/types/components/TooltipComponent/index.d.ts

@@ -0,0 +1,8 @@
+type TooltipComponentProps = {
+    trigger: React.ReactNode;
+    children: React.ReactNode;
+    className?: string;
+    triggerClassName?: string;
+};
+export declare const TooltipComponent: ({ triggerClassName, className, trigger, children, }: TooltipComponentProps) => import("react/jsx-runtime").JSX.Element;
+export {};