@nim.zone/ui 0.6.0

package/dist/components/admin-shell.d.ts

@@ -0,0 +1,121 @@
+import { ReactNode } from 'react';
+import { IconName } from './icon';
+export interface AdminNavItem {
+    href?: string;
+    icon?: IconName;
+    key: string;
+    label: ReactNode;
+    onSelect?: () => void;
+}
+export interface AdminNavGroup {
+    icon?: IconName;
+    items: AdminNavItem[];
+    key: string;
+    label: ReactNode;
+}
+export interface AdminShellProps {
+    /** Brand mark at the top of the sidebar. */
+    brand?: ReactNode;
+    children: ReactNode;
+    className?: string;
+    /** Under the nav: session state, build version — the things an operator
+        checks before believing a screen. */
+    sidebarFooter?: ReactNode;
+    groups: AdminNavGroup[];
+    labels?: {
+        menu: string;
+        nav: string;
+        close: string;
+    };
+    /** `key` of the active item. */
+    value: string;
+    /** Search field, status pills, the signed-in operator. */
+    toolbar?: ReactNode;
+    title?: ReactNode;
+}
+/**
+ * The console layout: a grouped sidebar, a topbar, and one scrolling workspace.
+ *
+ * The counterpart to `AppShell`, and deliberately a different component rather
+ * than a `variant`: an operator console is a desktop-first, two-column, deep
+ * hierarchy, and a phone app is a single column with five destinations. Sharing
+ * one component would mean every screen carrying the other's assumptions.
+ *
+ * Below the layout's breakpoint the same sidebar becomes a drawer — the same
+ * markup, not a second nav to keep in sync, which is how the two drift apart.
+ */
+export declare function AdminShell({ brand, children, className, groups, labels, sidebarFooter, title, toolbar, value, }: AdminShellProps): import("react").JSX.Element;
+export interface DetailHeaderProps {
+    /** Buttons for this record: approve, retry, export. */
+    actions?: ReactNode;
+    back?: {
+        href?: string;
+        label: string;
+        onClick?: () => void;
+    };
+    className?: string;
+    /** Status badge, owner, id — the facts that qualify the title. */
+    meta?: ReactNode;
+    status?: ReactNode;
+    subtitle?: ReactNode;
+    title: ReactNode;
+}
+/**
+ * The top of a record: where it sits, what it is, and what can be done to it.
+ *
+ * The actions live here rather than at the bottom of the page because an
+ * operator working a queue acts on the record without reading all of it, and a
+ * button below a thousand-row table is a button nobody finds.
+ */
+export declare function DetailHeader({ actions, back, className, meta, status, subtitle, title, }: DetailHeaderProps): import("react").JSX.Element;
+export interface FilterChip {
+    key: string;
+    label: ReactNode;
+    onRemove: () => void;
+    /** The value the filter is set to, shown after the label. */
+    value?: ReactNode;
+}
+export interface FilterChipsProps {
+    chips: FilterChip[];
+    className?: string;
+    clearLabel?: string;
+    labels?: {
+        remove: (label: string) => string;
+        toolbar: string;
+    };
+    onClearAll?: () => void;
+}
+/**
+ * The filters currently narrowing a table, each removable.
+ *
+ * It renders nothing when there are none — an empty toolbar reserving space
+ * for filters nobody set is the reason these strips feel like chrome. Every
+ * chip states what it removes in its accessible name, because "remove" ten
+ * times over is no name at all.
+ */
+export declare function FilterChips({ chips, className, clearLabel, labels, onClearAll, }: FilterChipsProps): import("react").JSX.Element | null;
+export interface ActivityEvent {
+    /** What happened, in the product's own words. */
+    action: ReactNode;
+    actor?: ReactNode;
+    /** ISO timestamp. Formatted here, in the viewer's locale. */
+    at?: string;
+    icon?: IconName;
+    id: string;
+    target?: ReactNode;
+    tone?: 'accent' | 'danger' | 'default' | 'success' | 'warning';
+}
+export interface ActivityFeedProps {
+    className?: string;
+    empty?: ReactNode;
+    events: ActivityEvent[];
+    locale?: string;
+}
+/**
+ * Who did what, most recent first.
+ *
+ * Timestamps are absolute rather than "3 hours ago": an audit trail is read to
+ * reconstruct a sequence, and a relative time that keeps moving is exactly
+ * what you cannot compare two of.
+ */
+export declare function ActivityFeed({ className, empty, events, locale }: ActivityFeedProps): import("react").JSX.Element;

