@altertable/data-app 0.59.1

package/dist/types/react/ui/HelpPopover.d.ts

@@ -0,0 +1,24 @@
+import { type ComponentPropsWithRef, type ReactNode, type RefObject } from 'react';
+import { type Placement } from '@floating-ui/react';
+
+
+export type HelpPopoverTriggerProps = Omit<ComponentPropsWithRef<'button'>, 'children' | 'type'>;
+export type HelpPopoverPanelProps = Omit<ComponentPropsWithRef<'section'>, 'children' | 'role'>;
+export type HelpPopoverProps = {
+    trigger: ReactNode;
+    triggerLabel: string;
+    label: string;
+    children: ReactNode;
+    triggerClassName?: string;
+    panelClassName?: string;
+    placement?: Placement;
+    portalRoot?: RefObject<HTMLElement | null>;
+    triggerProps?: HelpPopoverTriggerProps;
+    panelProps?: HelpPopoverPanelProps;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+/** A supplemental explanation that opens on click, Enter, or a deliberate mouse hover. Tabbing
+ * past the trigger does not open it, and a click keeps a hover-opened panel in place.
+ * triggerProps and panelProps target its two surfaces. */
+export declare function HelpPopover({ trigger, triggerLabel, label, children, triggerClassName, panelClassName, portalRoot, triggerProps, panelProps, placement, open: openProp, onOpenChange, }: HelpPopoverProps): import("react").JSX.Element;

package/dist/types/react/ui/IconButton.d.ts

@@ -0,0 +1,19 @@
+import type { ComponentPropsWithRef, ReactNode, RefObject } from 'react';
+import { type ButtonProps } from './Button.js';
+import { type AppIconName } from './icons.js';
+import { type Shortcut } from './shortcuts.js';
+export type IconButtonProps = Omit<ComponentPropsWithRef<'button'>, 'children' | 'aria-label'> & {
+    icon: AppIconName;
+    label: string;
+    variant?: ButtonProps['variant'];
+    shortcut?: Shortcut | {
+        label: string;
+        aria: string;
+    };
+    tooltip?: ReactNode;
+    portalRoot?: RefObject<HTMLElement | null>;
+    tooltipPlacement?: 'top' | 'bottom';
+    tooltipAlign?: 'start' | 'center' | 'end';
+    children?: ReactNode;
+};
+export declare function IconButton({ icon, label, variant, shortcut, tooltip, portalRoot, tooltipPlacement, tooltipAlign, children, type, ...props }: IconButtonProps): import("react").JSX.Element;

package/dist/types/react/ui/InspectionContext.d.ts

@@ -0,0 +1,10 @@
+import type { DisclosedQuery } from '../../core/contract.js';
+import type { AboutEmpty } from './AboutData.js';
+import type { DataContext } from './data-context.js';
+export type InspectionDefaults = {
+    dataContext: DataContext;
+    empty?: AboutEmpty;
+    queries?: DisclosedQuery[];
+};
+export declare const InspectionContext: import("react").Context<InspectionDefaults | null>;
+export declare function useInspectionDefaults(): InspectionDefaults | null;

package/dist/types/react/ui/Kbd.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentPropsWithRef } from 'react';
+import { type Shortcut } from './shortcuts.js';
+
+export type KbdProps = ComponentPropsWithRef<'kbd'> & {
+    shortcut?: Shortcut;
+};
+/** A visible key or shortcut. Keep aria-keyshortcuts on the associated control. */
+export declare function Kbd({ shortcut, children, className, ...props }: KbdProps): import("react").JSX.Element;

package/dist/types/react/ui/LiveControl.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentPropsWithRef } from 'react';
+
+export type LiveIntervalSeconds = 30 | 60 | 300;
+export type LiveControlProps = {
+    enabled: boolean;
+    onChange: (enabled: boolean) => void;
+    intervalSeconds: LiveIntervalSeconds;
+    onIntervalChange: (seconds: LiveIntervalSeconds) => void;
+} & Omit<ComponentPropsWithRef<'button'>, 'children' | 'onClick' | 'onChange'>;
+/** Toggle an app-owned recurring refresh. The app supplies the timer and its cadence. */
+export declare function LiveControl({ enabled, onChange, intervalSeconds, onIntervalChange, className, ...props }: LiveControlProps): import("react").JSX.Element;

