@candidhealth/react-vitals 1.0.0-alpha.12 → 1.0.0-alpha.14

package/dist/index.d.mts

@@ -5,15 +5,13 @@ import { IconDefinition, SizeProp } from '@fortawesome/fontawesome-svg-core';
 import { Placement } from '@floating-ui/react';
 import { DatePickerProps as DatePickerProps$1 } from 'react-datepicker';
 import * as react_hook_form from 'react-hook-form';
-import { SubmitHandler, DefaultValues, UseFormProps, FieldValues, FieldErrors, FieldPath, FieldError } from 'react-hook-form';
-export { ControllerRenderProps, Field, FieldArrayWithId, FieldError, FieldErrors, FieldPath, FieldValues, FormProvider, Path, UseControllerProps, UseControllerReturn, UseFieldArrayMove, UseFieldArrayProps, UseFieldArrayRemove, UseFieldArrayReturn, UseFieldArrayUpdate, UseFormGetValues, UseFormProps, UseFormReset, UseFormReturn, useController, useFieldArray, useFormContext, useFormState, useWatch } from 'react-hook-form';
+import { SubmitHandler, UseFormProps, DefaultValues, FieldValues, FieldErrors, FieldPath, FieldError } from 'react-hook-form';
 import { z } from 'zod';
 import * as _radix_ui_react_dropdown_menu from '@radix-ui/react-dropdown-menu';
 import { DropdownMenuProps, DropdownMenuContentProps, DropdownMenuItemProps } from '@radix-ui/react-dropdown-menu';
 import { DialogContentProps } from '@radix-ui/react-dialog';
 import * as RadixTooltip from '@radix-ui/react-tooltip';
 import { PhoneInputProps } from 'react-international-phone';
-export { getCountry } from 'react-international-phone';
 import * as RadixPopover from '@radix-ui/react-popover';
 import * as RadixSwitch from '@radix-ui/react-switch';
 import * as _tanstack_react_table from '@tanstack/react-table';
@@ -22,15 +20,49 @@ import { TabsContentProps } from '@radix-ui/react-tabs';
 
 type AvatarVariant = "active" | "inactive";
 type AvatarSize = "sm" | "md";
-declare const getInitials: (name: string) => string;
+/**
+ * Props for {@link Avatar}: the custom props below plus all native `<div>` attributes
+ * (`onClick`, `title`, `aria-*`, …), which are forwarded to the root element.
+ */
 type AvatarProps = ComponentPropsWithoutRef<"div"> & {
+    /** Full name used to derive the displayed initials. */
     name: string;
+    /**
+     * Visual emphasis. `inactive` dims the avatar.
+     * @default active
+     */
     variant?: AvatarVariant;
+    /**
+     * Avatar diameter.
+     * @default md
+     */
     size?: AvatarSize;
 };
+/**
+ * A circular avatar showing a person's initials.
+ *
+ * Initials are derived from `name`. The `ref` and native `<div>` props are
+ * forwarded to the root element. For stacks of avatars or an avatar paired with a name label, see
+ * the `AvatarGroup` and `AvatarWithName` components in this module.
+ *
+ * @example
+ * <Avatar name="Ada Lovelace" />
+ *
+ * @example
+ * <Avatar name="Grace Hopper" variant="inactive" size="sm" />
+ */
 declare const Avatar: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & {
+    /** Full name used to derive the displayed initials. */
     name: string;
+    /**
+     * Visual emphasis. `inactive` dims the avatar.
+     * @default active
+     */
     variant?: AvatarVariant;
+    /**
+     * Avatar diameter.
+     * @default md
+     */
     size?: AvatarSize;
 } & React$1.RefAttributes<HTMLDivElement>>;
 
@@ -60,7 +92,6 @@ type Justify = "start" | "center" | "end" | "between" | "around";
 type Soften = "left" | "right" | "both" | "none";
 type Variant = "default" | "transparent" | "dark";
 
-declare const linkStyles = "text-indigo-600 hover:underline active:text-indigo-400 focus:outline-indigo-400 focus:outline-offset-2";
 type ButtonSize = Extract<Size, "xs" | "sm" | "md" | "lg">;
 type ButtonIntent = Extract<Intent, "primary" | "default" | "danger"> | "error";
 type ButtonRoundedness = "default" | "large";
@@ -74,9 +105,28 @@ type ButtonStyleProps = {
     soften?: Soften;
     roundedness?: ButtonRoundedness;
 };
-declare const buttonStyles: ({ fullWidth, size, intent, variant, soften, loading, roundedness, }: Omit<ButtonStyleProps, "disabled">) => string;
 
+/**
+ * Props for {@link Button}: the design-system style variants merged with all native
+ * `<button>` attributes. Any prop not listed below (`onClick`, `type`, `aria-*`, etc.)
+ * is a standard button attribute and is forwarded to the underlying element.
+ */
 type ButtonProps = Simplify<ButtonStyleProps & React$1.ComponentPropsWithoutRef<"button">>;
