@amsterdamdatalabs/enact-design-system 0.1.10 → 0.1.19

package/dist/components/forms/HostConnectionForm/HostConnectionForm.d.ts

@@ -0,0 +1,64 @@
+import { type FormHTMLAttributes, type ReactNode, type Ref } from "react";
+export interface HostConnectionFormLabels {
+    advanced: string;
+    cancel: string;
+    connect: string;
+    connecting: string;
+    connectionUri: string;
+    hidePassword: string;
+    host: string;
+    hostPlaceholder?: string;
+    password: string;
+    passwordPlaceholder?: string;
+    port: string;
+    portPlaceholder?: string;
+    showPassword: string;
+    uriPlaceholder?: string;
+    useTls: string;
+}
+export interface HostConnectionFormIcons {
+    advancedClosed?: ReactNode;
+    advancedOpen?: ReactNode;
+    connect?: ReactNode;
+    passwordHidden?: ReactNode;
+    passwordVisible?: ReactNode;
+}
+export interface HostConnectionFormTestIds {
+    advancedToggle?: string;
+    hostInput?: string;
+    passwordInput?: string;
+    passwordVisibilityToggle?: string;
+    portInput?: string;
+    submit?: string;
+    uriInput?: string;
+    useTlsToggle?: string;
+}
+export interface HostConnectionFormProps extends Omit<FormHTMLAttributes<HTMLFormElement>, "onSubmit"> {
+    advancedOpen: boolean;
+    advancedUri: string;
+    error?: ReactNode;
+    host: string;
+    icons?: HostConnectionFormIcons;
+    labels: HostConnectionFormLabels;
+    onAdvancedToggle(): void;
+    onAdvancedUriChange(value: string): void;
+    onCancel(): void;
+    onHostChange(value: string): void;
+    onPasswordChange(value: string): void;
+    onPasswordVisibilityToggle(): void;
+    onPortChange(value: string): void;
+    onSubmit(): void;
+    onUseTlsChange(checked: boolean): void;
+    password: string;
+    passwordVisible: boolean;
+    pending?: boolean;
+    port: string;
+    ref?: Ref<HTMLFormElement>;
+    testIds?: HostConnectionFormTestIds;
+    useTls: boolean;
+}
+/**
+ * Controlled direct-host connection form. URI parsing, connection tests,
+ * persistence, secret handling, and sheet lifecycle remain with the caller.
+ */
+export declare function HostConnectionForm({ advancedOpen, advancedUri, className, error, host, icons, labels, onAdvancedToggle, onAdvancedUriChange, onCancel, onHostChange, onPasswordChange, onPasswordVisibilityToggle, onPortChange, onSubmit, onUseTlsChange, password, passwordVisible, pending, port, ref, testIds, useTls, ...rest }: HostConnectionFormProps): import("react").JSX.Element;

package/dist/components/forms/HostConnectionForm/index.d.ts

@@ -0,0 +1,2 @@
+export type { HostConnectionFormIcons, HostConnectionFormLabels, HostConnectionFormProps, HostConnectionFormTestIds, } from "./HostConnectionForm";
+export { HostConnectionForm } from "./HostConnectionForm";

package/dist/components/forms/Input/Input.d.ts

@@ -2,6 +2,8 @@ import type { InputHTMLAttributes, Ref } from "react";
 export interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
     invalid?: boolean;
     ref?: Ref<HTMLInputElement>;
-    size?: "sm" | "md" | "lg";
+    size?: "sm" | "md" | "lg" | "tableCell";
+    /** Borderless table/cell editing surface — matches tweakcn dashboard metric inputs. */
+    variant?: "default" | "ghost";
 }
-export declare function Input({ size, invalid, disabled, className, ref, ...rest }: InputProps): import("react").JSX.Element;
+export declare function Input({ size, variant, invalid, disabled, className, ref, ...rest }: InputProps): import("react").JSX.Element;

package/dist/components/forms/QuestionnaireCard/QuestionnaireCard.d.ts