package/dist/types/react/ui/MetricWidget.d.ts

@@ -0,0 +1,48 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+import { type WidgetStatus } from './RequestHint.js';
+import type { WidgetEvidence } from './WidgetEvidence.js';
+import { type MetricComparison } from './comparison.js';
+import { type MetricFormat } from '../../core/format.js';
+import type { MetricReading } from '../../core/reading.js';
+import { type MetricDefinition } from './metric.js';
+
+
+type MetricWidgetBaseProps = {
+    label: string;
+    description?: ReactNode;
+    comparison?: MetricComparison;
+    evidence?: WidgetEvidence;
+    action?: ReactNode;
+    insight?: ReactNode;
+    status?: WidgetStatus;
+    visual?: ReactNode;
+} & Omit<ComponentPropsWithRef<'div'>, 'about' | 'children'>;
+type UnboundMetricWidgetProps = MetricWidgetBaseProps & ({
+    loading: true;
+    value?: never;
+    format?: never;
+    content?: never;
+} | ({
+    loading?: false;
+} & ({
+    value: number;
+    format: MetricFormat;
+    content?: never;
+} | {
+    content: ReactNode;
+    value?: never;
+    format?: never;
+})));
+export type MetricWidgetProps = UnboundMetricWidgetProps | (Omit<MetricWidgetBaseProps, 'label' | 'comparison' | 'evidence'> & {
+    metric: MetricDefinition;
+    reading: MetricReading;
+    label?: never;
+    value?: never;
+    format?: never;
+    content?: never;
+    comparison?: never;
+    evidence?: never;
+    loading?: never;
+});
+export declare function MetricWidget(props: MetricWidgetProps): import("react").JSX.Element;
+export {};

package/dist/types/react/ui/PeriodSummary.d.ts

@@ -0,0 +1,17 @@
+import type { ReportingPeriod } from '../../core/contract.js';
+
+export type { ReportingPeriod } from '../../core/contract.js';
+export type PeriodComparison = {
+    kind: 'previous';
+} | {
+    kind: 'period';
+    period: ReportingPeriod;
+};
+export type PeriodSummaryProps = {
+    period: ReportingPeriod;
+    comparison?: PeriodComparison;
+    className?: string;
+};
+export declare function reportingPeriodText(period: ReportingPeriod): string;
+/** Read-only period context for the variable bar, including exact bounds for assistive technology. */
+export declare function PeriodSummary({ period, comparison, className, }: PeriodSummaryProps): import("react").JSX.Element;

package/dist/types/react/ui/PresentStory.d.ts

@@ -0,0 +1,34 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import type { ThemeController } from '../../core/appearance.js';
+import { type AboutEmpty } from './AboutData.js';
+import type { DataContext } from './data-context.js';
+import { type StoryFinding } from './story.js';
+
+export type StoryStep = {
+    id: string;
+    empty?: AboutEmpty;
+    headline: string;
+    context?: string;
+    glossaryIds?: string[];
+    queryNames?: string[];
+    visual: ReactNode;
+    visualKind?: 'metric' | 'chart';
+};
+export type PresentStoryProps = {
+    title: string;
+    findings: readonly StoryFinding[];
+    empty?: AboutEmpty;
+    scope?: ReactNode;
+    dataContext: DataContext;
+    theme?: ThemeController;
+    launcherProps?: Omit<ComponentPropsWithRef<'span'>, 'children'>;
+    dialogProps?: Omit<ComponentPropsWithRef<'dialog'>, 'children' | 'aria-labelledby' | 'open'>;
+    headerActions?: ReactNode;
+    footer?: ReactNode;
+} & Omit<ComponentPropsWithRef<'button'>, 'title'>;
+/**
+ * Uses an already loaded snapshot. Navigation is stored in `?present=1&step=`, and step
+ * inspection uses `?about=`. `launcherProps` targets the outer span; `dialogProps` targets the
+ * modal.
+ */
+export declare function PresentStory({ title, findings, empty, scope, dataContext, theme, launcherProps, dialogProps, headerActions, footer, children, className, onClick, disabled, ref, ...props }: PresentStoryProps): import("react").JSX.Element;

package/dist/types/react/ui/QueryList.d.ts

