@passui/react 0.1.17 → 0.1.19

package/dist/types/src/components/dialog/dialog-host.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Renders confirmation dialogs: a glass card that springs up over blurred
+ * content. Escape or a click outside cancels; Enter confirms unless the
+ * action is destructive, where the safe choice has focus.
+ */
+export declare function DialogHost(): import("react").JSX.Element;

package/dist/types/src/components/dialog/dialog-store.d.ts

@@ -0,0 +1,21 @@
+/**
+ * App-wide confirmation dialogs, replacing the browser's `confirm`.
+ * `await confirmDialog({...})` resolves true when confirmed. Render one
+ * `<DialogHost />`.
+ */
+export interface ConfirmOptions {
+    title: string;
+    message?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    /** Destructive actions are shown in red and are not the default button. */
+    destructive?: boolean;
+}
+export interface PendingDialog extends ConfirmOptions {
+    id: number;
+    resolve: (confirmed: boolean) => void;
+}
+export declare function confirmDialog(options: ConfirmOptions): Promise<boolean>;
+export declare function settleDialog(confirmed: boolean): void;
+export declare function subscribeDialogs(listener: () => void): () => void;
+export declare function getDialog(): PendingDialog | null;

package/dist/types/src/components/dialog/dialog.d.ts

@@ -0,0 +1,30 @@
+import { type FormEvent, type ReactNode } from "react";
+export type DialogPresentation = "drawer" | "center" | "inline";
+export type DialogTone = "default" | "destructive";
+export type DialogProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: ReactNode;
+    description?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    /** `drawer` (responsive sheet), `center` (floating panel), or `inline`. @default "drawer" */
+    presentation?: DialogPresentation;
+    className?: string;
+    onSubmit?: (event: FormEvent<HTMLFormElement>) => void;
+};
+type ActionsProps = {
+    submitLabel: ReactNode;
+    cancelLabel: ReactNode;
+    pending?: boolean;
+    disabled?: boolean;
+    tone?: DialogTone;
+    onConfirm?: () => void;
+};
+export declare function Dialog({ open, onOpenChange, title, description, children, footer, presentation, className, onSubmit, }: DialogProps): import("react").JSX.Element;
+export declare namespace Dialog {
+    export { Actions };
+}
+/** The standard footer: a primary action and a cancel that closes the dialog. */
+declare function Actions({ submitLabel, cancelLabel, pending, disabled, tone, onConfirm, }: ActionsProps): import("react").JSX.Element;
+export {};

package/dist/types/src/components/dialog/index.d.ts

@@ -0,0 +1 @@
+export * from "./dialog";

package/dist/types/src/components/disclosure-group/disclosure-group.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from "react";
+export interface DisclosureGroupProps {
+    label: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    children: ReactNode;
+    disabled?: boolean;
+    className?: string;
+    /** Supporting text beneath the title. */
+    description?: string;
+}
+/** A controlled, accessible disclosure row with the shared inline reveal. */
+export declare function DisclosureGroup({ label, open, onOpenChange, children, disabled, className, description, }: DisclosureGroupProps): import("react").JSX.Element;

package/dist/types/src/components/divider/divider.d.ts

@@ -0,0 +1,9 @@
+import type { HTMLAttributes } from "react";
+export type DividerOrientation = "horizontal" | "vertical";
+export interface DividerProps extends HTMLAttributes<HTMLHRElement> {
+    orientation?: DividerOrientation;
+    /** Decorative separators are omitted from the accessibility tree. @default true */
+    decorative?: boolean;
+}
+/** A semantic separator using the shared surface color. */
+export declare function Divider({ orientation, decorative, className, ...props }: DividerProps): import("react").JSX.Element;

package/dist/types/src/components/inline-disclosure/inline-disclosure.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+export interface InlineDisclosureProps {
+    /** Whether the content is expanded. */
+    open: boolean;
+    children: ReactNode;
+    className?: string;
+}
+/**
+ * An inline, spring-driven reveal for settings editors and small details.
+ *
+ * Height and opacity animate together so following rows move continuously
+ * instead of jumping. Motion is disabled when the user requests less motion.
+ * The content unmounts after its exit animation completes.
+ */
+export declare function InlineDisclosure({ open, children, className }: InlineDisclosureProps): import("react").JSX.Element;

