@amsterdamdatalabs/enact-design-system 0.1.12 → 0.1.19

package/dist/components/feedback/ActivitySkeleton/index.d.ts

@@ -0,0 +1 @@
+export { ActivitySkeleton, type ActivitySkeletonPlaceholder, type ActivitySkeletonPlaceholderKind, type ActivitySkeletonPlaceholderVariant, type ActivitySkeletonProps, } from "./ActivitySkeleton";

package/dist/components/feedback/Alert/Alert.d.ts

@@ -1,10 +1,35 @@
 import type { HTMLAttributes, ReactNode, Ref } from "react";
 export type AlertTone = "info" | "success" | "warning" | "danger";
+/**
+ * The visual treatment for an alert. The default keeps Alert's established
+ * inline-panel presentation; `sidebar` is for the full-width callout slot.
+ */
+export type AlertAppearance = "default" | "sidebar";
+export type AlertActionVariant = "primary" | "secondary";
+export interface AlertAction {
+    disabled?: boolean;
+    label: string;
+    onPress: () => void;
+    testID?: string;
+    variant?: AlertActionVariant;
+}
 export interface AlertProps extends HTMLAttributes<HTMLDivElement> {
+    /** At most two actions are displayed in the sidebar appearance. */
+    actions?: readonly AlertAction[];
+    appearance?: AlertAppearance;
     children?: ReactNode;
+    /** Accessible label for the dismiss control. Defaults to "Dismiss". */
+    dismissLabel?: string;
+    /** Replaces the tone icon when provided. */
+    icon?: ReactNode;
     onDismiss?: () => void;
     ref?: Ref<HTMLDivElement>;
+    /** Test-id prefix for the root, dismiss control, and action controls. */
+    testID?: string;
     title?: string;
     tone?: AlertTone;
 }
