@ahrowe/ui 0.35.0 → 0.36.0

package/dist/cjs-types/common/maskedInput/mask.d.ts

@@ -0,0 +1,48 @@
+/**
+ * A fixed-width digit mask: `99:99`, `99.99.9999`.
+ *
+ * Fixed means every character keeps its position. Clearing a digit in the middle leaves a hole
+ * rather than pulling the rest left, which is what a date or a time wants: deleting the month
+ * out of `11.11.2025` must not turn the year into the month.
+ *
+ * `9` marks a slot that takes a digit. Every other character is a literal the caret steps over
+ * and the user cannot type into.
+ */
+export interface MaskSelection {
+    start: number;
+    end: number;
+}
+export interface MaskState {
+    value: string;
+    selection: MaskSelection | null;
+}
+/** The mask indices that take a digit, in order. */
+export declare function slotIndices(mask: string): number[];
+/** The mask with every slot empty: `__.__.____`. */
+export declare function emptyMask(mask: string, placeholder: string): string;
+/**
+ * Any string as one character per mask index, so slots can be read and written by position.
+ *
+ * Every other function here assumes a value exactly as long as the mask, with literals where the
+ * mask has them. Putting a value through this is what guarantees that, whether it came from a
+ * keystroke, from a consumer's state, or from nothing at all.
+ */
+export declare function toMask(value: string, mask: string, placeholder: string): string;
+/**
+ * Where the caret belongs when the field is entered: the first slot with no digit in it.
+ *
+ * A mask is as wide when empty as when full, so a click lands wherever it likes, and clicking at
+ * the end of `__.__.____` would otherwise leave the caret past every slot with nowhere to put the
+ * next digit.
+ */
+export declare function firstEmptyCaret(value: string, mask: string, placeholder: string): number;
+/**
+ * What the field should show after the browser has changed its raw text, and where the caret
+ * belongs.
+ *
+ * Works from the edit rather than from key events, so a paste, a drag, a replaced selection, an
+ * autofill and a keystroke all arrive the same way.
+ */
+export declare function maskChange(previous: string, raw: string, caret: number, mask: string, placeholder: string): MaskState;
+/** Whether a masked value holds no digits at all, so the field reads as empty. */
+export declare function isBlank(value: string, mask: string): boolean;

package/dist/cjs-types/common/maskedInput/maskedInput.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+import { MaskedInputProps } from './maskedInput.types.js';
+/**
+ * A text input under a fixed digit mask, used by `DatePicker` and `TimeInput` through `Input`'s
+ * `customInput`. Internal: consumers reach it through those two.
+ *
+ * Controlled, with one exception. An empty field shows nothing until it is focused, and then shows
+ * the bare mask, so a form full of `__.__.____` does not greet someone who has typed nothing. That
+ * mask is display only and is never reported through `onChange`, or every untouched date field
+ * would submit a value made of underscores.
+ */
+declare function MaskedInput(props: MaskedInputProps): React.JSX.Element;
+export default MaskedInput;

package/dist/cjs-types/common/maskedInput/maskedInput.types.d.ts

@@ -0,0 +1,38 @@
+import { default as React } from 'react';
+import { DataProps } from '../types/slots.types.js';
+import { MaskSelection, MaskState } from './mask.js';
+export type { MaskSelection, MaskState };
+/**
+ * What a correction hook is handed. Both states are the value as the mask shapes it, exactly as
+ * long as the mask, with its literals in place.
+ */
+export interface BeforeMaskedStateChangeStates {
+    previousState: MaskState;
+    nextState: MaskState;
+}
+export interface MaskedInputProps extends DataProps, Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange' | 'value' | 'defaultValue'> {
+    /** The inner `<input>`. `Input` leaves the ref to a `customInput`, so this is the way to it. */
+    ref?: React.Ref<HTMLInputElement>;
+    /** `9` takes a digit, every other character is a literal: `99:99`, `99.99.9999`. */
+    mask: string;
+    /** Shown in a slot with no digit in it yet. Default `_`. */
+    maskPlaceholder?: string;
+    /**
+     * The masked value, e.g. `11.11.2025` or `1_.__.____`. Anything else is coerced to the mask,
+     * reading each slot positionally, so a value from elsewhere cannot leave the field a shape the
+     * next keystroke would be measured against wrongly. `''` means empty, and shows nothing until
+     * the field is focused.
+     */
+    value?: string;
+    /**
+     * Called with the new masked value, or `''` once the last digit is gone. A string rather than an
+     * event, which is what `Input`'s own handler accepts, so there is no synthetic event to forge.
+     */
+    onChange?: (value: string) => void;
+    /**
+     * Last word on what the field becomes, for corrections that depend on the value as a whole —
+     * clamping an hour past 23, padding a day typed as `4` to `04`. Returning `nextState` unchanged
+     * accepts the mask's own answer. Called only for a change the user made.
+     */
+    beforeMaskedStateChange?: (states: BeforeMaskedStateChangeStates) => MaskState;
+}