package/dist/types/src/components/labeled-content/labeled-content.d.ts

@@ -0,0 +1,19 @@
+import type { HTMLAttributes, ReactNode } from "react";
+export interface LabeledContentProps extends HTMLAttributes<HTMLDivElement> {
+    /** The visible name of the row. */
+    label: string;
+    /** Supporting text below the label. */
+    description?: string;
+    /** The row's control or value. */
+    children: ReactNode;
+    /** Places the control below the label at every width. @default false */
+    stacked?: boolean;
+    /** Places a wide control below its label on phones. @default false */
+    wide?: boolean;
+}
+/**
+ * A row: a label, an optional description, and its control at the trailing
+ * end, as SwiftUI's `LabeledContent`. Wide controls move under the label
+ * when there is no room beside it, rather than squeezing.
+ */
+export declare function LabeledContent({ label, description, children, stacked, wide, className, ...props }: LabeledContentProps): import("react").JSX.Element;

package/dist/types/src/components/locale-switcher/index.d.ts

@@ -0,0 +1 @@
+export * from "./locale-switcher";

package/dist/types/src/components/locale-switcher/locale-switcher.d.ts

@@ -0,0 +1,10 @@
+export type LocaleSwitcherProps<L extends string> = {
+    locales: readonly L[];
+    locale: L;
+    onSelect: (locale: L) => void;
+    /** localStorage key for where the person dragged it. */
+    storageKey: string;
+    label: string;
+};
+/** A draggable floating language picker that snaps to the nearest corner. */
+export declare function LocaleSwitcher<L extends string>({ locales, locale, onSelect, storageKey, label, }: LocaleSwitcherProps<L>): import("react").JSX.Element;

package/dist/types/src/components/menu/menu.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from "react";
+import { type ButtonProps } from "../button/button";
+import { type ContextMenuEdge, type ContextMenuItem } from "../context-menu/context-menu-store";
+export interface MenuProps extends Omit<ButtonProps, "onClick" | "children"> {
+    /** Accessible name for the menu trigger. */
+    label: string;
+    /** Items are rendered by the app's existing ContextMenuHost. */
+    items: readonly ContextMenuItem[];
+    children: ReactNode;
+    /** Logical edge used to align the menu, including RTL. @default "leading" */
+    edge?: ContextMenuEdge;
+    /** Open above the trigger instead of below it. @default false */
+    above?: boolean;
+}
+/** A declarative menu button using the same native host as context menus. */
+export declare const Menu: import("react").ForwardRefExoticComponent<MenuProps & import("react").RefAttributes<HTMLButtonElement>>;

package/dist/types/src/components/picker/picker-trigger.d.ts

@@ -0,0 +1,2 @@
+/** Shared field treatment for the popup-based Picker, date and time controls. */
+export declare function pickerTriggerStyle(className?: string): string;

package/dist/types/src/components/picker/picker.d.ts

@@ -0,0 +1,37 @@
+export interface PickerOption<T extends string> {
+    value: T;
+    label: string;
+    /** A quieter second line or trailing note, such as "Free" or a region. */
+    detail?: string;
+    /** The option's own language, so it is spoken and shaped right. */
+    lang?: string;
+}
+/** Values and callbacks share the option value type, including literal unions. */
+export interface PickerProps<T extends string> {
+    /** The selected option's value. */
+    value: T;
+    /** Available choices. Use a literal union for a fixed set of values. */
+    options: ReadonlyArray<PickerOption<T>>;
+    /** Called with the selected option value. */
+    onChange: (value: NoInfer<T>) => void;
+    /** Accessible name for the trigger. */
+    label: string;
+    /** Shown when the selected value has no matching option. */
+    placeholder?: string;
+    /** Defaults to on for lists of ten or more options. */
+    searchable?: boolean;
+    /** Label for the filter field. @default "Search" */
+    searchPlaceholder?: string;
+    /** Shown when the filter matches nothing. @default "No matches" */
+    emptyLabel?: string;
+    className?: string;
+    /** Prevents opening or choosing an option. @default false */
+    disabled?: boolean;
+}
+/**
+ * A pop-up button: shows the chosen value and opens a list that floats
+ * above everything, flips upward near the bottom edge and filters long
+ * lists. Replaces the browser's own select, which looks foreign on every
+ * platform.
+ */
+export declare function Picker<T extends string>({ value, options, onChange, label, placeholder, searchable, searchPlaceholder, emptyLabel, className, disabled, }: PickerProps<T>): import("react").JSX.Element;

