@passui/react 0.1.17 → 0.1.20

package/dist/types/src/components/context-menu/context-menu-store.d.ts

@@ -0,0 +1,57 @@
+import type { ReactNode } from "react";
+import type { MenuRect } from "./menu-reveal";
+export type ContextMenuAlignX = "start" | "end";
+export type ContextMenuAlignY = "top" | "bottom";
+export type ContextMenuEdge = "leading" | "trailing";
+/** One row of a context menu, or a divider between groups of rows. */
+export type ContextMenuItem = {
+    label: string;
+    icon?: ReactNode;
+    onSelect: () => void;
+    destructive?: boolean;
+    disabled?: boolean;
+    /** Marks the current choice, e.g. a note's kind. */
+    checked?: boolean;
+} | {
+    heading: string;
+} | "divider";
+export interface OpenMenu {
+    id: number;
+    anchor: Element | null;
+    x: number;
+    y: number;
+    items: ContextMenuItem[];
+    /** Opened by long-press: bigger rows for fingers. */
+    touch: boolean;
+    /** Which edge of the menu sits at `x`: its left (`start`) or its right (`end`). */
+    alignX: ContextMenuAlignX;
+    /** Which edge of the menu sits at `y`: its top (`top`) or its bottom (`bottom`). */
+    alignY: ContextMenuAlignY;
+    source?: MenuRect;
+    toolbar?: HTMLElement;
+    toolbarRect?: MenuRect;
+    restoreFocus?: boolean;
+}
+/** Opens a menu at a point, such as where a pointer was pressed. */
+export declare function openContextMenu(x: number, y: number, items: ContextMenuItem[], touch?: boolean, anchor?: Element | null): void;
+/**
+ * Opens a second menu where the last one stood, the way an iOS menu swaps
+ * in a submenu: a long list (a note's fonts, its kinds) stays one row in the
+ * first menu instead of making it tall.
+ */
+export declare function openFollowUpMenu(items: ContextMenuItem[]): void;
+/**
+ * Expands a control into a menu, lined up with its leading or trailing
+ * edge and growing down (or up) from the control's bounds. Leading and
+ * trailing follow the text direction, so right-to-left languages mirror.
+ * The menu's real size decides where it goes; nothing is guessed.
+ */
+export declare function openMenu(anchor: Element, items: ContextMenuItem[], { edge, above, toolbar, }?: {
+    edge?: ContextMenuEdge;
+    above?: boolean;
+    /** Replace this action group with a horizontally expanding menu surface. */
+    toolbar?: HTMLElement;
+}): void;
+export declare function closeContextMenu(restoreFocus?: boolean): void;
+export declare function subscribeContextMenu(listener: () => void): () => void;
+export declare function getContextMenu(): OpenMenu | null;

package/dist/types/src/components/context-menu/menu-navigation.d.ts

@@ -0,0 +1,6 @@
+export type MenuNavigationKey = "ArrowDown" | "ArrowUp" | "Home" | "End";
+export declare function isMenuNavigationKey(key: string): key is MenuNavigationKey;
+/** Index of the next enabled action in a menu, with wrapping arrow navigation. */
+export declare function nextMenuIndex(key: MenuNavigationKey, current: number, count: number): number;
+/** Finds a matching label after the current action, wrapping at the end. */
+export declare function findMenuTypeaheadIndex(labels: ReadonlyArray<string>, query: string, current: number): number;

package/dist/types/src/components/context-menu/menu-position.d.ts

@@ -0,0 +1,21 @@
+import type { OpenMenu } from "./context-menu-store";
+import type { MenuRect } from "./menu-reveal";
+type MenuAnchor = Pick<OpenMenu, "x" | "y" | "alignX" | "alignY">;
+type MenuSize = Pick<MenuRect, "width" | "height">;
+type MenuBounds = {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+};
+/** Fit within the current visible viewport, including a keyboard or Safari pan. */
+export declare function menuPosition(menu: MenuAnchor, size: MenuSize, bounds: MenuBounds): {
+    left: number;
+    top: number;
+    originX: number;
+    originY: number;
+    maxHeight: number;
+    width: number;
+    height: number;
+};
+export {};

package/dist/types/src/components/context-menu/menu-reveal.d.ts

@@ -0,0 +1,17 @@
+export type MenuRect = {
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+};
+/** Animate the material's bounds independently so menu text never stretches. */
+export declare function menuSurfaceReveal(source: MenuRect | undefined, target: MenuRect & {
+    radius?: number;
+}): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    opacity: number;
+    borderRadius: number;
+};