package/dist/cjs-types/common/menu/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './menu.js';
+export * from './menu.types.js';

package/dist/cjs-types/common/menu/menu.d.ts

@@ -0,0 +1,14 @@
+import { ReactElement } from 'react';
+import { MenuProps } from './menu.types.js';
+/**
+ * A menu of actions on a trigger of your choosing.
+ *
+ * `Popover` does the anchoring, portalling and outside-click work but takes
+ * arbitrary `content`, which leaves every consumer to write their own `ul`/`li`
+ * and, in practice, to leave out the roles and the arrow keys. This is that list,
+ * done once: `role="menu"`, a roving focus that skips disabled entries, Escape
+ * back to the trigger, and separators and headings that stay out of the keyboard
+ * order.
+ */
+declare function Menu({ items, children, onAction, isOpen: controlledOpen, onOpenChange, placement, align, presentation, className, style, classNames, styles: slotStyles, ...rest }: MenuProps): ReactElement;
+export default Menu;

package/dist/cjs-types/common/menu/menu.types.d.ts

@@ -0,0 +1,55 @@
+import { CSSProperties, ReactNode } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+import { IconContent } from '../types/icon.types.js';
+import { PopoverAlign, PopoverPlacement } from '../popover/popover.types.js';
+import { Presentation } from '../configProvider/presentation.types.js';
+/** One thing the menu can do. */
+export interface MenuAction {
+    /** Stable id, also what `onAction` reports. */
+    id: string;
+    label: ReactNode;
+    icon?: IconContent;
+    /**
+     * Keyboard hint on the trailing edge, e.g. `⌘K`. Display only: binding the
+     * shortcut is yours, since only you know what else is listening.
+     */
+    shortcut?: ReactNode;
+    disabled?: boolean;
+    /** Renders in the destructive colour. For deleting, discarding, revoking. */
+    danger?: boolean;
+    onClick?: () => void;
+}
+/** A line between groups of actions. */
+export interface MenuSeparator {
+    separator: true;
+}
+/** A label over the actions that follow it. */
+export interface MenuHeading {
+    heading: ReactNode;
+}
+export type MenuEntry = MenuAction | MenuSeparator | MenuHeading;
+export declare function isMenuSeparator(entry: MenuEntry): entry is MenuSeparator;
+export declare function isMenuHeading(entry: MenuEntry): entry is MenuHeading;
+export declare function isMenuAction(entry: MenuEntry): entry is MenuAction;
+export type MenuSlots = 'root' | 'trigger' | 'menu' | 'item' | 'itemIcon' | 'itemLabel' | 'itemShortcut' | 'separator' | 'heading';
+export interface MenuProps extends Omit<HtmlProps, 'onSelect'> {
+    /** What the menu offers, in the order it is read. */
+    items: MenuEntry[];
+    /** The element that opens the menu. */
+    children?: ReactNode;
+    /** Called with the id of the action that was picked, after its own `onClick`. */
+    onAction?: (id: string) => void;
+    /** Controlled open state. Leave it out to let the menu manage its own. */
+    isOpen?: boolean;
+    onOpenChange?: (isOpen: boolean) => void;
+    /** Which side of the trigger the menu opens on (default `Bottom`). */
+    placement?: PopoverPlacement;
+    /** Which edge it lines up with on the cross axis (default `Start`). */
+    align?: PopoverAlign;
+    /** Anchored to the trigger, pinned to the bottom of the screen, or the latter only on touch. */
+    presentation?: Presentation;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<MenuSlots>;
+    styles?: SlotStyles<MenuSlots>;
+}