package/dist/types/src/components/popover/popover-fit.d.ts

@@ -0,0 +1,21 @@
+import { type PlacementFrame } from "../../lib/anchored-placement";
+interface PanelRect {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}
+interface AnchorRect {
+    top: number;
+    bottom: number;
+}
+export interface PopoverFit {
+    shiftX: number;
+    shiftY: number;
+    maxWidth: number;
+    maxHeight?: number;
+    above: boolean;
+}
+/** Keep an absolutely positioned popover visible without scaling its contents. */
+export declare function fitPopover(panel: PanelRect, anchor: AnchorRect | undefined, frame: Pick<PlacementFrame, "viewport" | "edges">, gap?: number, origin?: "top-left" | "top-right"): PopoverFit;
+export {};

package/dist/types/src/components/popover/popover.d.ts

@@ -0,0 +1,14 @@
+import { type HTMLMotionProps } from "motion/react";
+export type PopoverOrigin = "top-left" | "top-right";
+export interface PopoverProps extends HTMLMotionProps<"div"> {
+    open: boolean;
+    /** Which corner the popover grows from. */
+    origin?: PopoverOrigin;
+}
+/**
+ * A glass surface that springs open from its anchor. Position it with
+ * `className` (it is absolutely positioned within a relative parent); it
+ * flips above its relative parent when the bottom edge is short, and
+ * stays inside the visible viewport as it resizes or scrolls.
+ */
+export declare function Popover({ open, ...props }: PopoverProps): import("react").JSX.Element;

package/dist/types/src/components/profile-image/profile-image.d.ts

@@ -0,0 +1,4 @@
+import { type ComponentProps } from "react";
+export declare function ProfileImage({ className, ...props }: ComponentProps<"span">): import("react").JSX.Element;
+export declare function ProfileImageContent({ src, className, onLoad, onError, ...props }: ComponentProps<"img">): import("react").JSX.Element | null;
+export declare function ProfileImageFallback({ className, ...props }: ComponentProps<"span">): import("react").JSX.Element | null;

package/dist/types/src/components/progress-view/progress-view.d.ts

@@ -0,0 +1,13 @@
+import type { HTMLAttributes } from "react";
+export type ProgressViewSize = "sm" | "md" | "lg";
+export interface ProgressViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    label: string;
+    /** Omit for an indeterminate operation. */
+    value?: number;
+    max?: number;
+    size?: ProgressViewSize;
+    /** Secondary text, such as bytes uploaded. */
+    detail?: string;
+}
+/** A determinate or indeterminate progress track respecting reduced motion. */
+export declare function ProgressView({ label, value, max, size, detail, className, ...props }: ProgressViewProps): import("react").JSX.Element;

package/dist/types/src/components/search-field/search-field.d.ts

@@ -0,0 +1,2 @@
+import { type InputHTMLAttributes } from "react";
+export declare const SearchField: import("react").ForwardRefExoticComponent<InputHTMLAttributes<HTMLInputElement> & import("react").RefAttributes<HTMLInputElement>>;

package/dist/types/src/components/search-list/search-list.d.ts