-export declare function Alert({ tone, title, onDismiss, className, children, ref, ...rest }: AlertProps): import("react").JSX.Element;
+export declare function Alert({ tone, title, onDismiss, appearance, icon, actions, testID, dismissLabel, className, children, ref, ...rest }: AlertProps): import("react").JSX.Element;
+export declare function AlertDescription({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

package/dist/components/feedback/Alert/index.d.ts

@@ -1 +1 @@
-export { Alert, type AlertProps, type AlertTone } from "./Alert";
+export { Alert, type AlertAction, type AlertActionVariant, type AlertAppearance, AlertDescription, type AlertProps, type AlertTone, } from "./Alert";

package/dist/components/feedback/ArchivedAgentCallout/ArchivedAgentCallout.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface ArchivedAgentCalloutViewProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Whether the application currently permits the action. */
+    actionDisabled?: boolean;
+    /** Display-ready action label supplied by the application. */
+    actionLabel: ReactNode;
+    /** Display-ready archived-state message supplied by the application. */
+    message: ReactNode;
+    /** Reports the user's unarchive intent; the application owns its outcome. */
+    onAction: () => void;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * Controlled archived-agent callout. The application maps connection and
+ * mutation state into the disabled prop and owns the action outcome; the
+ * design system owns the reusable layout, markup, and visual treatment.
+ */
+export declare function ArchivedAgentCalloutView({ actionDisabled, actionLabel, className, message, onAction, ref, ...rest }: ArchivedAgentCalloutViewProps): import("react").JSX.Element;

package/dist/components/feedback/ArchivedAgentCallout/index.d.ts

@@ -0,0 +1 @@
+export { ArchivedAgentCalloutView, type ArchivedAgentCalloutViewProps, } from "./ArchivedAgentCallout";

package/dist/components/feedback/EmptyState/EmptyState.d.ts

@@ -0,0 +1,18 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface EmptyStateProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Optional caller-owned action slot, such as a design-system button. */
+    action?: ReactNode;
+    /** Optional secondary, already-localized guidance. */
+    hint?: ReactNode;
+    /** Optional decorative or caller-owned icon slot. */
+    icon?: ReactNode;
+    /** Primary, already-localized empty-state copy. */
+    message: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * Controlled empty-state presentation for application-owned loading, routing,
+ * search, and data boundaries. Consumers provide localized copy and optional
+ * slots; this component owns the centered visual hierarchy and spacing.
+ */
+export declare function EmptyState({ action, className, hint, icon, message, ref, ...rest }: EmptyStateProps): import("react").JSX.Element;

package/dist/components/feedback/EmptyState/index.d.ts

@@ -0,0 +1 @@
+export { EmptyState, type EmptyStateProps } from "./EmptyState";

package/dist/components/feedback/OperationProgressList/OperationProgressList.d.ts

@@ -0,0 +1,28 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type OperationProgressState = "pending" | "running" | "completed" | "failed";
+/** A caller-normalized unit of collection or background-operation progress. */
+export interface OperationProgressItem {
+    /** Stable row key supplied by the consuming application. */
+    id: string;
+    /** Already-localized operation name. */
+    label: ReactNode;
+    state: OperationProgressState;
+    /** Optional already-localized state copy, rendered after the operation name. */
+    stateLabel?: ReactNode;
+}
+export interface OperationProgressListProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Accessible name for the operation-status region. */
+    accessibilityLabel?: string;
+    /** Content while the caller has not yet supplied operation rows. */
+    emptyLabel?: ReactNode;
+    items: readonly OperationProgressItem[];
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * Controlled visual progress for a collection of app-owned operations.
+ *
+ * Collection, retry, cancellation, translations, and state transitions stay
+ * with the consuming application. This component only renders the normalized
+ * rows and their token-backed status affordances.
+ */
+export declare function OperationProgressList({ accessibilityLabel, className, emptyLabel, items, ref, ...rest }: OperationProgressListProps): import("react").JSX.Element;

package/dist/components/feedback/OperationProgressList/index.d.ts

@@ -0,0 +1 @@
+export { type OperationProgressItem, OperationProgressList, type OperationProgressListProps, type OperationProgressState, } from "./OperationProgressList";

package/dist/components/feedback/Progress/Progress.d.ts

@@ -1,6 +1,8 @@
 import type { HTMLAttributes, Ref } from "react";
 export type ProgressTone = "brand" | "success" | "warning" | "danger" | "accent";
 export interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
+    /** Indeterminate spinner mode — animates continuously, ignoring value/max. */
+    indeterminate?: boolean;
     label?: string;
     max?: number;
     ref?: Ref<HTMLDivElement>;
@@ -8,4 +10,4 @@ export interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
     tone?: ProgressTone;
     value?: number;
 }
-export declare function Progress({ value, max, tone, label, showValue, className, ref, ...rest }: ProgressProps): import("react").JSX.Element;
+export declare function Progress({ value, max, tone, label, showValue, indeterminate, className, ref, ...rest }: ProgressProps): import("react").JSX.Element;

package/dist/components/feedback/PullRequestSkeleton/PullRequestSkeleton.d.ts

@@ -0,0 +1,39 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import { type SkeletonVariant } from "../Skeleton/Skeleton";
+export type PullRequestSkeletonPlaceholderKind = "activity-avatar" | "activity-detail" | "activity-title" | "check-dot" | "check-name" | "header-subtitle" | "header-title" | "toolbar-button";
+/** A DS-owned skeleton slot that an app may animate with its own runtime. */
+export interface PullRequestSkeletonPlaceholder {
+    /** CSS-module class that supplies this slot's DS-owned geometry. */
+    className: string;
+    /** Stable identifier for the visual skeleton slot. */
+    id: string;
+    /** Semantic slot category, for callers selecting an equivalent placeholder. */
+    kind: PullRequestSkeletonPlaceholderKind;
+    /** Default DS skeleton shape. */
+    variant: SkeletonVariant;
+}
+export interface PullRequestSkeletonProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Accessible name for the loading region. */
+    accessibilityLabel?: string;
+    /** Number of activity rows to render. Defaults to 3. */
+    activityRowCount?: number;
+    /** Number of check rows to render. Defaults to 3. */
+    checkRowCount?: number;
+    /** Already-localized heading shown above the check rows. */
+    checksLabel?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+    /**
+     * Optional app-owned placeholder renderer. The DS keeps the surrounding
+     * layout and geometry class; an adapter can use this to retain a native or
+     * runtime-specific pulse implementation without importing it into DS.
+     */
+    renderPlaceholder?: (placeholder: PullRequestSkeletonPlaceholder) => ReactNode;
+}
+/**
+ * Controlled loading presentation for a pull-request detail pane.
+ *
+ * The application owns fetching and any runtime-specific pulse implementation.
+ * By default, this component composes DS `Skeleton` placeholders; callers may
+ * supply `renderPlaceholder` to preserve an existing animated placeholder.
+ */
+export declare function PullRequestSkeleton({ accessibilityLabel, activityRowCount, checkRowCount, checksLabel, className, ref, renderPlaceholder, ...rest }: PullRequestSkeletonProps): import("react").JSX.Element;