package/dist/cjs-types/common/modal/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './modal.js';
+export * from './modal.types.js';

package/dist/cjs-types/common/modal/modal.d.ts

@@ -0,0 +1,3 @@
+import { ModalProps } from './modal.types.js';
+declare function Modal(props: ModalProps): import("react").JSX.Element | null;
+export default Modal;

package/dist/cjs-types/common/modal/modal.types.d.ts

@@ -0,0 +1,31 @@
+import { CSSProperties } from 'react';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+import { Presentation } from '../configProvider/presentation.types.js';
+export type ModalSlots = 'container' | 'backdrop' | 'modal' | 'header' | 'title' | 'closeButton' | 'body' | 'footer';
+/** Text Modal renders of its own, for translating it. */
+export interface ModalLabels {
+    /** Close button, read out by screen readers. */
+    close?: string;
+}
+export interface ModalProps extends HtmlProps<HTMLDivElement> {
+    children?: React.ReactNode;
+    title?: string;
+    isOpen?: boolean;
+    onClose?: () => void;
+    /** Applied to the modal panel itself */
+    className?: string;
+    style?: CSSProperties;
+    /** Pinned below the scrolling body, so action buttons stay visible however long the content
+     * is. Nothing is rendered when omitted. */
+    footer?: React.ReactNode;
+    hideHeader?: boolean;
+    /** Close on Escape while this is the topmost overlay. Default `true`. */
+    closeOnEscape?: boolean;
+    /** Present as a bottom sheet, always or only on a small touch screen. `Presentation.Default`
+     * (or omitting this) is the ordinary centred dialog. */
+    presentation?: Presentation;
+    classNames?: SlotClassNames<ModalSlots>;
+    styles?: SlotStyles<ModalSlots>;
+    /** Overrides the text Modal renders of its own. Merged per key. */
+    labels?: ModalLabels;
+}

package/dist/cjs-types/common/multiSelect/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './multiSelect.js';
+export * from './multiSelect.types.js';

package/dist/cjs-types/common/multiSelect/multiSelect.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+import { MultiSelectProps } from './multiSelect.types.js';
+declare function MultiSelect(props: MultiSelectProps): ReactElement;
+export default MultiSelect;

package/dist/cjs-types/common/multiSelect/multiSelect.types.d.ts