@@ -0,0 +1,15 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import type { DisclosedQuery } from '../../core/contract.js';
+
+export type QueryListProps = {
+    queries?: DisclosedQuery[];
+    names?: string[];
+    summary?: ReactNode;
+    expanded?: boolean;
+} & Omit<ComponentPropsWithRef<'details'>, 'children'>;
+export declare function formatSql(statement: string): string;
+/**
+ * `names` selects supporting queries. Missing query evidence is shown explicitly; `expanded`
+ * skips the disclosure in a dedicated Queries view.
+ */
+export declare function QueryList({ queries, names, summary, expanded, className, ...props }: QueryListProps): import("react").JSX.Element | null;

package/dist/types/react/ui/Ranking.d.ts

@@ -0,0 +1,14 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type RankingItem = {
+    id: string;
+    label: ReactNode;
+    value: number;
+    detail?: ReactNode;
+};
+export type RankingProps = {
+    items: readonly RankingItem[];
+    formatValue?: (value: number) => ReactNode;
+} & Omit<ComponentPropsWithRef<'ol'>, 'children'>;
+/** Ordered values scaled to the largest visible item, not shares of a whole. */
+export declare function Ranking({ items, formatValue, className, ...props }: RankingProps): import("react").JSX.Element;

package/dist/types/react/ui/RefreshControl.d.ts

