@candidhealth/react-vitals 1.0.0-alpha.1

package/dist/index.d.ts

@@ -0,0 +1,1821 @@
+import * as React$1 from 'react';
+import React__default, { InputHTMLAttributes, PropsWithChildren, ReactNode, TextareaHTMLAttributes, RefObject, ElementType, ComponentPropsWithoutRef } from 'react';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+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, 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, useFormState, useWatch } 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';
+import { Table as Table$1, TableOptions, ColumnSort, Row } from '@tanstack/react-table';
+import { TabsContentProps, TabsProps as TabsProps$1, TabsListProps } from '@radix-ui/react-tabs';
+
+type Size = "xs" | "sm" | "md" | "lg";
+type Intent = "primary" | "default" | "danger" | "warning" | "success";
+type Justify = "start" | "center" | "end" | "between" | "around";
+type Soften = "left" | "right" | "both" | "none";
+type Variant$1 = "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";
+type ButtonStyleProps = {
+    fullWidth?: boolean;
+    size?: ButtonSize;
+    intent?: ButtonIntent;
+    variant?: Variant$1 | "link";
+    disabled?: boolean;
+    loading?: boolean;
+    soften?: Soften;
+    roundedness?: ButtonRoundedness;
+};
+declare const buttonStyles: ({ fullWidth, size, intent, variant, soften, loading, roundedness, }: Omit<ButtonStyleProps, "disabled">) => string;
+
+type ButtonProps = Simplify<ButtonStyleProps & React$1.ComponentPropsWithoutRef<"button">>;
+declare const Button: React$1.ForwardRefExoticComponent<{
+    fullWidth?: boolean | undefined;
+    size?: ("xs" | "sm" | "md" | "lg") | undefined;
+    intent?: ("primary" | "default" | "danger" | "error") | undefined;
+    variant?: (Variant$1 | "link") | undefined;
+    disabled?: boolean | undefined;
+    loading?: boolean | undefined;
+    soften?: Soften | undefined;
+    roundedness?: ("default" | "large") | undefined;
+    form?: string | undefined | undefined;
+    slot?: string | undefined | undefined;
+    style?: React$1.CSSProperties | undefined;
+    title?: string | undefined | undefined;
+    key?: React$1.Key | null | undefined;
+    formAction?: string | undefined;
+    formEncType?: string | undefined | undefined;
+    formMethod?: string | undefined | undefined;
+    formNoValidate?: boolean | undefined | undefined;
+    formTarget?: string | undefined | undefined;
+    name?: string | undefined | undefined;
+    type?: "submit" | "reset" | "button" | undefined | undefined;
+    value?: string | number | readonly string[] | undefined;
+    defaultChecked?: boolean | undefined | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined | undefined;
+    suppressHydrationWarning?: boolean | undefined | undefined;
+    accessKey?: string | undefined | undefined;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+    autoFocus?: boolean | undefined | undefined;
+    className?: string | undefined | undefined;
+    contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+    contextMenu?: string | undefined | undefined;
+    dir?: string | undefined | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+    hidden?: boolean | undefined | undefined;
+    id?: string | undefined | undefined;
+    lang?: string | undefined | undefined;
+    nonce?: string | undefined | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    tabIndex?: number | undefined | undefined;
+    translate?: "yes" | "no" | undefined | undefined;
+    radioGroup?: string | undefined | undefined;
+    role?: React$1.AriaRole | undefined;
+    about?: string | undefined | undefined;
+    content?: string | undefined | undefined;
+    datatype?: string | undefined | undefined;
+    inlist?: any;
+    prefix?: string | undefined | undefined;
+    property?: string | undefined | undefined;
+    rel?: string | undefined | undefined;
+    resource?: string | undefined | undefined;
+    rev?: string | undefined | undefined;
+    typeof?: string | undefined | undefined;
+    vocab?: string | undefined | undefined;
+    autoCorrect?: string | undefined | undefined;
+    autoSave?: string | undefined | undefined;
+    color?: string | undefined | undefined;
+    itemProp?: string | undefined | undefined;
+    itemScope?: boolean | undefined | undefined;
+    itemType?: string | undefined | undefined;
+    itemID?: string | undefined | undefined;
+    itemRef?: string | undefined | undefined;
+    results?: number | undefined | undefined;
+    security?: string | undefined | undefined;
+    unselectable?: "on" | "off" | undefined | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+    is?: string | undefined | undefined;
+    exportparts?: string | undefined | undefined;
+    part?: string | undefined | undefined;
+    "aria-activedescendant"?: string | undefined | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+    "aria-braillelabel"?: string | undefined | undefined;
+    "aria-brailleroledescription"?: string | undefined | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-colcount"?: number | undefined | undefined;
+    "aria-colindex"?: number | undefined | undefined;
+    "aria-colindextext"?: string | undefined | undefined;
+    "aria-colspan"?: number | undefined | undefined;
+    "aria-controls"?: string | undefined | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+    "aria-describedby"?: string | undefined | undefined;
+    "aria-description"?: string | undefined | undefined;
+    "aria-details"?: string | undefined | undefined;
+    "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+    "aria-errormessage"?: string | undefined | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-flowto"?: string | undefined | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+    "aria-keyshortcuts"?: string | undefined | undefined;
+    "aria-label"?: string | undefined | undefined;
+    "aria-labelledby"?: string | undefined | undefined;
+    "aria-level"?: number | undefined | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+    "aria-owns"?: string | undefined | undefined;
+    "aria-placeholder"?: string | undefined | undefined;
+    "aria-posinset"?: number | undefined | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-roledescription"?: string | undefined | undefined;
+    "aria-rowcount"?: number | undefined | undefined;
+    "aria-rowindex"?: number | undefined | undefined;
+    "aria-rowindextext"?: string | undefined | undefined;
+    "aria-rowspan"?: number | undefined | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+    "aria-valuemax"?: number | undefined | undefined;
+    "aria-valuemin"?: number | undefined | undefined;
+    "aria-valuenow"?: number | undefined | undefined;
+    "aria-valuetext"?: string | undefined | undefined;
+    children?: React$1.ReactNode;
+    dangerouslySetInnerHTML?: {
+        __html: string | TrustedHTML;
+    } | undefined | undefined;
+    onCopy?: React$1.ClipboardEventHandler<HTMLButtonElement> | undefined;
+    onCopyCapture?: React$1.ClipboardEventHandler<HTMLButtonElement> | undefined;
+    onCut?: React$1.ClipboardEventHandler<HTMLButtonElement> | undefined;
+    onCutCapture?: React$1.ClipboardEventHandler<HTMLButtonElement> | undefined;
+    onPaste?: React$1.ClipboardEventHandler<HTMLButtonElement> | undefined;
+    onPasteCapture?: React$1.ClipboardEventHandler<HTMLButtonElement> | undefined;
+    onCompositionEnd?: React$1.CompositionEventHandler<HTMLButtonElement> | undefined;
+    onCompositionEndCapture?: React$1.CompositionEventHandler<HTMLButtonElement> | undefined;
+    onCompositionStart?: React$1.CompositionEventHandler<HTMLButtonElement> | undefined;
+    onCompositionStartCapture?: React$1.CompositionEventHandler<HTMLButtonElement> | undefined;
+    onCompositionUpdate?: React$1.CompositionEventHandler<HTMLButtonElement> | undefined;
+    onCompositionUpdateCapture?: React$1.CompositionEventHandler<HTMLButtonElement> | undefined;
+    onFocus?: React$1.FocusEventHandler<HTMLButtonElement> | undefined;
+    onFocusCapture?: React$1.FocusEventHandler<HTMLButtonElement> | undefined;
+    onBlur?: React$1.FocusEventHandler<HTMLButtonElement> | undefined;
+    onBlurCapture?: React$1.FocusEventHandler<HTMLButtonElement> | undefined;
+    onChange?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onChangeCapture?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onBeforeInput?: React$1.InputEventHandler<HTMLButtonElement> | undefined;
+    onBeforeInputCapture?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onInput?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onInputCapture?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onReset?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onResetCapture?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onSubmit?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onSubmitCapture?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onInvalid?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onInvalidCapture?: React$1.FormEventHandler<HTMLButtonElement> | undefined;
+    onLoad?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onLoadCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onError?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onErrorCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onKeyDown?: React$1.KeyboardEventHandler<HTMLButtonElement> | undefined;
+    onKeyDownCapture?: React$1.KeyboardEventHandler<HTMLButtonElement> | undefined;
+    onKeyPress?: React$1.KeyboardEventHandler<HTMLButtonElement> | undefined;
+    onKeyPressCapture?: React$1.KeyboardEventHandler<HTMLButtonElement> | undefined;
+    onKeyUp?: React$1.KeyboardEventHandler<HTMLButtonElement> | undefined;
+    onKeyUpCapture?: React$1.KeyboardEventHandler<HTMLButtonElement> | undefined;
+    onAbort?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onAbortCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onCanPlay?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onCanPlayCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onCanPlayThrough?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onCanPlayThroughCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onDurationChange?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onDurationChangeCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onEmptied?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onEmptiedCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onEncrypted?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onEncryptedCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onEnded?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onEndedCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onLoadedData?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onLoadedDataCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onLoadedMetadata?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onLoadedMetadataCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onLoadStart?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onLoadStartCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onPause?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onPauseCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onPlay?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onPlayCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onPlaying?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onPlayingCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onProgress?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onProgressCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onRateChange?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onRateChangeCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onSeeked?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onSeekedCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onSeeking?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onSeekingCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onStalled?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onStalledCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onSuspend?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onSuspendCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onTimeUpdate?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onTimeUpdateCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onVolumeChange?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onVolumeChangeCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onWaiting?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onWaitingCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onAuxClick?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onAuxClickCapture?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onClick?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onClickCapture?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onContextMenu?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onContextMenuCapture?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onDoubleClick?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onDoubleClickCapture?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onDrag?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragCapture?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragEnd?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragEndCapture?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragEnter?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragEnterCapture?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragExit?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragExitCapture?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragLeave?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragLeaveCapture?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragOver?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragOverCapture?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragStart?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDragStartCapture?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDrop?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onDropCapture?: React$1.DragEventHandler<HTMLButtonElement> | undefined;
+    onMouseDown?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseDownCapture?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseEnter?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseLeave?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseMove?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseMoveCapture?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseOut?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseOutCapture?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseOver?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseOverCapture?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseUp?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onMouseUpCapture?: React$1.MouseEventHandler<HTMLButtonElement> | undefined;
+    onSelect?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onSelectCapture?: React$1.ReactEventHandler<HTMLButtonElement> | undefined;
+    onTouchCancel?: React$1.TouchEventHandler<HTMLButtonElement> | undefined;
+    onTouchCancelCapture?: React$1.TouchEventHandler<HTMLButtonElement> | undefined;
+    onTouchEnd?: React$1.TouchEventHandler<HTMLButtonElement> | undefined;
+    onTouchEndCapture?: React$1.TouchEventHandler<HTMLButtonElement> | undefined;
+    onTouchMove?: React$1.TouchEventHandler<HTMLButtonElement> | undefined;
+    onTouchMoveCapture?: React$1.TouchEventHandler<HTMLButtonElement> | undefined;
+    onTouchStart?: React$1.TouchEventHandler<HTMLButtonElement> | undefined;
+    onTouchStartCapture?: React$1.TouchEventHandler<HTMLButtonElement> | undefined;
+    onPointerDown?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerDownCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerMove?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerMoveCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerUp?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerUpCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerCancel?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerCancelCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerEnter?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerLeave?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerOver?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerOverCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerOut?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onPointerOutCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onGotPointerCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onGotPointerCaptureCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onLostPointerCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onLostPointerCaptureCapture?: React$1.PointerEventHandler<HTMLButtonElement> | undefined;
+    onScroll?: React$1.UIEventHandler<HTMLButtonElement> | undefined;
+    onScrollCapture?: React$1.UIEventHandler<HTMLButtonElement> | undefined;
+    onWheel?: React$1.WheelEventHandler<HTMLButtonElement> | undefined;
+    onWheelCapture?: React$1.WheelEventHandler<HTMLButtonElement> | undefined;
+    onAnimationStart?: React$1.AnimationEventHandler<HTMLButtonElement> | undefined;
+    onAnimationStartCapture?: React$1.AnimationEventHandler<HTMLButtonElement> | undefined;
+    onAnimationEnd?: React$1.AnimationEventHandler<HTMLButtonElement> | undefined;
+    onAnimationEndCapture?: React$1.AnimationEventHandler<HTMLButtonElement> | undefined;
+    onAnimationIteration?: React$1.AnimationEventHandler<HTMLButtonElement> | undefined;
+    onAnimationIterationCapture?: React$1.AnimationEventHandler<HTMLButtonElement> | undefined;
+    onTransitionEnd?: React$1.TransitionEventHandler<HTMLButtonElement> | undefined;
+    onTransitionEndCapture?: React$1.TransitionEventHandler<HTMLButtonElement> | undefined;
+} & React$1.RefAttributes<HTMLButtonElement>>;
+
+type ButtonGroupProps<TValue extends string | number> = {
+    size?: ButtonProps["size"];
+    value: TValue;
+    onChange: (value: TValue) => void;
+    buttons: readonly {
+        content: React.ReactNode;
+        value: TValue;
+    }[];
+};
+declare const ButtonGroup: <TValue extends string | number>({ size, value, onChange, buttons, }: ButtonGroupProps<TValue>) => react_jsx_runtime.JSX.Element;
+
+type CalloutIntent = Extract<Intent, "default" | "warning" | "primary" | "danger">;
+type CalloutProps = {
+    intent?: CalloutIntent;
+    title?: string;
+    rightSlot?: React.ReactNode;
+    children?: React.ReactNode;
+    customIcon?: IconDefinition;
+    isAttachedAtBottom?: boolean;
+    isCentered?: boolean;
+};
+declare const Callout: ({ title, intent, rightSlot, children, customIcon, isAttachedAtBottom, isCentered, }: CalloutProps) => react_jsx_runtime.JSX.Element;
+
+type ErrorProps$1 = {
+    hasError?: boolean;
+    errorNode?: React.ReactNode;
+};
+type CheckboxProps = InputHTMLAttributes<HTMLInputElement> & ErrorProps$1;
+declare const Checkbox: React$1.ForwardRefExoticComponent<InputHTMLAttributes<HTMLInputElement> & ErrorProps$1 & React$1.RefAttributes<HTMLInputElement>>;
+declare const IndeterminateCheckbox: ({ indeterminate, ...rest }: {
+    indeterminate?: boolean;
+} & CheckboxProps) => react_jsx_runtime.JSX.Element;
+
+type CollapsibleProps = {
+    title: React$1.ReactNode;
+    children: React$1.ReactNode;
+    defaultOpen?: boolean;
+    iconPosition?: "left" | "right" | undefined;
+    hideIcon?: boolean;
+    open?: boolean;
+    setOpen?: (open: boolean) => void;
+    triggerClassName?: string;
+};
+declare const Collapsible: ({ title, children, defaultOpen, iconPosition, hideIcon, open: controlledOpen, setOpen: controlledSetOpen, triggerClassName, }: CollapsibleProps) => react_jsx_runtime.JSX.Element;
+
+type ToggleButtonProps = ButtonProps;
+type CollapsibleSectionProps = {
+    children: React$1.ReactNode;
+    defaultOpen?: boolean;
+};
+declare const CollapsibleSection: {
+    ({ children, defaultOpen }: CollapsibleSectionProps): react_jsx_runtime.JSX.Element;
+    ToggleButton: ({ children, ...rest }: ToggleButtonProps) => react_jsx_runtime.JSX.Element;
+    Content: ({ children }: {
+        children: React$1.ReactNode;
+    }) => React$1.ReactNode;
+};
+
+type CopyEasyProps = {
+    children: React$1.ReactNode;
+    value: string | undefined;
+    tooltip?: React$1.ReactNode;
+    onClick?: () => void;
+    asChild?: boolean;
+};
+declare const Copyable: ({ children, value, tooltip, onClick, asChild }: 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>;
+};
+
+type FalsyValues = false | null | undefined | 0;
+type ClassNameProps = {
+    className?: string;
+};
+type ChildrenProps$2 = PropsWithChildren<unknown>;
+type DisabledProps = {
+    disabled?: boolean;
+};
+type StylesProps = {
+    styles?: string | FalsyValues;
+};
+type PropsWithClassName<T> = T & ClassNameProps;
+type ErrorProps = {
+    hasError?: boolean;
+    errorNode?: ReactNode;
+};
+type AllAsNever<T> = {
+    [P in keyof Partial<T>]: T[P] extends object ? AllAsNever<T[P]> : never;
+};
+declare const RING_COLOR_CLASSNAME = "focus:ring-2 focus:ring-indigo-200";
+
+type DatePickerInputProps = InputHTMLAttributes<HTMLInputElement>;
+
+type DatePickerSharedProps = Pick<DatePickerProps$1, "inline" | "autoFocus" | "showTimeInput" | "preventOpenOnFocus" | "minDate" | "maxDate" | "disabled"> & {
+    inputProps?: DatePickerInputProps;
+    placeholder?: string;
+    position?: Placement;
+} & ErrorProps;
+
+type DatePickerRangeProps = DatePickerSharedProps & {
+    value: [Date | undefined, Date | undefined];
+    range: true;
+    onChange?: (newDate: [Date | undefined, Date | undefined]) => void;
+};
+
+type DatePickerSingleProps = DatePickerSharedProps & {
+    value: Date | undefined;
+    range?: false;
+    onChange?: (newDate: Date | undefined) => void;
+};
+
+type DatePickerProps = DatePickerSingleProps | DatePickerRangeProps;
+declare const DatePicker: (props: DatePickerProps) => react_jsx_runtime.JSX.Element;
+
+type DividerProps = ClassNameProps;
+declare const Divider: ({ className }: DividerProps) => react_jsx_runtime.JSX.Element;
+
+/** ErrorText will return `null` if `children` is falsy */
+declare const ErrorText: React__default.ForwardRefExoticComponent<Omit<React__default.DetailedHTMLProps<React__default.HTMLAttributes<HTMLParagraphElement>, HTMLParagraphElement>, "ref"> & {
+    className?: string;
+} & React__default.RefAttributes<HTMLParagraphElement>>;
+
+type FormSchema = z.ZodTypeAny;
+type OnSubmitHandler<T extends FormSchema> = SubmitHandler<z.infer<T>>;
+type GetEventHandlers<T extends keyof JSX.IntrinsicElements> = Extract<keyof JSX.IntrinsicElements[T], `on${string}`>;
+/**
+ * Provides the event type for a given element and handler.
+ *
+ * @example
+ *
+ * type MyEvent = EventFor<"input", "onChange">;
+ */
+type EventFor<TElement extends keyof JSX.IntrinsicElements, THandler extends GetEventHandlers<TElement>> = JSX.IntrinsicElements[TElement][THandler] extends ((e: infer TEvent) => any) | undefined ? TEvent : never;
+
+type UseFormOptions<TSchema extends FormSchema> = Pick<UseFormProps<z.infer<TSchema>>, "defaultValues" | "shouldUnregister" | "values" | "reValidateMode">;
+type FormFieldNameProps = {
+    name: string;
+};
+type UncontrolledFormFieldProps = FormFieldNameProps & {
+    onChange?: (e: EventFor<"input" | "textarea", "onChange">) => void;
+    onBlur?: (e: EventFor<"input" | "textarea", "onBlur">) => void;
+};
+declare const useForm: {
+    <T extends FormSchema>(schema: T, options?: UseFormOptions<T>): {
+        setRootError: (message: string) => void;
+        watch: react_hook_form.UseFormWatch<z.TypeOf<T>>;
+        getValues: react_hook_form.UseFormGetValues<z.TypeOf<T>>;
+        getFieldState: react_hook_form.UseFormGetFieldState<z.TypeOf<T>>;
+        setError: react_hook_form.UseFormSetError<z.TypeOf<T>>;
+        clearErrors: react_hook_form.UseFormClearErrors<z.TypeOf<T>>;
+        setValue: react_hook_form.UseFormSetValue<z.TypeOf<T>>;
+        trigger: react_hook_form.UseFormTrigger<z.TypeOf<T>>;
+        formState: react_hook_form.FormState<z.TypeOf<T>>;
+        resetField: react_hook_form.UseFormResetField<z.TypeOf<T>>;
+        reset: react_hook_form.UseFormReset<z.TypeOf<T>>;
+        handleSubmit: react_hook_form.UseFormHandleSubmit<z.TypeOf<T>, z.TypeOf<T>>;
+        unregister: react_hook_form.UseFormUnregister<z.TypeOf<T>>;
+        control: react_hook_form.Control<z.TypeOf<T>, any, z.TypeOf<T>>;
+        register: react_hook_form.UseFormRegister<z.TypeOf<T>>;
+        setFocus: react_hook_form.UseFormSetFocus<z.TypeOf<T>>;
+        subscribe: react_hook_form.UseFormSubscribe<z.TypeOf<T>>;
+    };
+    displayName: string;
+};
+declare const useFormContext: {
+    <T extends FieldValues>(): {
+        setRootError: (message: string) => void;
+        watch: react_hook_form.UseFormWatch<T>;
+        getValues: react_hook_form.UseFormGetValues<T>;
+        getFieldState: react_hook_form.UseFormGetFieldState<T>;
+        setError: react_hook_form.UseFormSetError<T>;
+        clearErrors: react_hook_form.UseFormClearErrors<T>;
+        setValue: react_hook_form.UseFormSetValue<T>;
+        trigger: react_hook_form.UseFormTrigger<T>;
+        formState: react_hook_form.FormState<T>;
+        resetField: react_hook_form.UseFormResetField<T>;
+        reset: react_hook_form.UseFormReset<T>;
+        handleSubmit: react_hook_form.UseFormHandleSubmit<T, T>;
+        unregister: react_hook_form.UseFormUnregister<T>;
+        control: react_hook_form.Control<T, any, T>;
+        register: react_hook_form.UseFormRegister<T>;
+        setFocus: react_hook_form.UseFormSetFocus<T>;
+        subscribe: react_hook_form.UseFormSubscribe<T>;
+    };
+    displayName: string;
+};
+declare const useControlledFormField: {
+    ({ name: fieldName }: FormFieldNameProps): {
+        error: react_hook_form.FieldError | undefined;
+        onChange: (...event: any[]) => void;
+        onBlur: react_hook_form.Noop;
+        value: any;
+        disabled?: boolean;
+        name: string;
+        ref: react_hook_form.RefCallBack;
+    };
+    displayName: string;
+};
+declare const useUncontrolledFormField: {
+    ({ name: fieldName, ...changeHandlers }: UncontrolledFormFieldProps): {
+        register: () => {
+            onChange: ((event: EventFor<"input" | "textarea", "onChange">) => Promise<void>) | react_hook_form.ChangeHandler;
+            onBlur: react_hook_form.ChangeHandler | ((event: EventFor<"input" | "textarea", "onBlur">) => Promise<void>);
+            ref: react_hook_form.RefCallBack;
+            name: string;
+            min?: string | number;
+            max?: string | number;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string;
+            required?: boolean;
+            disabled?: boolean;
+        };
+        error: react_hook_form.FieldError | undefined;
+    };
+    displayName: string;
+};
+
+declare const ControlledFieldProvider: {
+    ({ children, ...restField }: FormFieldNameProps & PropsWithChildren): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const useControlledField: {
+    (): {
+        error: react_hook_form.FieldError | undefined;
+        onChange: (...event: any[]) => void;
+        onBlur: react_hook_form.Noop;
+        value: any;
+        disabled?: boolean;
+        name: string;
+        ref: react_hook_form.RefCallBack;
+    };
+    displayName: string;
+};
+type ControlledFieldProps = FormFieldNameProps & {
+    render: (props: ReturnType<typeof useControlledFormField>) => React.ReactNode;
+};
+declare const ControlledField: {
+    ({ render, ...restField }: ControlledFieldProps): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+
+declare const UncontrolledFieldProvider: {
+    ({ children, ...restField }: UncontrolledFormFieldProps & PropsWithChildren): react_jsx_runtime.JSX.Element;
+    displayName: string;
+};
+declare const useUncontrolledField: {
+    (): {
+        register: () => {
+            onChange: ((event: EventFor<"input" | "textarea", "onChange">) => Promise<void>) | react_hook_form.ChangeHandler;
+            onBlur: react_hook_form.ChangeHandler | ((event: EventFor<"input" | "textarea", "onBlur">) => Promise<void>);
+            ref: react_hook_form.RefCallBack;
+            name: string;
+            min?: string | number;
+            max?: string | number;
+            maxLength?: number;
+            minLength?: number;
+            pattern?: string;
+            required?: boolean;
+            disabled?: boolean;
+        };
+        error: react_hook_form.FieldError | undefined;
+    };
+    displayName: string;
+};
+type UncontrolledFieldProps = UncontrolledFormFieldProps & {
+    render: (props: ReturnType<typeof useUncontrolledFormField>) => React.ReactNode;
+};
+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;
+};
+declare const inputBoxStyles: ({ size, variant, hasError, hasWarning }: InputBoxStyleProps) => string;
+declare const inputStyles = "w-full text-gray-800 placeholder:text-gray-400 disabled:text-gray-400";
+
+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;
+    tooltipLabel?: string;
+    tooltipIcon?: React.ReactNode;
+} | {
+    tooltip?: never;
+    tooltipLabel?: never;
+    tooltipIcon?: never;
+};
+type ItemOptions = InfoTooltip & {
+    optionalLabel?: boolean;
+    description?: React.ReactNode;
+    inlineLabelEndSlot?: React.ReactNode;
+    bottomSlot?: React.ReactNode;
+};
+type SharedFormItemProps = {
+    label?: React.ReactNode;
+    options?: ItemOptions;
+};
+
+type SharedFormControlProps = StylesProps & {
+    name: string;
+    layout?: FormItemVariants;
+    disabled?: boolean;
+};
+type CommonSelectProps = "items" | "hideSearch" | "triggerPlaceholder" | "onChange" | "disabled";
+
+type FormInputProps = SharedFormControlProps & SharedFormItemProps & Pick<UncontrolledFormFieldProps, "onChange" | "onBlur"> & Pick<InputProps, "placeholder" | "variant" | "prefix" | "type" | "step" | "autoFocus" | "min" | "max">;
+declare const FormInput: ({ name, styles, layout, label, options, onChange, onBlur, disabled, ...rest }: FormInputProps) => react_jsx_runtime.JSX.Element;
+
+type DollarInputProps = {
+    value: number | null | undefined;
+    onChange?: (cents: number | null | undefined) => void;
+    disabled?: boolean;
+    hasError?: boolean;
+    hasWarning?: boolean;
+    message?: string;
+};
+/**
+ * DollarInput component for displaying and editing a monetary value.
+ *
+ * Exposes `cents` to consuming components, which is the value in cents.
+ */
+declare const DollarInput: React$1.ForwardRefExoticComponent<DollarInputProps & React$1.RefAttributes<HTMLInputElement>>;
+declare const FormDollarInput: React$1.ForwardRefExoticComponent<StylesProps & {
+    name: string;
+    layout?: FormItemVariants;
+    disabled?: boolean;
+} & SharedFormItemProps & {
+    onChange?: (cents: number | null | undefined) => void;
+} & Pick<DollarInputProps, "message" | "hasWarning"> & React$1.RefAttributes<HTMLInputElement>>;
+
+type PercentInputProps = {
+    value: number | null | undefined;
+    onChange?: (percent: number | null | undefined) => void;
+    disabled?: boolean;
+    hasError?: boolean;
+    hasWarning?: boolean;
+    message?: string;
+};
+/**
+ * PercentInput component for displaying and editing a percentage value.
+ *
+ * Exposes `percent` to consuming components, which is the value as a number (0-100).
+ */
+declare const PercentInput: React$1.ForwardRefExoticComponent<PercentInputProps & React$1.RefAttributes<HTMLInputElement>>;
+declare const FormPercentInput: React$1.ForwardRefExoticComponent<StylesProps & {
+    name: string;
+    layout?: FormItemVariants;
+    disabled?: boolean;
+} & SharedFormItemProps & {
+    onChange?: (percent: number | null | undefined) => void;
+} & Pick<PercentInputProps, "message" | "hasWarning"> & React$1.RefAttributes<HTMLInputElement>>;
+
+type FormCheckboxProps = Pick<SharedFormControlProps, "name" | "disabled"> & {
+    children?: React.ReactNode;
+    onChange?: (checked: boolean) => void;
+};
+declare const FormCheckbox: {
+    ({ name, disabled, onChange: propsOnChange, children }: FormCheckboxProps): react_jsx_runtime.JSX.Element;
+    Label: typeof LabelImpl;
+    Checkbox: typeof CheckboxImpl;
+};
+declare function CheckboxImpl({ onChange: propsOnChange }: {
+    onChange?: (checked: boolean) => void;
+}): react_jsx_runtime.JSX.Element;
+declare function LabelImpl({ children, className }: {
+    children: React.ReactNode;
+    className?: string;
+}): react_jsx_runtime.JSX.Element;
+
+type SelectValue = string | number;
+/**
+ * An item in a Select component. This could represent an available option, or a selected value.
+ */
+type SelectItem<TValue extends SelectValue = string> = {
+    /**
+     * The value of the option. Must be unique and extend either string or number.
+     */
+    value: TValue;
+    /**
+     * Label to show in the select dropdown and trigger.
+     */
+    label: string;
+    /**
+     * Optional unique key for React rendering. Use when value may not be unique.
+     * Falls back to value if not provided.
+     */
+    reactKey?: string;
+    /**
+     * Optional React node to show in the select dropdown, but not in the trigger.
+     */
+    display?: React.ReactNode;
+    icon?: React.ReactNode;
+    disabled?: boolean;
+    /**
+     * Predicate to determine if the option matches a query.
+     * Default is to match if the lowercase label contains the lowercase query.
+     * @param query search query
+     * @returns whether the option matches the query
+     */
+    isMatch?: (query: string) => boolean;
+};
+/**
+ * Returns true if the option matches the query.
+ * @param option
+ * @param query
+ * @returns
+ */
+declare function doesSelectItemMatch<T extends SelectValue>(option: SelectItem<T>, query: string | undefined): boolean;
+
+declare const DEFAULT_NUM_VALUES_TO_SHOW = 2;
+/**
+ * Props to control the loading and error states of an AsyncSelect component.
+ */
+type LoadProps = {
+    isLoading: boolean;
+    isError: boolean;
+    canLoadMore: boolean;
+    onLoadMore: () => void;
+};
+/**
+ * Props for the AsyncMultiSelect component, the most unopinionated of the Select components and the base
+ * of all the others.
+ */
+type AsyncMultiSelectProps<T extends SelectValue> = {
+    value?: T[];
+    onChange?: (value: T[]) => void;
+    disabled?: boolean;
+    triggerPlaceholder?: string;
+    variant?: "default" | "simple";
+    /**
+     * Number of selected values to show by default. If more than this number are selected, the select will
+     * render a button to expand the list. Defaults to {@link DEFAULT_NUM_VALUES_TO_SHOW}.
+     */
+    numValuesToShow?: number;
+    /**
+     * If true, this select will strictly enforce ordering of the items. Items added first will
+     * be displayed first, and the user can reorder items by dragging them. Defaults to false.
+     */
+    ordered?: boolean;
+    /**
+     * Hide the search field. Defaults to false. Recommended only for Selects with a small number of items.
+     */
+    hideSearch?: boolean;
+    searchPlaceholder?: string;
+    /**
+     * Callback when the user types in the input field.
+     */
+    onSearchChange?: (query: string) => void;
+    /**
+     * All items that the Select knows about, for both selected and unselected values.
+     *
+     * This list should eventually include items for ALL values that are selected,
+     * including custom values. *The component will render a loading state until then.*
+     *
+     * This list may not necessarily include all available items, e.g., if the user
+     * is searching or if the list is paginated.
+     */
+    items: SelectItem<T>[];
+    /**
+     * Optional props to control the loading and error states of the AsyncMultiSelect, which can add item(s)
+     * to the bottom of the dropdown that convey and control this state.
+     */
+    loadProps?: LoadProps;
+    /**
+     * Min number of items that must be selected. Defaults to 0. If 1, the user cannot
+     * unselect the last item.
+     */
+    minSelection?: 0 | 1;
+    /**
+     * Max number of items that can be selected. Defaults to unlimited.
+     */
+    maxSelection?: number | "unlimited";
+    /**
+     * If true, the user can enter custom values. Defaults to false.
+     * Can only be true if T is string.
+     */
+    allowCustomValues?: T extends string ? boolean : false;
+    isValidCustomValue?: (value: string) => boolean;
+    /**
+     * What to do when "Select all" is clicked (only shown if there are no items selected).
+     * If not provided, no "Select all" button will be shown.
+     */
+    onSelectAll?: () => void;
+    hasError?: boolean;
+    popover?: {
+        customTrigger?: React.ReactNode;
+        contentClassName?: string;
+        triggerClassName?: string;
+        container?: Element;
+    };
+    emptyState?: React.ReactNode;
+    size?: "sm" | "md" | "lg";
+    onOpen?: () => void;
+    onClose?: () => void;
+};
+/**
+ * Props for the AsyncSelect component, which is a wrapper around AsyncMultiSelect that only allows
+ * a single item to be selected.
+ */
+type UnselectableProps<T extends SelectValue> = {
+    value?: T;
+    onChange?: (value: T | undefined) => void;
+    allowUnselect: boolean;
+};
+type NotUnselectableProps<T extends SelectValue> = {
+    value?: T;
+    onChange?: (value: T) => void;
+    allowUnselect?: false;
+};
+type AsyncSelectProps<T extends SelectValue> = Simplify<(UnselectableProps<T> | NotUnselectableProps<T>) & Omit<AsyncMultiSelectProps<T>, "value" | "onChange" | "minSelection" | "maxSelection" | "onSelectAll">>;
+/**
+ * Props for the MultiSelect component, which is a wrapper around AsyncMultiSelect that does not
+ * require async loading (and assumes that all options are always available).
+ */
+type MultiSelectProps<T extends SelectValue> = {
+    /**
+     * A function for creating a select option given a custom value. This is used to render
+     * the selected items both in the trigger and in the dropdown.
+     */
+    customValueToOption?: string extends T ? (value: string) => SelectItem<T> : never;
+} & Omit<AsyncMultiSelectProps<T>, "debounceMs">;
+/**
+ * Props for the Select component, which is a wrapper around MultiSelect that only allows
+ * a single item to be selected.
+ */
+type SelectProps<T extends SelectValue> = (UnselectableProps<T> | NotUnselectableProps<T>) & Omit<MultiSelectProps<T>, "value" | "onChange" | "minSelection" | "maxSelection" | "onSelectAll">;
+type SelectWithUnselectProps<T extends SelectValue> = Omit<UnselectableProps<T>, "allowUnselect"> & Omit<MultiSelectProps<T>, "value" | "onChange" | "minSelection" | "maxSelection" | "onSelectAll">;
+/**
+ * Helper type for async single-select components with enriched object callback.
+ * Makes it easy to define custom select component props.
+ */
+type AsyncSelectControlledProps<TValue extends SelectValue, TObj> = {
+    value: TValue | undefined;
+    onChange: (value: TValue | undefined, obj: TObj | undefined) => void;
+};
+/**
+ * Helper type for async multi-select components with enriched object callback.
+ * Makes it easy to define custom multi-select component props.
+ */
+type AsyncMultiSelectControlledProps<TValue extends SelectValue, TObj> = {
+    value: TValue[];
+    onChange: (value: TValue[] | undefined, objs: TObj[]) => void;
+};
+
+declare function useDebounce<T>(value: T, delay: number): T;
+type ErrorOr<T> = {
+    error: true;
+} | {
+    error: false;
+    value: T;
+};
+type UseAsyncMultiSelectArgs<TValue extends SelectValue, TObj, TPage> = {
+    value: TValue[];
+    /**
+     * Fetch objects associated with the selected values.
+     *
+     * If the select allows custom values, then some values may not resolve to a
+     * corresponding object (determined by objToItem). In this case, these values
+     * will be converted to items using customValueToItem.
+     * @param values current selected items
+     * @returns list of objects corresponding to the selected values
+     */
+    fetchValues: (values: TValue[]) => Promise<ErrorOr<TObj[]>>;
+    /**
+     * Fetch objects matching a search term and page token. This is used to render
+     * available options in the dropdown.
+     * @param query query the user has searched
+     * @param page page token
+     * @returns the results and the next page token, if any
+     */
+    fetchOptions: (query: string, page: TPage | undefined) => Promise<ErrorOr<{
+        results: TObj[];
+        nextPage?: TPage;
+    }>>;
+    /**
+     * Convert an object returned from a query to a select item.
+     * @param obj
+     * @returns
+     */
+    objToItem: (obj: TObj) => SelectItem<TValue>;
+    /**
+     * Convert a custom value to a select item. *Only provide this if the select
+     * accepts custom values.*
+     *
+     * If this is not provided, the select will render a loading state until all
+     * values have been resolved to objects by fetchValues.
+     *
+     * TODO: how to handle cases where custom values are disallowed, but a value
+     * previously entered by the user is no longer present on the backend?
+     * @param value
+     * @returns
+     */
+    customValueToItem?: (value: TValue) => SelectItem<TValue>;
+    queryKeyPrefix: string | string[] | readonly string[];
+};
+/**
+ * Utility hook for fetching data and getting props for AsyncMultiSelect.
+ */
+declare function useAsyncMultiSelect<TValue extends SelectValue, TObj, TPage>({ value, fetchValues, fetchOptions, objToItem, customValueToItem, queryKeyPrefix, }: UseAsyncMultiSelectArgs<TValue, TObj, TPage>): {
+    setQuery: React$1.Dispatch<React$1.SetStateAction<string>>;
+    selectItems: SelectItem<TValue>[];
+    loadProps: LoadProps;
+    queriedObjects: TObj[];
+};
+type UseAsyncSelectArgs<TValue extends SelectValue, TObj, TPage> = {
+    value: TValue | undefined;
+    fetchValue: (value: TValue) => Promise<ErrorOr<TObj | undefined>>;
+} & Omit<UseAsyncMultiSelectArgs<TValue, TObj, TPage>, "value" | "fetchValues">;
+/**
+ * Utility hook for fetching data and getting props for AsyncSelect.
+ */
+declare const useAsyncSelect: <TValue extends SelectValue, TObj, TPage>({ value, fetchValue, ...rest }: UseAsyncSelectArgs<TValue, TObj, TPage>) => {
+    setQuery: React$1.Dispatch<React$1.SetStateAction<string>>;
+    selectItems: SelectItem<TValue>[];
+    loadProps: LoadProps;
+    queriedObjects: TObj[];
+};
+
+/**
+ * The most unopinionated of the family of Select components, the base for all the others.
+ * Supports asynchronous loading (and does not assume that all available options are provided
+ * in the `options` prop).
+ */
+declare const AsyncMultiSelect: <TValue extends string | number>({ value, onChange, disabled, ordered, variant, triggerPlaceholder, hideSearch, searchPlaceholder, items, loadProps, onSearchChange, minSelection, maxSelection, allowCustomValues, hasError, popover, isValidCustomValue, onSelectAll, numValuesToShow, emptyState, size, onOpen, onClose, }: AsyncMultiSelectProps<TValue>) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Thin wrapper around AsyncMultiSelect that only allows a single value to be selected.
+ */
+declare const AsyncSelect: <T extends string | number>({ value, onChange, allowUnselect, ...rest }: AsyncSelectProps<T>) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Thin wrapper around AsyncMultiSelect that does not support asynchronous loading, and
+ * assumes all available options are provided in the `options` prop.
+ */
+declare const MultiSelect: <T extends string | number>({ value, items: options, onSearchChange, customValueToOption, ...rest }: MultiSelectProps<T>) => react_jsx_runtime.JSX.Element;
+
+/**
+ * Thin wrapper around MultiSelect that only allows a single value to be selected.
+ */
+declare function Select<T extends string | number>({ value, onChange, allowUnselect, ...rest }: SelectProps<T>): react_jsx_runtime.JSX.Element;
+
+/**
+ * Thin wrapper around MultiSelect that only allows a single value to be selected.
+ */
+declare function SelectWithUnselect<T extends string | number>({ value, onChange, ...rest }: SelectWithUnselectProps<T>): react_jsx_runtime.JSX.Element;
+
+type SelectListItemProps = {
+    sortableId?: string | number;
+    children?: React.ReactNode;
+    onClick?: () => void;
+    disabled?: boolean;
+    focused?: boolean;
+};
+/**
+ * An item rendered in a Select dropdown. Does not necessarily correspond to an option.
+ * @param param0
+ * @returns
+ */
+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">;
+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">;
+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>;
+declare const TextAreaComp: React$1.ForwardRefExoticComponent<TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    hasError?: boolean | undefined;
+    errorNode?: React$1.ReactNode;
+} & React$1.RefAttributes<HTMLTextAreaElement>>;
+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?: number;
+};
+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;
+};
+declare const FormSwitch: ({ name, styles, layout, label, options, onChange, ...props }: FormSwitchProps) => react_jsx_runtime.JSX.Element;
+
+type RadioButtonGroupItem = {
+    value: string;
+    displayValue: string;
+    description?: string | React.ReactNode;
+    expandedContents?: (isDisabled: boolean) => React.ReactNode;
+    expandedContentsStyle?: "inline" | "block";
+    disabled?: boolean;
+};
+type RadioButtonItemProps = RadioButtonGroupItem & {
+    isChecked: boolean;
+    onSelect?: (value: string) => void;
+    asCard?: boolean;
+};
+declare const RadioButtonItem: ({ value, displayValue, description, expandedContents, expandedContentsStyle, disabled, isChecked, onSelect, asCard, }: RadioButtonItemProps) => react_jsx_runtime.JSX.Element;
+
+type RadioButtonGroupProps = PropsWithClassName<{
+    items: RadioButtonGroupItem[];
+    value?: string | undefined;
+    onChange?: (newValue: string) => void;
+    asCards?: boolean;
+}>;
+declare const RadioButtonGroup: ({ className, items, onChange, value, asCards }: RadioButtonGroupProps) => react_jsx_runtime.JSX.Element;
+
+type FormRadioButtonGroupProps = Simplify<Pick<SharedFormControlProps, "name"> & Pick<RadioButtonGroupProps, "items" | "onChange" | "className" | "asCards">>;
+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"> & {
+    containerRef?: React.RefObject<HTMLDivElement>;
+};
+declare const FormDatePicker: ({ name, styles, layout, label, onChange, options, containerRef, disabled, ...rest }: FormDatePickerProps) => react_jsx_runtime.JSX.Element;
+
+/** This regex will match currency values like `123`, `-123`, `1,234`, `12,345.67`, `.12`, etc.
+ */
+declare const CURRENCY_REGEX: RegExp;
+declare const dollarsStrSchema: z.ZodString;
+declare const requiredDollarsStrSchema: z.ZodString;
+declare const requiredDollarsStrSchemaWithCustomMessage: (requiredError: string, invalidTypeError: string) => z.ZodString;
+declare const requiredNonZeroDollarsStrSchema: z.ZodEffects<z.ZodString, string, string>;
+declare const requiredPositiveDollarsStrSchema: z.ZodEffects<z.ZodString, string, string>;
+declare const requiredPositiveOrZeroDollarsStrSchema: z.ZodEffects<z.ZodString, string, string>;
+
+declare const npiSchema: z.ZodString;
+declare const npiSchemaOptional: z.ZodUnion<[z.ZodEffects<z.ZodLiteral<null>, undefined, null>, z.ZodEffects<z.ZodLiteral<"">, undefined, "">, z.ZodPipeline<z.ZodEffects<z.ZodString, string | undefined, string>, z.ZodUndefined>, z.ZodOptional<z.ZodString>]>;
+declare const taxonomyCodeSchema: z.ZodString;
+declare const taxIdSchema: z.ZodString;
+
+/** Handles empty values (`""`, `null`) and marks schema as `.optional()`. */
+declare const asOptional: <T extends z.ZodTypeAny>(schema: T) => z.ZodUnion<[z.ZodEffects<z.ZodLiteral<null>, undefined, null>, z.ZodEffects<z.ZodLiteral<"">, undefined, "">, z.ZodPipeline<z.ZodEffects<z.ZodString, string | undefined, string>, z.ZodUndefined>, z.ZodOptional<T>]>;
+/** Handles empty values (`""`, `null`) and marks schema as `.nullish()`. */
+declare const asNullish: <T extends z.ZodTypeAny>(schema: T) => z.ZodUnion<[z.ZodEffects<z.ZodLiteral<null>, undefined, null>, z.ZodEffects<z.ZodLiteral<"">, undefined, "">, z.ZodPipeline<z.ZodEffects<z.ZodString, string | undefined, string>, z.ZodUndefined>, z.ZodOptional<z.ZodNullable<T>>]>;
+/** Adds validation on string to ensure only numbers are allowed. */
+declare const asNumericStr: <T extends z.ZodString>(schema: T, message?: string) => z.ZodString;
+declare const asRequiredCustom: <T>(message?: string) => z.ZodType<T, z.ZodTypeDef, T>;
+
+declare const selectedAmountSchema: z.ZodObject<{
+    selected: z.ZodUnion<[z.ZodEffects<z.ZodLiteral<null>, undefined, null>, z.ZodEffects<z.ZodLiteral<"">, undefined, "">, z.ZodPipeline<z.ZodEffects<z.ZodString, string | undefined, string>, z.ZodUndefined>, z.ZodOptional<z.ZodBoolean>]>;
+    amountStr: z.ZodUnion<[z.ZodEffects<z.ZodLiteral<null>, undefined, null>, z.ZodEffects<z.ZodLiteral<"">, undefined, "">, z.ZodPipeline<z.ZodEffects<z.ZodString, string | undefined, string>, z.ZodUndefined>, z.ZodOptional<z.ZodString>]>;
+}, "strip", z.ZodTypeAny, {
+    selected?: boolean | undefined;
+    amountStr?: string | undefined;
+}, {
+    selected?: string | boolean | null | undefined;
+    amountStr?: string | null | undefined;
+}>;
+type SelectedAmountSchema = z.infer<typeof selectedAmountSchema>;
+
+declare const buildZodIssue: (path: string | string[], message: string) => {
+    path: string[];
+    message: string;
+    code: "custom";
+};
+
+type UseDrawerResizeParams = {
+    slider: RefObject<HTMLDivElement>;
+    drawer: RefObject<HTMLDivElement>;
+    isOpen: boolean;
+    defaultSizePct: number;
+    persistWidth?: PersistDrawerWidth;
+};
+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: {
+    sm: number;
+    md: number;
+    lg: number;
+};
+type DrawerProps = {
+    isOpen: boolean;
+    onClose?: () => void;
+    onClickOutside?: () => void;
+    blurredOverlay?: boolean;
+    width?: keyof typeof drawerSizes;
+    persistWidth?: PersistDrawerWidth;
+    children: React.ReactNode;
+};
+declare const Drawer: React$1.ForwardRefExoticComponent<DrawerProps & React$1.RefAttributes<HTMLDivElement>>;
+
+type DrawerHeaderProps = {
+    resource?: {
+        icon?: IconDefinition;
+        name: string;
+    };
+    pagination?: {
+        hasNext: boolean;
+        hasPrevious: boolean;
+        onNext: () => void;
+        onPrevious: () => void;
+        extra?: React.ReactNode;
+    };
+    title: React.ReactNode;
+    subtitle?: React.ReactNode;
+    actions?: React.ReactNode;
+    label?: React.ReactNode;
+    closeAction?: React.ReactNode;
+};
+declare const DrawerHeader: ({ resource, pagination, title, subtitle, actions, closeAction, label, }: DrawerHeaderProps) => react_jsx_runtime.JSX.Element;
+declare const DrawerHeaderSkeleton: () => react_jsx_runtime.JSX.Element;
+
+type DrawerState = {
+    isOpen: boolean;
+    onClose: () => void;
+};
+declare const DrawerStateContext: React$1.Context<DrawerState>;
+declare const useDrawer: () => DrawerState;
+
+declare const DropdownChevron: () => react_jsx_runtime.JSX.Element;
+
+type EmptyStateProps = {
+    icon?: IconDefinition;
+    title: React.ReactNode;
+    description?: React.ReactNode;
+};
+declare const EmptyState: React$1.ForwardRefExoticComponent<EmptyStateProps & React$1.RefAttributes<HTMLDivElement>>;
+
+declare const HeaderTile: (props: {
+    title: string;
+    content: ReactNode;
+    popover?: ReactNode;
+    className?: string;
+}) => react_jsx_runtime.JSX.Element;
+
+type IconProps = {
+    icon: IconDefinition;
+};
+declare const Icon: ({ icon }: IconProps) => react_jsx_runtime.JSX.Element;
+
+type LabelIntent = Intent | "disabled";
+type LabelVariant = "default" | "dark";
+type LabelStyleProps = {
+    variant?: LabelVariant;
+    intent?: LabelIntent;
+    size?: Size;
+};
+declare const labelStyles: ({ intent, size, variant }: LabelStyleProps) => string;
+
+declare const Label: React$1.ForwardRefExoticComponent<{
+    children: React$1.ReactNode;
+} & LabelStyleProps & React$1.RefAttributes<HTMLSpanElement>>;
+
+type LoaderProps = {
+    className?: string;
+    size?: SizeProp;
+};
+declare const Spinner: ({ className, ...props }: LoaderProps) => react_jsx_runtime.JSX.Element;
+
+declare const LoadingState: ({ size }: {
+    size?: SizeProp;
+}) => react_jsx_runtime.JSX.Element;
+
+type LoadingBarProps = {
+    className?: string;
+};
+declare const LoadingBar: ({ className }: LoadingBarProps) => react_jsx_runtime.JSX.Element;
+
+type MenuContentProps = DropdownMenuContentProps & {
+    unrestrictedHeight?: boolean;
+};
+type MenuItemProps = Pick<DropdownMenuItemProps, "asChild" | "children" | "disabled" | "textValue" | "onSelect"> & {
+    loading?: boolean;
+    size?: "default" | "lg";
+};
+type MenuItemWithToolTipProps = MenuItemProps & {
+    /**
+     * tooltip Content
+     */
+    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"];
+    variant?: "default" | "minimal";
+} & Pick<ButtonProps, "disabled">;
+/**
+ * @example
+ * <Menu trigger="Actions">
+ * 	<Menu.Item>Transform object...</Menu.Item>
+ * 	<Menu.Item>Edit</Menu.Item>
+ * </Menu>
+ * // use default trigger!
+ * <Menu>
+ * 	<Menu.Item onSelect={() => ...}>Transform object...</Menu.Item>
+ * 	<Menu.Item>Edit</Menu.Item>
+ * </Menu>
+ */
+declare const Menu: {
+    ({ children, trigger, align, variant, triggerSize, ...rest }: MenuProps): react_jsx_runtime.JSX.Element;
+    Root: (props: DropdownMenuProps) => react_jsx_runtime.JSX.Element;
+    Trigger: ({ children, ...rest }: ButtonProps) => react_jsx_runtime.JSX.Element;
+    RawTrigger: React$1.ForwardRefExoticComponent<_radix_ui_react_dropdown_menu.DropdownMenuTriggerProps & React$1.RefAttributes<HTMLButtonElement>>;
+    Content: ({ children, unrestrictedHeight, ...props }: MenuContentProps) => react_jsx_runtime.JSX.Element;
+    Item: ({ loading, disabled, size, ...rest }: MenuItemProps) => react_jsx_runtime.JSX.Element;
+    ItemWithDisabledToolTip: ({ tooltip, onSelect, ...props }: MenuItemWithToolTipProps) => react_jsx_runtime.JSX.Element;
+    Separator: () => react_jsx_runtime.JSX.Element;
+};
+
+type ModalContentBaseProps = Pick<DialogContentProps, "children" | "onOpenAutoFocus" | "onCloseAutoFocus">;
+type SoftDismissProps = {
+    dismissible?: never;
+    onDismiss?: (e: Event) => void;
+} | {
+    dismissible?: boolean;
+    onDismiss?: never;
+};
+type ModalContentProps = SoftDismissProps & {
+    maxWidthClassName?: `max-w-${string}`;
+    overflowYClassName?: `overflow-y-${string}`;
+};
+
+type ChildrenProps$1 = {
+    children?: React$1.ReactNode;
+};
+type ModalBodyImplProps$1 = {
+    title?: React$1.ReactNode;
+    error?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    actions?: React$1.ReactNode;
+    showX?: boolean;
+};
+type SharedModalProps = React$1.PropsWithChildren & {
+    isOpen?: boolean;
+    onClose?: () => void;
+};
+/**
+ * If using `trigger`, the modal will control its own visibility state though you can observe changes with onOpenChange
+ * Otherwise, pass `isOpen` and `onClose` to control modal state yourself.
+ */
+type DiscriminatedVisibilityProps = {
+    isOpen: boolean;
+    onClose: () => void;
+    trigger?: never;
+    onOpenChange?: never;
+} | {
+    isOpen?: never;
+    onClose?: never;
+    trigger: React$1.ReactNode;
+    onOpenChange?: (open: boolean) => void;
+};
+type DiscriminatedContentProps$1 = {
+    children?: React$1.ReactNode;
+    content?: never;
+    title?: never;
+    error?: never;
+    description?: never;
+    actions?: never;
+} | (ModalBodyImplProps$1 & {
+    children?: never;
+    content?: React$1.ReactNode;
+});
+type ModalProps$2 = DiscriminatedVisibilityProps & ModalContentBaseProps & ModalContentProps & DiscriminatedContentProps$1 & {
+    trigger?: React$1.ReactNode;
+};
+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;
+    TriggerButton: (props: ButtonProps) => react_jsx_runtime.JSX.Element;
+    CloseButton: (props: ButtonProps) => react_jsx_runtime.JSX.Element;
+};
+
+type FullscreenModalHeaderProps = {
+    title: React.ReactNode;
+    description?: React.ReactNode;
+    leftSlot?: React.ReactNode;
+    rightSlot?: React.ReactNode;
+    className?: string;
+};
+
+type ModalProps$1 = DiscriminatedVisibilityProps & ModalContentBaseProps & {
+    trigger?: React$1.ReactNode;
+    fullscreen?: boolean;
+    title?: React$1.ReactNode;
+    showX?: boolean;
+};
+declare const FullscreenModal: {
+    ({ children, trigger, isOpen, onClose, onOpenChange, fullscreen, showX, title, ...rest }: ModalProps$1): react_jsx_runtime.JSX.Element;
+    TriggerButton: (props: ButtonProps) => react_jsx_runtime.JSX.Element;
+    CloseButton: (props: ButtonProps) => 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 = {
+    title?: React$1.ReactNode;
+    error?: React$1.ReactNode;
+    description?: React$1.ReactNode;
+    actions?: React$1.ReactNode;
+};
+type DiscriminatedContentProps = {
+    children?: React$1.ReactNode;
+    content?: never;
+    title?: never;
+    error?: never;
+    description?: never;
+    actions?: never;
+} | (ModalBodyImplProps & {
+    children?: never;
+    content?: React$1.ReactNode;
+});
+type ModalProps = 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;
+    TriggerButton: (props: ButtonProps) => react_jsx_runtime.JSX.Element;
+    CloseButton: (props: ButtonProps) => react_jsx_runtime.JSX.Element;
+};
+
+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.
+     *
+     * @example
+     * element={elementRef => (
+     *   <span ref={elementRef} className="truncate ...">
+     *    {text}
+     *  </span>
+     * )}
+     */
+    element: (elementRef: React$1.RefObject<TElement>) => React$1.ReactElement;
+};
+type TooltipProps = Simplify<Omit<RadixTooltip.TooltipProps, "children"> & Omit<TooltipContentProps, "children"> & {
+    trigger?: React$1.ReactNode;
+    content?: React$1.ReactNode;
+}>;
+/**
+ * @example
+ * <Tooltip
+ *  trigger={<Button>Cool action</Button>}
+ * 	content={<p className="text-xs">This is the tooltip content</p>}
+ * />
+ */
+declare const Tooltip: {
+    ({ trigger, content, variant, side, ...rest }: TooltipProps): react_jsx_runtime.JSX.Element;
+    Provider: (props: RadixTooltip.TooltipProviderProps) => react_jsx_runtime.JSX.Element;
+    Root: (props: RadixTooltip.TooltipProps) => react_jsx_runtime.JSX.Element;
+    Trigger: (props: RadixTooltip.TooltipTriggerProps) => react_jsx_runtime.JSX.Element;
+    OverflowTrigger: <TElement extends HTMLElement = HTMLDivElement>({ element, ...rest }: OverflowTriggerProps<TElement>) => react_jsx_runtime.JSX.Element;
+    Content: {
+        ({ children, variant, ...rest }: TooltipContentProps): react_jsx_runtime.JSX.Element;
+        displayName: string | undefined;
+    };
+};
+
+type OverflowTooltipProps = Pick<React__default.ComponentPropsWithoutRef<typeof Tooltip>, "side" | "variant" | "open"> & {
+    tooltip: React__default.ReactNode;
+    /** The `elementRef` render prop should attach to a measurable DOM element.
+     *
+     * @example
+     * element={elementRef => (
+     * 	<span ref={elementRef} className="truncate ...">
+     * 		{text}
+     * 	</span>
+     * )}
+     */
+    element: (elementRef: React__default.RefObject<HTMLElement & HTMLDivElement>) => React__default.ReactElement;
+};
+declare const OverflowTooltip: ({ element, tooltip, side, variant, ...props }: OverflowTooltipProps) => react_jsx_runtime.JSX.Element;
+
+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 = {
+    triggerClassName?: string;
+    trigger: React.ReactNode;
+    open?: boolean;
+    disabled?: boolean;
+    alignContent?: Align;
+    side?: Side;
+    arrowClassName?: string;
+    contentClassName?: string;
+    children: React.ReactNode;
+    onOpenChange?: (open: boolean) => void;
+};
+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;
+    Trigger(props: ButtonProps): react_jsx_runtime.JSX.Element;
+    Body: ({ children, arrowClassName, contentClassName, container, ...props }: PopoverBodyProps) => react_jsx_runtime.JSX.Element;
+    Close(props: RadixPopover.PopoverCloseProps): react_jsx_runtime.JSX.Element;
+};
+type PopoverBodyProps = {
+    align?: Align;
+    side?: Side;
+    arrowClassName?: string;
+    contentClassName?: string;
+    children: React.ReactNode;
+    container?: Element;
+};
+
+type SkeletonProps = {
+    className?: string;
+};
+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 SwitchIdValue = string | undefined;
+declare const useSwitchId: () => SwitchIdValue;
+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;
+    Label: (props: React$1.ComponentPropsWithoutRef<"label">) => react_jsx_runtime.JSX.Element;
+};
+
+declare const variants: {
+    readonly default: "default";
+    readonly seamless: "seamless";
+    readonly transparent: "transparent";
+    readonly subtable: "subtable";
+};
+type Variant = (typeof variants)[keyof typeof variants];
+type TableProps<T> = {
+    table: Table$1<T>;
+    variant?: Variant;
+    loading?: boolean;
+    fillHeight?: boolean;
+};
+declare const Table: <T>({ variant, loading, fillHeight, ...props }: TableProps<T>) => react_jsx_runtime.JSX.Element;
+
+type SortOptions = {
+    sort: string | undefined;
+    onSortColumn?: (newSort: ColumnSort | undefined) => void;
+};
+type CustomTableMeta<T> = {
+    emptyText?: React.ReactNode;
+    activeRowId?: string;
+    onRowClick?: (row: Row<T>) => void;
+    staticSubRows?: boolean;
+};
+type DiscriminatedSortOptions = SortOptions | AllAsNever<SortOptions>;
+type CustomTableOptions<T> = Simplify<Omit<TableOptions<T>, "getCoreRowModel"> & DiscriminatedSortOptions & CustomTableMeta<T>>;
+declare const useTable: <T>(options: CustomTableOptions<T>) => _tanstack_react_table.Table<T>;
+
+type TabsTriggerProps<TabId extends string> = {
+    id: TabId;
+    label: React.ReactNode;
+    disabled?: boolean;
+    dataTestId?: string;
+    fsId?: string;
+    extra?: React.ReactNode;
+    className?: string;
+};
+declare const TabsTrigger: <TabId extends string>({ id, label, disabled, dataTestId, fsId, extra, className, }: TabsTriggerProps<TabId>) => react_jsx_runtime.JSX.Element;
+
+type TabDefinition<TabId extends string> = {
+    id: TabId;
+    label: React.ReactNode;
+    disabled?: boolean;
+    fsId?: string;
+};
+type TabsProps<TabId extends string> = PropsWithChildren & {
+    tabs: readonly TabDefinition<TabId>[];
+    currentTab: TabId;
+    setCurrentTab: (id: TabId) => void;
+    className?: string;
+    tabsListClassName?: string;
+    tabsListContainerClassName?: string;
+    tabsListTriggerClassName?: string;
+    extraNode?: React.ReactNode;
+};
+declare const Tabs: {
+    <TabId extends string>({ tabs, className, tabsListClassName, tabsListContainerClassName, tabsListTriggerClassName, currentTab, setCurrentTab, children, extraNode, }: TabsProps<TabId>): react_jsx_runtime.JSX.Element;
+    TabContent: <TabId extends string>({ id, ...rest }: TabContentProps<TabId>) => react_jsx_runtime.JSX.Element;
+    AlwaysMountedTabContent: <TabId extends string>({ id, visibleClassName, className, children, }: TabContentProps<TabId> & {
+        visibleClassName?: string;
+    }) => react_jsx_runtime.JSX.Element;
+};
+type TabContentProps<TabId = string> = {
+    id: TabId;
+} & Omit<TabsContentProps, "value">;
+type TabsRootProps<TabId extends string> = Omit<TabsProps$1, "value" | "onValueChange" | "defaultValue"> & {
+    defaultValue?: TabId;
+    currentTab?: TabId;
+    setCurrentTab?: (id: TabId) => void;
+    className?: string;
+};
+declare const createTypedTabs: <TabId extends string>() => {
+    Root: ({ currentTab, setCurrentTab, ...props }: TabsRootProps<TabId>) => react_jsx_runtime.JSX.Element;
+    List: ({ className, ...props }: TabsListProps) => react_jsx_runtime.JSX.Element;
+    Trigger: ({ id, label, disabled, dataTestId, fsId, extra, className, }: TabsTriggerProps<TabId>) => react_jsx_runtime.JSX.Element;
+    Content: ({ id, ...rest }: TabContentProps<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;
+    disabled?: boolean;
+};
+type ComposableTabsListProps = {
+    className?: string;
+    containerClassName?: string;
+    extraNode?: React.ReactNode;
+};
+type ComposableTabContentProps<TabId = string> = {
+    id: TabId;
+} & Omit<TabsContentProps, "value">;
+type ComposableTabsProps<TabId extends string> = PropsWithChildren & {
+    tabs: readonly ComposableTabDefinition<TabId>[];
+    currentTab: TabId;
+    setCurrentTab: (id: TabId) => void;
+    className?: string;
+};
+declare const ComposableTabs: {
+    Root: <TabId extends string>({ tabs, currentTab, setCurrentTab, className, children, }: ComposableTabsProps<TabId>) => react_jsx_runtime.JSX.Element;
+    List: ({ className, containerClassName, extraNode }: ComposableTabsListProps) => react_jsx_runtime.JSX.Element;
+    TabContent: <TabId extends string>({ id, ...rest }: ComposableTabContentProps<TabId>) => react_jsx_runtime.JSX.Element;
+    AlwaysMountedTabContent: <TabId extends string>({ id, visibleClassName, className, children, }: ComposableTabContentProps<TabId> & {
+        visibleClassName?: string;
+    }) => react_jsx_runtime.JSX.Element;
+};
+
+type TabGroupProps<TabId extends string> = {
+    tabs: TabDefinition<TabId>[];
+    currentTab: TabId;
+    setCurrentTab: (id: TabId) => void;
+};
+declare const TabGroup: <TabId extends string>({ tabs, currentTab, setCurrentTab }: TabGroupProps<TabId>) => react_jsx_runtime.JSX.Element;
+
+type TagLabelProps = {
+    children: React$1.ReactNode;
+    removable?: boolean;
+    onRemove?: () => void;
+    intent?: Intent;
+};
+type TagProps = TagLabelProps & {
+    tooltip?: string;
+};
+declare const Tag: ({ tooltip, ...rest }: TagProps) => react_jsx_runtime.JSX.Element;
+
+type TextTag = "h1" | "h2" | "h3" | "h4" | "h5" | "h6" | "p" | "span" | "label";
+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";
+};
+type TextVariant = keyof typeof VARIANT_STYLES;
+/**
+ * Props specific to Text component (excluding native HTML props)
+ */
+type TextOwnProps<T extends ElementType = "p"> = {
+    /**
+     * The HTML tag to render
+     * @default "p"
+     */
+    as?: T;
+    /**
+     * Typography variant to apply
+     * @default "body-1"
+     */
+    variant?: keyof typeof VARIANT_STYLES;
+    /**
+     * Content to render
+     */
+    children: ReactNode;
+};
+/**
+ * Full component props combining Text-specific props with native HTML element props
+ */
+type TextProps<T extends TextTag = "p"> = TextOwnProps<T> & Omit<ComponentPropsWithoutRef<T>, keyof TextOwnProps>;
+/**
+ * @summary A typography component for rendering styled text with semantic HTML tags.
+ *
+ * @description This component provides a consistent way to render text with proper semantic HTML
+ * while maintaining design system typography. It is extendable but closed for modification.
+ * The component is fully type-safe and provides proper autocompletion for all native HTML
+ * attributes based on the selected tag.
+ *
+ * @example Basic Usage (defaults to <p> tag)
+ *  <Text>Default paragraph text</Text>
+ *
+ * @example With Custom Tags (fully typed)
+ *  <Text as="h1">Heading Text</Text>
+ *  <Text as="span">Inline Text</Text>
+ *
+ * @example Type Safety - Native Props
+ *  // ✓ Valid: span supports onClick
+ *  <Text as="span" onClick={() => console.log('clicked')}>
+ *    Clickable text
+ *  </Text>
+ *
+ *  // ✓ Valid: h1 supports id
+ *  <Text as="h1" id="page-title">
+ *    Page Title
+ *  </Text>
+ *
+ * @example Extendable with className
+ *  <Text className="text-blue-500 font-bold">
+ *    Custom styled text
+ *  </Text>
+ *
+ * @example With Variants
+ *  <Text variant="headline-1">Large Heading</Text>
+ *  <Text variant="body-1">Body text</Text>
+ *  <Text variant="label">Label text</Text>
+ */
+declare const Text: <T extends TextTag = "p">({ as, variant, children, className, ...props }: TextProps<T>) => react_jsx_runtime.JSX.Element;
+
+/**
+ * @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];
+
+/**
+ * I've found managing hover state with onMouseOver and onMouseOut events can be unreliable
+ * when moving the mouse quickly. 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);
+ *
+ * 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);
+ */
+declare const useToggle: (initState?: boolean) => {
+    state: boolean;
+    update: React$1.Dispatch<React$1.SetStateAction<boolean>>;
+    toggle: () => void;
+};
+
+export { AlertModal, type AllAsNever, AsyncMultiSelect, type AsyncMultiSelectControlledProps, type AsyncMultiSelectProps, AsyncSelect, type AsyncSelectControlledProps, type AsyncSelectProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonProps, type ButtonStyleProps, CURRENCY_REGEX, Callout, type CalloutIntent, type CalloutProps, Checkbox, type CheckboxProps, type ChildrenProps$2 as ChildrenProps, type ClassNameProps, Collapsible, CollapsibleSection, type ComposableTabDefinition, ComposableTabs, type ComposableTabsProps, ControlledField, ControlledFieldProvider, Copyable, 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, ErrorText, type EventFor, type FalsyValues, FormCheckbox, FormDatePicker, FormDollarInput, type FormFieldNameProps, FormInput, FormMultiSelect, FormPercentInput, FormRadioButtonGroup, type FormSchema, FormSelect, type FormSelectProps, FormSwitch, FormTextArea, FullscreenModal, HeaderTile, 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 OnSubmitHandler, OverflowTooltip, PercentInput, type PersistDrawerWidth, PhoneNumber, Popover, type PopoverProps, type PropsWithClassName, RING_COLOR_CLASSNAME, RadioButtonGroup, type RadioButtonGroupItem, type RadioButtonGroupProps, RadioButtonItem, ScrollTabsLayout, Select, type SelectItem, SelectListItem, type SelectListItemProps, type SelectProps, type SelectValue, SelectWithUnselect, type SelectWithUnselectProps, type SelectedAmountSchema, type SharedModalProps, type Size, Skeleton, type SkeletonProps, type Soften, Spinner, type StylesProps, Switch, type TabDefinition, TabGroup, Table, TableCheckboxSkeleton, type TableProps, TableSkeleton, Tabs, type TabsProps, TabsSkeleton, TabsTrigger, type TabsTriggerProps, Tag, Text, TextArea, TextAreaComp, type TextAreaProps, type TextProps, type TextTag, type TextVariant, Tooltip, TooltipContent, type TooltipProps, UncontrolledField, UncontrolledFieldProvider, type UncontrolledFormFieldProps, type UseAsyncMultiSelectArgs, type UseAsyncSelectArgs, type UseDrawerResizeParams, type Variant$1 as Variant, asNullish, asNumericStr, asOptional, asRequiredCustom, buildZodIssue, buttonStyles, copyToClipboard, createContextHelper, createToggleContextHelper, createTypedTabs, doesSelectItemMatch, dollarsStrSchema, formatPhoneNumber, formatPhoneNumberForDisplay, getFieldError, inputBoxStyles, inputStyles, isValidPhoneNumber, labelStyles, linkStyles, localStoragePersist, npiSchema, npiSchemaOptional, requiredDollarsStrSchema, requiredDollarsStrSchemaWithCustomMessage, requiredNonZeroDollarsStrSchema, requiredPositiveDollarsStrSchema, requiredPositiveOrZeroDollarsStrSchema, selectedAmountSchema, taxIdSchema, taxonomyCodeSchema, useAsyncMultiSelect, useAsyncSelect, useControlledField, useControlledFormField, useCopyable, useDebounce, useDrawer, useDrawerResize, useForm, useFormContext, useIsEditing, useIsHovered, useIsVisible, useOverflowObserver, useSwitchId, useSyncState, useTable, useToggle, useUncontrolledField, useUncontrolledFormField };