@@ -0,0 +1,19 @@
+import { type ComponentProps } from "react";
+export declare function SearchList({ loop, open, onKeyDown, className, ...props }: ComponentProps<"div"> & {
+    loop?: boolean;
+    open?: boolean;
+}): import("react").JSX.Element;
+export declare function SearchListField({ value, onValueChange, className, ...props }: Omit<ComponentProps<"input">, "value" | "onChange"> & {
+    value?: string;
+    onValueChange?: (value: string) => void;
+}): import("react").JSX.Element;
+export declare function SearchListResults({ className, ...props }: ComponentProps<"div">): import("react").JSX.Element;
+export declare function SearchListEmpty(props: ComponentProps<"div">): import("react").JSX.Element | null;
+export declare function SearchListGroup({ heading, children, className, ...props }: ComponentProps<"div"> & {
+    heading?: React.ReactNode;
+}): import("react").JSX.Element;
+export declare function SearchListItem({ value, keywords, onSelect, className, ...props }: Omit<ComponentProps<"button">, "value" | "onSelect"> & {
+    value: string;
+    keywords?: string[];
+    onSelect?: (value: string) => void;
+}): import("react").JSX.Element;

package/dist/types/src/components/section/section.d.ts

@@ -0,0 +1,15 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+export interface SectionProps extends HTMLAttributes<HTMLElement> {
+    /** Optional group heading and accessible name. */
+    title?: string;
+    /** Supporting text below the grouped rows. */
+    footer?: ReactNode;
+    /** Rows, typically LabeledContent. */
+    children?: ReactNode;
+}
+/**
+ * A titled, inset group of rows with an optional footer, as in iOS Settings
+ * and SwiftUI's grouped `List` with `Section(header:footer:)`. Rows are
+ * usually `LabeledContent`; dividers between them come for free.
+ */
+export declare function Section({ title, footer, children, className, ...props }: SectionProps): import("react").JSX.Element;

package/dist/types/src/components/secure-field/secure-field.d.ts

@@ -0,0 +1,4 @@
+import { type TextFieldProps } from "../text-field/text-field";
+/** TextField's native input props, with the password type managed by SecureField. */
+export type SecureFieldProps = Omit<TextFieldProps, "type">;
+export declare function SecureField(props: SecureFieldProps): import("react").JSX.Element;

package/dist/types/src/components/segmented-control/segmented-control.d.ts

@@ -0,0 +1,20 @@
+export interface SegmentedControlProps<T extends string> {
+    /** Value of the selected segment. */
+    value: T;
+    /** The choices, in display order. */
+    options: ReadonlyArray<{
+        value: T;
+        label: string;
+    }>;
+    /** Called with the selected segment's value. */
+    onChange: (value: NoInfer<T>) => void;
+    /** Accessible name for the group and its compact picker. */
+    label: string;
+}
+/**
+ * Mutually exclusive choices with a sliding selection, as on Apple
+ * platforms. When the labels can't all fit the space it is given (a long
+ * translation, a narrow pane) it becomes a pop-up button instead of
+ * squeezing or spilling its text.
+ */
+export declare function SegmentedControl<T extends string>({ value, options, onChange, label, }: SegmentedControlProps<T>): import("react").JSX.Element;

package/dist/types/src/components/sheet/modal-environment.d.ts

@@ -0,0 +1,2 @@
+/** Keeps nested sheets and their portaled controls above an inactive background. */
+export declare function enterModalEnvironment(surface: HTMLElement): () => void;

package/dist/types/src/components/sheet/sheet-portal.d.ts

