@justin_evo/evo-ui 1.0.1

package/dist/Alert/Alert.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+type AlertType = 'success' | 'error' | 'warning' | 'info';
+interface EvoAlertProps {
+    type?: AlertType;
+    title?: string;
+    children: React.ReactNode;
+    dismissible?: boolean;
+    className?: string;
+}
+export declare const EvoAlert: ({ type, title, children, dismissible, className, }: EvoAlertProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/AutoComplete/AutoComplete.d.ts

@@ -0,0 +1,95 @@
+import { default as React } from 'react';
+export interface AutoCompleteOption {
+    /** Stable, unique identifier returned by `onChange`. */
+    value: string;
+    /** Human-readable text shown in the list and the input. */
+    label: string;
+    /** Optional secondary line under the label. */
+    description?: string;
+    /** Optional leading icon. */
+    icon?: React.ReactNode;
+    /** When true, the option is not selectable or keyboard-reachable. */
+    disabled?: boolean;
+}
+/** Pluggable persistence layer for the `recents` feature. */
+export interface RecentsStorage {
+    /** Return the stored option values, most-recent first. */
+    get: () => string[];
+    /** Persist the option values, most-recent first. */
+    set: (values: string[]) => void;
+}
+export interface RecentsConfig {
+    /** Max remembered selections. Default 5. */
+    max?: number;
+    /** Where recents live. Default: in-memory (per `id`/`name`). */
+    storage?: RecentsStorage;
+    /** Section heading shown above recents. Default "Recent". */
+    label?: string;
+}
+export interface EvoAutoCompleteProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'onChange' | 'value' | 'defaultValue'> {
+    /** The options to match against. In async mode, the already-filtered set. */
+    options: AutoCompleteOption[];
+    /** Selected option value (controlled). */
+    value?: string | null;
+    /** Selected option value (uncontrolled initial). */
+    defaultValue?: string | null;
+    /** Fires when a selection is made or cleared. */
+    onChange?: (value: string | null, option: AutoCompleteOption | null) => void;
+    /** The input's text (controlled — pair with `onInputChange`). */
+    inputValue?: string;
+    /** Fires when the typed text changes. Debounced by `debounce`. */
+    onInputChange?: (query: string) => void;
+    /** Field label. */
+    label?: string;
+    placeholder?: string;
+    helperText?: string;
+    /** Error message — also flips the field into the error state. */
+    error?: string;
+    size?: 'sm' | 'md' | 'lg';
+    fullWidth?: boolean;
+    disabled?: boolean;
+    /** Show a clear (✕) button when there is a value. Default true. */
+    clearable?: boolean;
+    /** Render a spinner row instead of results (for async fetches). */
+    loading?: boolean;
+    /** Debounce, in ms, applied to `onInputChange`. Default 0. */
+    debounce?: number;
+    /** Minimum query length before results show. Default 0. */
+    minChars?: number;
+    /** Cap on rendered rows — protects against huge lists. Default 50. */
+    maxResults?: number;
+    /**
+     * Filtering strategy:
+     *  - omitted → case-insensitive substring match on `label`.
+     *  - function → custom predicate.
+     *  - `false` → caller pre-filters (async mode); render `options` as-is.
+     */
+    filter?: false | ((option: AutoCompleteOption, query: string) => boolean);
+    /** Bold the matched substring in each row. Default true. */
+    highlightMatch?: boolean;
+    /** Open the menu when the input receives focus. Default true. */
+    openOnFocus?: boolean;
+    /** Message shown when a non-empty query has no matches. */
+    emptyMessage?: React.ReactNode;
+    /** 🆕 Offer a nearest-match correction when a query has zero results. */
+    smartRecovery?: boolean;
+    /** 🆕 Remember recent selections and surface them on empty focus. */
+    recents?: boolean | RecentsConfig;
+    /** Custom row renderer. Overrides icon/label/description layout. */
+    renderOption?: (option: AutoCompleteOption, state: {
+        active: boolean;
+        query: string;
+    }) => React.ReactNode;
+    id?: string;
+    name?: string;
+    className?: string;
+}
+/**
+ * A `RecentsStorage` backed by `localStorage` — survives reloads.
+ * SSR-safe: no-ops when `window` is unavailable.
+ *
+ * @example
+ * <EvoAutoComplete recents={{ storage: evoLocalRecents('country-picker') }} />
+ */
+export declare const evoLocalRecents: (key: string) => RecentsStorage;
+export declare const EvoAutoComplete: React.ForwardRefExoticComponent<EvoAutoCompleteProps & React.RefAttributes<HTMLInputElement>>;

package/dist/Badge/Badge.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+type BadgeSeverity = 'primary' | 'secondary' | 'success' | 'warning' | 'danger' | 'info';
+type BadgeVariant = 'solid' | 'outline' | 'subtle';
+type BadgeSize = 'sm' | 'md' | 'lg';
+interface EvoBadgeProps {
+    children: React.ReactNode;
+    severity?: BadgeSeverity;
+    variant?: BadgeVariant;
+    size?: BadgeSize;
+    dot?: boolean;
+    removable?: boolean;
+    onRemove?: () => void;
+    className?: string;
+}
+interface EvoBadgeGroupProps {
+    children: React.ReactNode;
+    className?: string;
+}
+export declare const EvoBadge: {
+    ({ children, severity, variant, size, dot, removable, onRemove, className, }: EvoBadgeProps): import("react/jsx-runtime").JSX.Element;
+    Group: ({ children, className }: EvoBadgeGroupProps) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/Breadcrumb/Breadcrumb.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+interface EvoBreadcrumbItemProps {
+    children: React.ReactNode;
+    href?: string;
+    current?: boolean;
+}
+interface EvoBreadcrumbProps {
+    children: React.ReactNode;
+    separator?: React.ReactNode;
+    className?: string;
+}
+export declare const EvoBreadcrumb: {
+    ({ children, separator, className }: EvoBreadcrumbProps): import("react/jsx-runtime").JSX.Element;
+    Item: ({ children, href, current }: EvoBreadcrumbItemProps) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/Button/Button.d.ts

@@ -0,0 +1,54 @@
+import { ButtonHTMLAttributes, ReactNode } from 'react';
+type Variant = 'solid' | 'outline' | 'ghost' | 'soft';
+type Severity = 'primary' | 'secondary' | 'danger' | 'warning' | 'success' | 'info';
+type Size = 'sm' | 'md' | 'lg';
+type Shape = 'default' | 'rounded' | 'square';
+/**
+ * Configuration properties for the EvoButton component.
+ *
+ * Extends every native `<button>` attribute (type, form, name, autoFocus,
+ * aria-*, onMouseEnter, …) so consumers don't have to ask for them one by one.
+ */
+export interface EvoButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Text shown inside the button. Convenience shorthand for `children`. */
+    label?: string;
+    /**
+     * Visual style of the button.
+     * - `solid`   — filled background (default).
+     * - `outline` — bordered, transparent background.
+     * - `ghost`   — no border or background until hover.
+     * - `soft`    — tinted background using the severity's soft token.
+     * @default 'solid'
+     */
+    variant?: Variant;
+    /**
+     * Semantic color theme.
+     * @default 'primary'
+     */
+    severity?: Severity;
+    /** @default 'md' */
+    size?: Size;
+    /**
+     * Border-radius shape, orthogonal to `variant`.
+     * - `default` — normal radius.
+     * - `rounded` — pill / fully rounded edges.
+     * - `square`  — equal width/height; use for icon-only buttons.
+     * @default 'default'
+     */
+    shape?: Shape;
+    /** Icon rendered before the label. */
+    iconLeft?: ReactNode;
+    /** Icon rendered after the label. */
+    iconRight?: ReactNode;
+    /**
+     * When true, replaces icons with a spinner and disables interaction.
+     * `aria-busy` is set automatically.
+     */
+    loading?: boolean;
+    /** Optional text shown next to the spinner while `loading` is true. */
+    loadingText?: string;
+    /** Stretch to fill the parent's width. */
+    fullWidth?: boolean;
+}
+export declare const EvoButton: import('react').ForwardRefExoticComponent<EvoButtonProps & import('react').RefAttributes<HTMLButtonElement>>;
+export {};

package/dist/Card/Card.d.ts

@@ -0,0 +1,60 @@
+import { AnchorHTMLAttributes, ButtonHTMLAttributes, HTMLAttributes, ReactNode } from 'react';
+export type EvoCardVariant = 'elevated' | 'outlined' | 'ghost';
+export type EvoCardOrientation = 'vertical' | 'horizontal' | 'responsive';
+export type EvoCardHeadingLevel = 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+interface EvoCardRootBase {
+    variant?: EvoCardVariant;
+    orientation?: EvoCardOrientation;
+    children: ReactNode;
+}
+interface EvoCardRootStaticProps extends EvoCardRootBase, Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    interactive?: false;
+    href?: never;
+}
+interface EvoCardRootButtonProps extends EvoCardRootBase, Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'type'> {
+    interactive: true;
+    href?: never;
+    /** @default 'button' (never auto-submits) */
+    type?: 'button' | 'submit' | 'reset';
+}
+interface EvoCardRootAnchorProps extends EvoCardRootBase, Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'children' | 'href'> {
+    interactive: true;
+    href: string;
+}
+export type EvoCardRootProps = EvoCardRootStaticProps | EvoCardRootButtonProps | EvoCardRootAnchorProps;
+export declare const EvoCardRoot: import('react').ForwardRefExoticComponent<EvoCardRootProps & import('react').RefAttributes<HTMLElement>>;
+export type EvoCardHeaderProps = HTMLAttributes<HTMLDivElement>;
+export type EvoCardBodyProps = HTMLAttributes<HTMLDivElement>;
+export type EvoCardFooterProps = HTMLAttributes<HTMLDivElement>;
+export declare const EvoCardHeader: import('react').ForwardRefExoticComponent<EvoCardHeaderProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const EvoCardBody: import('react').ForwardRefExoticComponent<EvoCardBodyProps & import('react').RefAttributes<HTMLDivElement>>;
+export declare const EvoCardFooter: import('react').ForwardRefExoticComponent<EvoCardFooterProps & import('react').RefAttributes<HTMLDivElement>>;
+export interface EvoCardTitleProps extends HTMLAttributes<HTMLHeadingElement> {
+    /** Semantic level. Visual size is fixed by the stylesheet. @default 'h3' */
+    as?: EvoCardHeadingLevel;
+    children: ReactNode;
+}
+export declare const EvoCardTitle: import('react').ForwardRefExoticComponent<EvoCardTitleProps & import('react').RefAttributes<HTMLHeadingElement>>;
+export type EvoCardDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+export declare const EvoCardDescription: import('react').ForwardRefExoticComponent<EvoCardDescriptionProps & import('react').RefAttributes<HTMLParagraphElement>>;
+export interface EvoCardMediaProps extends HTMLAttributes<HTMLDivElement> {
+    /** Convenience: renders an <img>. Omit and pass children for custom media. */
+    src?: string;
+    /** Required when `src` is set. Empty string marks the image as decorative. */
+    alt?: string;
+    /** e.g. 16/9 or '4/3'. Applied when no explicit dimensions are given. */
+    aspectRatio?: number | string;
+    children?: ReactNode;
+}
+export declare const EvoCardMedia: import('react').ForwardRefExoticComponent<EvoCardMediaProps & import('react').RefAttributes<HTMLDivElement>>;
+type EvoCardComponent = typeof EvoCardRoot & {
+    Root: typeof EvoCardRoot;
+    Header: typeof EvoCardHeader;
+    Title: typeof EvoCardTitle;
+    Description: typeof EvoCardDescription;
+    Body: typeof EvoCardBody;
+    Footer: typeof EvoCardFooter;
+    Media: typeof EvoCardMedia;
+};
+export declare const EvoCard: EvoCardComponent;
+export {};

package/dist/Checkbox/Checkbox.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+interface EvoCheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    label?: string;
+    helperText?: string;
+    indeterminate?: boolean;
+}
+interface EvoCheckboxGroupProps {
+    children: React.ReactNode;
+    label?: string;
+    className?: string;
+}
+export declare const EvoCheckbox: {
+    ({ label, helperText, indeterminate, className, disabled, id, ...rest }: EvoCheckboxProps): import("react/jsx-runtime").JSX.Element;
+    Group: ({ children, label, className }: EvoCheckboxGroupProps) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/CommandPalette/CommandPalette.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+export interface CommandPaletteItem {
+    label: string;
+    description?: string;
+    group?: string;
+    icon?: React.ReactNode;
+    shortcut?: string[];
+    onSelect: () => void;
+}
+interface EvoCommandPaletteProps {
+    items: CommandPaletteItem[];
+    placeholder?: string;
+    open?: boolean;
+    onClose?: () => void;
+}
+export declare const EvoCommandPalette: ({ items, placeholder, open: controlledOpen, onClose, }: EvoCommandPaletteProps) => import("react/jsx-runtime").JSX.Element | null;
+export {};

package/dist/Container/Container.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+type ContainerSize = 'sm' | 'md' | 'lg' | 'xl' | 'full';
+interface EvoContainerProps {
+    children: React.ReactNode;
+    size?: ContainerSize;
+    centered?: boolean;
+    className?: string;
+}
+export declare const EvoContainer: ({ children, size, centered, className, }: EvoContainerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Divider/Divider.d.ts

@@ -0,0 +1,7 @@
+interface EvoDividerProps {
+    orientation?: 'horizontal' | 'vertical';
+    label?: string;
+    className?: string;
+}
+export declare const EvoDivider: ({ orientation, label, className }: EvoDividerProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Form/Form.d.ts

@@ -0,0 +1,61 @@
+import { default as React } from 'react';
+type FormSize = 'sm' | 'md' | 'lg';
+type FormLayout = 'vertical' | 'horizontal';
+interface FormContextType {
+    disabled?: boolean;
+    size?: FormSize;
+    layout?: FormLayout;
+}
+export declare const useFormContext: () => FormContextType;
+interface EvoFormProps extends React.FormHTMLAttributes<HTMLFormElement> {
+    children: React.ReactNode;
+    disabled?: boolean;
+    size?: FormSize;
+    layout?: FormLayout;
+    maxWidth?: number | string;
+    className?: string;
+}
+export declare const EvoForm: {
+    ({ children, disabled, size, layout, maxWidth, className, style, ...rest }: EvoFormProps): import("react/jsx-runtime").JSX.Element;
+    Header: ({ title, description, badge, children, className }: EvoFormHeaderProps) => import("react/jsx-runtime").JSX.Element;
+    Section: ({ title, description, variant, children, className, }: EvoFormSectionProps) => import("react/jsx-runtime").JSX.Element;
+    Row: ({ children, gap, align, className }: EvoFormRowProps) => import("react/jsx-runtime").JSX.Element;
+    Field: ({ children, label, description, error, required, htmlFor, className, }: EvoFormFieldProps) => import("react/jsx-runtime").JSX.Element;
+    Actions: ({ children, align, divider, className, }: EvoFormActionsProps) => import("react/jsx-runtime").JSX.Element;
+};
+interface EvoFormHeaderProps {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    badge?: React.ReactNode;
+    children?: React.ReactNode;
+    className?: string;
+}
+interface EvoFormSectionProps {
+    title?: React.ReactNode;
+    description?: React.ReactNode;
+    variant?: 'stacked' | 'split';
+    children: React.ReactNode;
+    className?: string;
+}
+interface EvoFormRowProps {
+    children: React.ReactNode;
+    gap?: 'sm' | 'md' | 'lg';
+    align?: 'start' | 'center' | 'end';
+    className?: string;
+}
+interface EvoFormFieldProps {
+    children: React.ReactNode;
+    label?: React.ReactNode;
+    description?: React.ReactNode;
+    error?: React.ReactNode;
+    required?: boolean;
+    htmlFor?: string;
+    className?: string;
+}
+interface EvoFormActionsProps {
+    children: React.ReactNode;
+    align?: 'left' | 'right' | 'between' | 'center';
+    divider?: boolean;
+    className?: string;
+}
+export {};

package/dist/Grid/Grid.d.ts

@@ -0,0 +1,23 @@
+import { default as React, CSSProperties } from 'react';
+interface EvoGridProps {
+    children: React.ReactNode;
+    cols?: number | string;
+    rows?: number | string;
+    gap?: number | string;
+    colGap?: number | string;
+    rowGap?: number | string;
+    className?: string;
+    style?: CSSProperties;
+}
+interface EvoGridItemProps {
+    children: React.ReactNode;
+    colSpan?: number;
+    rowSpan?: number;
+    className?: string;
+    style?: CSSProperties;
+}
+export declare const EvoGrid: {
+    ({ children, cols, rows, gap, colGap, rowGap, className, style, }: EvoGridProps): import("react/jsx-runtime").JSX.Element;
+    Item: ({ children, colSpan, rowSpan, className, style }: EvoGridItemProps) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/ImageCropper/ImageCropper.d.ts

@@ -0,0 +1,111 @@
+/** Output of a crop operation, in the source image's natural pixel space. */
+export interface EvoCropArea {
+    /** Left offset in source image pixels. */
+    x: number;
+    /** Top offset in source image pixels. */
+    y: number;
+    /** Width in source image pixels. */
+    width: number;
+    /** Height in source image pixels. */
+    height: number;
+    /** Rotation applied (0, 90, 180, 270). */
+    rotation: number;
+    /** Natural dimensions of the source image — handy for callers. */
+    sourceWidth: number;
+    sourceHeight: number;
+}
+/** Options for producing a cropped image from the current state. */
+export interface EvoCropOutputOptions {
+    /** Output MIME type. @default 'image/png' */
+    type?: 'image/png' | 'image/jpeg' | 'image/webp';
+    /** Quality, 0–1, for lossy formats. @default 0.92 */
+    quality?: number;
+    /** Cap the output width. Height scales to keep the crop's aspect. */
+    maxWidth?: number;
+    /** Cap the output height. Width scales to keep the crop's aspect. */
+    maxHeight?: number;
+}
+/** Imperative handle returned via `ref`. */
+export interface EvoImageCropperHandle {
+    /** Current crop in source image pixels. */
+    getCrop: () => EvoCropArea | null;
+    /** Cropped image as a Blob. */
+    getCroppedBlob: (opts?: EvoCropOutputOptions) => Promise<Blob>;
+    /** Cropped image as a data URL. */
+    getCroppedDataURL: (opts?: EvoCropOutputOptions) => Promise<string>;
+    /** Cropped image as a fresh, detached canvas (caller owns it). */
+    getCroppedCanvas: (opts?: Pick<EvoCropOutputOptions, 'maxWidth' | 'maxHeight'>) => HTMLCanvasElement | null;
+    /** Reset crop, zoom, pan, and rotation back to their defaults. */
+    reset: () => void;
+    /** Rotate by ±90° (or set to a specific 90° multiple). */
+    rotate: (deg?: 90 | -90 | 0 | 180 | 270) => void;
+    /** Set zoom directly. Clamped to [minZoom, maxZoom]. */
+    setZoom: (zoom: number) => void;
+}
+export interface EvoImageCropperProps {
+    /** Source image URL or data URL. Required. */
+    src: string;
+    /**
+     * Locks the crop rectangle to this width/height ratio.
+     * Omit for a free-form crop. Use `1` for a square, `16/9` for widescreen, etc.
+     */
+    aspectRatio?: number;
+    /** Render the crop rect as a circle (avatars). Implies `aspectRatio: 1`. */
+    circular?: boolean;
+    /** Show a rule-of-thirds grid inside the crop rectangle. @default true */
+    showGrid?: boolean;
+    /** Show the bottom controls toolbar (zoom, rotate, presets). @default true */
+    showControls?: boolean;
+    /** Show aspect ratio preset chips above the canvas. Ignored if `circular`. */
+    ratioPresets?: Array<{
+        label: string;
+        value: number | null;
+    }>;
+    /**
+     * Minimum zoom level (relative to fit-to-stage = 1). @default 1
+     * @example minZoom={0.5} allows zooming out below fit.
+     */
+    minZoom?: number;
+    /** Maximum zoom level. @default 4 */
+    maxZoom?: number;
+    /** Initial zoom. @default 1 */
+    defaultZoom?: number;
+    /** Initial rotation in degrees. Snapped to multiples of 90. @default 0 */
+    defaultRotation?: number;
+    /**
+     * Initial crop rectangle as percentages of the stage (0–100).
+     * Omit to start with the crop covering 80% of the visible image.
+     */
+    defaultCrop?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Stage (canvas area) height. @default 360 */
+    height?: number | string;
+    /** Background under the image. @default 'checker' */
+    background?: 'checker' | 'surface' | 'transparent';
+    /** Optional label rendered above the cropper. */
+    label?: string;
+    /** Optional helper text rendered below the cropper. */
+    helperText?: string;
+    /** Fires whenever the resulting crop changes. */
+    onChange?: (crop: EvoCropArea) => void;
+    /** Fires once the image has loaded and is ready to crop. */
+    onReady?: (info: {
+        naturalWidth: number;
+        naturalHeight: number;
+    }) => void;
+    /** Fires if the image fails to load. */
+    onError?: (error: Error) => void;
+    /** Disable all interaction. */
+    disabled?: boolean;
+    /** Stretch to the parent's width. @default true */
+    fullWidth?: boolean;
+    /** Extra class on the root element. */
+    className?: string;
+    /** Accessible label for the cropper region. */
+    ariaLabel?: string;
+}
+export declare const EvoImageCropper: import('react').ForwardRefExoticComponent<EvoImageCropperProps & import('react').RefAttributes<EvoImageCropperHandle>>;

package/dist/Input/Input.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+interface EvoInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    label?: string;
+    helperText?: string;
+    error?: string;
+    size?: 'sm' | 'md' | 'lg';
+    leadingAdornment?: React.ReactNode;
+    trailingAdornment?: React.ReactNode;
+    fullWidth?: boolean;
+}
+export declare const EvoInput: ({ label, helperText, error, size, leadingAdornment, trailingAdornment, fullWidth, className, id, ...rest }: EvoInputProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/Modal/Modal.d.ts

@@ -0,0 +1,26 @@
+import { default as React } from 'react';
+type ModalSize = 'sm' | 'md' | 'lg' | 'fullscreen';
+interface EvoModalProps {
+    open: boolean;
+    onClose: () => void;
+    children: React.ReactNode;
+    size?: ModalSize;
+    className?: string;
+}
+interface EvoModalHeaderProps {
+    children: React.ReactNode;
+    onClose?: () => void;
+}
+interface EvoModalBodyProps {
+    children: React.ReactNode;
+}
+interface EvoModalFooterProps {
+    children: React.ReactNode;
+}
+export declare const EvoModal: {
+    ({ open, onClose, children, size, className }: EvoModalProps): React.ReactPortal | null;
+    Header: ({ children, onClose }: EvoModalHeaderProps) => import("react/jsx-runtime").JSX.Element;
+    Body: ({ children }: EvoModalBodyProps) => import("react/jsx-runtime").JSX.Element;
+    Footer: ({ children }: EvoModalFooterProps) => import("react/jsx-runtime").JSX.Element;
+};
+export {};

package/dist/Nav/Nav.d.ts

@@ -0,0 +1,63 @@
+import { ButtonHTMLAttributes, HTMLAttributes, KeyboardEvent as ReactKeyboardEvent, MouseEvent as ReactMouseEvent, ReactNode } from 'react';
+export interface EvoNavProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    children: ReactNode;
+    /** Below this viewport width (px), nav collapses to a drawer. @default 768 */
+    breakpoint?: number;
+    /** Controlled drawer open state (mobile only). */
+    drawerOpen?: boolean;
+    /** Uncontrolled initial drawer state. @default false */
+    defaultDrawerOpen?: boolean;
+    /** Called when the drawer opens or closes. */
+    onDrawerOpenChange?: (open: boolean) => void;
+    /** Hide the built-in hamburger trigger (use when wiring a trigger yourself). */
+    hideTrigger?: boolean;
+    /** Accessible label for the <nav> landmark. @default 'Main navigation' */
+    'aria-label'?: string;
+}
+export interface EvoNavGroupProps {
+    label: string;
+    children: ReactNode;
+    className?: string;
+}
+interface EvoNavRowProps {
+    children: ReactNode;
+    icon?: ReactNode;
+    /** Marks this row as the current page (sets aria-current="page"). */
+    active?: boolean;
+    /** Render as <a href> instead of <button>. */
+    href?: string;
+    onClick?: (event: ReactMouseEvent | ReactKeyboardEvent) => void;
+    /** Controlled expand state (only when row has SubItem children). */
+    open?: boolean;
+    /** Uncontrolled initial expand state. */
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+}
+export interface EvoNavItemProps extends EvoNavRowProps {
+}
+export interface EvoNavSubItemProps extends EvoNavRowProps {
+}
+export interface EvoNavSkeletonProps {
+    /** @default 4 */
+    count?: number;
+}
+export interface EvoNavQuickActionProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** @default 'Create New' */
+    label?: string;
+    icon?: ReactNode;
+}
+export declare const EvoNavItem: import('react').ForwardRefExoticComponent<EvoNavItemProps & import('react').RefAttributes<HTMLLIElement>>;
+export declare const EvoNavSubItem: import('react').ForwardRefExoticComponent<EvoNavSubItemProps & import('react').RefAttributes<HTMLLIElement>>;
+export declare const EvoNavGroup: import('react').ForwardRefExoticComponent<EvoNavGroupProps & import('react').RefAttributes<HTMLLIElement>>;
+export declare const EvoNavSkeleton: ({ count }: EvoNavSkeletonProps) => import("react/jsx-runtime").JSX.Element;
+export declare const EvoNavQuickAction: import('react').ForwardRefExoticComponent<EvoNavQuickActionProps & import('react').RefAttributes<HTMLButtonElement>>;
+export declare const EvoNav: import('react').ForwardRefExoticComponent<EvoNavProps & import('react').RefAttributes<HTMLElement>> & {
+    Group: import('react').ForwardRefExoticComponent<EvoNavGroupProps & import('react').RefAttributes<HTMLLIElement>>;
+    Item: import('react').ForwardRefExoticComponent<EvoNavItemProps & import('react').RefAttributes<HTMLLIElement>>;
+    SubItem: import('react').ForwardRefExoticComponent<EvoNavSubItemProps & import('react').RefAttributes<HTMLLIElement>>;
+    Skeleton: ({ count }: EvoNavSkeletonProps) => import("react/jsx-runtime").JSX.Element;
+    QuickAction: import('react').ForwardRefExoticComponent<EvoNavQuickActionProps & import('react').RefAttributes<HTMLButtonElement>>;
+};
+export {};