package/dist/components/app-shell.d.ts

@@ -0,0 +1,23 @@
+import { ReactNode } from 'react';
+import { TabBarProps } from './tab-bar';
+export interface AppShellProps {
+    children: ReactNode;
+    className?: string;
+    /** Sticky top row: a title, a back control, an action. Optional — many
+        screens carry their own header inside the content instead. */
+    header?: ReactNode;
+    /** The bottom navigation. Omit it on a screen deeper in the stack: a tab bar
+        that stays visible under a detail page invites the viewer to leave. */
+    tabs?: TabBarProps;
+}
+/**
+ * The frame an app lives in: a sticky header, one scrolling region, and the
+ * tab bar.
+ *
+ * The scroll container is here and nowhere else, which is what makes scroll
+ * restoration, pull-to-refresh and "scroll to top on tab change" one thing to
+ * implement rather than one per screen. The content region reserves room for
+ * the bar it is drawn under, so the last row of a list is never hidden behind
+ * it — the failure this component exists to prevent.
+ */
+export declare function AppShell({ children, className, header, tabs }: AppShellProps): import("react").JSX.Element;

package/dist/components/auth-screen.d.ts

@@ -0,0 +1,33 @@
+import { ReactNode } from 'react';
+export interface AuthScreenProps {
+    /** The form itself: a PhoneField, an OtpInput, a PasswordField. */
+    children: ReactNode;
+    className?: string;
+    /** Brand mark above the heading. */
+    brand?: ReactNode;
+    /** Small link back to the previous step — the OTP step's way home. */
+    back?: {
+        label: string;
+        onClick: () => void;
+    };
+    /** Terms line, support link, resend timer. Sits under the CTA. */
+    footer?: ReactNode;
+    subtitle?: ReactNode;
+    title: ReactNode;
+    /** The single primary action. A sign-in screen has exactly one. */
+    action?: {
+        disabled?: boolean;
+        label: string;
+        loading?: boolean;
+        onClick: () => void;
+    };
+}
+/**
+ * The frame every step of a sign-in flow shares: brand, one heading, one
+ * explanation, the fields, and a single action pinned to the bottom.
+ *
+ * Keeping it one component is what makes the phone step, the code step and the
+ * password step read as one screen changing rather than three screens — and it
+ * puts the CTA in the same place each time, which is the part a thumb learns.
+ */
+export declare function AuthScreen({ action, back, brand, children, className, footer, subtitle, title, }: AuthScreenProps): import("react").JSX.Element;

package/dist/components/avatar.d.ts

@@ -0,0 +1,10 @@
+import { HTMLAttributes } from 'react';
+export type AvatarSize = 'lg' | 'md' | 'sm';
+export interface AvatarProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Falls back to initials derived from `name` when no image is supplied. */
+    name: string;
+    shape?: 'round' | 'square';
+    size?: AvatarSize;
+    src?: string;
+}
+export declare function Avatar({ className, name, shape, size, src, ...props }: AvatarProps): import("react").JSX.Element;

package/dist/components/badge.d.ts

@@ -0,0 +1,14 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export type BadgeSize = 'md' | 'sm';
+export type BadgeTone = 'outline' | 'soft' | 'solid';
+export type BadgeVariant = 'accent' | 'danger' | 'info' | 'neutral' | 'success' | 'warning';
+export interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    children: ReactNode;
+    /** Shows a status dot before the label — for live/among-states meanings. */
+    dot?: boolean;
+    pill?: boolean;
+    size?: BadgeSize;
+    tone?: BadgeTone;
+    variant?: BadgeVariant;
+}
+export declare function Badge({ children, className, dot, pill, size, tone, variant, ...props }: BadgeProps): import("react").JSX.Element;

package/dist/components/banner.d.ts

@@ -0,0 +1,11 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { IconName } from './icon';
+export type BannerTone = 'accent' | 'danger' | 'info' | 'neutral' | 'success' | 'warning';
+export interface BannerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    action?: ReactNode;
+    children: ReactNode;
+    icon?: IconName;
+    title?: ReactNode;
+    tone?: BannerTone;
+}
+export declare function Banner({ action, children, className, icon, title, tone, ...props }: BannerProps): import("react").JSX.Element;

package/dist/components/breadcrumb.d.ts

@@ -0,0 +1,12 @@
+export interface Crumb {
+    href?: string;
+    label: string;
+}
+export interface BreadcrumbProps {
+    className?: string;
+    /** The trail, root first. The last entry is the current page and is never a
+        link — a link to where the reader already is has nothing to offer. */
+    items: Crumb[];
+    label?: string;
+}
+export declare function Breadcrumb({ className, items, label }: BreadcrumbProps): import("react").JSX.Element;