@@ -0,0 +1,69 @@
+import { CSSProperties } from 'react';
+import { FormValidator } from '../../services/formValidation/index.js';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+import { Presentation } from '../configProvider/presentation.types.js';
+export type MultiSelectValue = string | number;
+export interface MultiSelectItem {
+    key: MultiSelectValue;
+    /** Visible text. A string, not a `ReactNode`, because it also renders inside a `Chip`. */
+    label: string;
+    /** Disable just this option. */
+    disabled?: boolean;
+}
+export type MultiSelectSlots = 'root' | 'label' | 'fieldset' | 'control' | 'values' | 'chip' | 'placeholder' | 'clearButton' | 'icon' | 'panel' | 'search' | 'options' | 'option' | 'optionCheck' | 'optionLabel' | 'empty';
+/** Text MultiSelect renders of its own, for translating it. */
+export interface MultiSelectLabels {
+    /** Button that empties the selection, read out by screen readers. */
+    clearSelection?: string;
+    /** Entry that creates a value from what was typed (default `Add "<value>"`). */
+    create?: (value: string) => string;
+    /** Placeholder in the search field (default `Search…`). */
+    searchPlaceholder?: string;
+    /** Shown when nothing matches the search (default `No matches`). */
+    empty?: string;
+}
+export interface MultiSelectProps extends Omit<HtmlProps<HTMLDivElement>, 'onChange' | 'value' | 'defaultValue'> {
+    /** The selectable options. */
+    items: MultiSelectItem[];
+    /** Controlled selection. Omit for uncontrolled. */
+    value?: MultiSelectValue[];
+    /** Initial selection when uncontrolled (default `[]`). */
+    defaultValue?: MultiSelectValue[];
+    /** Fires with the full new selection, in the order the items were picked. */
+    onChange?: (value: MultiSelectValue[]) => void;
+    /** Field label. Rests inside the control and floats up into the border notch, like `Input`. */
+    label?: string;
+    /** Keep the label floating even when the field is empty and unfocused (default `false`). */
+    alwaysFloatLabel?: boolean;
+    /** Shown while nothing is selected. With a `label`, only once the label has floated clear. */
+    placeholder?: string;
+    /** Show a search box in the panel that filters the options (default `false`). */
+    searchable?: boolean;
+    /**
+     * Let the user add a value that isn't in `items` by typing it and picking the "add" row that
+     * appears. Implies `searchable`, since the search box is where the value is typed. The new
+     * value becomes its own key, so `onChange` reports it as a plain string.
+     */
+    allowCustomValues?: boolean;
+    /** Cap the number of selections. Unselected options disable once the cap is reached. */
+    maxSelected?: number;
+    /** Show a button that clears the whole selection (default `true`). */
+    clearable?: boolean;
+    disabled?: boolean;
+    /** Show the selection but allow no changes, without the dimming `disabled` applies. */
+    readOnly?: boolean;
+    /** Where the panel opens: anchored to the control, as a bottom sheet, or a sheet only on a
+     * small touch screen. Forwarded to `Popover`. */
+    presentation?: Presentation;
+    formValidator?: FormValidator | null;
+    /** Manual error message shown in a tooltip (used when there's no `formValidator`). */
+    errorMessage?: string;
+    /** Manual valid state when not using a `formValidator` (default `true`). */
+    isValid?: boolean;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<MultiSelectSlots>;
+    styles?: SlotStyles<MultiSelectSlots>;
+    /** Overrides the text MultiSelect renders of its own. Merged per key. */
+    labels?: MultiSelectLabels;
+}

package/dist/cjs-types/common/numberInput/index.d.ts

@@ -0,0 +1,3 @@
+import { default as NumberInput } from './numberInput.js';
+export type { NumberInputProps, NumberInputArrowsLayout } from './numberInput.types.js';
+export default NumberInput;

package/dist/cjs-types/common/numberInput/numberInput.d.ts

@@ -0,0 +1,5 @@
+import { ReactElement } from 'react';
+import { NumberInputProps } from './numberInput.types.js';
+export type { NumberInputProps, NumberInputArrowsLayout } from './numberInput.types.js';
+declare function NumberInput(props: NumberInputProps): ReactElement;
+export default NumberInput;

package/dist/cjs-types/common/numberInput/numberInput.types.d.ts