package/dist/types/src/components/context-menu/use-context-menu.d.ts

@@ -0,0 +1,14 @@
+import { type MouseEvent, type PointerEvent } from "react";
+import { type ContextMenuItem } from "./context-menu-store";
+/**
+ * Right-click on desktop, long-press on touch screens: both open the same
+ * menu of actions. Spread the returned handlers onto the element.
+ */
+export declare function useContextMenu(items: () => ContextMenuItem[]): {
+    onContextMenu(event: MouseEvent): void;
+    onPointerDown(event: PointerEvent): void;
+    onPointerMove(event: PointerEvent): void;
+    onPointerUp: () => void;
+    onPointerCancel: () => void;
+    onClickCapture(event: MouseEvent): void;
+};

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

@@ -0,0 +1,43 @@
+import type { ReactNode } from "react";
+export type ConversationMessage = {
+    id: string;
+    body: string;
+    /** Written by whoever is looking: drawn on the right. */
+    mine: boolean;
+    author?: string;
+    /** Shown beside the other side's messages, like their avatar. */
+    avatar?: ReactNode;
+    createdAt: string;
+};
+/**
+ * A thread of plain-text messages like Messages on iPhone: a day line when
+ * the date changes, back-to-back messages from one side grouped under one
+ * name, theirs on the left with an avatar, yours on the right.
+ */
+declare function Messages({ messages, locale, }: {
+    messages: ConversationMessage[];
+    /** For day names and times; the reader's own by default. */
+    locale?: string;
+}): import("react").JSX.Element;
+type ComposerProps = {
+    onSend: (body: string) => Promise<unknown>;
+    pending?: boolean;
+    maxLength: number;
+    placeholder: string;
+    /** Extra controls under the field, like a status picker. */
+    actions?: ReactNode;
+    /** Names the round Send button for screen readers. */
+    sendLabel: string;
+    /**
+     * Words for the characters left, shown near the limit, such as
+     * (count) => `${count} left`. Without it, just the number shows.
+     */
+    remaining?: (count: number) => string;
+};
+/** A reply field with a round send button; Ctrl/Cmd+Enter sends, and it clears only once the send worked. */
+declare function Composer({ onSend, pending, maxLength, placeholder, actions, sendLabel, remaining, }: ComposerProps): import("react").JSX.Element;
+export declare const Conversation: {
+    Messages: typeof Messages;
+    Composer: typeof Composer;
+};
+export {};

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

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

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

@@ -0,0 +1,16 @@
+type DatePickerProps = {
+    value: string;
+    onChange: (value: string) => void;
+    label: string;
+    labels: {
+        day: string;
+        month: string;
+        year: string;
+        invalid: string;
+    };
+    locale: string;
+    max?: string;
+};
+/** Segmented date entry suited to birthdays, without a native calendar dialog. */
+export declare function DatePicker({ value, onChange, label, labels, locale, max }: DatePickerProps): import("react").JSX.Element;
+export {};

package/dist/types/src/components/date-picker/date-value.d.ts