package/dist/components/feedback/PullRequestSkeleton/index.d.ts

@@ -0,0 +1 @@
+export { PullRequestSkeleton, type PullRequestSkeletonPlaceholder, type PullRequestSkeletonPlaceholderKind, type PullRequestSkeletonProps, } from "./PullRequestSkeleton";

package/dist/components/feedback/ReplayStatusBanner/ReplayStatusBanner.d.ts

@@ -0,0 +1,10 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ReplayStatus = "error" | "idle" | "loading" | "success";
+export interface ReplayStatusBannerProps extends Omit<HTMLAttributes<HTMLElement>, "children" | "title"> {
+    actions?: ReactNode;
+    detail?: ReactNode;
+    ref?: Ref<HTMLElement>;
+    status: ReplayStatus;
+    title: ReactNode;
+}
+export declare function ReplayStatusBanner({ actions, className, detail, ref, status, title, ...rest }: ReplayStatusBannerProps): import("react").JSX.Element;

package/dist/components/feedback/ReplayStatusBanner/index.d.ts

@@ -0,0 +1 @@
+export { type ReplayStatus, ReplayStatusBanner, type ReplayStatusBannerProps, } from "./ReplayStatusBanner";

package/dist/components/feedback/Spinner/Spinner.d.ts

@@ -0,0 +1,6 @@
+export interface SpinnerProps {
+    color?: string;
+    size?: "large" | "small" | number;
+}
+/** Decorative token-friendly loading indicator. */
+export declare function Spinner({ color, size, }: SpinnerProps): import("react").JSX.Element;

package/dist/components/feedback/Spinner/index.d.ts

@@ -0,0 +1 @@
+export { Spinner, type SpinnerProps } from "./Spinner";

package/dist/components/feedback/StatusDot/StatusDot.d.ts

@@ -0,0 +1,7 @@
+import type { HTMLAttributes, Ref } from "react";
+export type StatusDotTone = "success" | "danger" | "warning" | "neutral" | "info" | "running" | "unread";
+export interface StatusDotProps extends HTMLAttributes<HTMLSpanElement> {
+    ref?: Ref<HTMLSpanElement>;
+    tone: StatusDotTone;
+}
+export declare function StatusDot({ tone, className, ref, ...rest }: StatusDotProps): import("react").JSX.Element;

package/dist/components/feedback/StatusDot/index.d.ts

@@ -0,0 +1 @@
+export { StatusDot, type StatusDotProps, type StatusDotTone, } from "./StatusDot";

package/dist/components/feedback/Toast/Toast.d.ts

@@ -0,0 +1,49 @@
+import { type ReactNode } from "react";
+export type ToastTone = "info" | "success" | "warning" | "danger";
+export interface ToastOptions {
+    /** Optional call-to-action rendered inside the toast. */
+    action?: {
+        label: string;
+        onClick(): void;
+    };
+    /** Optional body content. */
+    description?: ReactNode;
+    /**
+     * Auto-dismiss delay in ms. Defaults to 5000.
+     * Pass 0 to keep the toast until manually dismissed.
+     */
+    duration?: number;
+    /** Heading text (required). */
+    title: string;
+    /** Visual/semantic tone. Defaults to "info". */
+    tone?: ToastTone;
+}
+interface ToastContextValue {
+    dismiss(id: string): void;
+    toast(opts: ToastOptions): string;
+}
+export declare function useToast(): ToastContextValue;
+export interface ToastProviderProps {
+    children: ReactNode;
+    /** Override the maximum number of visible toasts. Defaults to 5. */
+    maxStack?: number;
+}
+export declare function ToastProvider({ children, maxStack, }: ToastProviderProps): import("react").JSX.Element;
+export interface ToastProps {
+    action?: {
+        label: string;
+        onClick(): void;
+    };
+    className?: string;
+    description?: ReactNode;
+    id: string;
+    onBlur?: () => void;
+    onDismiss(): void;
+    onFocus?: () => void;
+    onMouseEnter?: () => void;
+    onMouseLeave?: () => void;
+    title: string;
+    tone?: ToastTone;
+}
+export declare function Toast({ id, tone, title, description, action, onDismiss, onMouseEnter, onMouseLeave, onFocus, onBlur, className, ...rest }: ToastProps): import("react").JSX.Element;
+export {};