@@ -0,0 +1,51 @@
+import type { HTMLAttributes } from "react";
+export interface QuestionnaireOption {
+    description?: string;
+    id: string;
+    label: string;
+}
+export interface QuestionnaireQuestion {
+    /** Applies to questions that render a free-form answer. */
+    allowEmpty?: boolean;
+    /** When true, the question renders a free-form answer in addition to options. */
+    allowOther?: boolean;
+    header: string;
+    /** An application-owned stable key used for controlled answers and navigation. */
+    id: string;
+    multiSelect?: boolean;
+    options: readonly QuestionnaireOption[];
+    placeholder?: string;
+    question: string;
+}
+export interface QuestionnaireAnswer {
+    selectedOptionIds?: readonly string[];
+    text?: string;
+}
+export type QuestionnaireAnswers = Readonly<Record<string, QuestionnaireAnswer | undefined>>;
+export interface QuestionnaireLabels {
+    answerPlaceholder: string;
+    dismiss: string;
+    next: string;
+    otherPlaceholder: string;
+    submit: string;
+}
+export interface QuestionnaireCardProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "onSubmit"> {
+    activeQuestionId: string;
+    answers: QuestionnaireAnswers;
+    labels?: Partial<QuestionnaireLabels>;
+    onActiveQuestionIdChange: (questionId: string) => void;
+    onChange: (questionId: string, answer: QuestionnaireAnswer) => void;
+    onDismiss: () => void;
+    onSubmit: () => void;
+    questions: readonly QuestionnaireQuestion[];
+    /** Disables all input and communicates the pending action to assistive tech. */
+    submitting?: boolean;
+    /** Identifies the action currently pending so only that action shows progress. */
+    submittingAction?: "dismiss" | "submit" | null;
+}
+/**
+ * Controlled, accessible questionnaire presentation. Applications own data
+ * parsing, persistence, and submission effects; this component owns visual
+ * state, answer-selection intent, and keyboard-native form controls.
+ */
+export declare function QuestionnaireCard({ activeQuestionId, answers, className, labels: labelsInput, onActiveQuestionIdChange, onChange, onDismiss, onSubmit, questions, submitting, submittingAction, ...rest }: QuestionnaireCardProps): import("react").JSX.Element | null;

package/dist/components/forms/QuestionnaireCard/index.d.ts

@@ -0,0 +1 @@
+export { type QuestionnaireAnswer, type QuestionnaireAnswers, QuestionnaireCard, type QuestionnaireCardProps, type QuestionnaireLabels, type QuestionnaireOption, type QuestionnaireQuestion, } from "./QuestionnaireCard";

package/dist/components/forms/QuestionnaireCard/questionnaire-card-parts.d.ts

@@ -0,0 +1,38 @@
+import type { KeyboardEvent } from "react";
+import type { QuestionnaireAnswer, QuestionnaireAnswers, QuestionnaireLabels, QuestionnaireQuestion } from "./QuestionnaireCard";
+export interface QuestionnaireCardBodyProps {
+    activeAnswer: QuestionnaireAnswer | undefined;
+    activeIndex: number;
+    activeQuestion: QuestionnaireQuestion;
+    activeQuestionId: string;
+    allAnswered: boolean;
+    answers: QuestionnaireAnswers;
+    className?: string;
+    isLastQuestion: boolean;
+    labels: QuestionnaireLabels;
+    onActiveQuestionIdChange: (questionId: string) => void;
+    onChange: (questionId: string, answer: QuestionnaireAnswer) => void;
+    onDismiss: () => void;
+    onSubmit: () => void;
+    primaryDisabled: boolean;
+    questions: readonly QuestionnaireQuestion[];
+    submitting: boolean;
+    submittingAction?: "dismiss" | "submit" | null;
+}
+export declare function QuestionnaireCardBody({ activeAnswer, activeIndex, activeQuestion, activeQuestionId, answers, className, isLastQuestion, labels, onActiveQuestionIdChange, onChange, onDismiss, onSubmit, primaryDisabled, questions, submitting, submittingAction, }: QuestionnaireCardBodyProps): import("react").JSX.Element;
+export declare function handleQuestionnaireTextChange(context: {
+    activeQuestionId: string;
+    onChange: (questionId: string, answer: QuestionnaireAnswer) => void;
+    selectedOptionIds: readonly string[];
+}, event: {
+    target: {
+        value: string;
+    };
+}): void;
+export declare function handleQuestionnaireTextKeyDown(context: {
+    isLastQuestion: boolean;
+    nextQuestionId?: string;
+    onActiveQuestionIdChange: (questionId: string) => void;
+    onSubmit: () => void;
+    primaryDisabled: boolean;
+}, event: KeyboardEvent<HTMLInputElement>): void;