@@ -0,0 +1,5 @@
+import { type ReactNode } from "react";
+/** Escape transformed page layers while retaining the source's scoped appearance. */
+export declare function SheetPortal({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/types/src/components/sheet/sheet.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from "react";
+export type SheetPlacement = "adaptive" | "center";
+export interface SheetProps {
+    /** Controls whether the sheet is presented. */
+    open: boolean;
+    /** Called on Escape or an outside press. */
+    onClose: () => void;
+    /** Read out by screen readers as the sheet's name. */
+    label: string;
+    /** ID of a visible heading to use instead of label for the accessible name. */
+    labelledBy?: string;
+    /** `adaptive` rises from the bottom on phones; `center` always floats. @default "adaptive" */
+    placement?: SheetPlacement;
+    className?: string;
+    children: ReactNode;
+}
+/**
+ * A modal card: rises from the bottom edge on phones and floats in the
+ * middle on larger screens. Escape or a tap outside closes it.
+ */
+export declare function Sheet({ open, ...props }: SheetProps): import("react").JSX.Element;

package/dist/types/src/components/sheet/use-sheet-focus.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from "react";
+/** Keeps keyboard focus in the foremost sheet, including its floating pickers. */
+export declare function useSheetFocus(panel: RefObject<HTMLDivElement | null>, onClose: () => void): void;

package/dist/types/src/components/sidebar/sidebar.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from "react";
+export interface SidebarSectionProps {
+    /** Visible heading for this group of navigation rows. */
+    title: string;
+    children: ReactNode;
+}
+export interface SidebarItemContentProps {
+    icon: ReactNode;
+    /** Optional trailing count. */
+    count?: number;
+    /** Matches the router link's active state. */
+    active?: boolean;
+    children: ReactNode;
+}
+export declare function SidebarSection({ title, children }: SidebarSectionProps): import("react").JSX.Element;
+/** Classes for a sidebar row; apply to the app's router link. */
+export declare function sidebarItemClass(active?: boolean): string;
+export declare function SidebarItemContent({ icon, count, active, children }: SidebarItemContentProps): import("react").JSX.Element;

package/dist/types/src/components/slider/slider.d.ts

@@ -0,0 +1,14 @@
+import { type ComponentProps } from "react";
+export interface SliderProps extends Omit<ComponentProps<"input">, "type" | "value" | "defaultValue" | "onChange" | "min" | "max" | "step"> {
+    value: number;
+    onChange: (value: number) => void;
+    label: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    description?: string;
+    /** Provides a localized, spoken description of the current value. */
+    formatValue?: (value: number) => string;
+}
+/** Native keyboard, touch and pointer behavior with Passui's control treatment. */
+export declare function Slider({ value, onChange, label, min, max, step, description, formatValue, id: suppliedId, className, disabled, ...props }: SliderProps): import("react").JSX.Element;

package/dist/types/src/components/stat-tile/index.d.ts

@@ -0,0 +1 @@
+export * from "./stat-tile";

package/dist/types/src/components/stat-tile/stat-tile.d.ts

@@ -0,0 +1,15 @@
+import type { ReactNode } from "react";
+export type StatTileTone = "critical";
+export interface StatTileProps {
+    label: string;
+    value: number;
+    /** A quiet line under the number, like "3 signed in now". */
+    caption?: ReactNode;
+    /** Turns the number red once it's above zero. */
+    tone?: StatTileTone;
+    /** Makes the tile a toggle, e.g. a filter. */
+    onClick?: () => void;
+    active?: boolean;
+}
+/** One number with its label, optionally a toggle. */
+export declare function StatTile({ label, value, caption, tone, onClick, active }: StatTileProps): import("react").JSX.Element;

package/dist/types/src/components/status-indicator/status-indicator.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes, ReactNode } from "react";
+declare const dots: {
+    readonly saved: "bg-success";
+    readonly syncing: "bg-warning animate-pulse";
+    readonly offline: "bg-label-tertiary";
+};
+export type StatusIndicatorState = keyof typeof dots;
+export interface StatusIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Visual treatment of the status dot. */
+    state: StatusIndicatorState;
+    children: ReactNode;
+}
+export declare function StatusIndicator({ state, children, className, ...props }: StatusIndicatorProps): import("react").JSX.Element;
+export {};

package/dist/types/src/components/stepper/stepper.d.ts

@@ -0,0 +1,19 @@
+export interface StepperProps {
+    value: number;
+    onChange: (value: number) => void;
+    label: string;
+    /** Localized accessible names for each action. */
+    labels: {
+        decrement: string;
+        increment: string;
+    };
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    className?: string;
+    /** Formats the displayed value. */
+    formatValue?: (value: number) => string;
+}
+/** Discrete increments with disabled boundary actions and a spoken value. */
+export declare function Stepper({ value, onChange, label, labels, min, max, step, disabled, className, formatValue, }: StepperProps): import("react").JSX.Element;

