@justin_evo/evo-ui 1.0.1

package/dist/Notification/Notification.d.ts

@@ -0,0 +1,186 @@
+import { ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
+export type EvoNotificationSeverity = 'success' | 'error' | 'warning' | 'info';
+export type EvoNotificationAnchor = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+export interface EvoNotificationAction {
+    label: string;
+    onClick: (e: React.MouseEvent) => void;
+}
+export interface EvoToastOptions {
+    id?: string;
+    title?: ReactNode;
+    description?: ReactNode;
+    severity?: EvoNotificationSeverity;
+    icon?: ReactNode;
+    duration?: number;
+    persistent?: boolean;
+    anchor?: EvoNotificationAnchor;
+    action?: EvoNotificationAction;
+    dismissible?: boolean;
+    onDismiss?: (id: string) => void;
+    onAutoClose?: (id: string) => void;
+    className?: string;
+    inbox?: boolean | Partial<EvoInboxItemInput>;
+    /**
+     * Coalescing key. Toasts pushed with the same `groupKey` while an earlier
+     * one is still on screen fold into it — the card refreshes in place and
+     * shows an incremented count badge instead of stacking a duplicate.
+     * Ignored when an explicit `id` is supplied (id matching takes priority).
+     */
+    groupKey?: string;
+    /**
+     * Determinate progress, 0–1. When set, the toast renders a progress bar.
+     * Values outside the range are clamped. Usually driven via
+     * `evoNotify.toast.progress()`, but valid on any toast.
+     */
+    progress?: number;
+}
+export interface EvoPromiseMessages<T> {
+    loading: ReactNode | EvoToastOptions;
+    success: ReactNode | ((value: T) => ReactNode | EvoToastOptions);
+    error: ReactNode | ((err: unknown) => ReactNode | EvoToastOptions);
+}
+/**
+ * Handle returned by `evoNotify.toast.progress()`. Drives a determinate
+ * progress bar and resolves the toast to a success or error end state.
+ */
+export interface EvoToastProgressHandle {
+    /** The underlying toast id — usable with `evoNotify.toast.dismiss`. */
+    readonly id: string;
+    /** Set the bar fill, 0–1 (values outside the range are clamped). */
+    setProgress: (value: number) => void;
+    /** Patch any toast option (title, description, severity, …). */
+    update: (options: EvoToastOptions) => void;
+    /** Resolve as success: bar fills to 100%, the toast then auto-dismisses. */
+    done: (options?: EvoToastOptions) => void;
+    /** Resolve as error: the toast becomes dismissible and auto-dismisses. */
+    fail: (options?: EvoToastOptions) => void;
+    /** Dismiss the toast immediately. */
+    dismiss: () => void;
+}
+export interface EvoInboxItemInput {
+    id?: string;
+    title: ReactNode;
+    description?: ReactNode;
+    severity?: EvoNotificationSeverity;
+    icon?: ReactNode;
+    avatarUrl?: string;
+    timestamp?: number | Date;
+    read?: boolean;
+    action?: EvoNotificationAction;
+    onClick?: (item: EvoInboxItem) => void;
+    meta?: Record<string, unknown>;
+    toast?: boolean | Partial<EvoToastOptions>;
+}
+export interface EvoInboxItem {
+    id: string;
+    title: ReactNode;
+    description?: ReactNode;
+    severity: EvoNotificationSeverity;
+    icon?: ReactNode;
+    avatarUrl?: string;
+    timestamp: number;
+    read: boolean;
+    action?: EvoNotificationAction;
+    onClick?: (item: EvoInboxItem) => void;
+    meta?: Record<string, unknown>;
+}
+export interface EvoNotifyAPI {
+    toast: {
+        (message: ReactNode, options?: EvoToastOptions): string;
+        success: (message: ReactNode, options?: EvoToastOptions) => string;
+        error: (message: ReactNode, options?: EvoToastOptions) => string;
+        warning: (message: ReactNode, options?: EvoToastOptions) => string;
+        info: (message: ReactNode, options?: EvoToastOptions) => string;
+        loading: (message: ReactNode, options?: EvoToastOptions) => string;
+        promise: <T>(p: Promise<T> | (() => Promise<T>), msgs: EvoPromiseMessages<T>) => string;
+        progress: (message: ReactNode, options?: EvoToastOptions) => EvoToastProgressHandle;
+        update: (id: string, options: EvoToastOptions) => void;
+        dismiss: (id?: string) => void;
+    };
+    push: (item: EvoInboxItemInput) => string;
+    inbox: {
+        markRead: (id: string) => void;
+        markUnread: (id: string) => void;
+        markAllRead: () => void;
+        remove: (id: string) => void;
+        clear: () => void;
+        setItems: (items: EvoInboxItem[]) => void;
+        getState: () => {
+            items: EvoInboxItem[];
+            unread: number;
+        };
+        subscribe: (fn: (s: {
+            items: EvoInboxItem[];
+            unread: number;
+        }) => void) => () => void;
+    };
+    dismissAll: () => void;
+}
+export declare const evoNotify: EvoNotifyAPI;
+export interface EvoNotificationProviderProps {
+    children: ReactNode;
+    defaultAnchor?: EvoNotificationAnchor;
+    maxVisible?: number;
+    defaultDuration?: number;
+    pauseOnFocusLoss?: boolean;
+    /**
+     * When true, `error` toasts stay until dismissed instead of auto-closing.
+     * Recommended for accessibility — errors should not vanish on a timer.
+     * A per-toast `duration` or `persistent` still overrides this.
+     */
+    persistErrors?: boolean;
+    inboxItems?: EvoInboxItem[];
+    onInboxChange?: (items: EvoInboxItem[]) => void;
+}
+export declare const EvoNotificationProvider: {
+    ({ children, defaultAnchor, maxVisible, defaultDuration, pauseOnFocusLoss, persistErrors, inboxItems, onInboxChange, }: EvoNotificationProviderProps): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+};
+export interface EvoNotificationToasterProps {
+    anchor?: EvoNotificationAnchor;
+    className?: string;
+}
+export declare const EvoNotificationToaster: {
+    ({ anchor, className }: EvoNotificationToasterProps): import('react').ReactPortal | null;
+    displayName: string;
+};
+export interface EvoNotificationBellProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    variant?: 'solid' | 'ghost';
+    size?: 'sm' | 'md' | 'lg';
+    hideZero?: boolean;
+    maxBadgeCount?: number;
+    panelPlacement?: 'bottom-end' | 'bottom-start' | 'bottom' | 'top-end' | 'top-start';
+    renderPanel?: 'popover' | 'none';
+    panelTitle?: ReactNode;
+    panelEmptyState?: ReactNode;
+}
+export declare const EvoNotificationBell: import('react').ForwardRefExoticComponent<EvoNotificationBellProps & import('react').RefAttributes<HTMLButtonElement>>;
+export interface EvoNotificationPanelProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    open?: boolean;
+    onClose?: () => void;
+    title?: ReactNode;
+    emptyState?: ReactNode;
+    loading?: boolean;
+    error?: ReactNode;
+    showMarkAllRead?: boolean;
+    maxHeight?: number | string;
+}
+export declare const EvoNotificationPanel: import('react').ForwardRefExoticComponent<EvoNotificationPanelProps & import('react').RefAttributes<HTMLDivElement>>;
+export interface EvoNotificationItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onClick'> {
+    item: EvoInboxItem;
+    onClick?: (item: EvoInboxItem) => void;
+}
+export declare const EvoNotificationItem: import('react').ForwardRefExoticComponent<EvoNotificationItemProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare function useEvoInbox(): {
+    items: EvoInboxItem[];
+    unread: number;
+};
+type EvoNotificationNS = {
+    Provider: typeof EvoNotificationProvider;
+    Toaster: typeof EvoNotificationToaster;
+    Bell: typeof EvoNotificationBell;
+    Panel: typeof EvoNotificationPanel;
+    Item: typeof EvoNotificationItem;
+};
+export declare const EvoNotification: EvoNotificationNS;
+export {};