@@ -0,0 +1,76 @@
+import { default as React } from 'react';
+import { NumericFormatProps } from 'react-number-format';
+import { FormValidator } from '../../services/formValidation/index.js';
+import { SlotClassNames, SlotStyles } from '../types/slots.types.js';
+/**
+ * How the stepper buttons are laid out.
+ *
+ * - `stacked` — chevrons stacked inside the field's right edge. Compact; suits a mouse.
+ * - `split` — square `−` / `+` buttons flanking the field, each as tall and wide as the field.
+ *   Far apart with the field between them, so a mis-tap can't step the value the wrong way.
+ * - `auto` — `split` on a coarse (touch) pointer, `stacked` otherwise.
+ */
+export type NumberInputArrowsLayout = 'auto' | 'stacked' | 'split';
+/** Text NumberInput renders of its own, for translating it. */
+export interface NumberInputLabels {
+    /** The step-up button, read out by screen readers (default `Increase`). */
+    increase?: string;
+    /** The step-down button, read out by screen readers (default `Decrease`). */
+    decrease?: string;
+}
+export type NumberInputSlots = 'root' | 'input' | 'arrows' | 'increaseButton' | 'decreaseButton';
+export interface NumberInputProps extends Omit<NumericFormatProps, 'onValueChange' | 'value' | 'customInput' | 'onChange' | 'step' | 'onKeyDown' | 'min' | 'max'> {
+    value?: number | string;
+    onChange?: (value: number | undefined) => void;
+    formValidator?: FormValidator | null;
+    label?: string;
+    error?: string;
+    className?: string;
+    allowNegative?: boolean;
+    decimalSeparator?: string;
+    thousandSeparator?: string | boolean;
+    prefix?: string;
+    suffix?: string;
+    decimalScale?: number;
+    /**
+     * Whether to pad the value to exactly `decimalScale` decimals. Default `true`
+     * (e.g. with `decimalScale={2}`, `12` displays as `12.00`). Set `false` to make
+     * `decimalScale` an upper limit only — the user may type fewer decimals and they
+     * are kept as-is (`12` stays `12`, `12.1` stays `12.1`), while anything beyond
+     * `decimalScale` is still truncated.
+     */
+    fixedDecimalScale?: boolean;
+    placeholder?: string;
+    sign?: '+' | '-';
+    showArrows?: boolean;
+    step?: number;
+    /**
+     * Lower bound. Constrains the steppers and the ArrowDown key, disables the decrease button
+     * once reached, and clamps a typed value on blur and on Enter — the two moments it stops
+     * being mid-edit. Typing is never blocked; see {@link NumberInputProps.max}.
+     */
+    min?: number;
+    /**
+     * Upper bound. Behaves exactly like {@link NumberInputProps.min} in the other direction.
+     *
+     * Neither bound rejects a keystroke as it is typed — an edit passes through out-of-range
+     * states on its way somewhere valid — and an empty field is never clamped. Use a
+     * `formValidator` if out-of-range input must be *rejected* rather than corrected.
+     */
+    max?: number;
+    /** Stepper layout. Default `'auto'`. */
+    arrowsLayout?: NumberInputArrowsLayout;
+    /** Accessible name for the increase button. Default `'Increase'`. */
+    /** Accessible name for the decrease button. Default `'Decrease'`. */
+    readOnly?: boolean;
+    isRequired?: boolean;
+    onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    /** Overrides the text NumberInput renders of its own. Merged per key. */
+    labels?: NumberInputLabels;
+    /** Ref to the inner `<input>`, for focusing the field. */
+    ref?: React.Ref<HTMLInputElement>;
+    /** Classes for the inner elements. See `NumberInputSlots`. */
+    classNames?: SlotClassNames<NumberInputSlots>;
+    /** Inline styles for the inner elements. See `NumberInputSlots`. */
+    styles?: SlotStyles<NumberInputSlots>;
+}

package/dist/cjs-types/common/numberInput/useStepRepeat.d.ts

@@ -0,0 +1,17 @@
+export interface UseStepRepeatResult {
+    /** Fires one step immediately, then starts the hold-to-repeat timer. */
+    start: (direction: 1 | -1, multiplier: number) => void;
+    /** Cancels a running repeat. Safe to call when nothing is running. */
+    stop: () => void;
+}
+/**
+ * Hold-to-repeat for the stepper buttons: one step on press, then an accelerating repeat.
+ *
+ * The release is watched on `window` rather than by capturing the pointer, which would retarget
+ * the following click past the node Button's ripple listens on. Capture would have guaranteed a
+ * `pointerup`, so the extra listeners cover the ways a press can end without one.
+ *
+ * `onStep` returns whether anything changed; `false` ends the repeat, so a hold at a bound stops.
+ */
+export declare function useStepRepeat(onStep: (delta: number) => boolean): UseStepRepeatResult;
+export default useStepRepeat;

package/dist/cjs-types/common/optionPicker/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './optionPicker.js';
+export * from './optionPicker.types.js';

package/dist/cjs-types/common/optionPicker/optionPicker.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+import { OptionPickerProps } from './optionPicker.types.js';
+declare function OptionPicker(props: OptionPickerProps): ReactElement;
+export default OptionPicker;

package/dist/cjs-types/common/optionPicker/optionPicker.types.d.ts