+/**
+ * The primary clickable button of the design system.
+ *
+ * Renders a native `<button>` styled by the `intent`/`variant`/`size` style props.
+ *
+ * @example
+ * <Button intent="primary" onClick={handleSave}>
+ *   Save
+ * </Button>
+ *
+ * @example Loading
+ * <Button intent="primary" loading={isSaving}>
+ *   Save
+ * </Button>
+ */
 declare const Button: React$1.ForwardRefExoticComponent<ButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
 
 type ButtonGroupProps<TValue extends string | number> = {
@@ -92,21 +142,48 @@ declare const ButtonGroup: <TValue extends string | number>({ size, value, onCha
 
 type CalloutIntent = Extract<Intent, "default" | "warning" | "primary" | "danger">;
 type CalloutProps = {
+    /**
+     * Semantic intent driving the background, border, and default leading icon.
+     * @default default
+     */
     intent?: CalloutIntent;
+    /** Bold heading shown above the body. */
     title?: React.ReactNode;
+    /** Content rendered at the trailing edge, e.g. a dismiss button or action link. */
     rightSlot?: React.ReactNode;
+    /** Body content of the callout. */
     children?: React.ReactNode;
+    /** Overrides the intent's default leading icon. */
     customIcon?: IconDefinition;
+    /**
+     * Squares off the bottom corners so the callout can sit flush against the element below it.
+     * @default false
+     */
     isAttachedAtBottom?: boolean;
+    /**
+     * Vertically centers the icon with the content instead of top-aligning it.
+     * @default false
+     */
     isCentered?: boolean;
 };
+/**
+ * A boxed, color-coded message for drawing attention to information, warnings, or errors.
+ *
+ * The `intent` sets the background, border, and a default leading icon (override with `customIcon`).
+ * Provide a `title`, body `children`, or both, plus an optional `rightSlot` for a trailing action.
+ *
+ * @example
+ * <Callout intent="warning" title="Heads up">
+ *   Saving will overwrite the existing draft.
+ * </Callout>
+ */
 declare const Callout: ({ title, intent, rightSlot, children, customIcon, isAttachedAtBottom, isCentered, }: CalloutProps) => react_jsx_runtime.JSX.Element;
 
 type FalsyValues = false | null | undefined | 0;
 type ClassNameProps = {
     className?: string;
 };
-type ChildrenProps$2 = PropsWithChildren<unknown>;
+type ChildrenProps = PropsWithChildren<unknown>;
 type DisabledProps = {
     disabled?: boolean;
 };
@@ -114,7 +191,7 @@ type StylesProps = {
     styles?: string | FalsyValues;
 };
 type PropsWithClassName<T> = T & ClassNameProps;
-type ErrorProps$1 = {
+type ErrorProps = {
     hasError?: boolean;
     errorNode?: ReactNode;
 };
@@ -123,41 +200,111 @@ type AllAsNever<T> = {
 };
 
 type CardProps = {
+    /**
+     * Click handler. When provided, the card gains a pointer cursor and a hover elevation to signal
+     * that it is interactive.
+     */
     onClick?: React__default.MouseEventHandler<HTMLDivElement>;
-} & ClassNameProps & ChildrenProps$2;
+} & ClassNameProps & ChildrenProps;
+/**
+ * A rounded, elevated surface that groups related content.
+ *
+ * Renders a white container with a border and shadow; the `ref` forwards to the root `<div>`.
+ * Supplying `onClick` makes it interactive (cursor + hover elevation). Use `className` to adjust
+ * padding, width, or margins.
+ *
+ * @example
+ * <Card className="p-4" onClick={() => openDetails(id)}>
+ *   <Text variant="title-2">Summary</Text>
+ * </Card>
+ */
 declare const Card: React__default.ForwardRefExoticComponent<{
+    /**
+     * Click handler. When provided, the card gains a pointer cursor and a hover elevation to signal
+     * that it is interactive.
+     */
     onClick?: React__default.MouseEventHandler<HTMLDivElement>;
 } & ClassNameProps & {
     children?: React__default.ReactNode | undefined;
 } & React__default.RefAttributes<HTMLDivElement>>;
 
-type ErrorProps = {
-    hasError?: boolean;
-    errorNode?: React.ReactNode;
-};
+/**
+ * Props for {@link Checkbox}: all native `<input>` attributes (`checked`, `onChange`, `disabled`,
+ * `name`, …) plus the design-system error props.
+ */
 type CheckboxProps = InputHTMLAttributes<HTMLInputElement> & ErrorProps;
+/**
+ * A styled checkbox input.
+ *
+ * Renders a native `<input type="checkbox">` with design-system styling and forwards its `ref` and
+ * all native attributes, so it works controlled (`checked` + `onChange`) or uncontrolled
+ * (`defaultChecked`). Set `hasError` for the error appearance. For the tri-state "some selected"
+ * look, use `IndeterminateCheckbox`.
+ *
+ * @example
+ * <Checkbox checked={agreed} onChange={(e) => setAgreed(e.target.checked)} />
+ */
 declare const Checkbox: React$1.ForwardRefExoticComponent<InputHTMLAttributes<HTMLInputElement> & ErrorProps & React$1.RefAttributes<HTMLInputElement>>;
-declare const IndeterminateCheckbox: ({ indeterminate, ...rest }: {
-    indeterminate?: boolean;
-} & CheckboxProps) => react_jsx_runtime.JSX.Element;
 
 type CollapsibleProps = {
+    /** Always-visible header that toggles the content when clicked. */
     title: React$1.ReactNode;
+    /** Content shown while expanded. */
     children: React$1.ReactNode;
+    /**
+     * Initial open state when uncontrolled.
+     * @default false
+     */
     defaultOpen?: boolean;
+    /**
+     * Which side of the title the chevron sits on.
+     * @default left
+     */
     iconPosition?: "left" | "right" | undefined;
+    /** Hides the chevron entirely. */
     hideIcon?: boolean;
+    /** Controlled open state. Pass together with `setOpen`. */
     open?: boolean;
+    /** Setter for controlled open state. Pass together with `open`. */
     setOpen?: (open: boolean) => void;
+    /** Class name for the clickable trigger row. */
     triggerClassName?: string;
 };
+/**
+ * A title row that expands and collapses to reveal its content, built on Radix `Collapsible`.
+ *
+ * Works uncontrolled (`defaultOpen`) or controlled (pass both `open` and `setOpen`). A chevron
+ * reflects the open state; position it with `iconPosition` or remove it with `hideIcon`.
+ *
+ * @example
+ * <Collapsible title="Advanced options">
+ *   <Options />
+ * </Collapsible>
+ */
 declare const Collapsible: ({ title, children, defaultOpen, iconPosition, hideIcon, open: controlledOpen, setOpen: controlledSetOpen, triggerClassName, }: CollapsibleProps) => react_jsx_runtime.JSX.Element;
 
 type ToggleButtonProps = ButtonProps;
 type CollapsibleSectionProps = {
+    /** The section, typically containing a {@link CollapsibleSection.ToggleButton} and {@link CollapsibleSection.Content}. */
     children: React$1.ReactNode;
+    /** Whether the section starts expanded. */
     defaultOpen?: boolean;
 };
+/**
+ * A collapsible region whose toggle and content can live anywhere within it.
+ *
+ * Unlike {@link Collapsible} (a single title-over-content unit), this shares open state via context,
+ * so {@link CollapsibleSection.ToggleButton} and {@link CollapsibleSection.Content} can be placed
+ * independently in the layout. The toggle is a transparent {@link Button} with a rotating chevron.
+ *
+ * @example
+ * <CollapsibleSection defaultOpen>
+ *   <CollapsibleSection.ToggleButton>Details</CollapsibleSection.ToggleButton>
+ *   <CollapsibleSection.Content>
+ *     <Details />
+ *   </CollapsibleSection.Content>
+ * </CollapsibleSection>
+ */
 declare const CollapsibleSection: {
     ({ children, defaultOpen }: CollapsibleSectionProps): react_jsx_runtime.JSX.Element;
     ToggleButton: ({ children, ...rest }: ToggleButtonProps) => react_jsx_runtime.JSX.Element;
@@ -167,16 +314,39 @@ declare const CollapsibleSection: {
 };
 
 type CopyEasyProps = {
+    /** The element the user clicks to copy. */
     children: React$1.ReactNode;
+    /**
+     * Text copied to the clipboard on click. When falsy, nothing is copyable: the children render
+     * as-is (wrapped in a tooltip if `tooltip` is provided).
+     */
     value: string | undefined;
+    /** Optional hover tooltip describing the copy action. */
     tooltip?: React$1.ReactNode;
+    /** Extra callback invoked after a successful copy. */
     onClick?: () => void;
+    /**
+     * Render children directly as the trigger instead of wrapping them in a `<span>`. Use when the
+     * child already forwards a ref and props.
+     */
     asChild?: boolean;
+    /** Class name for the trigger. */
     className?: string;
 };
+/**
+ * Makes its children click-to-copy, with a popover that confirms the copy.
+ *
+ * Clicking copies `value` to the clipboard and briefly shows a checkmark. If `value` is empty the
+ * content is non-interactive (shown plainly, or inside a tooltip when `tooltip` is set). The click
+ * is stopped from propagating, so it is safe to nest inside clickable rows.
+ *
+ * @example
+ * <Copyable value={patient.id} tooltip="Copy patient ID">
+ *   {patient.id}
+ * </Copyable>
+ */
 declare const Copyable: ({ children, value, tooltip, onClick, asChild, className }: CopyEasyProps) => string | number | boolean | Iterable<React$1.ReactNode> | react_jsx_runtime.JSX.Element | null | undefined;
 
-declare const copyToClipboard: (value: string) => Promise<void>;
 declare const useCopyable: () => {
     state: "idle" | "copying" | "copied";
     copy: (value: string | undefined, onClick?: () => void) => Promise<void>;
@@ -188,7 +358,7 @@ type DatePickerSharedProps = Pick<DatePickerProps$1, "inline" | "autoFocus" | "s
     inputProps?: DatePickerInputProps;
     placeholder?: string;
     position?: Placement;
-} & ErrorProps$1;
+} & ErrorProps;
 
 type DatePickerRangeProps = DatePickerSharedProps & {
     value: [Date | undefined, Date | undefined];
@@ -202,10 +372,41 @@ type DatePickerSingleProps = DatePickerSharedProps & {
     onChange?: (newDate: Date | undefined) => void;
 };
 
+/**
+ * Props for {@link DatePicker}, discriminated by `range`:
+ * - `range` omitted/`false` → single-date mode: `value: Date | undefined` and
+ *   `onChange(date: Date | undefined)`.
+ * - `range: true` → range mode: `value: [start, end]` and `onChange([start, end])`.
+ *
+ * Both modes also accept the shared options (placeholder, error state, popper `position`,
+ * `showTimeInput`, `inline`, native `inputProps`, etc.).
+ */
 type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps;
+/**
+ * A date input with a calendar popover, in either single-date or date-range mode.
+ *
+ * Set `range` to switch modes; this changes the types of `value` and `onChange` accordingly (see
+ * {@link DatePickerProps}). Controlled — supply `value` and handle `onChange`. Clearing the input
+ * emits `undefined` (single) or `[undefined, undefined]` (range).
+ *
+ * @example Single date
+ * <DatePicker value={date} onChange={setDate} placeholder="Select a date" />
+ *
+ * @example Date range
+ * <DatePicker range value={[start, end]} onChange={([s, e]) => setRange([s, e])} />
+ */
 declare const DatePicker: (props: DatePickerProps) => react_jsx_runtime.JSX.Element;
 
+/** Props for {@link Divider}. `className` is merged in, e.g. to add vertical margin. */
 type DividerProps = ClassNameProps;
+/**
+ * A thin horizontal rule that spans the full width of its container.
+ *
+ * Use it to separate sections of content. Pass `className` to adjust spacing or color.
+ *
+ * @example
+ * <Divider className="my-4" />
+ */
 declare const Divider: ({ className }: DividerProps) => react_jsx_runtime.JSX.Element;
 
 /** ErrorText will return `null` if `children` is falsy */
@@ -273,10 +474,28 @@ declare const useUncontrolledFormField: {
     displayName: string;
 };
 
+/**
+ * Binds a named, controlled form field and exposes its state to descendants via context.
+ *
+ * Resolves the field for the given `name` (value, change/blur handlers, error, etc.) and provides it
+ * to children, which read it with {@link useControlledField}. Use this when several pieces of UI
+ * need the same field's state; for a single input prefer the {@link ControlledField} render prop.
+ *
+ * @example
+ * <ControlledFieldProvider name="email">
+ *   <EmailInput />
+ *   <EmailHint />
+ * </ControlledFieldProvider>
+ */
 declare const ControlledFieldProvider: {
     ({ children, ...restField }: FormFieldNameProps & PropsWithChildren): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
+/**
+ * Reads the controlled field provided by the nearest {@link ControlledFieldProvider}.
+ *
+ * @throws if called outside a {@link ControlledFieldProvider}.
+ */
 declare const useControlledField: {
     (): {
         error: react_hook_form.FieldError | undefined;
@@ -290,17 +509,49 @@ declare const useControlledField: {
     displayName: string;
 };
 type ControlledFieldProps = FormFieldNameProps & {
+    /** Render prop receiving the resolved field state (value, handlers, error, …). */
     render: (props: ReturnType<typeof useControlledFormField>) => React.ReactNode;
 };
+/**
+ * Binds a named, controlled form field and hands its state to a render prop.
+ *
+ * The lightweight alternative to {@link ControlledFieldProvider} for a single consumer: wire the
+ * field's value and handlers straight into your input.
+ *
+ * @example
+ * <ControlledField
+ *   name="email"
+ *   render={({ value, onChange, error }) => (
+ *     <Input value={value} onChange={onChange} hasError={!!error} />
+ *   )}
+ * />
+ */
 declare const ControlledField: {
     ({ render, ...restField }: ControlledFieldProps): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 
+/**
+ * Registers a named, uncontrolled form field and exposes it to descendants via context.
+ *
+ * The uncontrolled counterpart to {@link ControlledFieldProvider}: the field registers with the
+ * form (ref-based) rather than tracking value in React state. Children read it with
+ * {@link useUncontrolledField}; for a single input prefer the {@link UncontrolledField} render prop.
+ *
+ * @example
+ * <UncontrolledFieldProvider name="title">
+ *   <TitleInput />
+ * </UncontrolledFieldProvider>
+ */
 declare const UncontrolledFieldProvider: {
     ({ children, ...restField }: UncontrolledFormFieldProps & PropsWithChildren): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
+/**
+ * Reads the uncontrolled field provided by the nearest {@link UncontrolledFieldProvider}.
+ *
+ * @throws if called outside an {@link UncontrolledFieldProvider}.
+ */
 declare const useUncontrolledField: {
     (): {
         register: () => {
@@ -321,39 +572,26 @@ declare const useUncontrolledField: {
     displayName: string;
 };
 type UncontrolledFieldProps = UncontrolledFormFieldProps & {
+    /** Render prop receiving the registered field (ref, name, error, …) to spread onto an input. */
     render: (props: ReturnType<typeof useUncontrolledFormField>) => React.ReactNode;
 };
+/**
+ * Registers a named, uncontrolled form field and hands it to a render prop.
+ *
+ * The lightweight alternative to {@link UncontrolledFieldProvider} for a single consumer: spread the
+ * provided registration props onto your input.
+ *
+ * @example
+ * <UncontrolledField
+ *   name="title"
+ *   render={(field) => <Input {...field} />}
+ * />
+ */
 declare const UncontrolledField: {
     ({ render, ...restField }: UncontrolledFieldProps): react_jsx_runtime.JSX.Element;
     displayName: string;
 };
 
-declare const getFieldError: <TFieldValues extends FieldValues>(errors: FieldErrors<TFieldValues> | undefined, name: FieldPath<TFieldValues> | undefined) => FieldError | undefined;
-
-type InputSize = Extract<Size, "sm" | "md" | "lg">;
-type InputVariants = "default" | "transparent";
-type InputBoxStyleProps = {
-    size?: InputSize;
-    variant?: InputVariants;
-    hasError?: boolean;
-    hasWarning?: boolean;
-    hasSuccess?: boolean;
-};
-declare const inputBoxStyles: ({ size, variant, hasError, hasWarning, hasSuccess, }: InputBoxStyleProps) => string;
-declare const inputStyles = "w-full text-gray-800 placeholder:text-placeholder disabled:text-placeholder";
-
-type InputBoxProps = InputBoxStyleProps & {
-    children: React$1.ReactNode;
-};
-type InputBaseProps = React$1.ComponentPropsWithoutRef<"input">;
-declare const NestedInput: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
-type CompoundInputBox = React$1.ForwardRefExoticComponent<InputBoxProps & React$1.RefAttributes<HTMLLabelElement>> & {
-    Input: typeof NestedInput;
-};
-declare const InputBox: CompoundInputBox;
-type InputProps = InputBoxStyleProps & InputBaseProps;
-declare const Input: React$1.ForwardRefExoticComponent<InputBoxStyleProps & Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
-
 type FormItemVariants = "none" | "stacked" | "side-by-side" | "inline";
 type InfoTooltip = {
     tooltip: string | undefined;
@@ -383,7 +621,45 @@ type SharedFormControlProps = StylesProps & {
 };
 type CommonSelectProps = "items" | "hideSearch" | "triggerPlaceholder" | "onChange" | "disabled";
 
+declare const getFieldError: <TFieldValues extends FieldValues>(errors: FieldErrors<TFieldValues> | undefined, name: FieldPath<TFieldValues> | undefined) => FieldError | undefined;
+
+type InputSize = Extract<Size, "sm" | "md" | "lg">;
+type InputVariants = "default" | "transparent";
+type InputBoxStyleProps = {
+    size?: InputSize;
+    variant?: InputVariants;
+    hasError?: boolean;
+    hasWarning?: boolean;
+    hasSuccess?: boolean;
+};
+
+type InputBoxProps = InputBoxStyleProps & {
+    /**
+     * Contents of the box — typically `<InputBox.Input />` alongside adornments such as icons,
+     * a prefix, or a clear button.
+     */
+    children: React$1.ReactNode;
+};
+type InputBaseProps = React$1.ComponentPropsWithoutRef<"input">;
+declare const NestedInput: React$1.ForwardRefExoticComponent<Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+type CompoundInputBox = React$1.ForwardRefExoticComponent<InputBoxProps & React$1.RefAttributes<HTMLLabelElement>> & {
+    Input: typeof NestedInput;
+};
+declare const InputBox: CompoundInputBox;
+/**
+ * Props for {@link Input}: the design-system style/state props (`size`, `variant`, `hasError`,
+ * `hasWarning`, `hasSuccess`, `prefix`) plus all native `<input>` attributes, which pass through.
+ */
+type InputProps = InputBoxStyleProps & InputBaseProps;
+declare const Input: React$1.ForwardRefExoticComponent<InputBoxStyleProps & Omit<React$1.DetailedHTMLProps<React$1.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React$1.RefAttributes<HTMLInputElement>>;
+
 type FormInputProps = SharedFormControlProps & SharedFormItemProps & Pick<UncontrolledFormFieldProps, "onChange" | "onBlur"> & Pick<InputProps, "placeholder" | "variant" | "prefix" | "type" | "step" | "autoFocus" | "min" | "max">;
+/**
+ * Text input bound to a named field of the surrounding form.
+ *
+ * Registers an uncontrolled field and surfaces its validation error. Forwards input-level props such
+ * as `placeholder`, `variant`, `prefix`, and `type` to the underlying {@link Input}.
+ */
 declare const FormInput: ({ name, styles, layout, label, options, onChange, onBlur, disabled, ...rest }: FormInputProps) => react_jsx_runtime.JSX.Element;
 
 type DollarInputProps = {
@@ -428,9 +704,23 @@ type FormPercentInputProps = SharedFormControlProps & SharedFormItemProps & {
 declare const FormPercentInput: ForwardRefExoticComponent<FormPercentInputProps & RefAttributes<HTMLInputElement>>;
 
 type FormCheckboxProps = Pick<SharedFormControlProps, "name" | "disabled"> & {
+    /**
+     * Optional content to render in place of the default checkbox. When provided, compose the field
+     * yourself with {@link FormCheckbox.Checkbox} and {@link FormCheckbox.Label}; when omitted, a
+     * standalone {@link Checkbox} is rendered.
+     */
     children?: React.ReactNode;
+    /** Called with the new checked state whenever the checkbox is toggled. */
     onChange?: (checked: boolean) => void;
 };
+/**
+ * Checkbox bound to a named field of the surrounding form.
+ *
+ * Reads and writes the field's boolean value and surfaces its validation error. Used without
+ * `children` it renders a standalone {@link Checkbox}; with `children` it provides the field via
+ * context so it can be composed with the {@link FormCheckbox.Checkbox} and {@link FormCheckbox.Label}
+ * subcomponents.
+ */
 declare const FormCheckbox: {
     ({ name, disabled, onChange: propsOnChange, children }: FormCheckboxProps): react_jsx_runtime.JSX.Element;
     Label: typeof LabelImpl;
@@ -617,7 +907,6 @@ type AsyncMultiSelectControlledProps<TValue extends SelectValue, TObj> = {
     onChange: (value: TValue[] | undefined, objs: TObj[]) => void;
 };
 
-declare function useDebounce<T>(value: T, delay: number): T;
 type ErrorOr<T> = {
     error: true;
 } | {
@@ -736,29 +1025,70 @@ type SelectListItemProps = {
 declare const SelectListItem: ({ sortableId, children, onClick, disabled, focused, }: SelectListItemProps) => react_jsx_runtime.JSX.Element;
 
 type FormSelectProps<TValue extends SelectValue> = SharedFormControlProps & SharedFormItemProps & Pick<SelectProps<TValue>, CommonSelectProps | "loadProps" | "triggerPlaceholder">;
+/**
+ * Single-select bound to a named field of the surrounding form.
+ *
+ * Reads and writes the field's selected value and surfaces its validation error. Forwards
+ * select-level props such as `loadProps` and `triggerPlaceholder` to the underlying {@link Select}.
+ */
 declare const FormSelect: <TValue extends SelectValue>({ name, styles, layout, label, options, onChange, ...rest }: FormSelectProps<TValue>) => react_jsx_runtime.JSX.Element;
 
 type FormMultiSelectProps<TValue extends SelectValue> = SharedFormControlProps & SharedFormItemProps & Pick<MultiSelectProps<TValue>, CommonSelectProps | "allowCustomValues" | "minSelection" | "maxSelection">;
+/**
+ * Multi-select bound to a named field of the surrounding form.
+ *
+ * Reads and writes the field's array of selected values and surfaces its validation error. Forwards
+ * select-level props such as `allowCustomValues`, `minSelection`, and `maxSelection` to the
+ * underlying {@link MultiSelect}.
+ */
 declare const FormMultiSelect: <TValue extends SelectValue>({ name, styles, layout, label, options, onChange, ...rest }: FormMultiSelectProps<TValue>) => react_jsx_runtime.JSX.Element;
 
-type TextAreaProps = TextareaHTMLAttributes<HTMLTextAreaElement> & Simplify<ErrorProps$1>;
-declare const TextAreaComp: React$1.ForwardRefExoticComponent<TextareaHTMLAttributes<HTMLTextAreaElement> & {
-    hasError?: boolean | undefined;
-    errorNode?: React$1.ReactNode;
-} & React$1.RefAttributes<HTMLTextAreaElement>>;
+/**
+ * Props for {@link TextArea}: all native `<textarea>` attributes (`value`, `onChange`, `rows`,
+ * `disabled`, …) plus the design-system error props (`hasError`, `errorNode`).
+ */
+type TextAreaProps = TextareaHTMLAttributes<HTMLTextAreaElement> & Simplify<ErrorProps>;
+/**
+ * A multi-line text input with built-in error messaging.
+ *
+ * Renders a styled `<textarea>` (controlled or uncontrolled via native props) and, when `hasError`
+ * is set, displays `errorNode` beneath it. The `ref` forwards to the textarea element.
+ *
+ * @example
+ * <TextArea
+ *   value={notes}
+ *   onChange={(e) => setNotes(e.target.value)}
+ *   hasError={!!error}
+ *   errorNode={error}
+ * />
+ */
 declare const TextArea: React$1.ForwardRefExoticComponent<TextareaHTMLAttributes<HTMLTextAreaElement> & {
     hasError?: boolean | undefined;
     errorNode?: React$1.ReactNode;
 } & React$1.RefAttributes<HTMLTextAreaElement>>;
 
 type FormTextAreaProps = SharedFormControlProps & SharedFormItemProps & TextAreaProps & {
+    /** Debounce interval in milliseconds for change events. When set, `onChange` fires at most once per interval. */
     debounce?: number;
 };
+/**
+ * Multi-line text input bound to a named field of the surrounding form.
+ *
+ * Registers an uncontrolled field and surfaces its validation error. When `debounce` is set, change
+ * events written back to the field are debounced by that many milliseconds.
+ */
 declare const FormTextArea: ({ name, styles, layout, label, options, debounce: debounceInterval, ...rest }: FormTextAreaProps) => react_jsx_runtime.JSX.Element;
 
 type FormSwitchProps = SharedFormControlProps & SharedFormItemProps & {
     onChange?: (value: boolean) => void;
 };
+/**
+ * Toggle switch bound to a named field of the surrounding form.
+ *
+ * Reads and writes the field's boolean value and surfaces its validation error. With the
+ * `side-by-side` layout the switch sits inline beside its label, description, and error; otherwise it
+ * renders within a standard form item.
+ */
 declare const FormSwitch: ({ name, styles, layout, label, options, onChange, ...props }: FormSwitchProps) => react_jsx_runtime.JSX.Element;
 
 type RadioButtonGroupItem = {
@@ -777,24 +1107,75 @@ type RadioButtonItemProps = RadioButtonGroupItem & {
 declare const RadioButtonItem: ({ value, displayValue, description, expandedContents, expandedContentsStyle, disabled, isChecked, onSelect, asCard, }: RadioButtonItemProps) => react_jsx_runtime.JSX.Element;
 
 type RadioButtonGroupProps = PropsWithClassName<{
+    /**
+     * The selectable options. Each item supplies its `value`, `displayValue`, and optional
+     * `description` / `expandedContents` shown when selected.
+     */
     items: RadioButtonGroupItem[];
+    /** The `value` of the currently selected item (controlled). */
     value?: string | undefined;
+    /** Called with the newly selected item's `value`. */
     onChange?: (newValue: string) => void;
+    /**
+     * Render each option as a bordered card instead of a plain radio row.
+     * @default false
+     */
     asCards?: boolean;
 }>;
+/**
+ * A single-select group of radio buttons rendered inside a `<fieldset>`.
+ *
+ * Controlled: the selected option is whichever item's `value` matches `value`, and `onChange` fires
+ * with the newly selected `value`. Options come from `items`; set `asCards` to render them as
+ * bordered cards (useful when items have descriptions or expanded content).
+ *
+ * @example
+ * <RadioButtonGroup
+ *   value={plan}
+ *   onChange={setPlan}
+ *   items={[
+ *     { value: "monthly", displayValue: "Monthly" },
+ *     { value: "annual", displayValue: "Annual", description: "Save 20%" },
+ *   ]}
+ * />
+ */
 declare const RadioButtonGroup: React$1.ForwardRefExoticComponent<{
+    /**
+     * The selectable options. Each item supplies its `value`, `displayValue`, and optional
+     * `description` / `expandedContents` shown when selected.
+     */
     items: RadioButtonGroupItem[];
+    /** The `value` of the currently selected item (controlled). */
     value?: string | undefined;
+    /** Called with the newly selected item's `value`. */
     onChange?: (newValue: string) => void;
+    /**
+     * Render each option as a bordered card instead of a plain radio row.
+     * @default false
+     */
     asCards?: boolean;
 } & ClassNameProps & React$1.RefAttributes<HTMLFieldSetElement>>;
 
 type FormRadioButtonGroupProps = Simplify<Pick<SharedFormControlProps, "name"> & Pick<RadioButtonGroupProps, "items" | "onChange" | "className" | "asCards">>;
+/**
+ * Radio button group bound to a named field of the surrounding form.
+ *
+ * Reads and writes the field's selected value and surfaces its validation error. Forwards
+ * group-level props such as `items`, `className`, and `asCards` to the underlying
+ * {@link RadioButtonGroup}.
+ */
 declare const FormRadioButtonGroup: ({ name, items, onChange, asCards, className, }: FormRadioButtonGroupProps) => react_jsx_runtime.JSX.Element;
 
 type FormDatePickerProps = SharedFormControlProps & SharedFormItemProps & Pick<DatePickerProps, "placeholder" | "minDate" | "range" | "onChange" | "maxDate" | "showTimeInput"> & {
+    /** Ref forwarded to the field's container element. */
     containerRef?: React.RefObject<HTMLDivElement>;
 };
+/**
+ * Date picker bound to a named field of the surrounding form.
+ *
+ * Reads and writes the field's date value and surfaces its validation error. An empty selection is
+ * normalised to `null` before being written back to the field.
+ */
 declare const FormDatePicker: ({ name, styles, layout, label, onChange, options, containerRef, disabled, ...rest }: FormDatePickerProps) => react_jsx_runtime.JSX.Element;
 
 type UseDrawerResizeParams = {
@@ -808,7 +1189,6 @@ type PersistDrawerWidth = {
     load: () => number | undefined;
     save: (widthPct: number) => void;
 };
-declare const localStoragePersist: (key: string) => PersistDrawerWidth;
 declare const useDrawerResize: ({ slider, drawer, isOpen, defaultSizePct, persistWidth }: UseDrawerResizeParams) => void;
 
 declare const drawerSizes: {
@@ -817,14 +1197,38 @@ declare const drawerSizes: {
     lg: number;
 };
 type DrawerProps = {
+    /** Whether the drawer is open. Controlled — the drawer never closes itself. */
     isOpen: boolean;
+    /** Called when the user requests close (pressing `Escape`). */
     onClose?: () => void;
+    /** Called when the user clicks the overlay outside the drawer. */
     onClickOutside?: () => void;
+    /** Renders a blurred, click-blocking overlay behind the drawer while open. */
     blurredOverlay?: boolean;
+    /**
+     * Initial drawer width as a fraction of the viewport: `sm` (½), `md` (¾), `lg` (⅚).
+     * The user can drag the left edge to resize.
+     * @default md
+     */
     width?: keyof typeof drawerSizes;
+    /** Persist the user's resized width (e.g. to localStorage) across opens. */
     persistWidth?: PersistDrawerWidth;
+    /** Drawer contents. Rendered lazily (inside `Suspense`) only while open. */
     children: React.ReactNode;
 };
+/**
+ * A resizable panel that slides in from the right edge of its positioned container.
+ *
+ * Controlled via `isOpen`; closing is up to the caller (`onClose` fires on `Escape`,
+ * `onClickOutside` on overlay clicks). The user can drag the left edge to resize, and
+ * `persistWidth` remembers that choice. Children mount lazily under `Suspense` (with a loading
+ * fallback) and only while open, so heavy content isn't rendered when the drawer is closed.
+ *
+ * @example
+ * <Drawer isOpen={isOpen} onClose={close} onClickOutside={close} width="lg" blurredOverlay>
+ *   <DrawerContents />
+ * </Drawer>
+ */
 declare const Drawer: React$1.ForwardRefExoticComponent<DrawerProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type DrawerHeaderProps = {
@@ -852,25 +1256,72 @@ type DrawerState = {
     isOpen: boolean;
     onClose: () => void;
 };
-declare const DrawerStateContext: React$1.Context<DrawerState>;
 declare const useDrawer: () => DrawerState;
 
+/**
+ * The small downward chevron used to mark dropdown/select triggers.
+ *
+ * A fixed-size, muted decorative icon with no props — place it inside a custom trigger to match the
+ * design system's dropdown affordance.
+ *
+ * @example
+ * <button className="flex items-center gap-1">
+ *   {label}
+ *   <DropdownChevron />
+ * </button>
+ */
 declare const DropdownChevron: () => react_jsx_runtime.JSX.Element;
 
 type EmptyStateProps = {
+    /**
+     * Icon shown above the text.
+     * @default faCircleDashed
+     */
     icon?: IconDefinition;
+    /** Primary message explaining why there's nothing to show. */
     title: React.ReactNode;
+    /** Optional supporting text, e.g. a hint on how to add data. */
     description?: React.ReactNode;
 };
+/**
+ * A centered placeholder for when a list, table, or view has no content.
+ *
+ * Renders an icon, a `title`, and an optional `description`. The `ref` forwards to the root element.
+ *
+ * @example
+ * <EmptyState
+ *   icon={faInbox}
+ *   title="No messages"
+ *   description="New messages will appear here."
+ * />
+ */
 declare const EmptyState: React$1.ForwardRefExoticComponent<EmptyStateProps & React$1.RefAttributes<HTMLDivElement>>;
 
 type HeaderTileProps = {
+    /** Small label shown above the content. */
     title: string;
+    /** Main value of the tile; a string is rendered as styled text, otherwise rendered as-is. */
     content: string | ReactNode;
+    /** When provided, the tile becomes a button that opens this content in a popover. */
     popover?: ReactNode;
+    /** Class name for the tile container. */
     className?: string;
+    /** Drops the tile's own border/rounding for use inside a grouped row of tiles. */
     grouped?: boolean;
 };
+/**
+ * A compact labeled stat tile for page headers (a `title` over a `content` value).
+ *
+ * When `popover` is provided the tile becomes an interactive button that reveals that content on
+ * click; otherwise it's a static tile. Set `grouped` to drop the border when placing several tiles
+ * side by side.
+ *
+ * @example
+ * <HeaderTile title="Balance" content="$1,240.00" />
+ *
+ * @example With a popover
+ * <HeaderTile title="Status" content="In review" popover={<StatusHistory />} />
+ */
 declare const HeaderTile: (props: HeaderTileProps) => react_jsx_runtime.JSX.Element;
 
 type HeaderTileGroupProps = {
@@ -883,8 +1334,21 @@ declare const HeaderTileGroup: {
 };
 
 type IconProps = {
+    /** A Font Awesome icon definition, imported from one of the `@fortawesome/*-svg-icons` packages. */
     icon: IconDefinition;
 };
+/**
+ * Renders a Font Awesome SVG icon.
+ *
+ * A thin wrapper over `FontAwesomeIcon` that constrains the API to a single `icon` prop, keeping
+ * icon usage consistent across the design system. Color and size are inherited from the surrounding
+ * text (`font-size` / `color`).
+ *
+ * @example
+ * import { faCircleInfo } from "@fortawesome/sharp-solid-svg-icons";
+ *
+ * <Icon icon={faCircleInfo} />
+ */
 declare const Icon: ({ icon }: IconProps) => react_jsx_runtime.JSX.Element;
 
 type LabelIntent = Intent | "disabled";
@@ -894,13 +1358,22 @@ type LabelStyleProps = {
     intent?: LabelIntent;
     size?: Size;
 };
-declare const labelStyles: ({ intent, size, variant }: LabelStyleProps) => string;
 
+/**
+ * A small inline text label/badge with design-system styling.
+ *
+ * Renders a `<span>` styled by `intent` (color), `size`, and `variant`, with the `ref` and any
+ * extra native attributes forwarded. Used on its own for status badges and as the visual base for
+ * {@link Tag}.
+ *
+ * @example
+ * <Label intent="success">Active</Label>
+ */
 declare const Label: React$1.ForwardRefExoticComponent<{
+    /** Label content. */
     children: React$1.ReactNode;
 } & LabelStyleProps & React$1.RefAttributes<HTMLSpanElement>>;
 
-declare const RESPONSIVE_PADDING = "px-4 md:px-8 lg:px-12 xl:px-16";
 /**
     The content container used across the app to get content centered, use consistent padding, and get whole page
     scrolling to work cohesively.
@@ -913,29 +1386,83 @@ declare const ScreenHeightPageContainer: React$1.ForwardRefExoticComponent<Class
 } & React$1.RefAttributes<HTMLDivElement>>;
 
 type LoaderProps = {
+    /** Additional classes, e.g. to override the color. */
     className?: string;
+    /** Font Awesome size token (e.g. `"sm"`, `"lg"`, `"2x"`). */
     size?: SizeProp;
 };
+/**
+ * A simple spinning loading indicator (a rotating Font Awesome spinner icon).
+ *
+ * Inline by default; size it with `size`. For a centered spinner with
+ * optional text, use {@link LoadingState}.
+ *
+ * @example
+ * <Spinner size="lg" />
+ */
 declare const Spinner: ({ className, ...props }: LoaderProps) => react_jsx_runtime.JSX.Element;
 
 type LoadingStateProps = {
+    /**
+     * Spinner size (Font Awesome token).
+     * @default 2x
+     */
     size?: SizeProp;
+    /** Optional heading shown beneath the spinner. */
     title?: React.ReactNode;
+    /** Optional supporting text shown beneath the title. */
     description?: React.ReactNode;
 };
+/**
+ * A centered spinner with optional title/description that fills its container.
+ *
+ * The standard "loading a whole view/section" indicator (e.g. as a `Suspense` fallback or while a
+ * page's primary query loads). For an inline spinner alone, use {@link Spinner}.
+ *
+ * @example
+ * <Suspense fallback={<LoadingState title="Loading patients…" />}>
+ *   <PatientList />
+ * </Suspense>
+ */
 declare const LoadingState: ({ size, title, description }: LoadingStateProps) => react_jsx_runtime.JSX.Element;
 
 type LoadingBarProps = {
+    /** Class name for the bar track, e.g. to set height or position. */
     className?: string;
 };
+/**
+ * An indeterminate progress bar — a shimmer sliding across a full-width track.
+ *
+ * Use it to signal background activity of unknown duration (e.g. refetching a table). For a
+ * blocking, centered loading view use {@link LoadingState}.
+ *
+ * @example
+ * {isFetching && <LoadingBar className="h-1" />}
+ */
 declare const LoadingBar: ({ className }: LoadingBarProps) => react_jsx_runtime.JSX.Element;
 
 type TwoCirclesSpinnerProps = {
+    /** Class name for the wrapper. */
     className?: string;
+    /**
+     * Spinner diameter.
+     * @default md
+     */
     size?: "sm" | "md" | "lg" | "xl";
+    /** Optional heading shown beneath the spinner. */
     title?: React.ReactNode;
+    /** Optional supporting text shown beneath the title. */
     description?: React.ReactNode;
 };
+/**
+ * A two-ring orbital loading animation with optional title/description.
+ *
+ * A more prominent, branded alternative to {@link LoadingState} for full-screen or marketing-style
+ * loading moments. Two concentric arcs counter-rotate; `size` scales the whole indicator.
+ *
+ * @example
+ * <TwoCirclesSpinner size="lg" title="Setting things up…" />
+ */
 declare const TwoCirclesSpinner: ({ className, size, title, description }: TwoCirclesSpinnerProps) => react_jsx_runtime.JSX.Element;
 
 type MenuContentProps = DropdownMenuContentProps & {
@@ -951,8 +1478,6 @@ type MenuItemWithToolTipProps = MenuItemProps & {
      */
     tooltip?: React$1.ReactNode;
 };
-declare const MenuRoot: (props: DropdownMenuProps) => react_jsx_runtime.JSX.Element;
-declare const MenuSeparator: () => react_jsx_runtime.JSX.Element;
 type MenuProps = DropdownMenuProps & Pick<DropdownMenuContentProps, "align"> & {
     trigger?: React$1.ReactNode;
     triggerSize?: ButtonProps["size"];
@@ -994,10 +1519,7 @@ type ModalContentProps = SoftDismissProps & {
     overflowYClassName?: `overflow-y-${string}`;
 };
 
-type ChildrenProps$1 = {
-    children?: React$1.ReactNode;
-};
-type ModalBodyImplProps$1 = {
+type ModalBodyImplProps = {
     title?: React$1.ReactNode;
     error?: React$1.ReactNode;
     description?: React$1.ReactNode;
@@ -1030,16 +1552,40 @@ type DiscriminatedContentProps$1 = {
     error?: never;
     description?: never;
     actions?: never;
-} | (ModalBodyImplProps$1 & {
+} | (ModalBodyImplProps & {
     children?: never;
     content?: React$1.ReactNode;
 });
-type ModalProps$2 = DiscriminatedVisibilityProps & ModalContentBaseProps & ModalContentProps & DiscriminatedContentProps$1 & {
+type ModalProps = DiscriminatedVisibilityProps & ModalContentBaseProps & ModalContentProps & DiscriminatedContentProps$1 & {
     trigger?: React$1.ReactNode;
 };
+/**
+ * A dialog overlay with two interchangeable modes for both visibility and content.
+ *
+ * **Visibility** is either controlled or self-managed (see {@link DiscriminatedVisibilityProps}):
+ * pass `isOpen` + `onClose` to drive it yourself, or pass a `trigger` element to let the modal own
+ * its open state (observe changes via `onOpenChange`). The two sets are mutually exclusive.
+ *
+ * **Content** is either fully custom or structured: pass `children` to render the body yourself, or
+ * pass `content` together with `title` / `description` / `error` / `actions` to use the standard
+ * layout (title bar, scrollable body, sticky actions). These two sets are also mutually exclusive.
+ *
+ * Sub-components: {@link Modal.Body} (the structured layout, also usable directly),
+ * {@link Modal.TriggerButton}, and {@link Modal.CloseButton}.
+ *
+ * @example Controlled
+ * <Modal isOpen={isOpen} onClose={close} title="Delete item" actions={<Button>Delete</Button>}>
+ *   This action cannot be undone.
+ * </Modal>
+ *
+ * @example Self-managed via a trigger
+ * <Modal trigger={<Modal.TriggerButton>Open</Modal.TriggerButton>} title="Settings">
+ *   <SettingsForm />
+ * </Modal>
+ */
 declare const Modal: {
-    ({ children, trigger, isOpen, onClose, onOpenChange, content, title, error, description, actions, ...rest }: ModalProps$2): react_jsx_runtime.JSX.Element;
-    Body: ({ children, title, error, description, actions, showX, }: ModalBodyImplProps$1 & ChildrenProps$1) => react_jsx_runtime.JSX.Element;
+    ({ children, trigger, isOpen, onClose, onOpenChange, content, title, error, description, actions, ...rest }: ModalProps): react_jsx_runtime.JSX.Element;
+    Body: ({ children, title, error, description, actions, showX, }: ModalBodyImplProps & ChildrenProps) => react_jsx_runtime.JSX.Element;
     TriggerButton: (props: undefined) => react_jsx_runtime.JSX.Element;
     CloseButton: (props: undefined) => react_jsx_runtime.JSX.Element;
 };
@@ -1052,22 +1598,19 @@ type FullscreenModalHeaderProps = {
     className?: string;
 };
 
-type ModalProps$1 = DiscriminatedVisibilityProps & ModalContentBaseProps & {
+type FullscreenModalProps = DiscriminatedVisibilityProps & ModalContentBaseProps & {
     trigger?: React$1.ReactNode;
     fullscreen?: boolean;
     title?: React$1.ReactNode;
     showX?: boolean;
 };
-declare const FullscreenModalNamespace: React$1.ForwardRefExoticComponent<ModalProps$1 & React$1.RefAttributes<HTMLDivElement>> & {
+declare const FullscreenModalNamespace: React$1.ForwardRefExoticComponent<FullscreenModalProps & React$1.RefAttributes<HTMLDivElement>> & {
     TriggerButton: (props: undefined) => react_jsx_runtime.JSX.Element;
     CloseButton: (props: undefined) => react_jsx_runtime.JSX.Element;
     Header: ({ className, title, description, leftSlot, rightSlot, }: FullscreenModalHeaderProps) => react_jsx_runtime.JSX.Element;
 };
 
-type ChildrenProps = {
-    children?: React$1.ReactNode;
-};
-type ModalBodyImplProps = {
+type AlertModalBodyProps = {
     title?: React$1.ReactNode;
     error?: React$1.ReactNode;
     description?: React$1.ReactNode;
@@ -1080,16 +1623,16 @@ type DiscriminatedContentProps = {
     error?: never;
     description?: never;
     actions?: never;
-} | (ModalBodyImplProps & {
+} | (AlertModalBodyProps & {
     children?: never;
     content?: React$1.ReactNode;
 });
-type ModalProps = Simplify<DiscriminatedVisibilityProps & Pick<ModalContentProps, "maxWidthClassName"> & DiscriminatedContentProps & {
+type AlertModalProps = Simplify<DiscriminatedVisibilityProps & Pick<ModalContentProps, "maxWidthClassName"> & DiscriminatedContentProps & {
     trigger?: React$1.ReactNode;
 }>;
 declare const AlertModal: {
-    ({ children, trigger, isOpen, onOpenChange, onClose, content, title, error, description, actions, ...rest }: ModalProps): react_jsx_runtime.JSX.Element;
-    Body: ({ children, title, error, description, actions }: ModalBodyImplProps & ChildrenProps) => react_jsx_runtime.JSX.Element;
+    ({ children, trigger, isOpen, onOpenChange, onClose, content, title, error, description, actions, ...rest }: AlertModalProps): react_jsx_runtime.JSX.Element;
+    Body: ({ children, title, error, description, actions }: AlertModalBodyProps & ChildrenProps) => react_jsx_runtime.JSX.Element;
     TriggerButton: (props: undefined) => react_jsx_runtime.JSX.Element;
     CloseButton: (props: undefined) => react_jsx_runtime.JSX.Element;
 };
@@ -1098,10 +1641,6 @@ type TooltipContentProps = Pick<RadixTooltip.TooltipContentProps, "side"> & {
     children: React$1.ReactNode;
     variant?: "dark" | "light";
 };
-declare const TooltipContent: {
-    ({ children, variant, ...rest }: TooltipContentProps): react_jsx_runtime.JSX.Element;
-    displayName: string | undefined;
-};
 type OverflowTriggerProps<TElement extends HTMLElement> = Omit<RadixTooltip.TooltipTriggerProps, "children"> & {
     /** The `elementRef` render prop should attach to a measurable DOM element.
      *
@@ -1152,28 +1691,66 @@ type OverflowTooltipProps = Pick<React__default.ComponentPropsWithoutRef<typeof
 };
 declare const OverflowTooltip: ({ element, tooltip, side, variant, ...props }: OverflowTooltipProps) => react_jsx_runtime.JSX.Element;
 
+/**
+ * An international phone-number input with a country selector, built on `react-international-phone`.
+ *
+ * Controlled: `onChange` receives the E.164 value (e.g. `"+12025550123"`), or `undefined` when the
+ * field is cleared. Defaults to the US country. Set `hasError` for error styling. All other
+ * `react-international-phone` `PhoneInput` props pass through.
+ *
+ * @example
+ * <PhoneNumber value={phone} onChange={(v) => setPhone(v)} hasError={!!error} />
+ */
 declare const PhoneNumber: React__default.FC<PhoneInputProps & {
     hasError?: boolean;
     onChange: (value?: string) => void;
 }>;
-declare const formatPhoneNumber: (input: string | undefined) => string | undefined;
-declare const formatPhoneNumberForDisplay: (input: string | undefined) => string | undefined;
-declare const isValidPhoneNumber: (input: string | undefined) => boolean;
 
 type Align = "start" | "center" | "end";
 type Side = "top" | "right" | "bottom" | "left";
 type PopoverProps = {
+    /** Class name applied to the trigger wrapper. */
     triggerClassName?: string;
+    /** Element that opens the popover. Rendered via Radix `asChild`. */
     trigger: React.ReactNode;
+    /** Controls open state. Omit to let the popover manage its own. */
     open?: boolean;
+    /** Disables the trigger. */
     disabled?: boolean;
+    /** Alignment of the content relative to the trigger. */
     alignContent?: Align;
+    /** Side of the trigger the content appears on. */
     side?: Side;
+    /** Class name for the arrow element. */
     arrowClassName?: string;
+    /** Class name for the content container. */
     contentClassName?: string;
+    /** Popover content. */
     children: React.ReactNode;
+    /** Called when the open state changes (controlled or uncontrolled). */
     onOpenChange?: (open: boolean) => void;
 };
+/**
+ * A floating content panel anchored to a trigger element, built on Radix `Popover`.
+ *
+ * The all-in-one form takes a `trigger` and `children` and renders a portaled, shadowed card with
+ * an arrow. For finer control over composition, use the compound parts: {@link Popover.Root},
+ * {@link Popover.Trigger} (a styled {@link Button}), {@link Popover.Body}, and {@link Popover.Close}.
+ *
+ * @example
+ * <Popover trigger={<Button>Options</Button>} side="bottom" alignContent="start">
+ *   <Menu />
+ * </Popover>
+ *
+ * @example Compound form
+ * <Popover.Root>
+ *   <Popover.Trigger>Options</Popover.Trigger>
+ *   <Popover.Body>
+ *     <Menu />
+ *     <Popover.Close><Button>Done</Button></Popover.Close>
+ *   </Popover.Body>
+ * </Popover.Root>
+ */
 declare const Popover: {
     ({ open, trigger, triggerClassName, children, arrowClassName, contentClassName, disabled, onOpenChange, alignContent, container, ...props }: PopoverProps & PopoverBodyProps): react_jsx_runtime.JSX.Element;
     Root(props: RadixPopover.PopoverProps): react_jsx_runtime.JSX.Element;
@@ -1191,43 +1768,58 @@ type PopoverBodyProps = {
 };
 
 type SkeletonProps = {
+    /** Sizing/shape classes for the placeholder (e.g. `"h-4 w-32"`). */
     className?: string;
 };
+/**
+ * An animated grey placeholder shown while content loads.
+ *
+ * Size and shape come entirely from `className`; render one per piece of content you're awaiting to
+ * preserve layout and reduce shift.
+ *
+ * @example
+ * {isLoading ? <Skeleton className="h-4 w-32" /> : <Text>{name}</Text>}
+ */
 declare const Skeleton: ({ className }: SkeletonProps) => react_jsx_runtime.JSX.Element;
 
-type TabsSkeletonProps = {
-    numTabs?: number;
-    className?: string;
-    tabClassName?: string;
-};
-declare const TabsSkeleton: ({ numTabs, className, tabClassName }: TabsSkeletonProps) => react_jsx_runtime.JSX.Element;
-
-type TableSkeletonProps$1 = {
-    numTableCols?: number;
-    numTableRows?: number;
-    className?: string;
-    rowHeight?: number;
-    hasBorder?: boolean;
-};
-declare const TableSkeleton: ({ numTableCols, numTableRows, className, rowHeight, hasBorder, }: TableSkeletonProps$1) => react_jsx_runtime.JSX.Element;
-
-type TableSkeletonProps = {
-    numTableRows?: number;
-    className?: string;
-    rowHeight?: number;
-    hasBorder?: boolean;
-};
-declare const TableCheckboxSkeleton: ({ numTableRows, className, rowHeight, hasBorder, }: TableSkeletonProps) => react_jsx_runtime.JSX.Element;
-
 type StepperProps = {
+    /** Ordered step labels; each renders a numbered circle (1-based) with its label. */
     steps: string[];
+    /** Zero-based index of the active step. */
     currentStep: number;
+    /** Class name for the row container. */
     className?: string;
 };
+/**
+ * A horizontal progress indicator for multi-step flows.
+ *
+ * Renders each label in `steps` as a numbered circle; the step at `currentStep` (zero-based) is
+ * highlighted as active.
+ *
+ * @example
+ * <Stepper steps={["Details", "Payment", "Review"]} currentStep={1} />
+ */
 declare const Stepper: ({ steps, currentStep, className }: StepperProps) => react_jsx_runtime.JSX.Element;
 
 type SwitchIdValue = string | undefined;
 declare const useSwitchId: () => SwitchIdValue;
+/**
+ * A toggle switch, built on Radix `Switch`.
+ *
+ * Controlled via `checked` + `onCheckedChange` (or uncontrolled via `defaultChecked`). Render it
+ * with no `children` for a bare control, or pass `children` containing {@link Switch.Control} and
+ * {@link Switch.Label} to get an accessible label wired to the control automatically (a shared `id`
+ * is generated and linked via `htmlFor`).
+ *
+ * @example Bare control
+ * <Switch checked={enabled} onCheckedChange={setEnabled} />
+ *
+ * @example With a linked label
+ * <Switch checked={enabled} onCheckedChange={setEnabled}>
+ *   <Switch.Control />
+ *   <Switch.Label>Enable notifications</Switch.Label>
+ * </Switch>
+ */
 declare const Switch: {
     ({ children, className, ...rest }: Simplify<Omit<RadixSwitch.SwitchProps, "id">>): react_jsx_runtime.JSX.Element;
     Control: (props: Simplify<RadixSwitch.SwitchProps>) => react_jsx_runtime.JSX.Element;
@@ -1246,22 +1838,57 @@ type ConfigClassNames = {
     rowClassName?: string;
     cellClassName?: string;
 };
-declare const headerClassNames: (variant: TableVariant) => ConfigClassNames;
-declare const bodyClassNames: (variant: TableVariant) => ConfigClassNames;
 type TableProps<T> = {
+    /**
+     * A TanStack `react-table` instance. The table reads its data, columns, and behavior
+     * (sorting, resizing, infinite scroll) from this instance's options and `meta`.
+     */
     table: Table$1<T>;
+    /**
+     * Visual treatment of the table chrome (borders, background, spacing).
+     * @default default
+     */
     variant?: TableVariant;
+    /**
+     * Forces the loading state (skeleton rows / dimmed UI). When omitted, the table falls back
+     * to `table.options.meta.isLoading` / `isFetching`.
+     */
     loading?: boolean;
 };
+/**
+ * Renders a TanStack `react-table` instance as a styled table.
+ *
+ * Pass a configured `table` instance and pick a `variant` for the chrome. Loading and fetching
+ * states come from `loading` or, if unset, from the table's `meta`; `default` and `seamless`
+ * variants also support infinite scroll via `meta.infiniteScroll` (a sentinel row fetches the next
+ * page as it scrolls into view).
+ *
+ * @example
+ * const table = useReactTable({ data, columns, getCoreRowModel: getCoreRowModel() });
+ *
+ * <Table table={table} variant="seamless" loading={isLoading} />
+ */
 declare const Table: <T>({ variant, loading: loadingProp, ...props }: TableProps<T>) => react_jsx_runtime.JSX.Element;
 
 type VirtualizedTableProps<T> = {
+    /** The TanStack table instance to render. */
     table: Table$1<T>;
+    /** Visual style of the table. Defaults to `default`. */
     variant?: Extract<TableVariant, "default" | "subtable">;
+    /** Whether to show the loading state. Falls back to the table's `meta.isLoading` when omitted. */
     loading?: boolean;
+    /** Estimated height in pixels of each row, used to size the virtualizer. Defaults to 37. */
     rowHeight?: number;
+    /** Number of rows to render beyond the visible window. Defaults to 5. */
     overscan?: number;
 };
+/**
+ * Table that renders only the rows in (and near) the viewport using row virtualization, so large
+ * datasets stay performant.
+ *
+ * Supports infinite scroll via the table's `meta.infiniteScroll`: the next page is fetched as the
+ * user nears the end, with skeleton rows shown while more pages remain.
+ */
 declare const VirtualizedTable: <T>({ table, variant, loading: loadingProp, rowHeight, overscan, }: VirtualizedTableProps<T>) => react_jsx_runtime.JSX.Element;
 
 type SortOptions = {
@@ -1967,22 +2594,6 @@ type TabsTriggerProps<TabId extends string> = {
 };
 declare const TabsTrigger: <TabId extends string>({ id, label, disabled, fsId, extra, className, isActive, layoutId, }: TabsTriggerProps<TabId>) => react_jsx_runtime.JSX.Element;
 
-type ScrollTab = {
-    tabName: string;
-    content: ReactNode;
-};
-type ScrollTabsProps = {
-    tabs: ScrollTab[];
-    onSelectTab?: (tabId: string) => void;
-    sectionClassName?: string;
-};
-/**
- * Reusable component for creating a page layout with a set of tabs which scroll to different
- * sections of the page. The layout will automatically keep track of scroll position and update
- * the selected tab accordingly.
- */
-declare const ScrollTabsLayout: ({ tabs, onSelectTab, sectionClassName }: ScrollTabsProps) => react_jsx_runtime.JSX.Element;
-
 type ComposableTabDefinition<TabId extends string> = {
     id: TabId;
     label: React.ReactNode;
@@ -2012,22 +2623,62 @@ declare const ComposableTabs: {
 };
 
 type TabGroupProps<TabId extends string> = {
+    /** The selectable tabs; each supplies an `id`, `label`, and optional `disabled`. */
     tabs: TabDefinition<TabId>[];
+    /** `id` of the currently selected tab (controlled). */
     currentTab: TabId;
+    /** Called with the newly selected tab's `id`. */
     setCurrentTab: (id: TabId) => void;
+    /**
+     * Control density.
+     * @default md
+     */
     size?: "sm" | "md";
 };
+/**
+ * A segmented control for switching between a small set of mutually exclusive tabs.
+ *
+ * Controlled single-select: the tab whose `id` matches `currentTab` is active, and `setCurrentTab`
+ * fires on change. An animated pill slides to the active tab. Use this for a compact, bordered
+ * toggle; for full page-level tab panels use the `Tabs` component instead.
+ *
+ * @example
+ * <TabGroup
+ *   tabs={[{ id: "all", label: "All" }, { id: "mine", label: "Mine" }]}
+ *   currentTab={tab}
+ *   setCurrentTab={setTab}
+ * />
+ */
 declare const TabGroup: <TabId extends string>({ tabs, currentTab, setCurrentTab, size, }: TabGroupProps<TabId>) => react_jsx_runtime.JSX.Element;
 
 type TagLabelProps = {
+    /** Tag content. */
     children: React$1.ReactNode;
+    /** When `true`, renders a trailing close button that calls `onRemove`. */
     removable?: boolean;
+    /** Called when the remove button is clicked (only relevant with `removable`). */
     onRemove?: () => void;
+    /**
+     * Color intent of the tag.
+     * @default default
+     */
     intent?: Intent;
 };
 type TagProps = TagLabelProps & {
+    /** Optional tooltip shown on hover; when set, the tag is wrapped in a {@link Tooltip}. */
     tooltip?: string;
 };
+/**
+ * A compact, color-coded chip — e.g. for categories, statuses, or selected filter values.
+ *
+ * Built on {@link Label}, with optional removability (`removable` + `onRemove` render a close
+ * button) and an optional hover `tooltip`. Set `intent` to control the color.
+ *
+ * @example
+ * <Tag intent="primary" removable onRemove={() => remove(id)}>
+ *   In progress
+ * </Tag>
+ */
 declare const Tag: ({ tooltip, ...rest }: TagProps) => react_jsx_runtime.JSX.Element;
 
 type TextTagElementMap = {
@@ -2042,34 +2693,19 @@ type TextTagElementMap = {
     label: HTMLLabelElement;
 };
 type TextTag = keyof TextTagElementMap;
-declare const VARIANT_STYLES: {
-    readonly "marketing-headline": "text-marketing-headline";
-    readonly "headline-1": "text-headline-1";
-    readonly "headline-2": "text-headline-2";
-    readonly "headline-3": "text-headline-3";
-    readonly "headline-4": "text-headline-4";
-    readonly "title-1": "text-title-1";
-    readonly "title-2": "text-title-2";
-    readonly "title-3": "text-title-3";
-    readonly "body-1": "text-body-1";
-    readonly "body-2": "text-body-2";
-    readonly label: "text-label";
-    readonly footnote: "text-footnote";
-    readonly smallcaps: "text-smallcaps uppercase";
-};
-type TextVariant = keyof typeof VARIANT_STYLES;
+type TextVariant = "marketing-headline" | "headline-1" | "headline-2" | "headline-3" | "headline-4" | "title-1" | "title-2" | "title-3" | "body-1" | "body-2" | "label" | "footnote" | "smallcaps";
 /**
  * Props specific to Text component (excluding native HTML props)
  */
 type TextOwnProps<T extends TextTag = "p"> = {
     /**
      * The HTML tag to render
-     * @default "p"
+     * @default p
      */
     as?: T;
     /**
      * Typography variant to apply
-     * @default "body-1"
+     * @default body-1
      */
     variant?: TextVariant;
     /**
@@ -2081,100 +2717,24 @@ type TextOwnProps<T extends TextTag = "p"> = {
  * Full component props combining Text-specific props with native HTML element props
  */
 type TextProps<T extends TextTag = "p"> = TextOwnProps<T> & Omit<JSX.IntrinsicElements[T], keyof TextOwnProps>;
-declare const Text: <T extends TextTag = "p">(props: TextProps<T> & {
-    ref?: React.ForwardedRef<TextTagElementMap[T]>;
-}) => React.ReactElement;
-
-/**
- * @example
- * type FooContextValue = { foo: string };
- * const [FooProvider, useFoo] = createContextHelper<FooContextValue>({ foo: "bar" });
- */
-declare const createContextHelper: <ContextValue extends object | null>(defaultContext?: ContextValue) => readonly [({ children, ...rest }: ContextValue & {
-    children: React$1.ReactNode;
-}) => react_jsx_runtime.JSX.Element, () => ContextValue];
-
-declare const useIntersectionObserver: <T extends Element>(options?: IntersectionObserverInit) => [React.RefCallback<T>, IntersectionObserverEntry | null];
-
-/**
- * I've found managing hover state with onMouseOver and onMouseOut events can be unreliable
- * when moving the mouse quickly over small targets. So this hook uses an event listener to more reliably track
- * mouse movement.
- */
-declare const useIsHovered: (ref: React.RefObject<HTMLElement>) => boolean;
-
-declare const useOverflowObserver: <T extends HTMLElement>() => {
-    elementRef: React$1.RefObject<T>;
-    hasOverflow: boolean;
-};
-
-declare const useSyncState: <T>(upstream: T) => readonly [T, React$1.Dispatch<React$1.SetStateAction<T>>];
-
 /**
- * @example
- * const defaultState = false; // optional as false is the default
- * const [Provider, useToggle] = createToggleContextHelper(defaultState);
+ * Renders text with design-system typography on a semantic HTML element.
+ *
+ * Choose the rendered tag with `as` (defaults to `<p>`) and the typography style with `variant`.
+ * Props are fully typed against the chosen tag, so native attributes (`onClick`, `id`, `htmlFor`,
+ * …) are type-checked and forwarded, and the `ref` points at the corresponding element. `className`
+ * is merged after the variant styles, so it can override them.
  *
- * const {
- * 	state,	// boolean
- * 	update,	// (state: boolean) => void
- * 	toggle	// () => void
- * } = useToggle();
- */
-declare const createToggleContextHelper: (defaultState?: boolean) => readonly [{
-    ({ children, state: initState }: {
-        children: React$1.ReactNode;
-        state?: boolean;
-    }): react_jsx_runtime.JSX.Element;
-    displayName: string;
-}, () => {
-    state: boolean;
-    update: React$1.Dispatch<React$1.SetStateAction<boolean>>;
-    toggle: () => void;
-}];
-/**
- * @example
- * const defaultState = true;
- * const { state, update, toggle } = useIsVisible(defaultState);
- */
-declare const IsVisibleProvider: {
-    ({ children, state: initState }: {
-        children: React$1.ReactNode;
-        state?: boolean;
-    }): react_jsx_runtime.JSX.Element;
-    displayName: string;
-};
-declare const useIsVisible: () => {
-    state: boolean;
-    update: React$1.Dispatch<React$1.SetStateAction<boolean>>;
-    toggle: () => void;
-};
-/**
- * @example
- * const defaultState = false;
- * const { state, update, toggle } = useIsEditing(defaultState);
- */
-declare const IsEditingProvider: {
-    ({ children, state: initState }: {
-        children: React$1.ReactNode;
-        state?: boolean;
-    }): react_jsx_runtime.JSX.Element;
-    displayName: string;
-};
-declare const useIsEditing: () => {
-    state: boolean;
-    update: React$1.Dispatch<React$1.SetStateAction<boolean>>;
-    toggle: () => void;
-};
-/**
  * @example
- * const defaultState = false; // optional as false is the default
- * const { state, update, toggle } = useToggle(defaultState);
+ * <Text>Body copy</Text>
+ *
+ * @example Semantic tag with a typography variant
+ * <Text as="h1" variant="headline-1">
+ *   Page title
+ * </Text>
  */
-declare const useToggle: (initState?: boolean) => {
-    state: boolean;
-    update: React$1.Dispatch<React$1.SetStateAction<boolean>>;
-    toggle: () => void;
-};
+declare const Text: <T extends TextTag = "p">(props: TextProps<T> & {
+    ref?: React.ForwardedRef<TextTagElementMap[T]>;
+}) => React.ReactElement;
 
-export { AlertModal, type AllAsNever, AsyncMultiSelect, type AsyncMultiSelectControlledProps, type AsyncMultiSelectProps, AsyncSelect, type AsyncSelectControlledProps, type AsyncSelectProps, Avatar, AvatarGroup, type AvatarGroupItem, type AvatarGroupProps, type AvatarProps, type AvatarSize, type AvatarVariant, AvatarWithName, type AvatarWithNameProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, type ButtonStyleProps, Callout, type CalloutIntent, type CalloutProps, Card, type CardProps, Checkbox, type CheckboxProps, type ChildrenProps$2 as ChildrenProps, type ClassNameProps, Collapsible, CollapsibleSection, type ComposableTabDefinition, ComposableTabs, type ComposableTabsProps, type ConfigClassNames, ControlledField, ControlledFieldProvider, Copyable, type CustomTableOptions, DEFAULT_NUM_VALUES_TO_SHOW, DatePicker, type DatePickerProps, type DisabledProps, type DiscriminatedVisibilityProps, Divider, type DividerProps, DollarInput, Drawer, DrawerHeader, type DrawerHeaderProps, DrawerHeaderSkeleton, type DrawerState, DrawerStateContext, DropdownChevron, EmptyState, type ErrorProps$1 as ErrorProps, ErrorText, type EventFor, type FalsyValues, FormCheckbox, FormDatePicker, FormDollarInput, type FormDollarInputProps, type FormFieldNameProps, FormInput, FormMultiSelect, FormPercentInput, type FormPercentInputProps, FormRadioButtonGroup, type FormSchema, FormSelect, type FormSelectProps, FormSwitch, FormTextArea, FullscreenModalNamespace as FullscreenModal, HeaderTile, HeaderTileGroup, Icon, IndeterminateCheckbox, Input, InputBox, type InputBoxProps, type InputBoxStyleProps, type InputProps, type Intent, IsEditingProvider, IsVisibleProvider, type Justify, Label, type LabelStyleProps, type LoadProps, LoadingBar, LoadingState, Menu, type MenuProps, MenuRoot, MenuSeparator, Modal, type ModalBodyImplProps$1 as ModalBodyImplProps, MultiSelect, type MultiSelectProps, type NonEmpty, type OnSubmitHandler, OverflowTooltip, PageContainer, PercentInput, type PersistDrawerWidth, PhoneNumber, Popover, type PopoverProps, type PropsWithClassName, RESPONSIVE_PADDING, RadioButtonGroup, type RadioButtonGroupItem, type RadioButtonGroupProps, RadioButtonItem, ScreenHeightPageContainer, ScrollTabsLayout, Select, type SelectItem, SelectListItem, type SelectListItemProps, type SelectProps, type SelectValue, SelectWithUnselect, type SelectWithUnselectProps, type SharedModalProps, type Size, Skeleton, type SkeletonProps, type Soften, Spinner, Stepper, type StepperProps, type StylesProps, Switch, type TabDefinition, TabGroup, Table, TableCheckboxSkeleton, type TableProps, TableSkeleton, type TableVariant, Tabs, type TabsProps, TabsSkeleton, TabsTrigger, type TabsTriggerProps, Tag, Text, TextArea, TextAreaComp, type TextAreaProps, type TextProps, Tooltip, TooltipContent, type TooltipProps, TwoCirclesSpinner, UncontrolledField, UncontrolledFieldProvider, type UncontrolledFormFieldProps, type UseAsyncMultiSelectArgs, type UseAsyncSelectArgs, type UseDrawerResizeParams, type Variant, VirtualizedTable, type VirtualizedTableProps, bodyClassNames, buttonStyles, copyToClipboard, createContextHelper, createToggleContextHelper, doesSelectItemMatch, formatPhoneNumber, formatPhoneNumberForDisplay, getFieldError, getInitials, headerClassNames, inputBoxStyles, inputStyles, isValidPhoneNumber, labelStyles, linkStyles, localStoragePersist, tableVariants, useAsyncMultiSelect, useAsyncSelect, useColumnResizing, useControlledField, useControlledFormField, useCopyable, useDebounce, useDrawer, useDrawerResize, useForm, useIntersectionObserver, useIsEditing, useIsHovered, useIsVisible, useOverflowObserver, useSwitchId, useSyncState, useTable, useToggle, useUncontrolledField, useUncontrolledFormField };
+export { AlertModal, type AlertModalBodyProps, type AlertModalProps, type Align, type AllAsNever, AsyncMultiSelect, type AsyncMultiSelectControlledProps, type AsyncMultiSelectProps, AsyncSelect, type AsyncSelectControlledProps, type AsyncSelectProps, Avatar, AvatarGroup, type AvatarGroupItem, type AvatarGroupProps, type AvatarProps, type AvatarSize, type AvatarVariant, AvatarWithName, type AvatarWithNameProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonIntent, type ButtonProps, type ButtonRoundedness, type ButtonSize, type ButtonStyleProps, Callout, type CalloutIntent, type CalloutProps, Card, type CardProps, Checkbox, type CheckboxProps, type ChildrenProps, type ClassNameProps, Collapsible, type CollapsibleProps, CollapsibleSection, type CollapsibleSectionProps, type CommonSelectProps, type ComposableTabContentProps, type ComposableTabDefinition, ComposableTabs, type ComposableTabsListProps, type ComposableTabsProps, type ConfigClassNames, ControlledField, type ControlledFieldProps, ControlledFieldProvider, type CopyEasyProps, Copyable, type CustomTableOptions, DEFAULT_NUM_VALUES_TO_SHOW, DatePicker, type DatePickerInputProps, type DatePickerProps, type DatePickerRangeProps, type DatePickerSharedProps, type DatePickerSingleProps, type DisabledProps, type DiscriminatedSortOptions, type DiscriminatedVisibilityProps, Divider, type DividerProps, DollarInput, type DollarInputProps, Drawer, DrawerHeader, type DrawerHeaderProps, DrawerHeaderSkeleton, type DrawerProps, type DrawerState, DropdownChevron, EmptyState, type EmptyStateProps, type ErrorOr, type ErrorProps, ErrorText, type EventFor, type FalsyValues, FormCheckbox, type FormCheckboxProps, FormDatePicker, type FormDatePickerProps, FormDollarInput, type FormDollarInputProps, type FormFieldNameProps, FormInput, type FormInputProps, type FormItemVariants, FormMultiSelect, type FormMultiSelectProps, FormPercentInput, type FormPercentInputProps, FormRadioButtonGroup, type FormRadioButtonGroupProps, type FormSchema, FormSelect, type FormSelectProps, FormSwitch, type FormSwitchProps, FormTextArea, type FormTextAreaProps, FullscreenModalNamespace as FullscreenModal, type FullscreenModalHeaderProps, type FullscreenModalProps, type GetEventHandlers, HeaderTile, HeaderTileGroup, type HeaderTileGroupProps, type HeaderTileProps, Icon, type IconProps, type InfoTooltip, Input, type InputBaseProps, InputBox, type InputBoxProps, type InputBoxStyleProps, type InputProps, type InputSize, type InputVariants, type Intent, type ItemOptions, type Justify, Label, type LabelIntent, type LabelStyleProps, type LabelVariant, type LoadProps, type LoaderProps, LoadingBar, type LoadingBarProps, LoadingState, type LoadingStateProps, Menu, type MenuContentProps, type MenuItemProps, type MenuItemWithToolTipProps, type MenuProps, Modal, type ModalBodyImplProps, type ModalContentBaseProps, type ModalContentProps, type ModalProps, MultiSelect, type MultiSelectProps, type NonEmpty, type NotUnselectableProps, type OnSubmitHandler, OverflowTooltip, type OverflowTooltipProps, type OverflowTriggerProps, PageContainer, PercentInput, type PercentInputProps, type PersistDrawerWidth, PhoneNumber, Popover, type PopoverBodyProps, type PopoverProps, type PropsWithClassName, RadioButtonGroup, type RadioButtonGroupItem, type RadioButtonGroupProps, RadioButtonItem, type RadioButtonItemProps, ScreenHeightPageContainer, Select, type SelectItem, SelectListItem, type SelectListItemProps, type SelectProps, type SelectValue, SelectWithUnselect, type SelectWithUnselectProps, type SharedFormControlProps, type SharedFormItemProps, type SharedModalProps, type Side, type Size, Skeleton, type SkeletonProps, type SoftDismissProps, type Soften, type SortOptions, Spinner, Stepper, type StepperProps, type StylesProps, Switch, type SwitchIdValue, type TabContentProps, type TabDefinition, TabGroup, type TabGroupProps, Table, type TableProps, type TableVariant, Tabs, type TabsProps, TabsTrigger, type TabsTriggerProps, Tag, type TagLabelProps, type TagProps, Text, TextArea, type TextAreaProps, type TextOwnProps, type TextProps, type TextTag, type TextTagElementMap, type TextVariant, type ToggleButtonProps, Tooltip, type TooltipContentProps, type TooltipProps, TwoCirclesSpinner, type TwoCirclesSpinnerProps, UncontrolledField, type UncontrolledFieldProps, UncontrolledFieldProvider, type UncontrolledFormFieldProps, type UnselectableProps, type UseAsyncMultiSelectArgs, type UseAsyncSelectArgs, type UseDrawerResizeParams, type UseFormOptions, type Variant, VirtualizedTable, type VirtualizedTableProps, doesSelectItemMatch, drawerSizes, getFieldError, tableVariants, useAsyncMultiSelect, useAsyncSelect, useColumnResizing, useControlledField, useControlledFormField, useCopyable, useDrawer, useDrawerResize, useForm, useSwitchId, useTable, useUncontrolledField, useUncontrolledFormField };