package/dist/components/forms/QuestionnaireCard/questionnaire-handlers.d.ts

@@ -0,0 +1,24 @@
+import type { QuestionnaireAnswer, QuestionnaireQuestion } from "./QuestionnaireCard";
+export declare function toggleQuestionnaireOption({ activeQuestion, activeQuestionId, isLastQuestion, nextQuestionId, onActiveQuestionIdChange, onChange, optionId, selectedOptionIds, }: {
+    activeQuestion: QuestionnaireQuestion;
+    activeQuestionId: string;
+    isLastQuestion: boolean;
+    nextQuestionId?: string;
+    onActiveQuestionIdChange: (questionId: string) => void;
+    onChange: (questionId: string, answer: QuestionnaireAnswer) => void;
+    optionId: string;
+    selectedOptionIds: readonly string[];
+}): void;
+export declare function updateQuestionnaireText({ activeQuestionId, onChange, selectedOptionIds, text, }: {
+    activeQuestionId: string;
+    onChange: (questionId: string, answer: QuestionnaireAnswer) => void;
+    selectedOptionIds: readonly string[];
+    text: string;
+}): void;
+export declare function runQuestionnairePrimaryAction({ isLastQuestion, nextQuestionId, onActiveQuestionIdChange, onSubmit, primaryDisabled, }: {
+    isLastQuestion: boolean;
+    nextQuestionId?: string;
+    onActiveQuestionIdChange: (questionId: string) => void;
+    onSubmit: () => void;
+    primaryDisabled: boolean;
+}): void;

package/dist/components/forms/QuestionnaireCard/questionnaire-parts.d.ts

@@ -0,0 +1 @@
+export declare function QuestionnaireSpinner(): import("react").JSX.Element;

package/dist/components/forms/QuestionnaireCard/questionnaire-utils.d.ts

@@ -0,0 +1,3 @@
+import type { QuestionnaireAnswer, QuestionnaireQuestion } from "./QuestionnaireCard";
+export declare function showsTextInput(question: QuestionnaireQuestion): boolean;
+export declare function isAnswered(question: QuestionnaireQuestion, answer?: QuestionnaireAnswer): boolean;

package/dist/components/forms/Radio/Radio.d.ts

@@ -0,0 +1,19 @@
+import { type HTMLAttributes, type ReactNode, type Ref } from "react";
+export interface RadioGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    children?: ReactNode;
+    defaultValue?: string;
+    disabled?: boolean;
+    name: string;
+    onChange?: (value: string) => void;
+    orientation?: "vertical" | "horizontal";
+    ref?: Ref<HTMLDivElement>;
+    value?: string;
+}
+export declare function RadioGroup({ name, value, defaultValue, onChange, disabled, orientation, children, className, ref, ...rest }: RadioGroupProps): import("react").JSX.Element;
+export interface RadioProps {
+    disabled?: boolean;
+    label?: ReactNode;
+    ref?: Ref<HTMLInputElement>;
+    value: string;
+}
+export declare function Radio({ value, label, disabled: itemDisabled, ref, }: RadioProps): import("react").JSX.Element;

package/dist/components/forms/Radio/index.d.ts

@@ -0,0 +1 @@
+export { Radio, RadioGroup, type RadioGroupProps, type RadioProps, } from "./Radio";

package/dist/components/forms/RadioCard/RadioCard.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from "react";
+export interface RadioCardProps {
+    description?: string;
+    meta?: ReactNode;
+    title: string;
+    value: string;
+}
+export declare function RadioCard({ description, meta, title, value }: RadioCardProps): import("react").JSX.Element;

package/dist/components/forms/RadioCard/index.d.ts

@@ -0,0 +1 @@
+export { RadioCard, type RadioCardProps } from "./RadioCard";

package/dist/components/forms/ResponsiveCombobox/ResponsiveCombobox.d.ts

