@amsterdamdatalabs/enact-design-system 0.1.12 → 0.1.24

package/dist/components/data/UsageBar/UsageBar.d.ts

@@ -0,0 +1,20 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type UsageBarTone = "danger" | "default" | "ok" | "warning";
+export interface UsageBarProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Short normalized metric label. */
+    label: ReactNode;
+    /** Percentage consumed. Null hides the progress track. Values are clamped for display. */
+    percent?: number | null;
+    ref?: Ref<HTMLDivElement>;
+    /** Visual status supplied by the consumer's product policy. */
+    tone?: UsageBarTone;
+    /** Optional secondary detail following the main value. */
+    trailing?: ReactNode;
+    /** Formatted primary value, such as `12 GB / 20 GB` or `75%`. */
+    value: ReactNode;
+}
+/**
+ * A normalized horizontal capacity meter. Applications format values and
+ * decide tone; the DS owns the meter layout, progress semantics, and CSS.
+ */
+export declare function UsageBar({ className, label, percent, ref, tone, trailing, value, ...rest }: UsageBarProps): import("react").JSX.Element;

package/dist/components/data/UsageBar/index.d.ts

@@ -0,0 +1 @@
+export { UsageBar, type UsageBarProps, type UsageBarTone, } from "./UsageBar";

package/dist/components/data/UsageRing/UsageRing.d.ts

@@ -0,0 +1,20 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type UsageRingTone = "auto" | "brand" | "warning" | "danger";
+export interface UsageRingProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Optional accessible or visible description shown by the design-system tooltip. */
+    label?: string;
+    /** Maximum usable capacity. Values less than or equal to zero render only when pending. */
+    max: number | null;
+    /** Reserve the compact footprint with a track-only ring while usage is loading. */
+    pending?: boolean;
+    ref?: Ref<HTMLSpanElement>;
+    /** Show label text beside the compact ring. Defaults to false. */
+    showValue?: boolean;
+    /** Visual status. `auto` maps 70% to warning and over 90% to danger. */
+    tone?: UsageRingTone;
+    /** Optional content displayed in the standard design-system tooltip. */
+    tooltipContent?: ReactNode;
+    /** Current usage. Null renders only when pending. */
+    value: number | null;
+}
+export declare function UsageRing({ value, max, pending, showValue, tone, label, tooltipContent, className, ref, ...rest }: UsageRingProps): import("react").JSX.Element | null;

package/dist/components/data/UsageRing/index.d.ts

@@ -0,0 +1 @@
+export { UsageRing, type UsageRingProps, type UsageRingTone, } from "./UsageRing";

package/dist/components/data/UsageSummaryCard/UsageSummaryCard.d.ts

@@ -0,0 +1,36 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+import { type UsageBarTone } from "../UsageBar";
+export interface UsageSummaryBar {
+    id: string;
+    label: ReactNode;
+    percent?: number | null;
+    tone?: UsageBarTone;
+    trailing?: ReactNode;
+    value: ReactNode;
+}
+export interface UsageSummaryDetail {
+    id: string;
+    label: ReactNode;
+    value: ReactNode;
+}
+export interface UsageSummaryStatus {
+    label: ReactNode;
+    tone?: "danger" | "default" | "ok";
+}
+export interface UsageSummaryCardProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "title"> {
+    bars?: UsageSummaryBar[];
+    /** Compact spacing for small overlay surfaces. */
+    compact?: boolean;
+    details?: UsageSummaryDetail[];
+    error?: ReactNode;
+    footer?: ReactNode;
+    icon?: ReactNode;
+    ref?: Ref<HTMLDivElement>;
+    status?: UsageSummaryStatus;
+    title: ReactNode;
+}
+/**
+ * A presentation-only summary of normalized capacity metrics. Consumers own
+ * data queries, formatting and status policy; the DS owns layout and CSS.
+ */
+export declare function UsageSummaryCard({ bars, className, compact, details, error, footer, icon, ref, status, title, ...rest }: UsageSummaryCardProps): import("react").JSX.Element;