package/dist/components/button.d.ts

@@ -0,0 +1,21 @@
+import { ButtonHTMLAttributes, ReactNode } from 'react';
+import { IconName } from './icon';
+export type ButtonSize = 'sm' | 'md' | 'lg';
+export type ButtonVariant = 'accent' | 'danger' | 'ghost' | 'primary' | 'secondary';
+export interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    children: ReactNode;
+    fullWidth?: boolean;
+    /** Icon on the trailing edge — travels with the reading direction. */
+    iconEnd?: IconName;
+    iconStart?: IconName;
+    /** Blocks interaction and announces busy; the label stays in place so the
+        button does not change width mid-request. */
+    loading?: boolean;
+    size?: ButtonSize;
+    variant?: ButtonVariant;
+}
+/**
+ * The ref is forwarded because overlays anchor to their trigger: Menu and
+ * Popover need the element, not a wrapper around it.
+ */
+export declare const Button: import('react').ForwardRefExoticComponent<ButtonProps & import('react').RefAttributes<HTMLButtonElement>>;

package/dist/components/card.d.ts

@@ -0,0 +1,15 @@
+import { HTMLAttributes, ReactNode } from 'react';
+export type CardPadding = 'lg' | 'md' | 'none' | 'sm';
+export type CardVariant = 'accent' | 'default' | 'muted' | 'outline' | 'raised';
+export interface CardProps extends HTMLAttributes<HTMLElement> {
+    as?: 'article' | 'div' | 'section';
+    children: ReactNode;
+    footer?: ReactNode;
+    header?: ReactNode;
+    /** Visual affordance only. An interactive card must still be wrapped in, or
+        rendered as, a real button or link — this never adds a handler. */
+    interactive?: boolean;
+    padding?: CardPadding;
+    variant?: CardVariant;
+}
+export declare function Card({ as: Component, children, className, footer, header, interactive, padding, variant, ...props }: CardProps): import("react").JSX.Element;

package/dist/components/chat-composer.d.ts

@@ -0,0 +1,52 @@
+import { ChatAttachment } from './chat';
+export interface ChatDraft {
+    attachments: ChatAttachment[];
+    text: string;
+}
+export interface ChatComposerProps {
+    /** Accept list for the attach button. Narrow it to what the product takes. */
+    accept?: string;
+    className?: string;
+    disabled?: boolean;
+    labels?: Partial<typeof DEFAULT_LABELS>;
+    /** Called with the draft. Uploading is the app's: the attachments carry
+        object URLs and their `File`s are handed over in `onFiles`. */
+    onSend: (draft: ChatDraft) => void;
+    /** The raw `File`s behind the attachments in the same order, so the caller
+        can upload them without re-reading the object URLs. */
+    onFiles?: (files: File[]) => void;
+    placeholder?: string;
+    /** Turn off what the product does not support. Voice also switches itself
+        off where the browser has no recorder. */
+    allow?: {
+        file?: boolean;
+        video?: boolean;
+        voice?: boolean;
+    };
+}
+declare const DEFAULT_LABELS: {
+    attach: string;
+    cancel: string;
+    discard: string;
+    record: string;
+    recording: string;
+    send: string;
+    stop: string;
+    video: string;
+};
+/**
+ * The composer: text, a file, a video, or a voice message recorded in place.
+ *
+ * It holds the draft and nothing else — no transport, no upload, no socket.
+ * `onSend` receives the text and the attachments, and `onFiles` hands over the
+ * original `File`s, because an object URL is for showing and a `File` is for
+ * uploading and the caller needs both.
+ *
+ * Voice recording is `MediaRecorder` over `getUserMedia`. Where either is
+ * missing — an old browser, an insecure origin, a denied microphone — the
+ * button is simply not rendered, rather than offered and then failing. The
+ * stream's tracks are stopped on every exit path, including unmount: a
+ * recorder left running is a microphone indicator that never goes away.
+ */
+export declare function ChatComposer({ accept, allow, className, disabled, labels, onFiles, onSend, placeholder, }: ChatComposerProps): import("react").JSX.Element;
+export {};

package/dist/components/chat.d.ts