@@ -0,0 +1,73 @@
+import { type ReactElement, type ReactNode, type RefObject } from "react";
+import { type ResponsiveComboboxOptionKind } from "./responsive-combobox-primitives";
+export interface ResponsiveComboboxOption {
+    description?: string;
+    disabled?: boolean;
+    id: string;
+    kind?: ResponsiveComboboxOptionKind;
+    label: string;
+}
+export interface ResponsiveComboboxStructuredHeader {
+    actions?: ReactNode;
+    back?: {
+        accessibilityLabel: string;
+        onPress: () => void;
+    };
+    leading?: ReactNode;
+    search?: {
+        autoFocus?: boolean;
+        onChange: (value: string) => void;
+        placeholder?: string;
+        resetKey?: string | number;
+        testId?: string;
+    };
+    subtitle?: ReactNode;
+    title: ReactNode;
+}
+export { ResponsiveComboboxEmpty, ResponsiveComboboxItem, type ResponsiveComboboxItemProps, type ResponsiveComboboxOptionKind, ResponsiveComboboxSearchInput, type ResponsiveComboboxSearchInputProps, } from "./responsive-combobox-primitives";
+type OptionsPosition = "above-search" | "below-search";
+export interface ResponsiveComboboxProps {
+    allowCustomValue?: boolean;
+    anchorRef: RefObject<HTMLElement | null>;
+    children?: ReactNode;
+    customValueDescription?: string;
+    customValueKind?: ResponsiveComboboxOptionKind;
+    customValuePrefix?: string;
+    desktopFixedHeight?: number;
+    desktopMinWidth?: number;
+    desktopPlacement?: "bottom-start" | "top-start";
+    desktopPreventInitialFlash?: boolean;
+    emptyText?: string;
+    header?: ReactNode;
+    isCompact?: boolean;
+    keepOpenOnSelect?: boolean;
+    mobileChildrenScrollEnabled?: boolean;
+    mobileHeader?: (input: {
+        onClose: () => void;
+    }) => ReactNode;
+    onOpenChange?: (open: boolean) => void;
+    onSearchQueryChange?: (query: string) => void;
+    onSelect: (id: string) => void;
+    open?: boolean;
+    options: readonly ResponsiveComboboxOption[];
+    optionsPosition?: OptionsPosition;
+    placeholder?: string;
+    renderOption?: (input: {
+        active: boolean;
+        onPress: () => void;
+        option: ResponsiveComboboxOption;
+        selected: boolean;
+    }) => ReactElement;
+    searchable?: boolean;
+    searchPlaceholder?: string;
+    stickyHeader?: ReactNode;
+    /** Structured, DS-rendered header that avoids app-local presentation. */
+    structuredHeader?: ResponsiveComboboxStructuredHeader;
+    title?: string;
+    value: string;
+}
+/**
+ * Controlled responsive option picker. The app owns option discovery, intent
+ * handling, translations, and compact-breakpoint policy; DS owns the view.
+ */
+export declare function ResponsiveCombobox({ allowCustomValue, anchorRef, children, customValueDescription, customValueKind, customValuePrefix, desktopFixedHeight, desktopMinWidth, desktopPlacement, desktopPreventInitialFlash, emptyText, header, structuredHeader, isCompact: controlledCompact, keepOpenOnSelect, mobileChildrenScrollEnabled, mobileHeader, onOpenChange, onSearchQueryChange, onSelect, open, options, optionsPosition, placeholder, renderOption, searchPlaceholder, searchable, stickyHeader, title, value, }: ResponsiveComboboxProps): ReactElement | null;

package/dist/components/forms/ResponsiveCombobox/helpers.d.ts