@@ -0,0 +1,11 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+
+export type RefreshControlProps = {
+    refreshing: boolean;
+    children: ReactNode;
+    label?: string;
+    statusProps?: Omit<ComponentPropsWithRef<'div'>, 'children' | 'role'>;
+    status?: ReactNode;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** Show refresh progress just before its action after a short delay. */
+export declare function RefreshControl({ refreshing, children, label, statusProps, status, className, ...props }: RefreshControlProps): import("react").JSX.Element;

package/dist/types/react/ui/RefreshRegion.d.ts

@@ -0,0 +1,10 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type RefreshRegionProps = {
+    refreshing: boolean;
+    dimOnUpdate?: boolean;
+    children: ReactNode;
+    contentProps?: Omit<ComponentPropsWithRef<'div'>, 'children' | 'aria-busy'>;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** Keep prior content in place while a fresh result loads. Local results can opt into dimming. */
+export declare function RefreshRegion({ refreshing, dimOnUpdate, children, contentProps, className, ...props }: RefreshRegionProps): import("react").JSX.Element;

package/dist/types/react/ui/RequestHint.d.ts

@@ -0,0 +1,21 @@
+
+/** Idle keeps the same reserved space as refresh and failure. Initial loading belongs to skeletons. */
+export type WidgetStatus = {
+    kind: 'idle';
+} | {
+    kind: 'updating';
+    message?: string;
+} | {
+    kind: 'error';
+    message?: string;
+    onRetry?: () => void;
+};
+/** Fixed-height feedback keeps data in place; the retry belongs beside its failure message. */
+export declare function RequestHint({ status, retryLabel, }: {
+    status?: WidgetStatus;
+    retryLabel?: string;
+}): import("react").JSX.Element;
+/** Fixed toolbar footprint preserves the title and action positions across request states. */
+export declare function WidgetStatusControl({ status }: {
+    status?: WidgetStatus;
+}): import("react").JSX.Element;

package/dist/types/react/ui/SearchField.d.ts

@@ -0,0 +1,23 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+
+export type SearchFieldProps = {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    onSubmit?: (value: string) => void;
+    placeholder?: string;
+    showLabel?: boolean;
+    size?: 'default' | 'compact';
+    description?: ReactNode;
+    status?: ReactNode;
+    busy?: boolean;
+    resetValue?: string;
+    inputProps?: Omit<ComponentPropsWithRef<'input'>, 'type' | 'value' | 'children'>;
+    clearButtonProps?: Omit<ComponentPropsWithRef<'button'>, 'type' | 'children'>;
+    children?: ReactNode;
+} & Omit<ComponentPropsWithRef<'form'>, 'onChange' | 'onSubmit' | 'children'>;
+/**
+ * The caller owns filtering, URL state, and whether search runs while typing or on submit.
+ * Escape and Clear reset the query.
+ */
+export declare function SearchField({ label, value, onChange, onSubmit, placeholder, showLabel, size, description, status, busy, resetValue, inputProps, clearButtonProps, children, className, ...props }: SearchFieldProps): import("react").JSX.Element;

package/dist/types/react/ui/SearchInput.d.ts

@@ -0,0 +1,9 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+/** One search control surface for picker search and table/page search. */
+export declare function SearchInput({ size, endAction, loading, className, ...props }: Omit<ComponentPropsWithRef<'input'>, 'size' | 'children'> & {
+    size?: 'default' | 'compact';
+    endAction?: ReactNode;
+    /** Replaces the search glyph in its existing space; input and results remain usable. */
+    loading?: boolean;
+}): import("react").JSX.Element;

package/dist/types/react/ui/SearchMatch.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentPropsWithRef } from 'react';
+import type { SearchMatchValue } from './searchItems.js';
+
+export type SearchMatchProps = {
+    match: SearchMatchValue;
+} & Omit<ComponentPropsWithRef<'span'>, 'children'>;
+export declare function SearchMatch({ match, className, ...props }: SearchMatchProps): import("react").JSX.Element;

package/dist/types/react/ui/SelectableBarChart.d.ts

@@ -0,0 +1,16 @@
+
+export type SelectableBarItem = {
+    id: string;
+    label: string;
+    value: number;
+};
+export type SelectableBarChartProps = {
+    items: readonly SelectableBarItem[];
+    selectedId: string | null;
+    onSelectionChange: (id: string | null) => void;
+    unit: string;
+    ariaLabel: string;
+    formatValue?: (value: number) => string;
+};
+/** Selection inspects a bar; it never silently filters the rest of the page. */
+export declare function SelectableBarChart({ items, selectedId, onSelectionChange, unit, ariaLabel, formatValue, }: SelectableBarChartProps): import("react").JSX.Element;

package/dist/types/react/ui/SelectionMark.d.ts

@@ -0,0 +1,5 @@
+
+/** Decorative selection indicator; the containing control owns its accessible semantics. */
+export declare function SelectionMark({ selected }: {
+    selected: boolean;
+}): import("react").JSX.Element;

package/dist/types/react/ui/Sheet.d.ts

@@ -0,0 +1,19 @@
+import { type ComponentPropsWithRef, type ReactNode, type RefObject } from 'react';
+
+export type SheetDialogProps = Omit<ComponentPropsWithRef<'dialog'>, 'children' | 'open' | 'title' | 'aria-labelledby'>;
+export type SheetProps = {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: ReactNode;
+    description?: ReactNode;
+    children: ReactNode;
+    headerActions?: ReactNode;
+    footer?: ReactNode;
+    wide?: boolean;
+    returnFocus?: RefObject<HTMLElement | null>;
+} & SheetDialogProps;
+/**
+ * Uses the native dialog top layer and focus trap. Closing keeps the modal mounted until its
+ * exit transition completes.
+ */
+export declare function Sheet({ open, onOpenChange, title, description, children, headerActions, footer, wide, returnFocus, className, onCancel, onClose, onClick, onTransitionEnd, ref, ...props }: SheetProps): import("react").JSX.Element;

package/dist/types/react/ui/Skeleton.d.ts

@@ -0,0 +1,6 @@
+import type { ComponentPropsWithRef } from 'react';
+
+export type SkeletonProps = Omit<ComponentPropsWithRef<'span'>, 'children' | 'aria-hidden'>;
+/** Decorative loading placeholder that fades in only when loading takes a moment.
+ * Put the accessible status on its container. */
+export declare function Skeleton({ className, ...props }: SkeletonProps): import("react").JSX.Element;

package/dist/types/react/ui/Stack.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type StackProps = {
+    children: ReactNode;
+    gap?: 'sm' | 'md' | 'lg';
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** Vertical layout for peer sections or request boundaries, with the page's section gap. */
+export declare function Stack({ children, gap, className, ...props }: StackProps): import("react").JSX.Element;

package/dist/types/react/ui/StatusPanel.d.ts

@@ -0,0 +1,11 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type StatusPanelProps = {
+    status: 'loading' | 'empty' | 'error';
+    title: ReactNode;
+    description?: ReactNode;
+    details?: ReactNode;
+    action?: ReactNode;
+    children?: ReactNode;
+} & Omit<ComponentPropsWithRef<'div'>, 'children' | 'title'>;
+export declare function StatusPanel({ status, title, description, details, action, children, className, role, ...props }: StatusPanelProps): import("react").JSX.Element;

package/dist/types/react/ui/TableWidget.d.ts

@@ -0,0 +1,57 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import type { WidgetEvidence } from './WidgetEvidence.js';
+import type { WidgetStatus } from './RequestHint.js';
+import { type DataTableSearch } from './DataTable.js';
+import type { EmptyStateProps } from './EmptyState.js';
+import { type SearchHit, type SearchItemsOptions } from './searchItems.js';
+import type { DataReading } from '../../core/reading.js';
+
+export type TableWidgetColumn<Row> = {
+    /** Stable, nonempty identity; unique within this table. */
+    id: string;
+    header: ReactNode;
+    type?: 'number' | 'datetime';
+    /** Render this column's value for one row. The table owns its cell element and semantics. */
+    cell: (row: Row, hit?: SearchHit<Row>) => ReactNode;
+};
+export type TableWidgetSearch<Row> = Omit<DataTableSearch, 'itemCount'> & Pick<SearchItemsOptions<Row>, 'attributes' | 'mode' | 'fuzzyThreshold'>;
+type TableWidgetBaseProps<Row> = {
+    title: ReactNode;
+    count?: number;
+    description?: ReactNode;
+    columns: readonly [TableWidgetColumn<Row>, ...TableWidgetColumn<Row>[]];
+    /** Unique, nonempty row identity. Numeric keys must be finite; 1 and "1" collide. */
+    rowKey: (row: Row) => string | number;
+    insight?: ReactNode;
+    status?: WidgetStatus;
+    action?: ReactNode;
+    evidence?: WidgetEvidence;
+    search?: TableWidgetSearch<Row>;
+    /** Valid result with no rows; the header remains visible. */
+    empty: Pick<EmptyStateProps, 'title' | 'description'>;
+} & ({
+    /** Positive integer preview cap after search; disables pagination. */
+    limit: number;
+    pagination?: never;
+} | {
+    /** Local pagination after search: 10 rows by default, false shows all supplied rows.
+     * pageSize must be a positive integer. Counts refer only to supplied rows.
+     * The widget owns bottom-footer controls and shares the current page with inspection. */
+    pagination?: {
+        pageSize: number;
+    } | false;
+    limit?: never;
+}) & Omit<ComponentPropsWithRef<'section'>, 'about' | 'title' | 'children'>;
+/** Column definitions own both header and body semantics; the first column is the row header. */
+export type TableWidgetProps<Row> = TableWidgetBaseProps<Row> & ({
+    rows: readonly Row[];
+    reading?: never;
+    skeletonRows?: never;
+} | {
+    reading: DataReading<readonly Row[]>;
+    rows?: never;
+    skeletonRows?: number;
+    evidence: WidgetEvidence;
+});
+export declare function TableWidget<Row>(props: TableWidgetProps<Row>): import("react").JSX.Element;
+export {};

package/dist/types/react/ui/Tabs.d.ts

@@ -0,0 +1,6 @@
+import { Tabs, TabList, Tab, TabPanels, TabPanel } from 'react-aria-components/Tabs';
+
+/** React Aria tabs with keyboard and ARIA behavior; pair each Tab and TabPanel by stable id. */
+export { Tabs, TabList, Tab, TabPanels, TabPanel };
+/** Keep a page-level tab in `?view=`; reserve `?tab=` for the inspect sheet. */
+export declare function useViewTab<View extends string>(views: readonly View[], fallback: View): [View, (key: string | number) => void];

package/dist/types/react/ui/ThemeSelector.d.ts

@@ -0,0 +1,13 @@
+import { type ComponentPropsWithRef, type ReactNode, type RefObject } from 'react';
+import type { ThemeController } from '../../core/appearance.js';
+
+export type ThemeSelectorProps = {
+    theme: ThemeController;
+    children?: ReactNode;
+} & Omit<ComponentPropsWithRef<'fieldset'>, 'children'>;
+/** Viewer color preference. Brand tokens remain app-owned. */
+export declare function ThemeSelector({ theme, children, className, ...props }: ThemeSelectorProps): import("react").JSX.Element;
+export declare function ThemeToggle({ theme, portalRoot, }: {
+    theme: ThemeController;
+    portalRoot?: RefObject<HTMLElement | null>;
+}): import("react").JSX.Element;

package/dist/types/react/ui/Tooltip.d.ts

@@ -0,0 +1,23 @@
+import { type ComponentPropsWithRef, type ReactNode, type RefObject } from 'react';
+
+export type TooltipProviderProps = {
+    children: ReactNode;
+    delay?: number;
+    skipDelayDuration?: number;
+};
+/** Delay the first hover, then open nearby tooltips without waiting during the skip window.
+ * Keyboard focus always opens immediately. AppLayout provides this by default. */
+export declare function TooltipProvider({ children, delay, skipDelayDuration, }: TooltipProviderProps): import("react").JSX.Element;
+export type TooltipProps = {
+    content: ReactNode;
+    children: ReactNode;
+    variant?: 'hint' | 'chart';
+    align?: 'start' | 'center' | 'end';
+    placement?: 'top' | 'bottom';
+    portalRoot?: RefObject<HTMLElement | null>;
+    tooltipProps?: Omit<ComponentPropsWithRef<'span'>, 'children' | 'role'>;
+} & Omit<ComponentPropsWithRef<'span'>, 'children' | 'content'>;
+/** Short visual hint for an already labeled control. variant="chart" follows the cursor
+ * on hover and toggles on tap so a bar or point can show the period and value. Hint
+ * tooltips hide once the control is pressed. Escape closes either. */
+export declare function Tooltip({ content, children, variant, align, placement, portalRoot, tooltipProps, className, ref, onPointerEnter, onPointerMove, onPointerLeave, onPointerDown, onFocusCapture, onBlurCapture, ...props }: TooltipProps): import("react").JSX.Element;

package/dist/types/react/ui/UpdatedAt.d.ts

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+import { type DateTimeTooltipProps } from './DateTimeTooltip.js';
+
+export type UpdatedAtProps = {
+    timestamp: number;
+    locale?: string;
+    label?: string;
+    children?: ReactNode;
+} & Omit<DateTimeTooltipProps, 'date' | 'children'>;
+export declare function UpdatedAt({ timestamp, locale, label, children, triggerClassName, ...props }: UpdatedAtProps): import("react").JSX.Element;

package/dist/types/react/ui/VariableBar.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type VariableBarProps = {
+    children: ReactNode;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** Reader-controlled inputs below the page header. */
+export declare function VariableBar({ children, className, role, 'aria-label': ariaLabel, ...props }: VariableBarProps): import("react").JSX.Element;

package/dist/types/react/ui/VisualizationWidget.d.ts

@@ -0,0 +1,52 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import type { WidgetEvidence } from './WidgetEvidence.js';
+import { type DataWidgetProps } from './DataWidget.js';
+import type { EmptyStateProps } from './EmptyState.js';
+import type { DataReading } from '../../core/reading.js';
+import { type ContentSkeletonProps } from './ContentSkeleton.js';
+
+type VisualizationWidgetBaseProps = {
+    title: ReactNode;
+    description?: ReactNode;
+    insight?: ReactNode;
+    action?: ReactNode;
+    evidence?: WidgetEvidence;
+    status?: DataWidgetProps['status'];
+    empty?: Pick<EmptyStateProps, 'title' | 'description'>;
+} & Omit<ComponentPropsWithRef<'section'>, 'about' | 'title' | 'children'>;
+type UnboundVisualizationWidgetProps = VisualizationWidgetBaseProps & ({
+    loading: true;
+    visual?: never;
+} | {
+    loading?: false;
+    visual: ReactNode;
+});
+export type VisualizationWidgetView<Data> = {
+    /** Stable, nonempty identity; unique within this widget. */
+    id: string;
+    label: ReactNode;
+    render: (data: Data) => ReactNode;
+};
+type BoundVisualizationWidgetBase<Data> = VisualizationWidgetBaseProps & {
+    evidence: WidgetEvidence;
+    reading: DataReading<Data>;
+    isEmpty: (data: Data) => boolean;
+    empty: Pick<EmptyStateProps, 'title' | 'description'>;
+    skeleton?: Pick<ContentSkeletonProps, 'variant' | 'rows'>;
+    visual?: never;
+    loading?: never;
+};
+/** The widget owns alternate-view selection and shares it with inspection.
+ * Custom chart interactions remain controlled by the caller, above both mounts. */
+export type VisualizationWidgetProps<Data = unknown> = UnboundVisualizationWidgetProps | (BoundVisualizationWidgetBase<Data> & {
+    children: (data: Data) => ReactNode;
+    views?: never;
+}) | (BoundVisualizationWidgetBase<Data> & {
+    views: readonly VisualizationWidgetView<Data>[];
+    viewLabel: string;
+    /** An existing view ID; defaults to the first view. Validated while loading too. */
+    initialView?: string;
+    children?: never;
+});
+export declare function VisualizationWidget<Data>(props: VisualizationWidgetProps<Data>): import("react").JSX.Element;
+export {};

package/dist/types/react/ui/WidgetDisclosure.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type WidgetDisclosureProps = {
+    label: ReactNode;
+    children: ReactNode;
+} & Omit<ComponentPropsWithRef<'details'>, 'children'>;
+export declare function WidgetDisclosure({ label, children, className, ...props }: WidgetDisclosureProps): import("react").JSX.Element;

package/dist/types/react/ui/WidgetEvidence.d.ts

@@ -0,0 +1,12 @@
+import type { AboutSubject } from './AboutData.js';
+type EvidenceDetails = Omit<AboutSubject, 'id' | 'title' | 'description' | 'visual' | 'visualKind' | 'references'> & {
+    id: string;
+};
+export type WidgetEvidence = EvidenceDetails & ({
+    glossaryIds: [string, ...string[]];
+    queryNames?: string[];
+} | {
+    queryNames: [string, ...string[]];
+    glossaryIds?: string[];
+});
+export {};

package/dist/types/react/ui/WidgetViewTabs.d.ts

@@ -0,0 +1,17 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+import { type EmptyStateProps } from './EmptyState.js';
+
+export type WidgetView = {
+    id: string;
+    label: ReactNode;
+    content: ReactNode;
+    empty: Pick<EmptyStateProps, 'title' | 'description'>;
+    isEmpty: boolean;
+};
+export type WidgetViewTabsProps<Views extends readonly WidgetView[] = readonly WidgetView[]> = {
+    label: string;
+    views: Views;
+    selectedKey: NoInfer<Views[number]['id']>;
+    onSelectionChange: (key: Views[number]['id']) => void;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+export declare function WidgetViewTabs<const Views extends readonly WidgetView[]>({ label, views, selectedKey, onSelectionChange, className, ...props }: WidgetViewTabsProps<Views>): import("react").JSX.Element;

package/dist/types/react/ui/chartColor.d.ts

@@ -0,0 +1 @@
+export declare function chartColor(id: string): string;

package/dist/types/react/ui/classNames.d.ts

@@ -0,0 +1 @@
+export declare function classNames(...values: Array<string | false | null | undefined>): string;

package/dist/types/react/ui/comparison.d.ts

@@ -0,0 +1,30 @@
+import type { DateRangeRequest } from '../../core/contract.js';
+import { type MetricFormat } from '../../core/format.js';
+export type MetricComparison = {
+    current: {
+        value: number;
+        formattedValue: string;
+        periodLabel?: string;
+    };
+    previous?: {
+        value: number | null;
+        formattedValue: string;
+        periodLabel?: string;
+    };
+    favorableDirection?: 'up' | 'down';
+};
+/** Label a comparison from the input that produced the displayed result. Null means the
+ * requested previous period has no comparable value; zero remains a measured value. */
+export declare function calendarMetricComparison(displayedInput: DateRangeRequest, values: {
+    current: number;
+    previous: number | null;
+    format: MetricFormat;
+    favorableDirection?: MetricComparison['favorableDirection'];
+}): MetricComparison | undefined;
+/** A zero or missing baseline has no meaningful relative percentage. */
+export declare function comparisonChange({ current, previous, favorableDirection, }: MetricComparison): {
+    readonly percent: number | null;
+    readonly direction: "down" | "flat" | "up";
+    readonly tone: "bad" | "good" | "neutral";
+    readonly icon: "trendDown" | "trendFlat" | "trendUp";
+};