package/dist/Pagination/Pagination.d.ts

@@ -0,0 +1,10 @@
+interface EvoPaginationProps {
+    total: number;
+    page: number;
+    pageSize?: number;
+    siblingCount?: number;
+    onChange: (page: number) => void;
+    className?: string;
+}
+export declare const EvoPagination: ({ total, page, pageSize, siblingCount, onChange, className, }: EvoPaginationProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Radio/Radio.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+interface EvoRadioGroupProps {
+    children: React.ReactNode;
+    name: string;
+    value: string;
+    onChange: (value: string) => void;
+    label?: string;
+    className?: string;
+}
+interface EvoRadioProps {
+    value: string;
+    label: string;
+    disabled?: boolean;
+    className?: string;
+}
+export declare const EvoRadio: {
+    ({ value, label, disabled, className }: EvoRadioProps): import("react/jsx-runtime").JSX.Element;
+    Group: ({ children, name, value, onChange, label, className, }: EvoRadioGroupProps) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/RichTextArea/RichTextArea.d.ts

@@ -0,0 +1,70 @@
+import { default as React } from 'react';
+export type EvoRichTextBuiltInTool = 'bold' | 'italic' | 'underline' | 'strike' | 'h1' | 'h2' | 'h3' | 'paragraph' | 'ul' | 'ol' | 'quote' | 'code' | 'link' | 'image' | 'align-left' | 'align-center' | 'align-right' | 'clear' | 'undo' | 'redo' | 'divider';
+export interface EvoRichTextCustomTool {
+    key: string;
+    label: string;
+    icon: React.ReactNode;
+    onAction: (api: EvoRichTextHandle) => void;
+    isActive?: () => boolean;
+}
+export type EvoRichTextTool = EvoRichTextBuiltInTool | EvoRichTextCustomTool;
+export interface EvoRichTextHandle {
+    /** Returns the current HTML content. */
+    getHTML: () => string;
+    /** Replaces the editor content with the given HTML. */
+    setHTML: (html: string) => void;
+    /** Returns the current plain text content. */
+    getText: () => string;
+    /** Focuses the editor. */
+    focus: () => void;
+    /** Inserts an image at the caret. */
+    insertImage: (src: string, alt?: string) => void;
+    /** Inserts arbitrary HTML at the caret. */
+    insertHTML: (html: string) => void;
+    /** Clears all content. */
+    clear: () => void;
+}
+export interface EvoRichTextAreaProps {
+    /** Controlled HTML value. */
+    value?: string;
+    /** Initial HTML for uncontrolled use. */
+    defaultValue?: string;
+    /** Fires whenever the content changes. Receives sanitized HTML. */
+    onChange?: (html: string) => void;
+    /** Which tools to render in the toolbar. Pass [] for no toolbar. */
+    tools?: EvoRichTextTool[];
+    /** Placeholder shown when empty. */
+    placeholder?: string;
+    /** Minimum editor height (CSS). */
+    minHeight?: number | string;
+    /** Maximum editor height before it scrolls (CSS). */
+    maxHeight?: number | string;
+    /** Disables editing. */
+    disabled?: boolean;
+    /** Read-only — same look, no editing. */
+    readOnly?: boolean;
+    /** Optional label rendered above. */
+    label?: string;
+    /** Helper text rendered below (hidden if `error` set). */
+    helperText?: string;
+    /** Error message — also marks the field invalid. */
+    error?: string;
+    /** Stretch to container width. */
+    fullWidth?: boolean;
+    /** Custom upload handler. Resolve with the URL to embed. */
+    onImageUpload?: (file: File) => Promise<string>;
+    /** Accepted image MIME types for the file picker. */
+    acceptedImageTypes?: string[];
+    /** Maximum image size in bytes. Larger images are rejected. */
+    maxImageSize?: number;
+    /** Fires when an image fails validation or upload. */
+    onImageError?: (error: {
+        code: 'too-large' | 'wrong-type' | 'upload-failed';
+        message: string;
+    }) => void;
+    /** Optional class name for the root. */
+    className?: string;
+    /** Optional id (forwarded to the editable surface). */
+    id?: string;
+}
+export declare const EvoRichTextArea: React.ForwardRefExoticComponent<EvoRichTextAreaProps & React.RefAttributes<EvoRichTextHandle>>;

package/dist/Select/Select.d.ts

@@ -0,0 +1,44 @@
+import { default as React } from 'react';
+export interface SelectOption {
+    value: string;
+    label: string;
+    description?: string;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+}
+interface EvoSelectBaseProps {
+    label?: string;
+    options: SelectOption[];
+    placeholder?: string;
+    helperText?: string;
+    error?: string;
+    size?: 'sm' | 'md' | 'lg';
+    fullWidth?: boolean;
+    disabled?: boolean;
+    searchable?: boolean;
+    clearable?: boolean;
+    id?: string;
+    name?: string;
+    className?: string;
+}
+export interface EvoSelectSingleProps extends EvoSelectBaseProps {
+    multiple?: false;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+}
+export interface EvoSelectMultipleProps extends EvoSelectBaseProps {
+    multiple: true;
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    /** How the trigger displays selected items. Defaults to 'chips'. */
+    multipleDisplay?: 'chips' | 'count';
+    /** Maximum number of options that can be selected at once. */
+    maxSelections?: number;
+    /** Show Select-all / Clear-all buttons at the top of the menu. */
+    showSelectAll?: boolean;
+}
+export type EvoSelectProps = EvoSelectSingleProps | EvoSelectMultipleProps;
+export declare const EvoSelect: (props: EvoSelectProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Skeleton/Skeleton.d.ts

@@ -0,0 +1,23 @@
+interface EvoSkeletonProps {
+    width?: number | string;
+    height?: number | string;
+    borderRadius?: number | string;
+    className?: string;
+    animated?: boolean;
+}
+interface EvoSkeletonTextProps {
+    lines?: number;
+    className?: string;
+    animated?: boolean;
+}
+interface EvoSkeletonCircleProps {
+    size?: number | string;
+    className?: string;
+    animated?: boolean;
+}
+export declare const EvoSkeleton: {
+    ({ width, height, borderRadius, className, animated, }: EvoSkeletonProps): import("react/jsx-runtime").JSX.Element;
+    Text: ({ lines, className, animated }: EvoSkeletonTextProps) => import("react/jsx-runtime").JSX.Element;
+    Circle: ({ size, className, animated }: EvoSkeletonCircleProps) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/Stack/Stack.d.ts

@@ -0,0 +1,16 @@
+import { default as React, CSSProperties } from 'react';
+type Direction = 'row' | 'column';
+type Align = 'start' | 'center' | 'end' | 'stretch' | 'baseline';
+type Justify = 'start' | 'center' | 'end' | 'between' | 'around' | 'evenly';
+interface EvoStackProps {
+    children: React.ReactNode;
+    direction?: Direction;
+    gap?: number | string;
+    align?: Align;
+    justify?: Justify;
+    wrap?: boolean;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare const EvoStack: ({ children, direction, gap, align, justify, wrap, className, style, }: EvoStackProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Table/Table.d.ts

@@ -0,0 +1,77 @@
+import { default as React } from 'react';
+export type TableSize = 'sm' | 'md' | 'lg';
+export type TableAlign = 'left' | 'center' | 'right';
+export type TableSortDirection = 'asc' | 'desc';
+export type TableResponsive = 'scroll' | 'stack';
+export interface TableSortState {
+    key: string;
+    direction: TableSortDirection;
+}
+export interface TableColumn<T> {
+    /** Key in the data object. Supports dot notation for nested paths ('role.name'). */
+    key: string;
+    /** Display label or node for the column header. */
+    header: React.ReactNode;
+    /** Optional fixed width, e.g. '120px' or '10%'. */
+    width?: string;
+    /** Cell alignment. Defaults to 'left'. */
+    align?: TableAlign;
+    /** Enable click-to-sort on this column. */
+    sortable?: boolean;
+    /** Custom comparator. Falls back to a numeric-aware string compare. */
+    sortFn?: (a: T, b: T, direction: TableSortDirection) => number;
+    /** Custom cell renderer. Defaults to string coercion. */
+    render?: (value: unknown, row: T, rowIndex: number) => React.ReactNode;
+    /** Extra class for cells in this column. */
+    cellClassName?: string;
+    /** Extra class for the header cell. */
+    headerClassName?: string;
+}
+export interface EvoTableProps<T extends Record<string, unknown>> {
+    /** Column definitions. */
+    columns: TableColumn<T>[];
+    /** Row data array. */
+    data: T[];
+    /** Density variant — controls cell padding and font size. Default 'md'. */
+    size?: TableSize;
+    /** Alternating row backgrounds. */
+    striped?: boolean;
+    /** Highlight rows on hover. Default true. */
+    hoverable?: boolean;
+    /** Add vertical dividers between columns. Default false. */
+    bordered?: boolean;
+    /** Keep the header pinned while the body scrolls. */
+    stickyHeader?: boolean;
+    /** Show skeleton rows in place of data. */
+    loading?: boolean;
+    /** Skeleton row count when loading. Default 5. */
+    loadingRows?: number;
+    /** Stable key for each row. Pass a property name or a getter. */
+    rowKey?: keyof T | ((row: T, index: number) => React.Key);
+    /** Custom empty-state slot. Takes priority over `emptyText`. */
+    emptyState?: React.ReactNode;
+    /** Plain-text fallback when data is empty. */
+    emptyText?: string;
+    /** Fires on single row click. */
+    onRowClick?: (row: T, index: number) => void;
+    /** Fires on row double-click. */
+    onRowDoubleClick?: (row: T, index: number) => void;
+    /** Add custom classes to specific rows. */
+    getRowClassName?: (row: T, index: number) => string | undefined;
+    /**
+     * Small-viewport behaviour.
+     * - `scroll` (default): horizontal scroll with a thin scrollbar.
+     * - `stack`: under ~640px each row becomes a labelled card.
+     */
+    responsive?: TableResponsive;
+    /** Optional caption rendered above the table. */
+    caption?: React.ReactNode;
+    /** Controlled sort state. Pair with `onSortChange`. */
+    sort?: TableSortState | null;
+    /** Sort change callback. */
+    onSortChange?: (next: TableSortState | null) => void;
+    /** Initial sort for uncontrolled mode. */
+    defaultSort?: TableSortState;
+    className?: string;
+}
+export declare const EvoTable: <T extends Record<string, unknown>>({ columns, data, size, striped, hoverable, bordered, stickyHeader, loading, loadingRows, rowKey, emptyState, emptyText, onRowClick, onRowDoubleClick, getRowClassName, responsive, caption, sort, onSortChange, defaultSort, className, }: EvoTableProps<T>) => import("react/jsx-runtime").JSX.Element;

package/dist/Tabs/Tabs.d.ts

@@ -0,0 +1,28 @@
+import { default as React } from 'react';
+interface EvoTabsProps {
+    children: React.ReactNode;
+    defaultTab?: string;
+    className?: string;
+}
+interface EvoTabsListProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface EvoTabProps {
+    id: string;
+    children: React.ReactNode;
+    disabled?: boolean;
+    className?: string;
+}
+interface EvoTabsPanelProps {
+    id: string;
+    children: React.ReactNode;
+    className?: string;
+}
+export declare const EvoTabs: {
+    ({ children, defaultTab, className }: EvoTabsProps): import("react/jsx-runtime").JSX.Element;
+    List: ({ children, className }: EvoTabsListProps) => import("react/jsx-runtime").JSX.Element;
+    Tab: ({ id, children, disabled, className }: EvoTabProps) => import("react/jsx-runtime").JSX.Element;
+    Panel: ({ id, children, className }: EvoTabsPanelProps) => import("react/jsx-runtime").JSX.Element | null;
+};
+export {};

package/dist/Theme/ThemeProvider.d.ts

@@ -0,0 +1,96 @@
+import { ReactNode } from 'react';
+/**
+ * The three theme modes EvoUI supports.
+ * - `'light'` / `'dark'` — force the theme regardless of OS preference.
+ * - `'system'` — follow the user's OS-level color-scheme preference.
+ */
+export type EvoTheme = 'light' | 'dark' | 'system';
+/**
+ * The actually-applied theme after resolving `'system'` against
+ * `window.matchMedia('(prefers-color-scheme: dark)')`. Always either
+ * `'light'` or `'dark'` — never `'system'`.
+ */
+export type EvoResolvedTheme = 'light' | 'dark';
+export interface EvoThemeContextValue {
+    /** The user-selected mode (may be `'system'`). */
+    theme: EvoTheme;
+    /** The mode that is actually painted right now (`'light'` or `'dark'`). */
+    resolvedTheme: EvoResolvedTheme;
+    /** Switch to a specific mode. */
+    setTheme: (theme: EvoTheme) => void;
+    /** Convenience: flip between light and dark (treats `'system'` as its resolved value). */
+    toggleTheme: () => void;
+}
+export interface EvoThemeProviderProps {
+    /** Subtree to provide the theme to. */
+    children: ReactNode;
+    /**
+     * Initial theme used before any persisted value is read.
+     * @default 'system'
+     */
+    defaultTheme?: EvoTheme;
+    /**
+     * localStorage key used to persist the user's choice across reloads.
+     * Pass `null` to disable persistence entirely.
+     * @default 'evo-ui-theme'
+     */
+    storageKey?: string | null;
+    /**
+     * HTML attribute written to the document root. Most apps want
+     * `'data-theme'`; pass `'class'` to instead toggle `light` / `dark`
+     * as className (useful if you're sharing tokens with Tailwind).
+     * @default 'data-theme'
+     */
+    attribute?: 'data-theme' | 'class';
+    /**
+     * Animate color transitions when the theme flips.
+     * Automatically disabled for users with `prefers-reduced-motion`.
+     * @default true
+     */
+    enableTransitions?: boolean;
+    /**
+     * Element to apply the theme attribute to.
+     * @default document.documentElement
+     */
+    target?: HTMLElement;
+}
+/**
+ * Provides EvoUI theming context to descendant components.
+ *
+ * @example
+ * ```tsx
+ * import { EvoThemeProvider } from '@justin_evo/evo-ui';
+ *
+ * <EvoThemeProvider defaultTheme="system">
+ *   <App />
+ * </EvoThemeProvider>
+ * ```
+ */
+export declare const EvoThemeProvider: ({ children, defaultTheme, storageKey, attribute, enableTransitions, target, }: EvoThemeProviderProps) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Read and update the EvoUI theme.
+ *
+ * Must be called from a descendant of `<EvoThemeProvider>`. If used
+ * outside the provider, returns a no-op object with `resolvedTheme`
+ * set to whatever is currently on `document.documentElement`.
+ *
+ * @example
+ * ```tsx
+ * const { resolvedTheme, setTheme, toggleTheme } = useEvoTheme();
+ * <button onClick={toggleTheme}>
+ *   {resolvedTheme === 'dark' ? '☀️' : '🌙'}
+ * </button>
+ * ```
+ */
+export declare const useEvoTheme: () => EvoThemeContextValue;
+/**
+ * Inline script that applies the persisted theme before React hydrates,
+ * preventing the white-flash on first paint in dark mode. Drop into your
+ * `<head>` (or Next.js `<Script strategy="beforeInteractive">`):
+ *
+ * @example
+ * ```html
+ * <script dangerouslySetInnerHTML={{ __html: getEvoThemeScript() }} />
+ * ```
+ */
+export declare const getEvoThemeScript: (storageKey?: string) => string;

package/dist/Theme/ThemeToggle.d.ts

@@ -0,0 +1,22 @@
+export interface EvoThemeToggleProps {
+    /** Visual size of the toggle. @default 'md' */
+    size?: 'sm' | 'md' | 'lg';
+    /** Accessible label. @default 'Toggle color theme' */
+    ariaLabel?: string;
+    /** Extra className to merge with the built-in styles. */
+    className?: string;
+}
+/**
+ * A drop-in button that flips between light and dark mode.
+ *
+ * Sits inside an `<EvoThemeProvider>`. The icon and animation
+ * automatically reflect the resolved theme.
+ *
+ * @example
+ * ```tsx
+ * <EvoThemeProvider>
+ *   <EvoThemeToggle />
+ * </EvoThemeProvider>
+ * ```
+ */
+export declare const EvoThemeToggle: ({ size, ariaLabel, className, }: EvoThemeToggleProps) => import("react/jsx-runtime").JSX.Element;

package/dist/Toggle/Toggle.d.ts

@@ -0,0 +1,11 @@
+type ToggleSize = 'sm' | 'md' | 'lg';
+interface EvoToggleProps {
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    label?: string;
+    disabled?: boolean;
+    size?: ToggleSize;
+    className?: string;
+}
+export declare const EvoToggle: ({ checked, onChange, label, disabled, size, className, }: EvoToggleProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Tooltip/Tooltip.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+interface EvoTooltipProps {
+    content: React.ReactNode;
+    children: React.ReactNode;
+    placement?: TooltipPlacement;
+    className?: string;
+}
+export declare const EvoTooltip: ({ content, children, placement, className, }: EvoTooltipProps) => import("react/jsx-runtime").JSX.Element;
+export {};