@@ -0,0 +1,25 @@
+import type { ResponsiveComboboxOption, ResponsiveComboboxOptionKind } from "./ResponsiveCombobox";
+export interface ResponsiveComboboxMatchScore {
+    offset: number;
+    spread?: number;
+    tier: number;
+}
+export interface BuildResponsiveComboboxOptionsInput {
+    allowCustomValue: boolean;
+    customValueDescription?: string;
+    customValueKind?: ResponsiveComboboxOptionKind;
+    customValuePrefix: string;
+    options: readonly ResponsiveComboboxOption[];
+    searchable: boolean;
+    searchQuery: string;
+}
+export declare function shouldShowCustomResponsiveComboboxOption({ allowCustomValue, options, searchable, searchQuery, }: Pick<BuildResponsiveComboboxOptionsInput, "allowCustomValue" | "options" | "searchable" | "searchQuery">): boolean;
+export declare function filterAndRankResponsiveComboboxOptions(options: readonly ResponsiveComboboxOption[], searchQuery: string): ResponsiveComboboxOption[];
+export declare function buildResponsiveComboboxOptions({ allowCustomValue, customValueDescription, customValueKind, customValuePrefix, options, searchable, searchQuery, }: BuildResponsiveComboboxOptionsInput): ResponsiveComboboxOption[];
+export declare function orderResponsiveComboboxOptions(options: readonly ResponsiveComboboxOption[], position: "above-search" | "below-search"): ResponsiveComboboxOption[];
+export declare function getResponsiveComboboxFallbackIndex(itemCount: number, position: "above-search" | "below-search"): number;
+export declare function getNextResponsiveComboboxIndex({ currentIndex, itemCount, key, }: {
+    currentIndex: number;
+    itemCount: number;
+    key: "ArrowDown" | "ArrowUp";
+}): number;

package/dist/components/forms/ResponsiveCombobox/index.d.ts

@@ -0,0 +1,2 @@
+export { type BuildResponsiveComboboxOptionsInput, buildResponsiveComboboxOptions, filterAndRankResponsiveComboboxOptions, getNextResponsiveComboboxIndex, getResponsiveComboboxFallbackIndex, orderResponsiveComboboxOptions, shouldShowCustomResponsiveComboboxOption, } from "./helpers";
+export { ResponsiveCombobox, ResponsiveComboboxEmpty, ResponsiveComboboxItem, type ResponsiveComboboxItemProps, type ResponsiveComboboxOption, type ResponsiveComboboxOptionKind, type ResponsiveComboboxProps, ResponsiveComboboxSearchInput, type ResponsiveComboboxSearchInputProps, type ResponsiveComboboxStructuredHeader, } from "./ResponsiveCombobox";

package/dist/components/forms/ResponsiveCombobox/responsive-combobox-events.d.ts

@@ -0,0 +1,15 @@
+export declare function handleResponsiveComboboxOptionPress(onSelect: (id: string) => void, optionId: string): void;
+export declare function handleResponsiveComboboxSearchChange(setSearchQuery: (query: string) => void, onSearchQueryChange: ((query: string) => void) | undefined, nextQuery: string): void;
+export declare function applyResponsiveComboboxOpenChange(isControlled: boolean, setInternalOpen: (open: boolean) => void, onOpenChange: ((open: boolean) => void) | undefined, nextOpen: boolean): void;
+export declare function shouldIgnoreResponsiveComboboxSelection(options: readonly {
+    disabled?: boolean;
+    id: string;
+}[], id: string): boolean;
+export declare function runResponsiveComboboxSelection(options: readonly {
+    disabled?: boolean;
+    id: string;
+}[], id: string, onSelect: (id: string) => void, keepOpenOnSelect: boolean, onClose: () => void): void;
+export declare function submitResponsiveComboboxSearch(orderedOptions: readonly {
+    disabled?: boolean;
+    id: string;
+}[], activeIndex: number, handleSelect: (id: string) => void): void;

package/dist/components/forms/ResponsiveCombobox/responsive-combobox-focus.d.ts

@@ -0,0 +1,3 @@
+import type { RefObject } from "react";
+export declare function scheduleResponsiveComboboxSearchFocus(inputRef: RefObject<HTMLInputElement | null>, delayMs?: number): ReturnType<typeof setTimeout>;
+export declare function cancelResponsiveComboboxSearchFocus(timer: ReturnType<typeof setTimeout>): void;

package/dist/components/forms/ResponsiveCombobox/responsive-combobox-navigation.d.ts

@@ -0,0 +1,8 @@
+import type { ResponsiveComboboxOption } from "./ResponsiveCombobox";
+export declare function measureResponsiveComboboxAnchor(anchor: HTMLElement): DOMRect;
+export declare function nextResponsiveComboboxEnabledIndex({ currentIndex, itemCount, key, options, }: {
+    currentIndex: number;
+    itemCount: number;
+    key: "ArrowDown" | "ArrowUp";
+    options: readonly ResponsiveComboboxOption[];
+}): number;