@@ -0,0 +1,77 @@
+import { ReactNode } from 'react';
+/** What a message carries. Text is a string; the rest is an attachment. */
+export type ChatMediaKind = 'file' | 'image' | 'text' | 'video' | 'voice';
+export interface ChatAttachment {
+    /** Seconds. Voice and video only — a duration the viewer sees before playing. */
+    duration?: number;
+    kind: Exclude<ChatMediaKind, 'text'>;
+    name?: string;
+    /** Still frame for a video. Without one the browser draws its own first frame. */
+    poster?: string;
+    /** Bytes. Shown on files so nobody taps a 40MB download on mobile data. */
+    size?: number;
+    /** Object URL or remote URL. The kit never uploads anything itself. */
+    url: string;
+    /** Normalised 0–1 samples for a voice message. Absent draws a flat track. */
+    waveform?: number[];
+}
+export interface ChatMessage {
+    attachments?: ChatAttachment[];
+    /** Who wrote it. `own` messages are the viewer's and sit on the trailing edge. */
+    author?: {
+        avatar?: string;
+        name: string;
+    };
+    id: string;
+    own?: boolean;
+    /** Delivery state, shown on own messages only — the other side's receipts
+        are not the viewer's business. */
+    status?: 'failed' | 'read' | 'sending' | 'sent';
+    text?: string;
+    /** ISO timestamp. Formatted in the viewer's locale, never by the caller. */
+    at?: string;
+}
+export interface ChatProps {
+    className?: string;
+    /** Someone is typing. A name renders "Sara is typing", bare `true` renders
+        the dots alone. */
+    typing?: boolean | string;
+    /** Rendered under the last message — a date divider, a system notice. */
+    footer?: ReactNode;
+    /** Accessible names and the few words the transcript itself says. */
+    labels?: Partial<typeof DEFAULT_LABELS>;
+    /** The composer. Passing none makes the transcript read-only, which is what
+        an archive or a shared thread wants. */
+    composer?: ReactNode;
+    locale?: string;
+    messages: ChatMessage[];
+    /** Header row: who this conversation is with, and its actions. */
+    header?: ReactNode;
+}
+declare const DEFAULT_LABELS: {
+    download: string;
+    failed: string;
+    pause: string;
+    play: string;
+    read: string;
+    sending: string;
+    sent: string;
+    today: string;
+    typing: string;
+    yesterday: string;
+    voiceMessage: string;
+};
+/**
+ * One conversation: a scrolling transcript with a composer under it.
+ *
+ * The transcript is a `<ol>` in a live region, so a message arriving is
+ * announced without stealing focus from whatever the viewer is typing. It
+ * follows the newest message only when the viewer is already at the bottom —
+ * yanking someone back down while they are reading history is the single most
+ * common chat bug, and it is a scroll check, not a scroll call.
+ *
+ * Media is played by the platform's own elements. The kit renders transports
+ * and bubbles; it never uploads, transcodes, or holds a socket.
+ */
+export declare function Chat({ className, composer, footer, header, labels, locale, messages, typing, }: ChatProps): import("react").JSX.Element;
+export {};

package/dist/components/checkout.d.ts

