@collective-intelligence/ui-react 0.0.0-stage → 0.1.0

package/dist/components/ui-extensions/index.d.ts

@@ -0,0 +1,1147 @@
+// Generated by dts-bundle-generator v9.5.1
+
+import * as DropdownMenuPrimitive from '@radix-ui/react-dropdown-menu';
+import * as PopoverPrimitive from '@radix-ui/react-popover';
+import * as RadioGroupPrimitive from '@radix-ui/react-radio-group';
+import { VariantProps } from 'class-variance-authority';
+import * as React$1 from 'react';
+import React$1 from 'react';
+import { ComponentProps, ComponentType, ReactNode } from 'react';
+
+declare const buttonVariants: (props?: ({
+	size?: "default" | "icon" | "lg" | "sm" | null | undefined;
+	variant?: "default" | "destructive" | "ghost" | "link" | "outline" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare const Button: ({ className, variant, size, asChild, ...props }: React$1.ComponentProps<"button"> & VariantProps<typeof buttonVariants> & {
+	asChild?: boolean;
+}) => React$1.JSX.Element;
+export interface ActionButtonProps extends React$1.ButtonHTMLAttributes<HTMLButtonElement>, VariantProps<typeof buttonVariants> {
+	loading?: boolean;
+	fullWidth?: boolean;
+}
+export declare const ActionButton: React$1.FC<ActionButtonProps>;
+export type AddItemButtonProps = React$1.ButtonHTMLAttributes<HTMLButtonElement>;
+export declare const AddItemButton: React$1.ForwardRefExoticComponent<AddItemButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+export type DateInputProps = Omit<React$1.ComponentProps<"input">, "type">;
+/**
+ * Date input that accepts pasted values in common human formats
+ * (dd/mm/yyyy, dd-mm-yyyy, dd.mm.yyyy) and converts them to the
+ * ISO format required by `<input type="date">`.
+ *
+ * Works as a drop-in replacement for `<Input type="date" />` and is
+ * compatible with react-hook-form by dispatching a native input event
+ * via the prototype value setter so registered onChange handlers fire.
+ */
+export declare const DateInput: import("react").ForwardRefExoticComponent<Omit<DateInputProps, "ref"> & import("react").RefAttributes<HTMLInputElement>>;
+export declare const displayHeadingVariants: (props?: ({
+	size?: "lg" | "sm" | "md" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface DisplayHeadingProps extends React$1.HTMLAttributes<HTMLHeadingElement>, VariantProps<typeof displayHeadingVariants> {
+	as?: "h1" | "h2" | "h3" | "h4" | "div" | "span";
+}
+export declare const DisplayHeading: React$1.ForwardRefExoticComponent<DisplayHeadingProps & React$1.RefAttributes<HTMLHeadingElement>>;
+export interface CopyButtonProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "onCopy"> {
+	/** The text written to the clipboard. */
+	value: string;
+	/** Accessible name for what is being copied, e.g. "Server URL". */
+	label: string;
+	/**
+	 * "icon" renders a compact square icon button; "button" renders an outline
+	 * button with a visible Copy/Copied label.
+	 */
+	variant?: "icon" | "button";
+	/** Visible labels for the "button" variant. */
+	copyLabel?: React$1.ReactNode;
+	copiedLabel?: React$1.ReactNode;
+	/** Toast message when the clipboard write fails. */
+	errorMessage?: string;
+	/** How long the copied state persists, in milliseconds. */
+	resetDelay?: number;
+}
+export declare const CopyButton: React$1.ForwardRefExoticComponent<CopyButtonProps & React$1.RefAttributes<HTMLButtonElement>>;
+export type CollectiveIntelligenceLoaderProps = Omit<React$1.ComponentProps<"svg">, "children">;
+export declare const CollectiveIntelligenceLoader: {
+	({ className, ...props }: CollectiveIntelligenceLoaderProps): React$1.JSX.Element;
+	displayName: string;
+};
+export interface ErrorMessageProps {
+	children: React$1.ReactNode;
+	className?: string;
+}
+export declare const ErrorMessage: ({ children, className }: ErrorMessageProps) => React$1.JSX.Element;
+export interface FormattedNumberProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+	value: number | null | undefined;
+	fallback?: React$1.ReactNode;
+	locale?: string;
+}
+export declare const FormattedNumber: React$1.ForwardRefExoticComponent<FormattedNumberProps & React$1.RefAttributes<HTMLSpanElement>>;
+export type IconTileTone = "accent" | "sage" | "gold" | "sky" | "violet" | "neutral";
+export interface IconTileProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+	tone?: IconTileTone;
+	size?: "sm" | "md" | "lg";
+	/**
+	 * Short text rendered instead of an icon child — typically a single
+	 * initial. Ignored when `children` is provided.
+	 */
+	initial?: string;
+}
+/**
+ * App-icon style identity tile: a softly tinted square holding either an
+ * icon or an initial letter. Use it to give list items (extensions, apps,
+ * connectors) a recognisable face; pick the tone from the item's category
+ * so groups become scannable without reading.
+ */
+export declare const IconTile: React$1.ForwardRefExoticComponent<IconTileProps & React$1.RefAttributes<HTMLSpanElement>>;
+export interface KickerProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+	as?: React$1.ElementType;
+	tone?: "default" | "muted" | "accent" | "copper";
+}
+export declare const Kicker: React$1.ForwardRefExoticComponent<KickerProps & React$1.RefAttributes<HTMLSpanElement>>;
+export interface ShowMoreTagProps extends Omit<React$1.ButtonHTMLAttributes<HTMLButtonElement>, "children" | "type"> {
+	expanded: boolean;
+	hiddenCount: number;
+	collapsedLabel?: (hiddenCount: number) => React$1.ReactNode;
+	expandedLabel?: React$1.ReactNode;
+	onToggle: () => void;
+}
+export declare const ShowMoreTag: React$1.ForwardRefExoticComponent<ShowMoreTagProps & React$1.RefAttributes<HTMLButtonElement>>;
+declare const serifNumeralVariants: (props?: ({
+	size?: "lg" | "sm" | "md" | "xl" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface SerifNumeralProps extends React$1.HTMLAttributes<HTMLSpanElement>, VariantProps<typeof serifNumeralVariants> {
+}
+export declare const SerifNumeral: React$1.ForwardRefExoticComponent<SerifNumeralProps & React$1.RefAttributes<HTMLSpanElement>>;
+export declare const Ring: {
+	({ className, classes, label, max, min, title, value, "aria-label": ariaLabel, ...props }: RingProps): React$1.JSX.Element;
+	displayName: string;
+};
+export interface RingProps extends Omit<React$1.ComponentProps<"span">, "children"> {
+	label: string;
+	value: number;
+	max?: number;
+	min?: number;
+	classes?: {
+		root?: string;
+		svg?: string;
+		track?: string;
+		indicator?: string;
+	};
+}
+export type ThemeToggleValue = "light" | "dark" | "system";
+export interface ThemeToggleProps {
+	onThemeChange: (theme: ThemeToggleValue) => void;
+	value?: ThemeToggleValue;
+	labels?: ThemeToggleLabels;
+	className?: string;
+}
+export interface ThemeToggleLabels {
+	title: string;
+	toggle: string;
+	light: string;
+	dark: string;
+	system: string;
+}
+export declare const ThemeToggle: ({ onThemeChange, value, labels, className }: ThemeToggleProps) => React$1.JSX.Element;
+export type StatusDotTone = "success" | "warning" | "danger" | "primary" | "neutral";
+export interface StatusDotProps extends React$1.HTMLAttributes<HTMLSpanElement> {
+	tone?: StatusDotTone;
+	/** Renders an expanding ping halo for "live right now" states. */
+	pulse?: boolean;
+	size?: "sm" | "md";
+}
+export declare const StatusDot: React$1.ForwardRefExoticComponent<StatusDotProps & React$1.RefAttributes<HTMLSpanElement>>;
+declare const badgeVariants: (props?: ({
+	variant?: "default" | "destructive" | "outline" | "secondary" | "mono" | "soft" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare const Badge: ({ className, variant, asChild, ...props }: React$1.ComponentProps<"span"> & VariantProps<typeof badgeVariants> & {
+	asChild?: boolean;
+}) => React$1.JSX.Element;
+export type TooltipBadgeTone = "neutral" | "warning";
+export interface TooltipBadgeProps extends Omit<React$1.ComponentProps<typeof Badge>, "variant" | "asChild"> {
+	/** Explanation shown on hover/focus; the badge label stays compact. */
+	tooltip: React$1.ReactNode;
+	tone?: TooltipBadgeTone;
+	icon?: React$1.ReactNode;
+}
+export declare const TooltipBadge: React$1.ForwardRefExoticComponent<Omit<TooltipBadgeProps, "ref"> & React$1.RefAttributes<HTMLSpanElement>>;
+export type TypographyVariant = "h1" | "h2" | "h3" | "h4" | "subtitle1" | "subtitle2" | "body1" | "body2";
+export interface TypographyProps extends React$1.HTMLAttributes<HTMLElement> {
+	variant?: TypographyVariant;
+	as?: React$1.ElementType;
+}
+export declare const Typography: React$1.ForwardRefExoticComponent<TypographyProps & React$1.RefAttributes<HTMLElement>>;
+export type FormFrameProps = React$1.HTMLAttributes<HTMLDivElement> & {
+	children: React$1.ReactNode;
+	as?: React$1.ElementType;
+	onSubmit?: (event: React$1.SubmitEvent<HTMLFormElement>) => void;
+};
+export declare const FormFrame: ({ children, as: Component, className, onSubmit, ...props }: FormFrameProps) => React$1.JSX.Element;
+export interface GridCols {
+	cols?: number;
+	colsSm?: number;
+	colsMd?: number;
+	colsLg?: number;
+	colsXl?: number;
+	cols2xl?: number;
+}
+export interface GridProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	cols?: GridCols;
+	children: React$1.ReactNode;
+}
+/**
+ * Responsive Grid component using CSS variables and Tailwind for breakpoints.
+ *
+ * @param cols - Object specifying column counts for each breakpoint.
+ * @param children - Grid content.
+ * @param rest - Other div props.
+ */
+export declare const Grid: React$1.FC<GridProps>;
+export type PageRootProps = React$1.ComponentProps<"div"> & {
+	spaced?: boolean;
+};
+export declare const PageRoot: ({ className, spaced, ...props }: PageRootProps) => React$1.JSX.Element;
+export interface PageTitleProps {
+	title: React$1.ReactNode;
+	description?: React$1.ReactNode;
+	/**
+	 * Optional decorative icon. Rendered inside an accent-tinted square.
+	 */
+	icon?: React$1.ReactNode;
+	/**
+	 * Breadcrumb-style label rendered above the title (e.g. "AI · Skills").
+	 */
+	kicker?: React$1.ReactNode;
+	/**
+	 * Right-aligned content that sits inline with the title (e.g. status pill).
+	 */
+	status?: React$1.ReactNode;
+	/**
+	 * Action buttons aligned with the title row on the right.
+	 */
+	actions?: React$1.ReactNode;
+	className?: string;
+}
+export declare const PageTitle: ({ title, description, icon, kicker, status, actions, className }: PageTitleProps) => React$1.JSX.Element;
+export interface SectionHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+	/** Optional glyph rendered inside a muted square. */
+	icon?: React$1.ReactNode;
+	title: React$1.ReactNode;
+	description?: React$1.ReactNode;
+	/** Right-aligned trailing content (e.g. a small action button). */
+	action?: React$1.ReactNode;
+}
+export declare const SectionHeader: React$1.ForwardRefExoticComponent<SectionHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface TableHeadProps {
+	title: string;
+	toolbar?: React$1.ReactNode;
+}
+export declare const TableHead: ({ title, toolbar }: TableHeadProps) => React$1.JSX.Element;
+declare const Input: ({ className, type, ...props }: React$1.ComponentProps<"input">) => React$1.JSX.Element;
+export interface ArrayInputItemProps<Value> {
+	disabled: boolean;
+	id: string;
+	index: number;
+	validationMessage?: string;
+	onValueChange: (value: Value) => void;
+	value: Value;
+}
+export interface ArrayInputProps<Value = string> extends Omit<React$1.ComponentProps<"div">, "defaultValue" | "onChange"> {
+	/** Controlled list of input values. */
+	values?: Value[];
+	/** Initial values when the component is uncontrolled. */
+	defaultValues?: Value[];
+	/** Called with the complete list whenever an item changes. */
+	onValuesChange?: (values: Value[]) => void;
+	/** Visible label for the add action. */
+	addLabel: string;
+	/** Accessible label for an item input. */
+	getItemLabel: (index: number) => string;
+	/** Accessible label for an item's remove action. */
+	getRemoveLabel: (index: number) => string;
+	/** Optional action aligned opposite the add control. */
+	actions?: React$1.ReactNode;
+	placeholder?: string;
+	minItems?: number;
+	required?: boolean;
+	disabled?: boolean;
+	/** Supplies a domain-specific item control while ArrayInput owns list actions. */
+	renderItem?: (props: ArrayInputItemProps<Value>) => React$1.ReactNode;
+	/** Creates an item for the add action when values are not plain strings. */
+	createItem?: () => Value;
+	/** Returns a row-specific validation message, if any. */
+	validateItem?: (value: Value, index: number) => string | undefined;
+	inputProps?: Omit<React$1.ComponentProps<typeof Input>, "aria-label" | "defaultValue" | "disabled" | "id" | "onChange" | "placeholder" | "required" | "value">;
+	classes?: {
+		root?: string;
+		row?: string;
+		input?: string;
+		removeButton?: string;
+		addButton?: string;
+		actionRow?: string;
+		actions?: string;
+	};
+}
+export type CustomArrayInputProps<Value> = ArrayInputProps<Value> & {
+	createItem: () => Value;
+	renderItem: (props: ArrayInputItemProps<Value>) => React$1.ReactNode;
+};
+export interface ArrayInputComponent {
+	<Value>(props: CustomArrayInputProps<Value>): React$1.ReactElement;
+	(props: ArrayInputProps): React$1.ReactElement;
+	displayName?: string;
+}
+export declare const ArrayInput: ArrayInputComponent;
+export declare const CronBuilder: ({ value, onChange, className, showPreview, timezone, onTimezoneChange }: CronBuilderProps) => React$1.JSX.Element;
+export interface CronBuilderProps {
+	value: string;
+	onChange: (cron: string) => void;
+	className?: string;
+	/** Show the compact human-readable summary below the controls. Default: true. */
+	showPreview?: boolean;
+	/** Selected IANA timezone. When provided, renders a timezone picker. */
+	timezone?: string;
+	onTimezoneChange?: (timezone: string) => void;
+}
+export type CronMode = "minutes" | "hours" | "day" | "days" | "week" | "weeks" | "month";
+export interface CronSimpleState {
+	mode: CronMode;
+	interval: number;
+	hour: number;
+	minute: number;
+	weekdays: number[];
+	monthday: number;
+}
+export declare const defaultSimpleState: CronSimpleState;
+export declare const parseCron: (cron: string) => CronSimpleState | null;
+export declare const buildCron: (s: CronSimpleState) => string;
+export declare const describeCron: (cron: string) => string;
+export declare const isValidCron: (cron: string) => boolean;
+export interface TimezonePickerProps {
+	value: string;
+	onChange: (value: string) => void;
+	className?: string;
+	width?: string;
+	disabled?: boolean;
+	placeholder?: string;
+}
+export declare const TimezonePicker: ({ value, onChange, className, width, disabled, placeholder }: TimezonePickerProps) => React$1.JSX.Element;
+export interface TimezoneOption {
+	value: string;
+	label: string;
+}
+export declare const getTimezoneOptions: () => TimezoneOption[];
+export type CoverImageFill = "horizontal" | "vertical" | "both" | "none";
+export interface CoverImageProps {
+	src: string;
+	alt?: string;
+	className?: string;
+	width?: number;
+	height?: number;
+	fill?: CoverImageFill;
+	style?: React$1.CSSProperties;
+}
+export declare const CoverImage: React$1.FC<CoverImageProps>;
+export interface SummaryListProps extends Omit<React$1.HTMLAttributes<HTMLElement>, "title"> {
+	/** Optional heading shown above the list. */
+	title?: React$1.ReactNode;
+}
+export declare const SummaryList: ({ title, className, children, ...props }: SummaryListProps) => React$1.JSX.Element;
+export interface SummaryItemProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+	label: React$1.ReactNode;
+	value: React$1.ReactNode;
+	/** Mutes the value, e.g. for "Not set" placeholders. */
+	muted?: boolean;
+}
+export declare const SummaryItem: ({ label, value, muted, className, ...props }: SummaryItemProps) => React$1.JSX.Element;
+export type ChoiceCardGroupProps = React$1.ComponentProps<typeof RadioGroupPrimitive.Root>;
+export declare const ChoiceCardGroup: ({ className, ...props }: ChoiceCardGroupProps) => React$1.JSX.Element;
+export interface ChoiceCardProps extends Omit<React$1.ComponentProps<typeof RadioGroupPrimitive.Item>, "title" | "children"> {
+	title: React$1.ReactNode;
+	description?: React$1.ReactNode;
+	/** Leading visual, typically an `IconTile`. */
+	media?: React$1.ReactNode;
+	/** Extra content under the description, pinned to the card bottom. */
+	footer?: React$1.ReactNode;
+}
+export declare const ChoiceCard: ({ title, description, media, footer, className, ...props }: ChoiceCardProps) => React$1.JSX.Element;
+declare const cardVariants: (props?: ({
+	variant?: "default" | "sheet" | "island" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare const Card: ({ children, className, variant, visual, ...props }: CardProps) => React$1.JSX.Element;
+export interface CardProps extends React$1.ComponentProps<"div">, VariantProps<typeof cardVariants> {
+	visual?: "accent_gradient";
+}
+declare const DropdownMenu: ({ ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Root>) => React$1.JSX.Element;
+declare const DropdownMenuContent: ({ className, sideOffset, ...props }: React$1.ComponentProps<typeof DropdownMenuPrimitive.Content>) => React$1.JSX.Element;
+declare const PopoverContent: ({ className, align, sideOffset, ...props }: React$1.ComponentProps<typeof PopoverPrimitive.Content>) => React$1.JSX.Element;
+declare const RadioGroup: ({ className, ...props }: React$1.ComponentProps<typeof RadioGroupPrimitive.Root>) => React$1.JSX.Element;
+export type CardOptionsBlockProps = React$1.HTMLAttributes<HTMLDivElement>;
+export declare const CardOptionsBlock: React$1.ForwardRefExoticComponent<CardOptionsBlockProps & React$1.RefAttributes<HTMLDivElement>>;
+export declare const RadioCardOptionsBlock: {
+	({ className, ...props }: RadioCardOptionsBlockProps): React$1.JSX.Element;
+	displayName: string;
+};
+export declare const CardOption: React$1.ForwardRefExoticComponent<CardOptionProps & React$1.RefAttributes<HTMLLabelElement>>;
+export declare const RadioCardOption: ({ value, title, radioLabel, disabled, onClick, ...props }: RadioCardOptionProps) => React$1.JSX.Element;
+export declare const CheckboxCardOption: ({ checked, title, checkboxLabel, disabled, onClick, onCheckedChange, ...props }: CheckboxCardOptionProps) => React$1.JSX.Element;
+export type RadioCardOptionsBlockProps = React$1.ComponentProps<typeof RadioGroup>;
+export interface CardOptionProps extends Omit<React$1.LabelHTMLAttributes<HTMLLabelElement>, "title"> {
+	title: React$1.ReactNode;
+	description?: React$1.ReactNode;
+	disabled?: boolean;
+	control: React$1.ReactNode;
+}
+export interface RadioCardOptionProps extends Omit<CardOptionProps, "control"> {
+	value: string;
+	radioLabel?: string;
+}
+export interface CheckboxCardOptionProps extends Omit<CardOptionProps, "control"> {
+	checked: boolean;
+	checkboxLabel?: string;
+	onCheckedChange: (checked: boolean) => void;
+}
+export interface CommandStepProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+	title: string;
+	description?: React$1.ReactNode;
+	/** The command shown verbatim and copied; may span several lines. */
+	command: string;
+	/** Accessible name of the copied value; defaults to `title`. */
+	copyLabel?: string;
+	/** Toast message when the clipboard write fails. */
+	copyErrorMessage?: string;
+}
+export declare const CommandStep: React$1.ForwardRefExoticComponent<CommandStepProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface CurrencyInputProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "type" | "step"> {
+	currency: string;
+	label?: string;
+	hint?: string;
+	hideLabel?: boolean;
+	hideHint?: boolean;
+	error?: string;
+	wrapperClassName?: string;
+	decimals?: number;
+	step?: number;
+}
+export declare const CurrencyInput: import("react").ForwardRefExoticComponent<CurrencyInputProps & import("react").RefAttributes<HTMLInputElement>>;
+export interface FieldRowProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	index?: string;
+	label: string;
+	hint?: React$1.ReactNode;
+}
+export declare const FieldRow: React$1.ForwardRefExoticComponent<FieldRowProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface FileDropAreaProps {
+	/** Root props from dropzone (includes event handlers, ref, etc.) */
+	rootProps?: React$1.HTMLAttributes<HTMLDivElement>;
+	/** Input props from dropzone */
+	inputProps?: React$1.InputHTMLAttributes<HTMLInputElement> & React$1.RefAttributes<HTMLInputElement>;
+	/** Whether drag is currently active */
+	isDragActive?: boolean;
+	/** Selected file information */
+	selectedFile?: {
+		name: string;
+		size: number;
+		previewUrl?: string | null;
+	} | null;
+	/** Error message to display */
+	error?: string | null;
+	/** Handler for removing the selected file */
+	onRemoveFile?: (e: React$1.MouseEvent) => void;
+	/** Handler for downloading the selected file */
+	onDownloadFile?: (e: React$1.MouseEvent) => void;
+	/** Whether the selected file download is running */
+	isDownloadingFile?: boolean;
+	/** Whether the dropzone is disabled */
+	disabled?: boolean;
+	/** Custom className for the container */
+	className?: string;
+	/** Labels for customization */
+	labels?: {
+		dragActive?: string;
+		dragInactive?: string;
+		fileTypeHint?: string;
+		errorRetry?: string;
+		downloadFile?: string;
+		downloadingFile?: string;
+	};
+}
+export declare const FileDropArea: React$1.FC<FileDropAreaProps>;
+export interface FilterChipOption {
+	value: string;
+	label: React$1.ReactNode;
+	/** Optional trailing count rendered as a quiet numeral. */
+	count?: number;
+	disabled?: boolean;
+}
+declare const chipVariants: (props?: ({
+	active?: boolean | null | undefined;
+	size?: "sm" | "md" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface FilterChipsProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof chipVariants> {
+	options: FilterChipOption[];
+	value: string;
+	onValueChange: (value: string) => void;
+	/** Accessible name for the chip group. */
+	label: string;
+	className?: string;
+	classes?: {
+		root?: string;
+		chip?: string;
+		count?: string;
+	};
+}
+/**
+ * A single-select row of pill filters. Use it as the primary narrowing axis
+ * of a listing — one chip per bucket, with counts so the shape of the data
+ * is readable before any click.
+ */
+export declare const FilterChips: {
+	({ options, value, onValueChange, label, size, className, classes, ...props }: FilterChipsProps): React$1.JSX.Element;
+	displayName: string;
+};
+/**
+ * A left-to-right band of work where concurrency is drawn rather than
+ * flattened: sequential items sit on one line, concurrent ones leave it as
+ * parallel lanes and rejoin after the slowest finishes.
+ *
+ * The band owns geometry only. Callers render their own content inside
+ * `FlowStep` and `FlowBranch`, so labels, colour, and interaction stay with
+ * the domain that understands them.
+ */
+export declare const FlowBand: ({ lanes, stepHeight, laneHeight, className, style, children, ...props }: FlowBandProps) => React$1.JSX.Element;
+/** One item on the band's main line, centred against taller branches. */
+export declare const FlowStep: ({ className, style, children, ...props }: FlowStepProps) => React$1.JSX.Element;
+/** Concurrent work: the line splits into one lane per item and rejoins. */
+export declare const FlowBranch: ({ lanes, fork, rejoin, label, className, ...props }: FlowBranchProps) => React$1.JSX.Element;
+export interface FlowBandProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+	/**
+	 * Widest branch in the band. The band reserves enough height for that many
+	 * lanes so the main line stays straight from the first step to the last.
+	 */
+	lanes?: number;
+	stepHeight?: number;
+	laneHeight?: number;
+	children: React$1.ReactNode;
+}
+export interface FlowStepProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	children: React$1.ReactNode;
+}
+export interface FlowLane {
+	key: string;
+	/** CSS colour tinting this lane's fork and merge curve. */
+	color?: string;
+	content: React$1.ReactNode;
+}
+export interface FlowBranchProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "children"> {
+	lanes: FlowLane[];
+	/** Draw the bracket that leaves the main line. */
+	fork?: boolean;
+	/** Draw the bracket that returns to it. Turn off when nothing follows. */
+	rejoin?: boolean;
+	/** Names the group for assistive tech, e.g. "Steps ran in parallel". */
+	label?: string;
+}
+export interface GuideStepProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	index: string;
+}
+export declare const GuideStep: React$1.ForwardRefExoticComponent<GuideStepProps & React$1.RefAttributes<HTMLDivElement>>;
+export type HierarchyTreeProps = CardProps;
+export declare const HierarchyTree: React$1.ForwardRefExoticComponent<Omit<CardProps, "ref"> & React$1.RefAttributes<HTMLDivElement>>;
+export interface HierarchyTreeHeaderProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+	title: React$1.ReactNode;
+	icon?: React$1.ReactNode;
+	count?: React$1.ReactNode;
+	actions?: React$1.ReactNode;
+}
+export declare const HierarchyTreeHeader: React$1.ForwardRefExoticComponent<HierarchyTreeHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+export type HierarchyTreeBodyProps = React$1.HTMLAttributes<HTMLDivElement>;
+export declare const HierarchyTreeBody: React$1.ForwardRefExoticComponent<HierarchyTreeBodyProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface HierarchyTreeRowProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	depth: number;
+	rails?: boolean[];
+	isLastChild?: boolean;
+	hasChildren?: boolean;
+	contentClassName?: string;
+}
+export declare const HierarchyTreeRow: React$1.ForwardRefExoticComponent<HierarchyTreeRowProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface HierarchyTreeToggleProps extends Omit<React$1.ComponentProps<typeof Button>, "children" | "size" | "variant"> {
+	expanded: boolean;
+	count: React$1.ReactNode;
+	visible?: boolean;
+}
+export declare const HierarchyTreeToggle: React$1.ForwardRefExoticComponent<Omit<HierarchyTreeToggleProps, "ref"> & React$1.RefAttributes<HTMLButtonElement>>;
+declare const jsonViewerVariants: (props?: ({
+	size?: "lg" | "sm" | "md" | null | undefined;
+	variant?: "default" | "filled" | "outlined" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface JsonViewerProps extends VariantProps<typeof jsonViewerVariants> {
+	/** Any caller-owned value; unsupported or cyclic values are normalized safely. */
+	data: unknown;
+	className?: string;
+	classes?: {
+		root?: string;
+		toolbar?: string;
+		content?: string;
+	};
+	expandAll?: boolean;
+	expandRoot?: boolean;
+	/**
+	 * Take over how a primitive value is drawn, keeping the tree's structure and
+	 * expand/collapse behaviour. Return `undefined` to fall back to the default
+	 * colouring. Used to give some values their own meaning — a redacted field,
+	 * a link, a unit — without forking the viewer.
+	 */
+	renderValue?: (value: JsonPrimitive, path: string) => React$1.ReactNode;
+	indentSize?: number;
+	showLineNumbers?: boolean;
+	showToolbar?: boolean;
+	maxHeight?: number | string;
+	maxWidth?: number | string;
+}
+export type JsonPrimitive = boolean | null | number | string | undefined;
+export declare const JsonViewer: React$1.FC<JsonViewerProps>;
+export type MarkdownEditorPreviewMode = "write" | "preview";
+export interface MarkdownEditorPreviewToggleLabels {
+	write: string;
+	preview: string;
+	writeTitle?: string;
+	previewTitle?: string;
+}
+export interface MarkdownEditorPreviewToggleProps {
+	mode: MarkdownEditorPreviewMode;
+	onModeChange: (mode: MarkdownEditorPreviewMode) => void;
+	labels: MarkdownEditorPreviewToggleLabels;
+	disabled?: boolean;
+	className?: string;
+}
+export declare const MarkdownEditorPreviewToggle: ({ mode, onModeChange, labels, disabled, className }: MarkdownEditorPreviewToggleProps) => React$1.JSX.Element;
+export interface MarkdownEditorPreviewProps {
+	label: string;
+	value: string;
+	onValueChange: (value: string) => void;
+	emptyPreview: React$1.ReactNode;
+	toggleLabels: MarkdownEditorPreviewToggleLabels;
+	mode?: MarkdownEditorPreviewMode;
+	defaultMode?: MarkdownEditorPreviewMode;
+	onModeChange?: (mode: MarkdownEditorPreviewMode) => void;
+	previewValue?: string;
+	disabled?: boolean;
+	placeholder?: string;
+	editorId?: string;
+	showHeader?: boolean;
+	footer?: React$1.ReactNode;
+	className?: string;
+	editorClassName?: string;
+	previewClassName?: string;
+	textareaProps?: Omit<React$1.ComponentProps<"textarea">, "id" | "value" | "disabled" | "placeholder" | "onChange" | "className">;
+}
+export declare const MarkdownEditorPreview: ({ label, value, onValueChange, emptyPreview, toggleLabels, mode, defaultMode, onModeChange, previewValue, disabled, placeholder, editorId, showHeader, footer, className, editorClassName, previewClassName, textareaProps }: MarkdownEditorPreviewProps) => React$1.JSX.Element;
+export interface JsonViewerDialogProps {
+	open: boolean;
+	onOpenChange: (open: boolean) => void;
+	title?: React$1.ReactNode;
+	data: unknown;
+	jsonViewerProps?: Omit<JsonViewerProps, "data">;
+}
+export declare const JsonViewerDialog: ({ open, onOpenChange, title, data, jsonViewerProps }: JsonViewerDialogProps) => React$1.JSX.Element;
+export interface LinkComponentProps {
+	to: string;
+	className?: string;
+	children?: React$1.ReactNode;
+}
+export interface LinkedItemProps {
+	href: string;
+	children: React$1.ReactNode;
+	className?: string;
+	external?: boolean;
+	linkComponent?: React$1.ComponentType<LinkComponentProps>;
+}
+export declare const LinkedItem: ({ href, children, className, external, linkComponent: LinkComponent }: LinkedItemProps) => React$1.JSX.Element;
+export interface MaskedValueProps {
+	value: string;
+	isSensitive?: boolean;
+	className?: string;
+	maskChar?: string;
+	showToggle?: boolean;
+}
+export declare const MaskedValue: ({ value, isSensitive, className, maskChar, showToggle }: MaskedValueProps) => React$1.JSX.Element;
+export interface MutedPlaceholderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	icon?: React$1.ReactNode;
+	text: React$1.ReactNode;
+	trailing?: React$1.ReactNode;
+}
+export declare const MutedPlaceholder: React$1.ForwardRefExoticComponent<MutedPlaceholderProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface ObjectSchemaExplorerProps {
+	/** A caller-owned schema value normalized at the component boundary. */
+	schema: unknown;
+	className?: string;
+	defaultExpandedDepth?: number;
+	emptyLabel?: string;
+}
+/**
+ * A compact, human-readable explorer for JSON Schema-shaped objects.
+ * It intentionally renders schema semantics rather than raw JSON.
+ */
+export declare const ObjectSchemaExplorer: ({ schema, className, defaultExpandedDepth, emptyLabel }: ObjectSchemaExplorerProps) => React$1.JSX.Element;
+export interface SortableListProps<T extends {
+	id: string;
+}> {
+	items: T[];
+	onReorder: (newOrder: T[]) => void;
+	/** Provides an item-specific accessible name for the drag handle. */
+	getItemLabel?: (item: T) => string;
+	/** Renders a row given the item and a drag-handle node to mount somewhere
+	 *  inside it. The handle is the only mouse target that initiates a drag —
+	 *  click handlers on the rest of the row keep working normally. */
+	renderItem: (item: T, handle: React$1.ReactNode) => React$1.ReactNode;
+	/** Renders the rows without drag affordances, for orders the caller cannot
+	 *  change (e.g. an order inherited from elsewhere). */
+	disabled?: boolean;
+}
+/**
+ * Thin wrapper around @dnd-kit/sortable that handles the boilerplate of
+ * sensors, keyboard support, drag-end → arrayMove, and per-row transform
+ * styles. The caller is responsible for translating the new order into
+ * persistence (typically writing each row's `order_index`).
+ *
+ * Designed to be reusable: items only need a stable `id` field; everything
+ * else is up to the caller's `renderItem`.
+ */
+export declare const SortableList: <T extends {
+	id: string;
+}>({ items, onReorder, getItemLabel, renderItem, disabled }: SortableListProps<T>) => React$1.JSX.Element | React$1.JSX.Element[];
+export interface ConfirmDialogProps {
+	open: boolean;
+	onOpenChange: (open: boolean) => void;
+	title: string;
+	description: React$1.ReactNode;
+	confirmLabel: string;
+	cancelLabel?: string;
+	confirmVariant?: "default" | "destructive";
+	/** Label shown on the confirm button while `onConfirm` is pending. */
+	pendingLabel?: string;
+	/** Awaited before closing; the dialog stays open if it throws. */
+	onConfirm: () => Promise<void> | void;
+}
+export declare const ConfirmDialog: {
+	({ open, onOpenChange, title, description, confirmLabel, cancelLabel, confirmVariant, pendingLabel, onConfirm }: ConfirmDialogProps): React$1.JSX.Element;
+	displayName: string;
+};
+export interface StageHeaderProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	step: number;
+	total: number;
+	title: string;
+	helper: string;
+	action?: React$1.ReactNode;
+}
+export declare const StageHeader: React$1.ForwardRefExoticComponent<StageHeaderProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const chipVariants$1: (props?: ({
+	tone?: "default" | "accent" | "success" | "warning" | "danger" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface StatTileProps extends Omit<React$1.ComponentProps<typeof Card>, "children" | "variant">, VariantProps<typeof chipVariants$1> {
+	/**
+	 * "tile" is the icon-led showcase card for summary strips; "compact" is the
+	 * dense left-aligned form for stat rows inside busier pages.
+	 */
+	variant?: "tile" | "compact";
+	/** Lucide icon (or any node). Chip on "tile", small inline glyph on "compact". */
+	icon?: React$1.ReactNode;
+	/** Short uppercase caption describing the metric. */
+	label: React$1.ReactNode;
+	/** The headline figure — kept in primary text color for legibility. */
+	value: React$1.ReactNode;
+	/** Secondary qualifier under the figure (e.g. "Current failures"). */
+	detail?: React$1.ReactNode;
+}
+/**
+ * The canonical dashboard metric. Lay several out in a
+ * `grid grid-cols-2 md:grid-cols-4` to build a summary strip; do not
+ * re-implement one-off stat blocks in page templates.
+ */
+export declare const StatTile: {
+	({ variant, icon, label, value, detail, tone, className, ...props }: StatTileProps): React$1.JSX.Element;
+	displayName: string;
+};
+export type StatusPillTone = "neutral" | "success" | "warning" | "danger" | "live";
+export interface StatusPillProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	/**
+	 * Semantic state. "live" renders a pulsing accent dot for in-flight
+	 * activity. When set, `tone` wins over the legacy `active` flag.
+	 */
+	tone?: StatusPillTone;
+	active?: boolean;
+	/**
+	 * Optional convenience label rendered as the pill text. If `children` is
+	 * provided it takes precedence so consumers can compose richer content.
+	 */
+	label?: React$1.ReactNode;
+}
+export declare const StatusPill: React$1.ForwardRefExoticComponent<StatusPillProps & React$1.RefAttributes<HTMLDivElement>>;
+declare const searchFieldVariants: (props?: ({
+	size?: "sm" | "md" | null | undefined;
+	variant?: "pill" | "plain" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export interface SearchFieldProps extends Omit<React$1.InputHTMLAttributes<HTMLInputElement>, "onChange" | "value" | "defaultValue" | "size" | "type">, VariantProps<typeof searchFieldVariants> {
+	/** Controlled value. Omit to run uncontrolled with `defaultValue`. */
+	value?: string;
+	defaultValue?: string;
+	onValueChange?: (value: string) => void;
+	/** Accessible label for the clear button. Hidden when empty. */
+	clearLabel?: string;
+	className?: string;
+	classes?: {
+		root?: string;
+		icon?: string;
+		input?: string;
+		clear?: string;
+	};
+}
+/**
+ * Search input with a leading magnifier and an optional clear affordance.
+ * The canonical way to filter a listing — reach for this instead of
+ * restyling a bare `Input` per page.
+ */
+export declare const SearchField: {
+	({ value, defaultValue, onValueChange, clearLabel, variant, size, className, classes, ...props }: SearchFieldProps): React$1.JSX.Element;
+	displayName: string;
+};
+export interface SectionSwitcherOption {
+	value: string;
+	label: string;
+	ariaLabel?: string;
+	disabled?: boolean;
+}
+export interface SectionSwitcherProps extends Omit<React$1.HTMLAttributes<HTMLElement>, "onChange" | "title"> {
+	title: React$1.ReactNode;
+	description?: React$1.ReactNode;
+	value: string;
+	options: SectionSwitcherOption[];
+	onValueChange: (value: string) => void;
+	align?: "start" | "center";
+}
+export declare const SectionSwitcher: {
+	({ title, description, value, options, onValueChange, align, className, ...props }: SectionSwitcherProps): React$1.JSX.Element;
+	displayName: string;
+};
+export interface StepperProps extends React$1.ComponentProps<"div"> {
+	value?: number;
+	defaultValue?: number;
+	indicators?: {
+		completed?: React$1.ReactNode;
+		loading?: React$1.ReactNode;
+	};
+}
+export declare const Stepper: ({ value, defaultValue, indicators, className, ...props }: StepperProps) => React$1.JSX.Element;
+export declare const StepperNav: ({ className, ...props }: React$1.ComponentProps<"nav">) => React$1.JSX.Element;
+export interface StepperItemProps extends React$1.ComponentProps<"div"> {
+	step: number;
+	loading?: boolean;
+}
+export declare const StepperItem: ({ step, loading, className, ...props }: StepperItemProps) => React$1.JSX.Element;
+export declare const StepperTrigger: ({ className, ...props }: React$1.ComponentProps<"div">) => React$1.JSX.Element;
+export declare const StepperIndicator: ({ className, children, ...props }: React$1.ComponentProps<"div">) => React$1.JSX.Element;
+export declare const StepperTitle: ({ className, ...props }: React$1.ComponentProps<"span">) => React$1.JSX.Element;
+export declare const StepperSeparator: ({ className, ...props }: React$1.ComponentProps<"div">) => React$1.JSX.Element;
+export declare const StepperPanel: ({ className, ...props }: React$1.ComponentProps<"div">) => React$1.JSX.Element;
+export interface StepperContentProps extends React$1.ComponentProps<"div"> {
+	value: number;
+}
+export declare const StepperContent: ({ value: stepValue, className, ...props }: StepperContentProps) => React$1.JSX.Element | null;
+export type SplitButtonStyle = Pick<VariantProps<typeof buttonVariants>, "size" | "variant">;
+/**
+ * A primary action joined to a menu of related actions. Compose it from
+ * `SplitButtonAction` and `SplitButtonMenu`; both halves share `variant` and
+ * `size`.
+ */
+export declare const SplitButton: ({ className, size, variant, ...props }: React$1.ComponentProps<"fieldset"> & SplitButtonStyle) => React$1.JSX.Element;
+/** The main action: the left half of the split button. */
+export declare const SplitButtonAction: ({ className, ...props }: Omit<React$1.ComponentProps<typeof Button>, "size" | "variant">) => React$1.JSX.Element;
+/**
+ * The right half: a chevron that opens the related actions. Children are
+ * dropdown menu items.
+ */
+export declare const SplitButtonMenu: ({ align, children, contentClassName, disabled, label, modal, onOpenChange, open }: Pick<React$1.ComponentProps<typeof DropdownMenu>, "modal" | "onOpenChange" | "open"> & Pick<React$1.ComponentProps<typeof DropdownMenuContent>, "align"> & {
+	children: React$1.ReactNode;
+	contentClassName?: string;
+	disabled?: boolean;
+	/** Accessible name of the chevron, e.g. "More actions". */
+	label: string;
+}) => React$1.JSX.Element;
+export interface TechnicalDetailsItem {
+	label: string;
+	value: string;
+	/** Show a copy-to-clipboard button next to the value. Defaults to true. */
+	copyable?: boolean;
+}
+export interface TechnicalDetailsPopoverProps {
+	items: TechnicalDetailsItem[];
+	/** Heading shown at the top of the popover. */
+	title?: React$1.ReactNode;
+	/** Accessible label for the info trigger button. */
+	triggerAriaLabel?: string;
+	/** Accessible label prefix for each copy button, e.g. "Copy". */
+	copyLabel?: string;
+	/** Custom trigger; replaces the default info icon button. */
+	trigger?: React$1.ReactNode;
+	align?: React$1.ComponentProps<typeof PopoverContent>["align"];
+	side?: React$1.ComponentProps<typeof PopoverContent>["side"];
+	onCopy?: (item: TechnicalDetailsItem) => void;
+	className?: string;
+	classes?: {
+		root?: string;
+		trigger?: string;
+		content?: string;
+		row?: string;
+		label?: string;
+		value?: string;
+	};
+}
+/**
+ * A quiet info affordance that keeps technical metadata (identifiers, FQNs,
+ * timestamps) off the surface of a card or row. Opens on click so its content
+ * stays interactive: values render in monospace with `select-all` (one click
+ * selects the whole value) and an optional copy button per row.
+ */
+export declare const TechnicalDetailsPopover: ({ items, title, triggerAriaLabel, copyLabel, trigger, align, side, onCopy, className, classes }: TechnicalDetailsPopoverProps) => React$1.JSX.Element;
+export interface TreeSelectNode {
+	/** Unique across the whole tree. */
+	id: string;
+	label: string;
+	/** When present the node is a group (folder) and cannot be selected. */
+	children?: readonly TreeSelectNode[];
+	/** Overrides the default icon of the row. */
+	icon?: React$1.ReactNode;
+}
+export interface TreeSelectProps {
+	nodes: readonly TreeSelectNode[];
+	/** The selected leaf id. */
+	value?: string;
+	onChange: (id: string) => void;
+	/** A durable label for a selected leaf that is not in `nodes`. */
+	selectedLabel?: string;
+	placeholder?: string;
+	searchPlaceholder?: string;
+	emptyMessage?: string;
+	id?: string;
+	className?: string;
+	width?: string;
+	disabled?: boolean;
+	/** Indicates that nodes are being fetched from a remote source. */
+	loading?: boolean;
+	/** Announced while remote nodes are loading. */
+	loadingMessage?: string;
+	/**
+	 * Enables server-side search: the consumer filters `nodes`, and every leaf
+	 * they contain is listed while a query is active.
+	 */
+	onSearchChange?: (search: string) => void;
+	/** Enables modal focus and scroll handling for use inside another modal. */
+	modal?: boolean;
+}
+export declare const TreeSelect: React$1.ForwardRefExoticComponent<TreeSelectProps & React$1.RefAttributes<HTMLButtonElement>>;
+export interface ValueRowProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	value: React$1.ReactNode;
+	state?: "value" | "secret";
+	trailing?: React$1.ReactNode;
+	monospace?: boolean;
+}
+export declare const ValueRow: React$1.ForwardRefExoticComponent<ValueRowProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface VariableOption {
+	key: string;
+	description?: string;
+}
+export interface VariableRecord extends VariableOption {
+	value: string | null;
+	secret: boolean;
+}
+export type VariableFieldMode = "linked" | "inline";
+export interface VariableReferenceFieldProps {
+	/** Stored primitive value. In ``linked`` mode this is the variable key
+	 *  (e.g. ``SQL_PG_CONNECTOR_PASSWORD``); in ``inline`` mode it's the
+	 *  literal value the user typed. */
+	value: string;
+	/** Whether this field references a stored variable or holds a literal. */
+	mode: VariableFieldMode;
+	/** Emit a new (value, mode) pair. ``mode`` reflects which side of the
+	 *  toggle the user is on; ``value`` always carries the primitive. */
+	onChange: (value: string, mode: VariableFieldMode) => void;
+	onBlur?: () => void;
+	/** Stored variables to choose from, supplied by the bridge. */
+	options: VariableOption[];
+	/** True while the bridge is performing its initial fetch. */
+	optionsLoading?: boolean;
+	/** True whenever the bridge is fetching (initial + background refetches). */
+	optionsFetching?: boolean;
+	onSearch?: (query: string) => void;
+	onCreate?: (input: {
+		key: string;
+		value: string;
+		secret?: boolean;
+	}) => Promise<VariableOption>;
+	/** Resolve a single variable record so the inline editor can show / save its value. */
+	onResolve?: (key: string) => Promise<VariableRecord | null>;
+	/** Persist a new value to an existing linked variable. */
+	onUpdate?: (input: {
+		key: string;
+		value: string;
+	}) => void | Promise<void>;
+	suggestedName?: string;
+	placeholder?: string;
+	disabled?: boolean;
+	className?: string;
+	/** Mask the value visually by default (forces a reveal toggle to read it). */
+	masked?: boolean;
+}
+export declare const VariableReferenceField: import("react").ForwardRefExoticComponent<VariableReferenceFieldProps & import("react").RefAttributes<HTMLButtonElement>>;
+export interface XmlViewerDialogProps {
+	open: boolean;
+	onOpenChange: (open: boolean) => void;
+	title?: React$1.ReactNode;
+	data: string;
+}
+export declare const XmlViewerDialog: ({ open, onOpenChange, title, data }: XmlViewerDialogProps) => React$1.JSX.Element;
+export interface ErrorAlertProps {
+	title?: React$1.ReactNode;
+	children: React$1.ReactNode;
+	details?: {
+		label: string;
+		content: React$1.ReactNode;
+	};
+	className?: string;
+	open?: boolean;
+	defaultOpen?: boolean;
+	onOpenChange?: (open: boolean) => void;
+	classes?: {
+		root?: string;
+		title?: string;
+		message?: string;
+		details?: string;
+		trigger?: string;
+		content?: string;
+	};
+}
+export declare const ErrorAlert: ({ title, children, details, className, open, defaultOpen, onOpenChange, classes }: ErrorAlertProps) => React$1.JSX.Element;
+export type LaneProgressLane = Readonly<{
+	fillClassName?: string;
+	mode?: "determinate" | "indeterminate";
+	value?: number;
+}>;
+export type LaneProgressProps = Readonly<{
+	className?: string;
+	detail?: string | null;
+	label: string;
+	lanes: readonly LaneProgressLane[];
+}>;
+export declare const LaneProgress: ({ className, detail, label, lanes }: LaneProgressProps) => React$1.JSX.Element;
+export type LifecycleStatusTone = "default" | "active" | "success" | "warning" | "danger" | "muted";
+export interface LifecycleStatusCardProgress {
+	mode?: "determinate" | "indeterminate";
+	value?: number;
+	completed?: number;
+	total?: number;
+	label?: React$1.ReactNode;
+}
+export interface LifecycleStatusCardMilestone {
+	id: string;
+	label: React$1.ReactNode;
+	description?: React$1.ReactNode;
+	tone?: LifecycleStatusTone;
+}
+export interface LifecycleStatusCardError {
+	title?: React$1.ReactNode;
+	summary?: React$1.ReactNode;
+	detail?: React$1.ReactNode;
+	tone?: "default" | "destructive";
+}
+export interface LifecycleStatusCardModel {
+	statusLabel: React$1.ReactNode;
+	title: React$1.ReactNode;
+	description: React$1.ReactNode;
+	tone?: LifecycleStatusTone;
+	icon?: React$1.ReactNode;
+	iconAnimated?: boolean;
+	currentStep?: React$1.ReactNode;
+	progress?: LifecycleStatusCardProgress;
+	milestones?: LifecycleStatusCardMilestone[];
+	error?: LifecycleStatusCardError;
+	completedState?: React$1.ReactNode;
+}
+export interface LifecycleStatusCardContext {
+	model: LifecycleStatusCardModel;
+	statusLabel: React$1.ReactNode;
+	title: React$1.ReactNode;
+	description: React$1.ReactNode;
+}
+export type LifecycleStatusCardSlot = React$1.ReactNode | ((context: LifecycleStatusCardContext) => React$1.ReactNode);
+export interface LifecycleStatusCardSlots {
+	shell?: (context: LifecycleStatusCardContext & {
+		children: React$1.ReactNode;
+	}) => React$1.ReactNode;
+	header?: LifecycleStatusCardSlot;
+	icon?: LifecycleStatusCardSlot;
+	title?: LifecycleStatusCardSlot;
+	description?: LifecycleStatusCardSlot;
+	progressBody?: LifecycleStatusCardSlot;
+	milestoneList?: LifecycleStatusCardSlot;
+	errorPanel?: LifecycleStatusCardSlot;
+	actions?: LifecycleStatusCardSlot;
+	completedState?: LifecycleStatusCardSlot;
+}
+export interface LifecycleStatusCardProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+	model: LifecycleStatusCardModel;
+	slots?: LifecycleStatusCardSlots;
+}
+export declare const LifecycleStatusCard: ({ model, slots, className, ...props }: LifecycleStatusCardProps) => React$1.ReactNode;
+export interface SkeletonRowsProps extends React$1.HTMLAttributes<HTMLDivElement> {
+	/** Number of placeholder rows. Match the typical page size, not a random N. */
+	rows?: number;
+	/** Classes applied to each row (height, radius). Default is a table row. */
+	rowClassName?: string;
+}
+export declare const SkeletonRows: React$1.ForwardRefExoticComponent<SkeletonRowsProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface EmptyStateProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+	icon?: React$1.ReactNode;
+	/**
+	 * Larger spot illustration shown above the title in place of the icon tile.
+	 * Takes precedence over `icon`. Pair with `@collective-intelligence/ui-react/illustrations`.
+	 */
+	illustration?: React$1.ReactNode;
+	title: React$1.ReactNode;
+	description?: React$1.ReactNode;
+	action?: React$1.ReactNode;
+	secondaryAction?: React$1.ReactNode;
+	size?: "sm" | "md";
+	variant?: "framed" | "bare";
+}
+export declare const EmptyState: React$1.ForwardRefExoticComponent<EmptyStateProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface TechnicalErrorDisclosureProps extends Omit<React$1.HTMLAttributes<HTMLDivElement>, "title"> {
+	title?: React$1.ReactNode;
+	message: React$1.ReactNode;
+	detail?: React$1.ReactNode;
+	detailLabel?: React$1.ReactNode;
+	detailHeading?: React$1.ReactNode;
+	defaultOpen?: boolean;
+}
+export declare const TechnicalErrorDisclosure: React$1.ForwardRefExoticComponent<TechnicalErrorDisclosureProps & React$1.RefAttributes<HTMLDivElement>>;
+export interface AppLoadingLayoutProps {
+	icon?: React$1.ReactNode;
+	title?: React$1.ReactNode;
+	className?: string;
+	spinnerSize?: number;
+}
+export declare const AppLoadingLayout: ({ icon, title, className, spinnerSize }: AppLoadingLayoutProps) => React$1.JSX.Element;
+export interface SplashScreenLayoutProps {
+	children?: React$1.ReactNode;
+	className?: string;
+	classes?: {
+		root?: string;
+		content?: string;
+		left?: string;
+		right?: string;
+	};
+	loading?: boolean;
+	coverImage?: React$1.ReactNode;
+}
+export declare const SplashScreenLayout: ({ children, className, classes, loading, coverImage }: SplashScreenLayoutProps) => React$1.JSX.Element;
+export declare const useIsMobile: () => boolean;
+
+export {};