package/dist/components/forms/ResponsiveCombobox/responsive-combobox-options-list.d.ts

@@ -0,0 +1,10 @@
+import type { ReactElement } from "react";
+import { type ResponsiveComboboxOption, type ResponsiveComboboxProps } from "./ResponsiveCombobox";
+export declare function ResponsiveComboboxOptionsList({ activeIndex, emptyText, onSelect, options, renderOption, value, }: {
+    activeIndex: number;
+    emptyText: string;
+    onSelect: (id: string) => void;
+    options: readonly ResponsiveComboboxOption[];
+    renderOption: ResponsiveComboboxProps["renderOption"];
+    value: string;
+}): ReactElement;

package/dist/components/forms/ResponsiveCombobox/responsive-combobox-primitives.d.ts

@@ -0,0 +1,27 @@
+import { type ReactElement, type ReactNode } from "react";
+export type ResponsiveComboboxOptionKind = "directory" | "file";
+export interface ResponsiveComboboxSearchInputProps {
+    autoFocus?: boolean;
+    onChangeText: (text: string) => void;
+    onSubmitEditing?: () => void;
+    placeholder: string;
+    resetKey?: number | string;
+    value?: string;
+}
+export declare function ResponsiveComboboxSearchInput({ autoFocus, onChangeText, onSubmitEditing, placeholder, resetKey: _resetKey, value, }: ResponsiveComboboxSearchInputProps): ReactElement;
+export interface ResponsiveComboboxItemProps {
+    active?: boolean;
+    description?: string;
+    disabled?: boolean;
+    kind?: ResponsiveComboboxOptionKind;
+    label: string;
+    leadingSlot?: ReactNode;
+    onPress: () => void;
+    selected?: boolean;
+    testID?: string;
+    trailingSlot?: ReactNode;
+}
+export declare function ResponsiveComboboxItem({ active, description, disabled, kind, label, leadingSlot, onPress, selected, testID, trailingSlot, }: ResponsiveComboboxItemProps): ReactElement;
+export declare function ResponsiveComboboxEmpty({ children, }: {
+    children: ReactNode;
+}): ReactElement;

package/dist/components/forms/ResponsiveCombobox/responsive-combobox-structured-header.d.ts

@@ -0,0 +1,6 @@
+import type { ReactElement } from "react";
+import type { ResponsiveComboboxStructuredHeader } from "./ResponsiveCombobox";
+export declare function ResponsiveComboboxStructuredHeaderView({ header, onClose, }: {
+    header: ResponsiveComboboxStructuredHeader;
+    onClose?: () => void;
+}): ReactElement;

package/dist/components/forms/ResponsiveCombobox/use-compact-breakpoint.d.ts

@@ -0,0 +1,2 @@
+export declare const COMPACT_BREAKPOINT_QUERY = "(max-width: 719px)";
+export declare function useCompactBreakpoint(): boolean;

package/dist/components/forms/SearchInput/SearchInput.d.ts

@@ -0,0 +1,13 @@
+import type { InputHTMLAttributes, Ref } from "react";
+import { type InputProps } from "../Input/Input";
+export interface SearchInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type"> {
+    /** Show a clear button when the field has a value. */
+    clearable?: boolean;
+    /** Called when the clear button is pressed. */
+    onClear?: () => void;
+    ref?: Ref<HTMLInputElement>;
+    size?: InputProps["size"];
+    /** `filled` = muted bordered bar; `plain` = icon + borderless input. */
+    variant?: "filled" | "plain";
+}
+export declare function SearchInput({ className, clearable, onClear, ref, size, value, variant, ...rest }: SearchInputProps): import("react").JSX.Element;

package/dist/components/forms/SearchInput/index.d.ts

@@ -0,0 +1 @@
+export { SearchInput, type SearchInputProps } from "./SearchInput";

package/dist/components/forms/Select/Select.d.ts