package/dist/types/src/components/swatch-picker/swatch-picker.d.ts

@@ -0,0 +1,17 @@
+export interface SwatchPickerOption<T extends string> {
+    value: T;
+    label: string;
+    /** Swatch background color. */
+    color: string;
+    /** Color of the selected checkmark. */
+    ink: string;
+}
+export interface SwatchPickerProps<T extends string> {
+    value: T;
+    options: ReadonlyArray<SwatchPickerOption<T>>;
+    onChange: (value: T) => void;
+    /** Accessible name for the group. */
+    label: string;
+}
+/** Colour swatches with a check on the chosen one. */
+export declare function SwatchPicker<T extends string>({ value, options, onChange, label, }: SwatchPickerProps<T>): import("react").JSX.Element;

package/dist/types/src/components/tab-bar/tab-bar.d.ts

@@ -0,0 +1,40 @@
+import { type ReactNode } from "react";
+export interface TabBarTab<Id extends string = string> {
+    id: Id;
+    label: string;
+    icon: ReactNode;
+}
+/** What a tab's link receives; spread it onto the router's own link. */
+export interface TabBarLinkProps {
+    className: string;
+    "aria-current": "page" | undefined;
+    onClick: () => void;
+    children: ReactNode;
+}
+export type TabBarMinimizeBehavior = "platform" | "scroll" | "never";
+export interface TabBarProps<Tab extends TabBarTab> {
+    /** `platform` follows the platform, `scroll` always minimizes, `never` stays expanded. @default "platform" */
+    minimizeBehavior?: TabBarMinimizeBehavior;
+    tabs: readonly Tab[];
+    /** Active tab ID, or null for a destination outside the bar. */
+    active: Tab["id"] | null;
+    /** Renders your router's link with the supplied appearance and accessibility props. */
+    renderLink: (tab: Tab, props: TabBarLinkProps) => ReactNode;
+    search?: {
+        label: string;
+        onPress: () => void;
+    };
+    /** Accessible name for the navigation. */
+    label: string;
+    className?: string;
+}
+/**
+ * The app's main places a thumb's reach away, drawn as iOS 26 draws them: a
+ * floating glass capsule of tabs, with Search as its own round button at the
+ * trailing end. Scrolling down through content shrinks the capsule to the
+ * current tab; scrolling back up, or a tap, restores it. Android shares the
+ * glass, but its bar stays full size, as Android's own bars do.
+ *
+ * Links stay the app's own (`renderLink`), so the bar works with any router.
+ */
+export declare function TabBar<Tab extends TabBarTab>({ tabs, active, renderLink, search, label, className, minimizeBehavior, }: TabBarProps<Tab>): import("react").JSX.Element;

package/dist/types/src/components/tab-view/tab-view.d.ts

@@ -0,0 +1,24 @@
+import { type ReactNode } from "react";
+export type TabViewAlign = "start" | "center";
+export interface TabViewProps<Value extends string> {
+    /** Available tabs, in keyboard navigation order. */
+    options: readonly {
+        value: Value;
+        label: string;
+        disabled?: boolean;
+    }[];
+    /** Initial selection when value is not controlled. */
+    defaultValue: Value;
+    /** Controlled selection; omit to keep selection inside TabView. */
+    value?: Value;
+    onValueChange?: (value: Value) => void;
+    /** Tab alignment: `start` or `center`. @default "center" */
+    align?: TabViewAlign;
+    /** Accessible name for the tab list. */
+    label: string;
+    /** Renders the selected tab's panel. */
+    children: (value: Value) => ReactNode;
+    className?: string;
+}
+/** Content tabs with native buttons, roving focus and automatic keyboard activation. */
+export declare function TabView<Value extends string>({ options, defaultValue, value: controlledValue, onValueChange, align, label, children, className, }: TabViewProps<Value>): import("react").JSX.Element | null;

package/dist/types/src/components/table/table.d.ts