package/dist/components/feedback/Toast/ToastViewport.d.ts

@@ -0,0 +1,37 @@
+import type { ReactNode } from "react";
+/** Visual treatment for the controlled, single-notification toast surface. */
+export type ToastViewportTone = "default" | "success" | "error";
+/**
+ * Layout context for a controlled toast surface.
+ *
+ * `overlay` is positioned relative to the portal or overlay root supplied by
+ * the consumer. `panel` keeps the same visual surface in ordinary document
+ * flow, with the panel spacing used by embedded application panes.
+ */
+export type ToastViewportPlacement = "overlay" | "panel";
+export interface ToastViewportProps {
+    /** Content supplied by the consumer; it may include rich, controlled UI. */
+    content: ReactNode;
+    /** Optional leading visual, such as a status icon. */
+    icon?: ReactNode;
+    /** Called when a pointer enters the toast, typically to pause app-owned dismissal. */
+    onPointerEnter?: () => void;
+    /** Called when a pointer leaves the toast, typically to resume app-owned dismissal. */
+    onPointerLeave?: () => void;
+    /** Whether the toast is overlaid or rendered in an embedded panel. */
+    placement?: ToastViewportPlacement;
+    /** Optional DOM test id. */
+    testId?: string;
+    /** Visual tone only; timing, queueing, and platform behaviour remain controlled by the consumer. */
+    tone?: ToastViewportTone;
+    /** Vertical inset supplied by the host for shell headers and safe areas. */
+    topOffset?: number | string;
+}
+/**
+ * A controlled, single-toast visual surface.
+ *
+ * This deliberately owns neither queueing, timers, portals, safe-area policy,
+ * native Android dispatch, nor enter/exit animation. Consumers normalize that
+ * runtime behaviour and pass just the rendered content and interaction intents.
+ */
+export declare function ToastViewport({ content, icon, onPointerEnter, onPointerLeave, placement, topOffset, tone, testId, }: ToastViewportProps): import("react").JSX.Element;

package/dist/components/feedback/Toast/index.d.ts

@@ -0,0 +1,2 @@
+export { Toast, type ToastOptions, type ToastProps, ToastProvider, type ToastProviderProps, type ToastTone, useToast, } from "./Toast";
+export { ToastViewport, type ToastViewportPlacement, type ToastViewportProps, type ToastViewportTone, } from "./ToastViewport";

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