@@ -1,8 +1,17 @@
-import type { ReactNode, Ref, SelectHTMLAttributes } from "react";
-export interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "size"> {
+import { type ReactNode, type Ref, type SelectHTMLAttributes } from "react";
+export interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, "size" | "onChange"> {
     children?: ReactNode;
+    /** When false, trigger sizes to content (inline toolbars / share rows). Default true. */
+    fullWidth?: boolean;
     invalid?: boolean;
-    ref?: Ref<HTMLSelectElement>;
+    onChange?: (event: {
+        target: {
+            value: string;
+        };
+    }) => void;
+    ref?: Ref<HTMLButtonElement>;
     size?: "sm" | "md" | "lg";
+    /** `ghost` matches tweakcn borderless table metric inputs and inline selects. */
+    variant?: "default" | "ghost";
 }
-export declare function Select({ size, invalid, disabled, className, children, ref, ...rest }: SelectProps): import("react").JSX.Element;
+export declare function Select({ size, variant, fullWidth, invalid, disabled, className, children, value: controlledValue, defaultValue, onChange, id, name, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, ref, ...rest }: SelectProps): import("react").JSX.Element;

package/dist/components/forms/SelectableOptionGrid/SelectableOptionGrid.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes } from "react";
+export interface SelectableOption {
+    description: string;
+    id: string;
+    label: string;
+}
+export interface SelectableOptionGridProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    activeId?: string | null;
+    onChange?: (id: string) => void;
+    options: readonly SelectableOption[];
+    testIdPrefix?: string;
+}
+/**
+ * Controlled segmented option picker with the selected option's supporting
+ * description. Application code owns persistence and state; this component
+ * owns the presentation and selection intent.
+ */
+export declare function SelectableOptionGrid({ activeId, "aria-label": ariaLabel, className, onChange, options, testIdPrefix, ...rest }: SelectableOptionGridProps): import("react").JSX.Element;

package/dist/components/forms/SelectableOptionGrid/index.d.ts

@@ -0,0 +1 @@
+export { type SelectableOption, SelectableOptionGrid, type SelectableOptionGridProps, } from "./SelectableOptionGrid";

package/dist/components/forms/Slider/Slider.d.ts

@@ -0,0 +1,13 @@
+import type { ChangeEvent } from "react";
+export interface SliderProps {
+    "aria-label": string;
+    id?: string;
+    max: number;
+    min: number;
+    onChange: (event: ChangeEvent<HTMLInputElement>) => void;
+    step?: number;
+    /** Prefix for data-testid on root, track, and range (default: slider). */
+    testIdPrefix?: string;
+    value: number;
+}
+export declare function Slider({ "aria-label": ariaLabel, id, max, min, onChange, step, testIdPrefix, value, }: SliderProps): import("react").JSX.Element;

package/dist/components/forms/Slider/index.d.ts

@@ -0,0 +1 @@
+export { Slider, type SliderProps } from "./Slider";

package/dist/components/forms/Textarea/Textarea.d.ts

@@ -0,0 +1,8 @@
+import { type Ref, type TextareaHTMLAttributes } from "react";
+export interface TextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> {
+    autoResize?: boolean;
+    invalid?: boolean;
+    ref?: Ref<HTMLTextAreaElement>;
+    size?: "sm" | "md" | "lg";
+}
+export declare function Textarea({ size, invalid, disabled, autoResize, className, ref, onChange, value, defaultValue, ...rest }: TextareaProps): import("react").JSX.Element;

package/dist/components/forms/Textarea/index.d.ts

@@ -0,0 +1 @@
+export { Textarea, type TextareaProps } from "./Textarea";

package/dist/components/layout/Box/Box.d.ts

@@ -1,5 +1,5 @@
 import type { HTMLAttributes, Ref } from "react";