@@ -0,0 +1,2 @@
+/** Returns a date-only value without timezone conversion or date rollover. */
+export declare function dateValue(year: string, month: string, day: string, max?: string): string;

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,23 @@
+/**
+ * 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, id?: number): void;
+/** Advance queued confirmations only after the dismissed card has exited. */
+export declare function advanceDialogQueue(): 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,15 @@
+import { type ReactNode } from "react";
+export interface DisclosureGroupProps {
+    label: string;
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    children: ReactNode;
+    disabled?: boolean;
+    className?: string;
+    /** Trigger layout when composed inside a shared surface such as Accordion. */
+    triggerClassName?: 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, triggerClassName, 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/keyboard-shortcut/keyboard-shortcut.d.ts

@@ -0,0 +1,5 @@
+import type { ComponentProps } from "react";
+export interface KeyboardShortcutProps extends ComponentProps<"kbd"> {
+}
+/** A quiet keycap for a shortcut supplied and localized by the application. */
+export declare function KeyboardShortcut({ className, ...props }: KeyboardShortcutProps): 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;
+    /** Expand upward from the trigger instead of downward. @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/one-time-code/one-time-code.d.ts

@@ -0,0 +1,18 @@
+import { type InputHTMLAttributes } from "react";
+export type OneTimeCodeStatus = "idle" | "verifying" | "success" | "error";
+export interface OneTimeCodeProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "defaultValue" | "onChange" | "type" | "maxLength" | "size"> {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    /** Called when a complete code is entered, including paste and autofill. */
+    onComplete?: (value: string) => void;
+    /** Number of digits, 3–8. @default 6 */
+    length?: number;
+    status?: OneTimeCodeStatus;
+    /** Localized verification feedback announced without reading decorative cells. */
+    statusLabel?: string;
+}
+/** Normalize common numeric keyboards without splitting the browser's input into cells. */
+export declare function normalizeCode(value: string, length: number): string;
+/** Six cells, one field: paste, autofill, selection and Backspace stay native. */
+export declare function OneTimeCode({ label, value, onChange, onComplete, length, status, statusLabel, className, disabled, id: suppliedId, ...props }: OneTimeCodeProps): import("react").JSX.Element;

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,43 @@
+export interface PickerOption<T extends string> {
+    value: T;
+    label: string;
+    /** A quieter second line or trailing note, such as "Free" or a region. */
+    disabled?: boolean;
+    keywords?: string[];
+    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;
+    /** Offers a new value when no option has the same label or value. */
+    onCreate?: (query: string) => void;
+    /** Localized creation action; receives the trimmed query. */
+    createLabel?: (query: string) => 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, onCreate, createLabel, disabled, }: PickerProps<T>): import("react").JSX.Element;

package/dist/types/src/components/popover/anchored-surface.d.ts

@@ -0,0 +1,13 @@
+import { type HTMLAttributes } from "react";
+interface AnchoredSurfaceProps extends HTMLAttributes<HTMLDivElement> {
+    open: boolean;
+    onExited: () => void;
+    anchor: HTMLElement;
+    width: number;
+    needed: number;
+    onClose: (restoreFocus: boolean) => void;
+    contentClassName?: string;
+}
+/** Shared material and lifetime for portaled pickers; their content owns selection. */
+export declare const AnchoredSurface: import("react").ForwardRefExoticComponent<AnchoredSurfaceProps & import("react").RefAttributes<HTMLDivElement>>;
+export {};

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,18 @@
+import { type HTMLMotionProps } from "motion/react";
+import { type ReactNode, type RefObject } from "react";
+export type PopoverOrigin = "top-left" | "top-right";
+export interface PopoverProps extends Omit<HTMLMotionProps<"div">, "children"> {
+    open: boolean;
+    children?: ReactNode;
+    /** Which corner the popover grows from. */
+    origin?: PopoverOrigin;
+    /** Trigger whose shape the popover uses during its opening and closing motion. */
+    anchorRef?: RefObject<HTMLElement | null>;
+}
+/**
+ * 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/progress-view/use-liquid-progress.d.ts

@@ -0,0 +1,3 @@
+import { type RefObject } from "react";
+/** Read-only progress shares the liquid fill without acquiring slider semantics. */
+export declare function useLiquidProgress(ref: RefObject<HTMLDivElement | null>, target: number | undefined): void;

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

@@ -0,0 +1,17 @@
+export interface RadioGroupOption<T extends string> {
+    value: T;
+    label: string;
+    description?: string;
+    disabled?: boolean;
+}
+export interface RadioGroupProps<T extends string> {
+    value: T;
+    onChange: (value: NoInfer<T>) => void;
+    label: string;
+    options: readonly RadioGroupOption<T>[];
+    disabled?: boolean;
+    name?: string;
+    className?: string;
+}
+/** A labelled choice group using the browser's native radio keyboard behavior. */
+export declare function RadioGroup<T extends string>({ value, onChange, label, options, disabled, name, className, }: RadioGroupProps<T>): import("react").JSX.Element;

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

@@ -0,0 +1,5 @@
+import { type InputHTMLAttributes, type Ref } from "react";
+/** One object: the field stays inside the pill, and the lens never moves within it. */
+export declare function ExpandingSearchField({ inputRef, className, placeholder, ...props }: InputHTMLAttributes<HTMLInputElement> & {
+    inputRef: Ref<HTMLInputElement>;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,6 @@
+import { type InputHTMLAttributes } from "react";
+export interface SearchFieldProps extends InputHTMLAttributes<HTMLInputElement> {
+    /** Expand a single pill from its search icon on focus. @default false */
+    collapsible?: boolean;
+}
+export declare const SearchField: import("react").ForwardRefExoticComponent<SearchFieldProps & 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;