package/dist/components/data/UsageSummaryCard/index.d.ts

@@ -0,0 +1 @@
+export { type UsageSummaryBar, UsageSummaryCard, type UsageSummaryCardProps, type UsageSummaryDetail, type UsageSummaryStatus, } from "./UsageSummaryCard";

package/dist/components/data/UsageSummaryList/UsageSummaryList.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export interface UsageSummaryListProps<T> extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    /** Rendered when no normalized items are available. */
+    empty?: ReactNode;
+    /** Stable key resolver. Defaults to the item index. */
+    getItemKey?: (item: T, index: number) => string | number;
+    items: readonly T[];
+    ref?: Ref<HTMLDivElement>;
+    /** Maps a normalized item to its product-specific DS view. */
+    renderItem: (item: T, index: number) => ReactNode;
+}
+/**
+ * A generic framed list for usage summaries. Applications provide item models
+ * and rendering; the DS owns list border, separators, empty state and CSS.
+ */
+export declare function UsageSummaryList<T>({ className, empty, getItemKey, items, ref, renderItem, ...rest }: UsageSummaryListProps<T>): import("react").JSX.Element | null;

package/dist/components/data/UsageSummaryList/index.d.ts

@@ -0,0 +1 @@
+export { UsageSummaryList, type UsageSummaryListProps, } from "./UsageSummaryList";

package/dist/components/data/WaterfallChart/WaterfallChart.d.ts

@@ -0,0 +1,12 @@
+import type { HTMLAttributes, Ref } from "react";
+export type WaterfallChartStepKind = "decrease" | "increase" | "total";
+export interface WaterfallChartStep {
+    kind: WaterfallChartStepKind;
+    label: string;
+    value: number;
+}
+export interface WaterfallChartProps extends HTMLAttributes<HTMLDivElement> {
+    data: WaterfallChartStep[];
+    ref?: Ref<HTMLDivElement>;
+}
+export declare function WaterfallChart({ data, className, ref, ...rest }: WaterfallChartProps): import("react").JSX.Element | null;

package/dist/components/data/WaterfallChart/index.d.ts

@@ -0,0 +1 @@
+export { WaterfallChart, type WaterfallChartProps, type WaterfallChartStep, type WaterfallChartStepKind, } from "./WaterfallChart";

package/dist/components/data/chartPlotMetrics.d.ts

@@ -0,0 +1,3 @@
+/** SVG viewBox height — keep in sync with `--chart-plot-height` in theme-contract.css */
+export declare const CHART_PLOT_HEIGHT = 180;
+export declare const CHART_PLOT_WIDTH = 420;

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

@@ -0,0 +1,22 @@
+import type { HTMLAttributes, ReactNode, Ref } from "react";
+export type ActivitySkeletonPlaceholderKind = "avatar" | "wide-line" | "narrow-line";
+export type ActivitySkeletonPlaceholderVariant = "circle" | "text";
+export interface ActivitySkeletonPlaceholder {
+    /** DS-owned geometry class for the placeholder slot. */
+    className: string;
+    /** Stable identifier for the placeholder slot. */
+    id: string;
+    /** Semantic shape of the placeholder slot. */
+    kind: ActivitySkeletonPlaceholderKind;
+    /** Default DS skeleton variant for the slot. */
+    variant: ActivitySkeletonPlaceholderVariant;
+}
+export interface ActivitySkeletonProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    ref?: Ref<HTMLDivElement>;
+    /** Optional application-owned placeholder renderer. */
+    renderPlaceholder?: (slot: ActivitySkeletonPlaceholder) => ReactNode;
+    /** Number of activity rows to render. Defaults to 3. */
+    rowCount?: number;
+}
+/** Controlled activity loading presentation with an optional app-owned pulse. */
+export declare function ActivitySkeleton({ className, ref, renderPlaceholder, rowCount, ...rest }: ActivitySkeletonProps): import("react").JSX.Element;

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";