@@ -0,0 +1,16 @@
+import { ReactElement } from 'react';
+import { HtmlProps, SlotClassNames, SlotStyles } from '../types/slots.types.js';
+export interface Option {
+    label: ReactElement | string;
+    key: string;
+}
+export type OptionPickerSlots = 'root' | 'chip' | 'option';
+export interface OptionPickerProps extends Omit<HtmlProps, 'onChange'> {
+    className?: string;
+    style?: React.CSSProperties;
+    classNames?: SlotClassNames<OptionPickerSlots>;
+    styles?: SlotStyles<OptionPickerSlots>;
+    options: Option[];
+    onChange: (key: string, event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+    value: string;
+}

package/dist/cjs-types/common/otpInput/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './otpInput.js';
+export * from './otpInput.types.js';

package/dist/cjs-types/common/otpInput/otpInput.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+import { OtpInputProps } from './otpInput.types.js';
+declare function OtpInput(props: OtpInputProps): ReactElement;
+export default OtpInput;

package/dist/cjs-types/common/otpInput/otpInput.types.d.ts

@@ -0,0 +1,60 @@
+import { default as React } from 'react';
+import { FormValidator } from '../../services/formValidation/index.js';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type OtpInputSlots = 'root' | 'label' | 'inputs' | 'input' | 'separator';
+export declare enum OtpInputCharset {
+    /** Digits only (0-9). Shows a numeric mobile keyboard. */
+    Numeric = "numeric",
+    /** Letters and digits. */
+    Alphanumeric = "alphanumeric"
+}
+/** Text OtpInput renders of its own, for translating it. */
+export interface OtpInputLabels {
+    /** The group of boxes, used when no `label` is given. */
+    field?: string;
+    /** One box, given its 1-based position and how many there are. */
+    digit?: (position: number, length: number) => string;
+}
+export interface OtpInputProps extends Omit<HtmlProps, 'onChange'> {
+    /** Number of character boxes. Default 6. */
+    length?: number;
+    /** Current code as a plain string, e.g. "123456". */
+    value?: string;
+    /** Fired on every change with the full current code (may be shorter than `length`). */
+    onChange?: ((value: string) => void) | null;
+    /** Fired once, when the code reaches `length` characters. */
+    onComplete?: ((value: string) => void) | null;
+    formValidator?: FormValidator | null;
+    /** Restricts which characters can be typed and picks the mobile keyboard. Default `numeric`. */
+    charset?: OtpInputCharset;
+    /** Render each box's value as a dot, like a password field. */
+    masked?: boolean;
+    /** Draw a small gap after these 1-based box indices, e.g. `[3]` to split 6 boxes into 3+3. */
+    groupAfter?: number[];
+    label?: string;
+    isValid?: boolean;
+    /** Shown in an error Tooltip on focus/hover once `isValid` is `false` (or, with a
+     * `formValidator`, once it's touched and has an error). Persists until the value changes
+     * `isValid`/`formValidator`'s error state itself — see `clearOnError` to auto-dismiss it. */
+    errorMessage?: string;
+    isRequired?: boolean;
+    /** When an error newly appears (`isValid`/`formValidator` turning invalid), clear every box and
+     * refocus the first one after `clearErrorDelay`, so the next attempt starts clean instead of the
+     * user editing individual wrong digits (and re-triggering `onComplete` on every keystroke while
+     * the code stays at full length). Default `false`. */
+    clearOnError?: boolean;
+    /** Delay in ms before `clearOnError` clears the boxes, so the wrong code and error message are
+     * still visible for a moment first. Default `900`. */
+    clearErrorDelay?: number;
+    disabled?: boolean;
+    /** Focuses the first empty box (or the first box) on mount. */
+    autoFocus?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    /** Ref to the root element. */
+    ref?: React.Ref<HTMLDivElement>;
+    classNames?: SlotClassNames<OtpInputSlots>;
+    styles?: SlotStyles<OtpInputSlots>;
+    /** Overrides the text OtpInput renders of its own. Merged per key. */
+    labels?: OtpInputLabels;
+}

package/dist/cjs-types/common/overscroll/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './overscroll.js';
+export * from './overscroll.types.js';

package/dist/cjs-types/common/overscroll/overscroll.d.ts

@@ -0,0 +1,2 @@
+import { OverscrollProps } from './overscroll.types.js';
+export default function Overscroll({ children, overscrollContent, overscrollContentDesktop, centerHeader, min, max, start, unit, mobileOnly, onScrollChange, scrollDisabled, }: OverscrollProps): import("react").JSX.Element;

package/dist/cjs-types/common/overscroll/overscroll.types.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+export interface OverscrollProps {
+    children?: ReactNode;
+    overscrollContent?: ReactNode;
+    overscrollContentDesktop?: ReactNode;
+    centerHeader?: boolean;
+    min?: number;
+    max?: number;
+    start?: number;
+    unit?: string;
+    mobileOnly?: boolean;
+    onScrollChange?: (isScrolling: boolean) => void;
+    scrollDisabled?: boolean;
+}

package/dist/cjs-types/common/pagination/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './pagination.js';
+export * from './pagination.types.js';

package/dist/cjs-types/common/pagination/pagination.d.ts

@@ -0,0 +1,4 @@
+import { ReactElement } from 'react';
+import { PaginationProps } from './pagination.types.js';
+declare function Pagination(props: PaginationProps): ReactElement | null;
+export default Pagination;

package/dist/cjs-types/common/pagination/pagination.types.d.ts

@@ -0,0 +1,45 @@
+import { CSSProperties } from 'react';
+import { IconContent } from '../types/icon.types.js';
+import { SlotClassNames, SlotStyles, HtmlProps } from '../types/slots.types.js';
+export type PaginationSlots = 'root' | 'item' | 'control' | 'ellipsis';
+/** Text Pagination renders of its own, for translating it. */
+export interface PaginationLabels {
+    /** One page button, given its number. */
+    goToPage?: (page: number) => string;
+    /** Jump to the first page. */
+    first?: string;
+    /** Step back one page. */
+    previous?: string;
+    /** Step forward one page. */
+    next?: string;
+    /** Jump to the last page. */
+    last?: string;
+}
+export interface PaginationProps extends Omit<HtmlProps<HTMLElement>, 'onChange'> {
+    /** Total number of pages. Nothing renders below `1`. */
+    total: number;
+    /** Controlled current page, 1-based (omit for uncontrolled). */
+    page?: number;
+    /** Initial page when uncontrolled (default `1`). */
+    defaultPage?: number;
+    onChange?: (page: number) => void;
+    /** Pages shown either side of the current one (default `1`). */
+    siblings?: number;
+    /** Pages always shown at the start and end (default `1`). */
+    boundaries?: number;
+    /** Show the previous/next controls (default `true`). */
+    showControls?: boolean;
+    /** Show first/last jump controls outside the previous/next ones (default `false`). */
+    showEdges?: boolean;
+    disabled?: boolean;
+    previousIcon?: IconContent;
+    nextIcon?: IconContent;
+    firstIcon?: IconContent;
+    lastIcon?: IconContent;
+    className?: string;
+    style?: CSSProperties;
+    classNames?: SlotClassNames<PaginationSlots>;
+    styles?: SlotStyles<PaginationSlots>;
+    /** Overrides the text Pagination renders of its own. Merged per key. */
+    labels?: PaginationLabels;
+}

package/dist/cjs-types/common/planCanvas/index.d.ts

@@ -0,0 +1,2 @@
+export { default } from './planCanvas.js';
+export * from './planCanvas.types.js';

package/dist/cjs-types/common/planCanvas/planCanvas.d.ts

@@ -0,0 +1,7 @@
+import { PlanCanvasProps } from './planCanvas.types.js';
+/**
+ * The ref lands on the `<svg>` itself, which is what a consumer wants for measuring or
+ * screenshotting. Both the drawer and the viewer expose it as `getSvgElement()`.
+ */
+declare function PlanCanvas(props: PlanCanvasProps): import("react").JSX.Element;
+export default PlanCanvas;