-import type { Space } from "../scale";
+import type { Space } from "../shared/scale";
 export interface BoxProps extends HTMLAttributes<HTMLDivElement> {
     border?: boolean;
     padding?: Space;

package/dist/components/layout/Container/Container.d.ts

@@ -1,5 +1,5 @@
 import type { HTMLAttributes, Ref } from "react";
-import type { Space } from "../scale";
+import type { Space } from "../shared/scale";
 export interface ContainerProps extends HTMLAttributes<HTMLDivElement> {
     /** Horizontal padding (padding-inline). */
     gutter?: Space;

package/dist/components/layout/Divider/Divider.d.ts

@@ -0,0 +1,11 @@
+import type { HTMLAttributes, Ref } from "react";
+export interface DividerProps extends HTMLAttributes<HTMLDivElement> {
+    /** Adds horizontal inset margin. */
+    inset?: boolean;
+    /** Optional centered text label. */
+    label?: string;
+    /** Orientation. Defaults to "horizontal". */
+    orientation?: "horizontal" | "vertical";
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function Divider({ label, inset, orientation, className, ref, ...rest }: DividerProps): import("react").JSX.Element;

package/dist/components/layout/Divider/index.d.ts

@@ -0,0 +1 @@
+export { Divider, type DividerProps } from "./Divider";

package/dist/components/layout/Grid/Grid.d.ts

@@ -1,8 +1,10 @@
 import type { HTMLAttributes, Ref } from "react";
-import { type Space } from "../scale";
+import { type Space } from "../shared/scale";
 export interface GridProps extends HTMLAttributes<HTMLDivElement> {
     columns?: 1 | 2 | 3 | 4 | 6 | 12;
     gap?: Space;
+    /** When set, columns auto-wrap using minmax(auto-fit) instead of a fixed count. */
+    minItemWidth?: string | number;
     ref?: Ref<HTMLDivElement>;
 }
-export declare function Grid({ columns, gap, className, children, ref, ...rest }: GridProps): import("react").JSX.Element;
+export declare function Grid({ columns, gap, className, children, minItemWidth, ref, style, ...rest }: GridProps): import("react").JSX.Element;

package/dist/components/layout/Inline/Inline.d.ts

@@ -1,5 +1,5 @@
 import type { HTMLAttributes, Ref } from "react";
-import { type Align, type Justify, type Space } from "../scale";
+import { type Align, type Justify, type Space } from "../shared/scale";
 export interface InlineProps extends HTMLAttributes<HTMLDivElement> {
     align?: Align;
     gap?: Space;

package/dist/components/layout/PanelDock/PanelDock.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface PanelDockProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Optional fixed-width supplementary panel. */
+    dock?: ReactNode;
+    /** Places the dock at the start or end of the main panel. Default: "end". */
+    dockPosition?: "start" | "end";
+    /** Fixed dock width in pixels. Default: 280. */
+    dockWidth?: number;
+    /** Primary panel content. */
+    main: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * A non-resizable main panel with an optional fixed-width dock. Consumers own
+ * the panel contents and any persisted layout state; the DS owns the shared
+ * canvas, clipping, and dock divider treatment.
+ */
+export declare function PanelDock({ className, dock, dockPosition, dockWidth, main, ref, ...rest }: PanelDockProps): import("react").JSX.Element;

package/dist/components/layout/PanelDock/index.d.ts

@@ -0,0 +1 @@
+export { PanelDock, type PanelDockProps } from "./PanelDock";

package/dist/components/layout/ScrollbarOverlay/ScrollbarOverlay.d.ts

@@ -0,0 +1,26 @@
+import type { HTMLAttributes } from "react";
+export interface ScrollbarMetrics {
+    contentSize: number;
+    offset: number;
+    viewportSize: number;
+}
+export interface ScrollbarOverlayProps extends Omit<HTMLAttributes<HTMLDivElement>, "onScroll"> {
+    /** Whether the overlay may render. Default: true. */
+    enabled?: boolean;
+    /** Reverses the controlled offset for inverted scroll containers. */
+    inverted?: boolean;
+    /** Current app-owned scroll measurements. */
+    metrics: ScrollbarMetrics;
+    /** Minimum visible thumb height in pixels. Default: 36. */
+    minHandleSize?: number;
+    /** Receives an app-owned target scroll offset while the thumb is dragged. */
+    onScrollToOffset: (offset: number) => void;
+}
+/**
+ * A controlled vertical scrollbar visual for web layouts.
+ *
+ * Consumers retain DOM or React Native measurement, native-scrollbar hiding,
+ * and scroll-event wiring. This component owns only the visual thumb and emits
+ * normalized target offsets while that thumb is dragged.
+ */
+export declare function ScrollbarOverlay({ className, enabled, inverted, metrics, minHandleSize, onScrollToOffset, ...rest }: ScrollbarOverlayProps): import("react").JSX.Element | null;