@@ -0,0 +1,79 @@
+import { ReactNode } from 'react';
+import { IconName } from './icon';
+export interface OptionCardProps {
+    /** A short word on the trailing edge: "manual review", "default". */
+    badge?: ReactNode;
+    className?: string;
+    description?: ReactNode;
+    disabled?: boolean;
+    icon?: IconName;
+    /** Rendered under the description when chosen — an account number, a
+        delivery window. Hidden otherwise, because it is only true of the
+        selected option. */
+    detail?: ReactNode;
+    name?: string;
+    onSelect: () => void;
+    selected: boolean;
+    title: ReactNode;
+}
+/**
+ * One choice in a list of choices: a payment method, a saved address, a
+ * delivery window.
+ *
+ * A real `<input type="radio">` inside the card, visually hidden, is what makes
+ * a set of these behave like a radio group — arrow keys move between them, the
+ * name groups them, and a form submits the chosen one. The card is the label,
+ * so the whole plate is the target rather than a 20px dot beside it.
+ */
+export declare function OptionCard({ badge, className, description, detail, disabled, icon, name, onSelect, selected, title, }: OptionCardProps): import("react").JSX.Element;
+export interface SummaryLine {
+    /** Set on the line the eye should land on — the total. At most one. */
+    emphasis?: boolean;
+    key: string;
+    label: ReactNode;
+    /** A qualifier under the label: "6 months · renews 1405/12/01". */
+    meta?: ReactNode;
+    /** Already formatted. Currency and digits are the product's locale call. */
+    value: ReactNode;
+}
+export interface OrderSummaryProps {
+    className?: string;
+    /** Deductions. Rendered in the success tone with the sign the caller gives
+        them — the kit does not do arithmetic on money it cannot see. */
+    items: SummaryLine[];
+    /** Subtotal, tax, fees, total: the arithmetic, under a rule. */
+    totals?: SummaryLine[];
+    title?: ReactNode;
+}
+/**
+ * What is being bought, and what it comes to.
+ *
+ * Every figure is a `ReactNode` the caller has already formatted. That is
+ * deliberate: money is the last thing a UI kit should be computing or
+ * rounding, and a component that took numbers would have to guess a currency,
+ * a tax rule and a digit shape — three decisions that belong to the product
+ * and are wrong in Persian first.
+ */
+export declare function OrderSummary({ className, items, title, totals }: OrderSummaryProps): import("react").JSX.Element;
+export interface ActionBarProps {
+    /** The primary control. One only: a bar with two equal buttons has none. */
+    action: ReactNode;
+    className?: string;
+    /** Fine print under the row — renewal terms, delivery estimate. */
+    note?: ReactNode;
+    /** The figure the action commits to, beside it rather than above it, so it
+        is read in the same glance as the button. */
+    total?: {
+        label: ReactNode;
+        value: ReactNode;
+    };
+}
+/**
+ * The bar a purchase screen ends with: what it costs, and the button.
+ *
+ * It sticks to the bottom of the scroll container rather than the viewport, so
+ * it belongs to the screen it is part of and cannot end up floating over an
+ * unrelated one. It sits above the safe-area inset, and the content above owes
+ * it room the way it does the tab bar.
+ */
+export declare function ActionBar({ action, className, note, total }: ActionBarProps): import("react").JSX.Element;

package/dist/components/choice.d.ts

@@ -0,0 +1,15 @@
+import { InputHTMLAttributes, ReactNode } from 'react';
+interface ChoiceBaseProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type'> {
+    children: ReactNode;
+    description?: string;
+}
+export type CheckboxProps = ChoiceBaseProps;
+export type SwitchProps = ChoiceBaseProps;
+/**
+ * Both controls keep a real `<input>` in the tree — visually hidden but
+ * focusable — so keyboard behaviour, form participation, and assistive tech
+ * come from the platform rather than from re-implemented ARIA.
+ */
+export declare function Checkbox({ children, className, description, ...props }: CheckboxProps): import("react").JSX.Element;
+export declare function Switch({ children, className, description, ...props }: SwitchProps): import("react").JSX.Element;
+export {};

package/dist/components/combobox.d.ts

@@ -0,0 +1,31 @@
+export interface ComboboxOption<T extends string> {
+    disabled?: boolean;
+    label: string;
+    /** A trailing hint set in the mono — a count, a code, a date. */
+    meta?: string;
+    value: T;
+}
+export interface ComboboxProps<T extends string> {
+    className?: string;
+    /** Shown when nothing matches. Give the viewer the way forward rather than
+        a dead end: "No client matches — create it". */
+    emptyState?: (query: string) => React.ReactNode;
+    error?: string;
+    hint?: string;
+    id?: string;
+    label?: string;
+    onChange: (value: T | null) => void;
+    options: ComboboxOption<T>[];
+    placeholder?: string;
+    required?: boolean;
+    value: T | null;
+}
+/**
+ * A text input that suggests, and can still be typed into.
+ *
+ * A real `<input>` with `role="combobox"` over a `role="listbox"`, so the
+ * platform's text editing, autofill and form participation are untouched.
+ * Arrow keys move the active option, Enter commits it, Escape reverts to the
+ * last committed value rather than clearing the field.
+ */
+export declare function Combobox<T extends string>({ className, emptyState, error, hint, id, label, onChange, options, placeholder, required, value, }: ComboboxProps<T>): import("react").JSX.Element;

package/dist/components/date-field.d.ts