@@ -0,0 +1,36 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type CadenceEditorMode = "cron" | "interval";
+export interface CadenceEditorOption {
+    id: string;
+    label: string;
+}
+export interface CadenceEditorPreset {
+    id: string;
+    label: string;
+    value: string;
+}
+export interface CadenceEditorProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** A normalized description or validation message for the current cron value. */
+    cronFeedback?: ReactNode;
+    cronValue: string;
+    error?: ReactNode;
+    intervalPreview?: ReactNode;
+    intervalUnit: string;
+    intervalUnits: CadenceEditorOption[];
+    intervalValue: string;
+    mode: CadenceEditorMode;
+    onCronChange: (value: string) => void;
+    onIntervalUnitChange: (unit: string) => void;
+    onIntervalValueChange: (value: string) => void;
+    onModeChange: (mode: CadenceEditorMode) => void;
+    onPresetSelect?: (preset: CadenceEditorPreset) => void;
+    presets?: CadenceEditorPreset[];
+    ref?: Ref<HTMLDivElement>;
+    timezoneHint?: ReactNode;
+}
+/**
+ * Controlled recurrence editor presentation. Consumers convert domain cadence
+ * values, validate cron, select timezones and persist changes; DS owns fields,
+ * presets, feedback states and CSS.
+ */
+export declare function CadenceEditor({ className, cronFeedback, cronValue, error, intervalPreview, intervalUnit, intervalUnits, intervalValue, mode, onCronChange, onIntervalUnitChange, onIntervalValueChange, onModeChange, onPresetSelect, presets, ref, timezoneHint, ...rest }: CadenceEditorProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { CadenceEditor, type CadenceEditorMode, type CadenceEditorOption, type CadenceEditorPreset, type CadenceEditorProps, } from "./CadenceEditor";

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

@@ -1,6 +1,6 @@
 import { type ChangeEvent, type LabelHTMLAttributes, type ReactNode, type Ref } from "react";
 export interface CheckboxProps extends Omit<LabelHTMLAttributes<HTMLLabelElement>, "onChange"> {
-    checked?: boolean;
+    checked?: boolean | "indeterminate";
     defaultChecked?: boolean;
     disabled?: boolean;
     label?: ReactNode;

package/dist/components/forms/Combobox/Autocomplete.d.ts

@@ -0,0 +1,28 @@
+import { type ReactElement } from "react";
+export interface AutocompleteOption {
+    description?: string;
+    detail?: string;
+    id: string;
+    /** Application-defined classification used for optional icon and preview treatments. */
+    kind?: string;
+    label: string;
+    meta?: string;
+}
+export interface AutocompleteProps {
+    emptyText?: string;
+    errorMessage?: string;
+    isLoading?: boolean;
+    /** Accessible label for the controlled result list. */
+    listboxLabel?: string;
+    loadingText?: string;
+    maxHeight?: number;
+    onSelect: (option: AutocompleteOption) => void;
+    options: readonly AutocompleteOption[];
+    selectedIndex: number;
+    /** Selects the compact composer treatment. Defaults to the file/command treatment. */
+    variant?: "default" | "composer";
+    /** Suppresses rendering without unmounting the caller's positioning adapter. */
+    visible?: boolean;
+}
+/** A controlled autocomplete result list with DS-owned visual states. */
+export declare function Autocomplete({ emptyText, errorMessage, isLoading, listboxLabel, loadingText, maxHeight, onSelect, options, selectedIndex, variant, visible, }: AutocompleteProps): ReactElement | null;

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

@@ -0,0 +1,33 @@
+import { type InputHTMLAttributes, type Ref } from "react";
+export interface ComboboxOption {
+    disabled?: boolean;
+    label: string;
+    value: string;
+}
+export interface ComboboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange" | "defaultValue"> {
+    /** Show a clear button when there is a value. */
+    clearable?: boolean;
+    /** Uncontrolled default — the initial `value` of the selected option. */
+    defaultValue?: string;
+    /** Whether the combobox is disabled. */
+    disabled?: boolean;
+    /** Text shown when no options match the query. */
+    emptyText?: string;
+    /** Override the default case-insensitive substring filter. */
+    filter?: (query: string, option: ComboboxOption) => boolean;
+    /** Whether the combobox is in an invalid/error state. */
+    invalid?: boolean;
+    /** Called with the option value when the user selects an option, or "" when cleared. */
+    onChange?: (value: string) => void;
+    /** The list of options to display. */
+    options: ComboboxOption[];
+    /** Placeholder text for the input. */
+    placeholder?: string;
+    /** Forwarded ref to the underlying input element. */
+    ref?: Ref<HTMLInputElement>;
+    /** Input height: sm=32px, md=40px, lg=48px. */
+    size?: "sm" | "md" | "lg";
+    /** Controlled value — the `value` of the selected option. */
+    value?: string;
+}
+export declare function Combobox({ options, value: controlledValue, defaultValue, onChange, placeholder, clearable, disabled, invalid, size, filter, emptyText, className, ref, ...rest }: ComboboxProps): import("react").JSX.Element;

package/dist/components/forms/Combobox/ComboboxTrigger.d.ts

@@ -0,0 +1,33 @@
+import { type CSSProperties, type MouseEvent, type ReactElement, type ReactNode, type Ref } from "react";
+export interface ComboboxTriggerState {
+    hovered?: boolean;
+    open?: boolean;
+    pressed: boolean;
+}
+export interface ComboboxTriggerProps {
+    accessibilityLabel?: string;
+    accessibilityRole?: string;
+    block?: boolean;
+    chevron?: ReactNode | null;
+    children?: ReactNode | ((state: ComboboxTriggerState) => ReactNode);
+    className?: string | ((state: ComboboxTriggerState) => string);
+    /** Compatibility no-op for React Native Web callers. */
+    collapsable?: boolean;
+    disabled?: boolean;
+    /** Stretches the trigger to its container without application CSS. */
+    fill?: boolean;
+    /** Optional DS-owned label for the model-selector variant. */
+    label?: ReactNode;
+    /** Optional DS-owned leading visual for the model-selector variant. */
+    leading?: ReactNode;
+    onPress?: (event: MouseEvent<HTMLButtonElement>) => void;
+    /** Controlled popup state used for visual and ARIA state. */
+    open?: boolean;
+    ref?: Ref<HTMLButtonElement>;
+    style?: CSSProperties;
+    testID?: string;
+    /** Additive DS visual treatment. The default preserves the existing bare trigger. */
+    variant?: "bare" | "icon" | "model-selector";
+}
+/** A compact, token-owned trigger for controlled combobox and picker views. */
+export declare function ComboboxTrigger({ accessibilityLabel, accessibilityRole, block, chevron, children, className, disabled, fill, leading, label, onPress, open, ref, style, testID, variant, }: ComboboxTriggerProps): ReactElement;

package/dist/components/forms/Combobox/autocomplete-utils.d.ts

@@ -0,0 +1,7 @@
+export declare function removeBoltGlyphs(value?: string): string | undefined;
+export declare function getScrollOffset({ currentOffset, itemHeight, itemTop, viewportHeight, }: {
+    currentOffset: number;
+    itemHeight: number;
+    itemTop: number;
+    viewportHeight: number;
+}): number;

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

@@ -0,0 +1,6 @@
+export type { AutocompleteOption, AutocompleteProps } from "./Autocomplete";
+export { Autocomplete } from "./Autocomplete";
+export type { ComboboxOption, ComboboxProps } from "./Combobox";
+export { Combobox } from "./Combobox";
+export type { ComboboxTriggerProps, ComboboxTriggerState, } from "./ComboboxTrigger";
+export { ComboboxTrigger } from "./ComboboxTrigger";

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

@@ -6,7 +6,9 @@ export interface FieldProps extends HTMLAttributes<HTMLDivElement> {
     /** Forwarded to the label's `for` attribute. */
     htmlFor?: string;
     label?: string;
+    /** Extra class applied to the label element (merged after the base label style). */
+    labelClassName?: string;
     ref?: Ref<HTMLDivElement>;
     required?: boolean;
 }
-export declare function Field({ label, hint, error, required, htmlFor, className, children, ref, ...rest }: FieldProps): import("react").JSX.Element;
+export declare function Field({ label, labelClassName, hint, error, required, htmlFor, className, children, ref, ...rest }: FieldProps): import("react").JSX.Element;

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

@@ -0,0 +1,23 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface FileDropZoneProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** The file types accepted by the application-owned drop handler. */
+    accept?: string;
+    /** Shows the controlled drag-active presentation. */
+    active?: boolean;
+    children: ReactNode;
+    /** Hides the active presentation when the application cannot accept a drop. */
+    disabled?: boolean;
+    /** Optional supporting text beneath the drop label. */
+    hint?: ReactNode;
+    /** Text presented in the drag-active overlay. */
+    label?: ReactNode;
+    /** Replaces the default upload icon and text in the active overlay. */
+    overlay?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+}
+/**
+ * Controlled drag-and-drop presentation shell. Applications retain event
+ * listeners, file routing, persistence, and any runtime-specific acceptance
+ * logic; this component owns only the visual active and disabled states.
+ */
+export declare function FileDropZone({ accept, active, children, className, disabled, hint, label, overlay, ref, ...rest }: FileDropZoneProps): import("react").JSX.Element;

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

@@ -0,0 +1 @@
+export { FileDropZone, type FileDropZoneProps } from "./FileDropZone";

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;