@@ -0,0 +1,10 @@
+import type * as React from "react";
+declare function Table({ className, ...props }: React.ComponentProps<"table">): React.JSX.Element;
+declare function TableHeader({ className, ...props }: React.ComponentProps<"thead">): React.JSX.Element;
+declare function TableBody({ className, ...props }: React.ComponentProps<"tbody">): React.JSX.Element;
+declare function TableFooter({ className, ...props }: React.ComponentProps<"tfoot">): React.JSX.Element;
+declare function TableRow({ className, ...props }: React.ComponentProps<"tr">): React.JSX.Element;
+declare function TableHead({ className, ...props }: React.ComponentProps<"th">): React.JSX.Element;
+declare function TableCell({ className, ...props }: React.ComponentProps<"td">): React.JSX.Element;
+declare function TableCaption({ className, ...props }: React.ComponentProps<"caption">): React.JSX.Element;
+export { Table, TableBody, TableCaption, TableCell, TableFooter, TableHead, TableHeader, TableRow };

package/dist/types/src/components/text-editor/text-editor.d.ts

@@ -0,0 +1,2 @@
+import type { ComponentProps } from "react";
+export declare function TextEditor({ className, ...props }: ComponentProps<"textarea">): import("react").JSX.Element;

package/dist/types/src/components/text-field/text-field.d.ts

@@ -0,0 +1,18 @@
+import { type ComponentProps, type ReactNode } from "react";
+export declare const textControlClasses: string;
+export type TextFieldProps = ComponentProps<"input"> & {
+    label: string;
+    description?: ReactNode;
+    errors?: string[];
+    /** A decorative icon before the text, such as a mail glyph. */
+    icon?: ReactNode;
+    /** A decorative icon after the text, such as a unit or a check. */
+    trailingIcon?: ReactNode;
+    /** An interactive control after the text, such as a clear button. Size it to the field: an `xs` or `icon-xs` button, never the default. */
+    action?: ReactNode;
+    revealLabels?: {
+        show: string;
+        hide: string;
+    };
+};
+export declare function TextField({ label, description, errors, icon, trailingIcon, action, revealLabels, type, id: suppliedId, className, ...props }: TextFieldProps): import("react").JSX.Element;

package/dist/types/src/components/toast/toast-store.d.ts

@@ -0,0 +1,47 @@
+/**
+ * App-wide toasts: short messages that confirm, report progress or explain
+ * a failure. Call `toast` from anywhere; render one `<Toaster />`.
+ */
+export type ToastTone = "neutral" | "success" | "error" | "loading";
+export interface ToastAction {
+    label: string;
+    onClick: () => void;
+}
+export interface Toast {
+    id: number;
+    tone: ToastTone;
+    title: string;
+    description?: string;
+    action?: ToastAction;
+    /** Milliseconds before it leaves on its own; `null` stays until dismissed. */
+    duration: number | null;
+    createdAt: number;
+}
+export interface ToastOptions {
+    description?: string;
+    action?: ToastAction;
+    duration?: number | null;
+}
+/** Changes a toast in place; it morphs to its new state. */
+declare function update(id: number, tone: ToastTone, title: string, options?: ToastOptions): number;
+declare function dismiss(id: number): void;
+interface PromiseMessages<T> {
+    loading: string;
+    success: string | ((value: T) => string);
+    error: string | ((error: unknown) => string);
+}
+export declare const toast: ((title: string, options?: ToastOptions) => number) & {
+    success: (title: string, options?: ToastOptions) => number;
+    error: (title: string, options?: ToastOptions) => number;
+    loading: (title: string, options?: ToastOptions) => number;
+    update: typeof update;
+    dismiss: typeof dismiss;
+    /** Shows progress, then morphs into the outcome. Returns the promise. */
+    promise<T>(promise: Promise<T>, messages: PromiseMessages<T>): Promise<T>;
+};
+export declare function subscribeToasts(listener: () => void): () => void;
+export declare function getToasts(): Toast[];
+export declare const toastLimits: {
+    readonly visible: 3;
+};
+export {};