@jc-times/business-ui 0.2.43

package/dist/types/FormField.d.ts

@@ -0,0 +1,35 @@
+import { type InputHTMLAttributes, type ReactNode, type SelectHTMLAttributes, type TextareaHTMLAttributes } from "react";
+type FieldPresentation = {
+    label?: ReactNode;
+    helpText?: ReactNode;
+    error?: ReactNode;
+    containerClassName?: string;
+};
+type FormFieldProps = FieldPresentation & {
+    controlId: string;
+    required?: boolean;
+    children: ReactNode;
+};
+export declare function FormField({ controlId, label, required, helpText, error, containerClassName, children }: FormFieldProps): import("react").JSX.Element;
+export type TextInputProps = InputHTMLAttributes<HTMLInputElement> & FieldPresentation & {
+    /** Content displayed inside the control before the editable value. */
+    startAdornment?: ReactNode;
+    /** Content displayed inside the control after the editable value. */
+    endAdornment?: ReactNode;
+};
+export declare const TextInput: import("react").ForwardRefExoticComponent<InputHTMLAttributes<HTMLInputElement> & FieldPresentation & {
+    /** Content displayed inside the control before the editable value. */
+    startAdornment?: ReactNode;
+    /** Content displayed inside the control after the editable value. */
+    endAdornment?: ReactNode;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export type SelectInputProps = SelectHTMLAttributes<HTMLSelectElement> & FieldPresentation;
+export declare const SelectInput: import("react").ForwardRefExoticComponent<SelectHTMLAttributes<HTMLSelectElement> & FieldPresentation & import("react").RefAttributes<HTMLSelectElement>>;
+export type TextAreaProps = TextareaHTMLAttributes<HTMLTextAreaElement> & FieldPresentation;
+export declare const TextArea: import("react").ForwardRefExoticComponent<TextareaHTMLAttributes<HTMLTextAreaElement> & FieldPresentation & import("react").RefAttributes<HTMLTextAreaElement>>;
+export declare const Checkbox: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "type"> & {
+    label: ReactNode;
+    description?: ReactNode;
+    containerClassName?: string;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export {};

package/dist/types/MetricCard.d.ts

@@ -0,0 +1,17 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+import { type BadgeTone } from "./Badge";
+export type MetricCardTone = BadgeTone;
+export type MetricCardProps = Omit<HTMLAttributes<HTMLElement>, "children"> & {
+    label: ReactNode;
+    value: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    tone?: MetricCardTone;
+};
+export declare const MetricCard: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLElement>, "children"> & {
+    label: ReactNode;
+    value: ReactNode;
+    description?: ReactNode;
+    icon?: ReactNode;
+    tone?: MetricCardTone;
+} & import("react").RefAttributes<HTMLElement>>;

package/dist/types/ModalShell.d.ts

@@ -0,0 +1,33 @@
+import { type ComponentPropsWithRef, type ReactNode, type Ref } from "react";
+import { type FocusTarget } from "./useModalFocusTrap";
+type DataAttributes = {
+    [key: `data-${string}`]: string | number | boolean | undefined;
+};
+export type ModalShellProps = {
+    backdropClassName?: string;
+    panelClassName?: string;
+    titleId: string;
+    eyebrow?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    closeLabel: string;
+    onClose: () => void;
+    closeDisabled?: boolean;
+    showCloseButton?: boolean;
+    closeIconSize?: number;
+    closeOnBackdrop?: boolean;
+    closeOnEscape?: boolean;
+    initialFocus?: FocusTarget;
+    returnFocus?: FocusTarget | false;
+    rootRef?: Ref<HTMLDivElement>;
+    role?: "dialog" | "alertdialog";
+    describedBy?: string;
+    children: ReactNode;
+    contentClassName?: string;
+    contentProps?: Omit<ComponentPropsWithRef<"div">, "children" | "className" | "dangerouslySetInnerHTML"> & DataAttributes;
+    footer?: ReactNode;
+    footerClassName?: string;
+};
+export declare function ModalShell({ backdropClassName, panelClassName, titleId, eyebrow, title, description, closeLabel, onClose, closeDisabled, showCloseButton, closeIconSize, closeOnBackdrop, rootRef, closeOnEscape, initialFocus, returnFocus, role, describedBy, children, footer, contentClassName, contentProps, footerClassName }: ModalShellProps): import("react").JSX.Element;
+export declare const Dialog: typeof ModalShell;
+export {};

package/dist/types/MultiSelect.d.ts

@@ -0,0 +1,12 @@
+import type { ComboboxOption, ComboboxProps } from "./Combobox";
+export type MultiSelectProps = Omit<ComboboxProps, "selectedKey" | "defaultSelectedKey" | "onSelectionChange" | "allowsCustomValue"> & {
+    values?: readonly string[];
+    defaultValues?: readonly string[];
+    onValuesChange?(values: string[]): void;
+    name?: string;
+    selectedItems?: readonly ComboboxOption[];
+    clearLabel?: string;
+    selectionLabel?: string;
+    maxSelected?: number;
+};
+export declare function MultiSelect({ values, defaultValues, onValuesChange, name, selectedItems, items, disabled, clearLabel, selectionLabel, maxSelected, inputValue, defaultInputValue, onInputChange, required, label, placeholder, helpText, error, loading, emptyText, inputRef, inputProps, placement, portalContainer, virtualized, className }: MultiSelectProps): import("react").JSX.Element;

package/dist/types/NumericInput.d.ts

@@ -0,0 +1,54 @@
+import { type TextInputProps } from "./FormField";
+import { type MoneyFormat } from "./AmountFormat";
+export type NumericInputProps = Omit<TextInputProps, "type" | "value" | "defaultValue" | "min" | "max"> & {
+    /** Controlled decimal string; an empty string represents no value. */
+    value: string;
+    /** Called only with normalized values on blur or Enter. */
+    onValueCommit(value: string): void;
+    /** Optional edit notification, including intermediate states such as '-' and '1.'. */
+    onDraftChange?(value: string): void;
+    decimalPlaces?: number;
+    /** Minimum fraction digits in the resting display; does not pad drafts or committed values. */
+    minimumFractionDigits?: number;
+    min?: string;
+    max?: string;
+    useGrouping?: boolean;
+    /** Currency presentation in resting state only; editing and commits remain numeric. */
+    moneyFormat?: MoneyFormat;
+    selectAllOnFocus?: boolean;
+    selectAllOnClick?: boolean;
+};
+export declare const NumericInput: import("react").ForwardRefExoticComponent<Omit<TextInputProps, "type" | "defaultValue" | "value" | "max" | "min"> & {
+    /** Controlled decimal string; an empty string represents no value. */
+    value: string;
+    /** Called only with normalized values on blur or Enter. */
+    onValueCommit(value: string): void;
+    /** Optional edit notification, including intermediate states such as '-' and '1.'. */
+    onDraftChange?(value: string): void;
+    decimalPlaces?: number;
+    /** Minimum fraction digits in the resting display; does not pad drafts or committed values. */
+    minimumFractionDigits?: number;
+    min?: string;
+    max?: string;
+    useGrouping?: boolean;
+    /** Currency presentation in resting state only; editing and commits remain numeric. */
+    moneyFormat?: MoneyFormat;
+    selectAllOnFocus?: boolean;
+    selectAllOnClick?: boolean;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export type ScaledNumericInputProps = Omit<NumericInputProps, "value" | "onValueCommit" | "decimalPlaces" | "min" | "max"> & {
+    value: number | null;
+    onValueCommit(value: number | null): void;
+    /** Positive power of ten, default 100. Value and bounds are safe integers in storage units. */
+    scale?: number;
+    min?: number;
+    max?: number;
+};
+export declare const ScaledNumericInput: import("react").ForwardRefExoticComponent<Omit<NumericInputProps, "value" | "max" | "min" | "onValueCommit" | "decimalPlaces"> & {
+    value: number | null;
+    onValueCommit(value: number | null): void;
+    /** Positive power of ten, default 100. Value and bounds are safe integers in storage units. */
+    scale?: number;
+    min?: number;
+    max?: number;
+} & import("react").RefAttributes<HTMLInputElement>>;

package/dist/types/OverlayContainer.d.ts

@@ -0,0 +1,2 @@
+export declare const OverlayContainerContext: import("react").Context<HTMLElement | null>;
+export declare function useOverlayContainer(explicit?: Element | null): Element | undefined;

package/dist/types/PageHeader.d.ts

@@ -0,0 +1,23 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+type PageHeaderSlotProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    [key: `data-${string}`]: string | number | undefined;
+};
+export type PageHeaderProps = Omit<HTMLAttributes<HTMLElement>, "children" | "title"> & {
+    eyebrow?: ReactNode;
+    title: ReactNode;
+    titleId?: string;
+    description?: ReactNode;
+    actions?: ReactNode;
+    copyProps?: PageHeaderSlotProps;
+    actionsProps?: PageHeaderSlotProps;
+};
+export declare const PageHeader: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLElement>, "title" | "children"> & {
+    eyebrow?: ReactNode;
+    title: ReactNode;
+    titleId?: string;
+    description?: ReactNode;
+    actions?: ReactNode;
+    copyProps?: PageHeaderSlotProps;
+    actionsProps?: PageHeaderSlotProps;
+} & import("react").RefAttributes<HTMLElement>>;
+export {};

package/dist/types/Pagination.d.ts

@@ -0,0 +1,14 @@
+export type PaginationProps = {
+    totalItems: number;
+    page: number;
+    pageSize: number;
+    onPageChange(page: number): void;
+    onPageSizeChange?(pageSize: number): void;
+    itemLabel?: string;
+    pageSizeOptions?: readonly number[];
+    compact?: boolean;
+};
+export declare function Pagination({ totalItems, page, pageSize, onPageChange, onPageSizeChange, itemLabel, pageSizeOptions, compact }: PaginationProps): import("react").JSX.Element;
+export declare function pageCount(totalItems: number, pageSize: number): number;
+export declare function clampPage(page: number, totalItems: number, pageSize: number): number;
+export declare function visiblePages(page: number, totalPages: number): (number | "ellipsis")[];

package/dist/types/PdfiumViewer.d.ts

@@ -0,0 +1,5 @@
+import type { DocumentViewerV2HeadlessProps } from './document-viewer-v2/HeadlessPdfViewer';
+export type PdfiumViewerProps = Omit<DocumentViewerV2HeadlessProps, 'renderer'>;
+export type { PluginRegistry } from '@embedpdf/core';
+/** Native PDF-only entry: excludes legacy PDF.js rendering and the full viewer shell. */
+export declare function PdfiumViewer(props: PdfiumViewerProps): import("react").JSX.Element;

package/dist/types/PreparedFileDropzone.d.ts

@@ -0,0 +1,7 @@
+import { type FileDropzoneProps } from "./FileDropzone";
+import { type FilePreparationLabels } from "./FilePreparationDialog";
+import { type FilePreparationOptions } from "./useFilePreparation";
+export type PreparedFileDropzoneProps = FileDropzoneProps & Pick<FilePreparationOptions, "ownerKey" | "prepareFile" | "errorMessage"> & {
+    labels: FilePreparationLabels;
+};
+export declare function PreparedFileDropzone({ ownerKey, prepareFile, errorMessage, labels, onFilesSelected, ...props }: PreparedFileDropzoneProps): import("react").JSX.Element;

package/dist/types/RecoverableAsyncState.d.ts

@@ -0,0 +1,11 @@
+export type RecoverableAsyncStateProps = {
+    phase: "loading" | "error";
+    loadingTitle: string;
+    errorTitle: string;
+    detail?: string;
+    retryLabel?: string;
+    compact?: boolean;
+    onRetry?(): void;
+};
+export declare function RecoverableAsyncState(props: RecoverableAsyncStateProps): import("react").JSX.Element;
+export declare const AsyncState: typeof RecoverableAsyncState;

package/dist/types/RovingTabs.d.ts

@@ -0,0 +1,21 @@
+import { type ReactNode } from "react";
+export type TabOption<Value extends string> = {
+    value: Value;
+    label: ReactNode;
+};
+export type TabListProps<Value extends string> = {
+    groupId: string;
+    label: string;
+    value: Value;
+    options: readonly TabOption<Value>[];
+    className?: string;
+    onChange(value: Value): void;
+};
+export declare function RovingTabList<Value extends string>(props: TabListProps<Value>): import("react").JSX.Element;
+export declare function RovingTabPanel<Value extends string>({ groupId, value, className, children }: {
+    groupId: string;
+    value: Value;
+    className?: string;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function nextRovingTabValue<Value extends string>(values: readonly Value[], current: Value, key: string): Value | null;

package/dist/types/SectionCard.d.ts

@@ -0,0 +1,18 @@
+import { type HTMLAttributes, type ReactNode } from "react";
+export type SectionCardHeadingLevel = 2 | 3 | 4 | 5 | 6;
+export type SectionCardProps = Omit<HTMLAttributes<HTMLElement>, "children" | "title"> & {
+    title: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    children: ReactNode;
+    headingId?: string;
+    headingLevel?: SectionCardHeadingLevel;
+};
+export declare const SectionCard: import("react").ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLElement>, "title" | "children"> & {
+    title: ReactNode;
+    description?: ReactNode;
+    actions?: ReactNode;
+    children: ReactNode;
+    headingId?: string;
+    headingLevel?: SectionCardHeadingLevel;
+} & import("react").RefAttributes<HTMLElement>>;

package/dist/types/SegmentedControl.d.ts

@@ -0,0 +1,26 @@
+import { type ReactNode } from "react";
+export type SegmentedControlOption<Value extends string> = {
+    value: Value;
+    label: ReactNode;
+    icon?: ReactNode;
+    /** Required for icon-only labels. */
+    "aria-label"?: string;
+    disabled?: boolean;
+};
+export type SegmentedControlProps<Value extends string> = {
+    value: Value;
+    options: readonly SegmentedControlOption<Value>[];
+    onChange(value: Value): void;
+    "aria-label": string;
+    name?: string;
+    disabled?: boolean;
+    className?: string;
+    size?: "compact" | "default" | "touch";
+    variant?: "solid" | "soft";
+    /** Defaults to true for compatibility with existing full-width controls. */
+    block?: boolean;
+    orientation?: "horizontal" | "vertical";
+    shape?: "default" | "round";
+};
+/** Accessible controlled single choice rendered as one continuous segmented surface. */
+export declare function SegmentedControl<Value extends string>({ value, options, onChange, name, disabled, className, size, variant, block, orientation, shape, ...ariaProps }: SegmentedControlProps<Value>): import("react").JSX.Element;

package/dist/types/Select.d.ts

@@ -0,0 +1,31 @@
+import * as RadixSelect from "@radix-ui/react-select";
+import { type ReactNode, type Ref } from "react";
+export type SelectOption = {
+    value: string;
+    label: ReactNode;
+    disabled?: boolean;
+};
+type DataAttributes = {
+    [key: `data-${string}`]: string | number | boolean | undefined;
+};
+export type SelectProps = {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    options: readonly SelectOption[];
+    label?: ReactNode;
+    placeholder?: ReactNode;
+    helpText?: ReactNode;
+    error?: ReactNode;
+    required?: boolean;
+    disabled?: boolean;
+    name?: string;
+    id?: string;
+    className?: string;
+    triggerRef?: Ref<HTMLButtonElement>;
+    triggerProps?: Omit<RadixSelect.SelectTriggerProps, "id" | "className" | "disabled"> & DataAttributes;
+    portalContainer?: HTMLElement | null;
+    placement?: Pick<RadixSelect.SelectContentProps, "side" | "align" | "sideOffset" | "alignOffset" | "collisionPadding" | "avoidCollisions">;
+};
+export declare function Select({ value, defaultValue, onValueChange, options, label, placeholder, helpText, error, required, disabled, name, id, className, triggerRef, triggerProps, portalContainer, placement }: SelectProps): import("react").JSX.Element;
+export {};

package/dist/types/Skeleton.d.ts

@@ -0,0 +1,11 @@
+import { type CSSProperties, type HTMLAttributes } from "react";
+export type SkeletonProps = HTMLAttributes<HTMLSpanElement> & {
+    width?: CSSProperties["width"];
+    height?: CSSProperties["height"];
+    rounded?: boolean;
+};
+export declare function Skeleton({ width, height, rounded, className, style, ...props }: SkeletonProps): import("react").JSX.Element;
+export type SkeletonTextProps = HTMLAttributes<HTMLDivElement> & {
+    lines?: number;
+};
+export declare function SkeletonText({ lines, className, ...props }: SkeletonTextProps): import("react").JSX.Element;

package/dist/types/SortableList.d.ts

@@ -0,0 +1,17 @@
+import { type ReactNode } from "react";
+type SortableKey = string | number;
+export type SortableListProps<T> = {
+    items: T[];
+    getKey(item: T): SortableKey;
+    getTextValue(item: T, index: number): string;
+    renderItem(item: T, index: number): ReactNode;
+    onReorder(items: T[]): void;
+    "aria-label": string;
+    disabled?: boolean;
+    className?: string;
+    dragLabel?(item: T, index: number): string;
+};
+/** Accessible controlled reordering for interactive cards, powered by React Aria drag and drop. */
+export declare function SortableList<T>(props: SortableListProps<T>): import("react").JSX.Element;
+export declare function moveSortableItems<T>(items: T[], movingKeys: Set<SortableKey>, targetKey: SortableKey, position: "before" | "after" | "on", getKey: (item: T) => SortableKey): T[];
+export {};

package/dist/types/StructuredAddressInput.d.ts

@@ -0,0 +1,57 @@
+import { type InputHTMLAttributes, type ReactNode, type Ref } from "react";
+type DataAttributes = {
+    [key: `data-${string}`]: string | number | boolean | undefined;
+};
+export type AddressRegion = {
+    id: string;
+    label: string;
+    children?: readonly AddressRegion[];
+    disabled?: boolean;
+};
+export type StructuredAddressValue = {
+    mode: "structured" | "freeform";
+    regionIds: string[];
+    detail: string;
+    freeform: string;
+};
+export type AddressRegionPath = {
+    ids: string[];
+    labels: string[];
+    leaf: AddressRegion;
+};
+export type StructuredAddressInputProps = {
+    regions: readonly AddressRegion[];
+    value: StructuredAddressValue;
+    onValueChange(value: StructuredAddressValue): void;
+    label?: ReactNode;
+    required?: boolean;
+    disabled?: boolean;
+    annotation?: ReactNode;
+    dataVersion?: ReactNode;
+    className?: string;
+    structuredModeLabel?: string;
+    freeformModeLabel?: string;
+    /** Legacy opt-in. Defaults to false; use a top-level overseas region. */
+    showModeSelector?: boolean;
+    regionLabel?: string;
+    detailLabel?: string;
+    freeformLabel?: string;
+    searchPlaceholder?: string;
+    emptyText?: ReactNode;
+    maxLength?: number;
+    regionInputRef?: Ref<HTMLInputElement>;
+    detailInputRef?: Ref<HTMLInputElement>;
+    freeformInputRef?: Ref<HTMLInputElement>;
+    regionInputProps?: Omit<InputHTMLAttributes<HTMLInputElement>, "children" | "className" | "disabled" | "onChange" | "placeholder" | "role" | "value"> & DataAttributes;
+    detailInputProps?: Omit<InputHTMLAttributes<HTMLInputElement>, "children" | "className" | "disabled" | "onChange" | "value"> & DataAttributes;
+    freeformInputProps?: Omit<InputHTMLAttributes<HTMLInputElement>, "children" | "className" | "disabled" | "onChange" | "value"> & DataAttributes;
+};
+export declare function StructuredAddressInput({ regions, value, onValueChange, label, required, disabled, annotation, dataVersion, className, structuredModeLabel, freeformModeLabel, showModeSelector, regionLabel, detailLabel, freeformLabel, searchPlaceholder, emptyText, maxLength, regionInputRef, detailInputRef, freeformInputRef, regionInputProps, detailInputProps, freeformInputProps }: StructuredAddressInputProps): import("react").JSX.Element;
+export declare function flattenAddressRegions(regions: readonly AddressRegion[]): AddressRegionPath[];
+export declare function searchAddressRegions(regions: readonly AddressRegion[], query: string, limit?: number): AddressRegionPath[];
+export declare function findAddressRegionPath(regions: readonly AddressRegion[], ids: readonly string[]): {
+    ids: string[];
+    labels: string[];
+    leaf: AddressRegion;
+} | undefined;
+export {};

package/dist/types/Toast.d.ts

@@ -0,0 +1,22 @@
+import { type ReactNode } from "react";
+export type ToastTone = "info" | "success" | "warning" | "danger";
+export type ToastOptions = {
+    id?: string;
+    tone?: ToastTone;
+    title: ReactNode;
+    description?: ReactNode;
+    duration?: number;
+    actionLabel?: ReactNode;
+    onAction?: () => void;
+};
+type ToastApi = {
+    toast(options: ToastOptions): string;
+    dismiss(id: string): void;
+    dismissAll(): void;
+};
+export declare function ToastProvider({ children, maxVisible }: {
+    children: ReactNode;
+    maxVisible?: number;
+}): import("react").JSX.Element;
+export declare function useToast(): ToastApi;
+export {};

package/dist/types/ToggleSwitch.d.ts

@@ -0,0 +1,15 @@
+import { type InputHTMLAttributes, type ReactNode } from "react";
+export type ToggleSwitchProps = Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "checked" | "defaultChecked" | "onChange" | "children" | "className"> & {
+    checked: boolean;
+    children: ReactNode;
+    className?: string;
+    disabledDescriptionId?: string;
+    onChange(checked: boolean): void;
+};
+export declare const ToggleSwitch: import("react").ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "defaultChecked" | "className" | "children" | "onChange" | "checked"> & {
+    checked: boolean;
+    children: ReactNode;
+    className?: string;
+    disabledDescriptionId?: string;
+    onChange(checked: boolean): void;
+} & import("react").RefAttributes<HTMLInputElement>>;

package/dist/types/TreeSelect.d.ts

@@ -0,0 +1,58 @@
+import { type InputHTMLAttributes, type ReactNode, type Ref } from "react";
+type DataAttributes = {
+    [key: `data-${string}`]: string | number | boolean | undefined;
+};
+export type TreeSelectItem = {
+    id: string;
+    label: string;
+    parentId?: string | null;
+    order?: number;
+    disabled?: boolean;
+};
+export type TreeSelectNode = TreeSelectItem & {
+    children: TreeSelectNode[];
+};
+export type TreeSelectProps = {
+    items: readonly TreeSelectItem[];
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (value: string | null) => void;
+    selectionMode?: "single" | "multiple";
+    values?: readonly string[];
+    defaultValues?: readonly string[];
+    onValuesChange?: (values: string[]) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    query?: string;
+    defaultQuery?: string;
+    onQueryChange?: (query: string) => void;
+    expandedIds?: ReadonlySet<string>;
+    defaultExpandedIds?: Iterable<string>;
+    onExpandedIdsChange?: (ids: Set<string>) => void;
+    label?: ReactNode;
+    placeholder?: string;
+    searchPlaceholder?: string;
+    clearLabel?: string;
+    allLabel?: ReactNode;
+    emptyText?: ReactNode;
+    loading?: boolean;
+    loadingText?: ReactNode;
+    loadError?: ReactNode;
+    disabled?: boolean;
+    required?: boolean;
+    helpText?: ReactNode;
+    error?: ReactNode;
+    id?: string;
+    name?: string;
+    /** ID is submitted by default. label is a migration option for legacy forms. */
+    formValueMode?: "id" | "label";
+    className?: string;
+    popoverClassName?: string;
+    inputRef?: Ref<HTMLInputElement>;
+    inputProps?: Omit<InputHTMLAttributes<HTMLInputElement>, "children" | "className" | "disabled" | "id" | "name" | "onChange" | "placeholder" | "required" | "role" | "value"> & DataAttributes;
+};
+export declare function TreeSelect({ items, value, defaultValue, onValueChange, open, defaultOpen, onOpenChange, selectionMode, values, defaultValues, onValuesChange, query, defaultQuery, onQueryChange, expandedIds, defaultExpandedIds, onExpandedIdsChange, label, placeholder, searchPlaceholder, clearLabel, allLabel, emptyText, loading, loadingText, loadError, disabled, required, helpText, error, id, name, formValueMode, className, popoverClassName, inputRef, inputProps }: TreeSelectProps): import("react").JSX.Element;
+export declare function buildTreeSelectTree(items: readonly TreeSelectItem[]): TreeSelectNode[];
+export declare function filterTreeSelectTree(nodes: readonly TreeSelectNode[], query: string): TreeSelectNode[];
+export {};

package/dist/types/classNames.d.ts

@@ -0,0 +1 @@
+export declare function joinClassNames(...classNames: Array<string | false | null | undefined>): string;

package/dist/types/document-viewer/ContinuousPdfViewer.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from "react";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+export declare function ContinuousPdfViewer({ document, pages, currentPage, onCurrentPageChange, zoom, rotation, focusTarget, renderPage }: {
+    document: PDFDocumentProxy;
+    pages: number[];
+    currentPage: number;
+    onCurrentPageChange: (page: number) => void;
+    zoom?: number;
+    rotation?: number;
+    focusTarget?: {
+        page: number;
+        y: number;
+        token: string;
+    } | null;
+    renderPage?: (page: number) => ReactNode;
+}): import("react").JSX.Element;

package/dist/types/document-viewer/DocumentViewer.d.ts

@@ -0,0 +1,31 @@
+import { type CSSProperties, type ReactNode } from "react";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+import { type PreviewImage } from "./ImagePage";
+export type DocumentViewerSource = {
+    id: string;
+} & ({
+    kind: "pdf";
+    document: PDFDocumentProxy;
+} | {
+    kind: "image";
+    images: readonly PreviewImage[];
+});
+export type DocumentViewerProps = {
+    source: DocumentViewerSource;
+    title?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    ariaLabel?: string;
+    toolbar?: ReactNode;
+    footer?: ReactNode;
+    currentPage?: number;
+    onCurrentPageChange?: (page: number) => void;
+    pageMode?: "continuous" | "single";
+    renderPage?: (context: {
+        page: number;
+        zoom: number;
+        rotation: number;
+    }) => ReactNode;
+};
+/** The caller owns PDF loading, credentials/passwords and document destruction. */
+export declare function DocumentViewer(props: DocumentViewerProps): import("react").JSX.Element;

package/dist/types/document-viewer/DocumentViewerViewport.d.ts

@@ -0,0 +1,23 @@
+import type { HTMLAttributes, ReactNode } from "react";
+import type { PDFDocumentProxy } from "pdfjs-dist";
+export type DocumentViewerViewportProps = {
+    document: PDFDocumentProxy;
+    pageMode: "continuous" | "single";
+    pages: number[];
+    currentPage: number;
+    onCurrentPageChange: (page: number) => void;
+    zoom?: number;
+    rotation?: number;
+    rail?: ReactNode;
+    overlay?: ReactNode;
+    className?: string;
+    workspaceClassName?: string;
+    workspaceProps?: HTMLAttributes<HTMLDivElement>;
+    focusTarget?: {
+        page: number;
+        y: number;
+        token: string;
+    } | null;
+    renderPage?: (page: number) => ReactNode;
+};
+export declare function DocumentViewerViewport({ document, pageMode, pages, currentPage, onCurrentPageChange, zoom, rotation, rail, overlay, className, workspaceClassName, workspaceProps, focusTarget, renderPage }: DocumentViewerViewportProps): import("react").JSX.Element;

package/dist/types/document-viewer/ImagePage.d.ts

@@ -0,0 +1,9 @@
+export type PreviewImage = {
+    src: string;
+    alt: string;
+};
+export declare function ImagePage({ image, zoom, rotation }: {
+    image: PreviewImage;
+    zoom: number;
+    rotation: number;
+}): import("react").JSX.Element;

package/dist/types/document-viewer/PdfCanvasPage.d.ts

@@ -0,0 +1,7 @@
+import type { PDFDocumentProxy } from "pdfjs-dist";
+export declare function PdfCanvasPage({ document, page, renderWidth, rotation }: {
+    document: PDFDocumentProxy;
+    page: number;
+    renderWidth?: number;
+    rotation?: number;
+}): import("react").JSX.Element;

package/dist/types/document-viewer/PdfThumbnailRail.d.ts

@@ -0,0 +1,12 @@
+import type { PDFDocumentProxy } from "pdfjs-dist";
+export declare function PdfThumbnailRail({ document, currentPage, onCurrentPageChange }: {
+    document: PDFDocumentProxy;
+    currentPage: number;
+    onCurrentPageChange: (page: number) => void;
+}): import("react").JSX.Element;
+export declare function PageThumbnail({ document, page, active, onClick }: {
+    document: PDFDocumentProxy;
+    page: number;
+    active: boolean;
+    onClick: () => void;
+}): import("react").JSX.Element;

package/dist/types/document-viewer/PdfToolbar.d.ts

@@ -0,0 +1,13 @@
+type Props = {
+    zoom: number;
+    disabled: boolean;
+    fullscreen: boolean;
+    canZoomIn: boolean;
+    canZoomOut: boolean;
+    onZoomIn: () => void;
+    onZoomOut: () => void;
+    onRotate: () => void;
+    onToggleFullscreen: () => void;
+};
+export declare function PdfToolbar(props: Props): import("react").JSX.Element;
+export {};