@@ -0,0 +1,58 @@
+import { CalendarSystem, IsoDate } from '../lib/calendars';
+export type { CalendarSystem, IsoDate } from '../lib/calendars';
+export interface CalendarProps {
+    className?: string;
+    /** Days to flag — a due date, a booking, anything the month should mark. */
+    marked?: IsoDate[];
+    max?: IsoDate;
+    min?: IsoDate;
+    month: IsoDate;
+    onMonthChange: (month: IsoDate) => void;
+    onSelect: (date: IsoDate) => void;
+    /** The calendar the grid is drawn in. Defaults to Jalali for an `fa` locale
+        and Gregorian everywhere else. The value stays an ISO Gregorian date in
+        both — the calendar is what the viewer reads, not what the API gets. */
+    system?: CalendarSystem;
+    value?: IsoDate | null;
+    /** 1 = Monday. Defaults to Saturday on the Jalali calendar, Monday on the
+        Gregorian one — the week does not start on the same day everywhere. */
+    weekStart?: number;
+}
+export declare function Calendar({ className, marked, max, min, month, onMonthChange, onSelect, system, value, weekStart, }: CalendarProps): import("react").JSX.Element;
+interface DateEntryProps extends Omit<CalendarProps, 'month' | 'onMonthChange' | 'onSelect' | 'value'> {
+    error?: string;
+    hint?: string;
+    id?: string;
+    label?: string;
+    onChange: (value: IsoDate) => void;
+    required?: boolean;
+    value: IsoDate;
+}
+export type DateFieldProps = DateEntryProps;
+/**
+ * A text field with a calendar under it, in that order of importance: typing a
+ * date always works, which matters more to more people than the grid does.
+ *
+ * Both halves answer the same calendar system, so a Persian interface types
+ * ۱۴۰۴/۰۶/۰۱ into a Jalali grid — and still hands the caller `2025-08-23`.
+ */
+export declare function DateField({ error, hint, id, label, onChange, required, value, ...calendarProps }: DateFieldProps): import("react").JSX.Element;
+export interface DatePickerProps extends DateEntryProps {
+    /** Accessible names for the two controls the picker adds. */
+    labels?: {
+        clear: string;
+        open: string;
+    };
+    /** The same date on the other calendar, under the field. On by default for
+        Jalali, where a viewer often has to reconcile a Gregorian document. */
+    showEquivalent?: boolean;
+}
+/**
+ * The compact form of date entry: one field, with the grid behind a button.
+ *
+ * Use it in a form, where a permanently open month steals the space three
+ * other fields need; `DateField` is for the screen whose subject is the date.
+ * On the Jalali calendar it prints the Gregorian equivalent under the field —
+ * the reconciliation an Iranian office does by hand all day.
+ */
+export declare function DatePicker({ error, hint, id, label, labels: names, onChange, required, showEquivalent, value, ...calendarProps }: DatePickerProps): import("react").JSX.Element;

package/dist/components/dialog.d.ts

@@ -0,0 +1,20 @@
+import { ReactNode } from 'react';
+export interface DialogProps {
+    children: ReactNode;
+    className?: string;
+    closeLabel?: string;
+    description?: ReactNode;
+    footer?: ReactNode;
+    onClose: () => void;
+    open: boolean;
+    title: ReactNode;
+}
+/**
+ * The centred modal, for a decision that has to be made now. The Sheet remains
+ * nim's mobile-first surface; this is what a desktop confirmation wants.
+ *
+ * It renders a real `<dialog>` opened with `showModal()`, so the top layer,
+ * the focus trap, the inert background and Escape all come from the platform
+ * rather than from a scrim div and a keydown listener.
+ */
+export declare function Dialog({ children, className, closeLabel, description, footer, onClose, open, title, }: DialogProps): import("react").JSX.Element;

package/dist/components/empty-state.d.ts

@@ -0,0 +1,9 @@
+import { HTMLAttributes, ReactNode } from 'react';
+import { IconName } from './icon';
+export interface EmptyStateProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    actions?: ReactNode;
+    description?: ReactNode;
+    icon?: IconName;
+    title: ReactNode;
+}
+export declare function EmptyState({ actions, className, description, icon, title, ...props }: EmptyStateProps): import("react").JSX.Element;

package/dist/components/feedback.d.ts

@@ -0,0 +1,18 @@
+import { HTMLAttributes } from 'react';
+export interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
+    label?: string;
+    size?: 'lg' | 'md' | 'sm';
+}
+export declare function Spinner({ className, label, size, ...props }: SpinnerProps): import("react").JSX.Element;
+export interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
+    label?: string;
+    /** Omit for an indeterminate bar. */
+    value?: number;
+}
+export declare function Progress({ className, label, value, ...props }: ProgressProps): import("react").JSX.Element;
+export interface SkeletonProps extends HTMLAttributes<HTMLSpanElement> {
+    height?: number | string;
+    radius?: string;
+    width?: number | string;
+}
+export declare function Skeleton({ className, height, radius, width, ...props }: SkeletonProps): import("react").JSX.Element;