@altertable/data-app 0.59.1

package/dist/types/react/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * React bindings and UI; load the stylesheet separately in the browser entry.
+ * @module @altertable/data-app/react
+ * @see https://github.com/altertable-ai/data-app/blob/main/docs/react.md
+ */
+export { mountDataApp, DataAppProvider } from './mount.js';
+export { createDataHooks } from './hooks.js';
+export { defineDataContent } from './content.js';
+export type { DataContentState } from './content.js';
+export type { DataViewDefinition, ResolvedVariables, ViewBindings, } from './view.js';
+export * from './ui/index.js';

package/dist/types/react/mount.d.ts

@@ -0,0 +1,11 @@
+import { type ComponentType, type ReactNode } from 'react';
+import { type DataAppConfig } from '../core/config.js';
+/** Mount once per document; installs document identity and the shared request provider. */
+export declare function mountDataApp({ config, component: Component, root, }: {
+    config: DataAppConfig;
+    component: ComponentType;
+    root?: HTMLElement | null;
+}): void;
+export declare function DataAppProvider({ children }: {
+    children: ReactNode;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,61 @@
+import { type ComponentPropsWithRef, type ReactNode, type RefObject } from 'react';
+import type { DisclosedQuery } from '../../core/contract.js';
+import type { DataContext, GlossaryEntry } from './data-context.js';
+import { type ButtonProps } from './Button.js';
+import { type SheetDialogProps } from './Sheet.js';
+
+export type AboutTab = 'glossary' | 'queries';
+export type AboutEmpty = {
+    glossary: {
+        title: string;
+        description?: string;
+    };
+    queries: {
+        title: string;
+        description?: string;
+    };
+};
+export declare const defaultAboutEmpty: AboutEmpty;
+export type AboutSubject = {
+    empty?: AboutEmpty;
+    id?: string;
+    title?: ReactNode;
+    description?: ReactNode;
+    visual?: ReactNode;
+    visualKind?: 'metric' | 'chart' | 'widget';
+    dataContext?: DataContext;
+    references?: {
+        kind: 'ids';
+        glossaryIds?: readonly string[];
+        queryNames?: readonly string[];
+    } | {
+        kind: 'entries';
+        entries: readonly GlossaryEntry[];
+    };
+    queries?: DisclosedQuery[];
+};
+export type AboutDataProps = AboutSubject & {
+    variant?: ButtonProps['variant'];
+    iconOnly?: boolean;
+    /**
+     * Register the global inspect shortcut. Defaults on for existing toolbar triggers; local
+     * triggers set false.
+     */
+    shortcut?: boolean;
+    tooltip?: ReactNode;
+    children?: ReactNode;
+    footer?: ReactNode;
+    portalRoot?: RefObject<HTMLElement | null>;
+    sheetProps?: SheetDialogProps;
+    headerActions?: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Initial inspect tab. While open, the URL's `tab` parameter tracks selection. */
+    tab?: AboutTab;
+    trigger?: boolean;
+} & Omit<ComponentPropsWithRef<'button'>, 'children' | 'title'>;
+/**
+ * Open state uses `?about=`; tab selection uses `?tab=`. Enable the global shortcut only on the
+ * page-level trigger.
+ */
+export declare function AboutData({ id, title, description, visual, visualKind, variant, dataContext, references, queries, empty, iconOnly, shortcut, tooltip, children, footer, portalRoot, sheetProps, headerActions, open: openProp, onOpenChange, tab, trigger, className, onClick, ref, ...props }: AboutDataProps): import("react").JSX.Element;

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

@@ -0,0 +1,3 @@
+import type { SVGProps } from 'react';
+export type AltertableLogoProps = SVGProps<SVGSVGElement>;
+export declare function AltertableLogo(props: AltertableLogoProps): import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type AppFooterProps = ComponentPropsWithRef<'footer'> & {
+    attribution?: ReactNode;
+};
+/** `children` fills the action slot; `attribution` replaces the default link. */
+export declare function AppFooter({ children, attribution, className, ...props }: AppFooterProps): import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type AppHeaderProps = {
+    scope?: ReactNode;
+    title: ReactNode;
+    description?: ReactNode;
+    toolbar?: ReactNode;
+    children?: ReactNode;
+    headingProps?: Omit<ComponentPropsWithRef<'div'>, 'children'>;
+} & Omit<ComponentPropsWithRef<'header'>, 'children' | 'title'>;
+/** Page identity and actions; on narrow screens the scope shares a row with actions. */
+export declare function AppHeader({ scope, title, description, toolbar, children, headingProps, className, ...props }: AppHeaderProps): import("react").JSX.Element;

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

@@ -0,0 +1,17 @@
+import type { ComponentProps, ComponentPropsWithRef, ReactNode } from 'react';
+import { AppFooter } from './AppFooter.js';
+import { type TooltipProviderProps } from './Tooltip.js';
+
+export type AppLayoutProps = {
+    children: ReactNode;
+    footerActions?: ReactNode;
+    footer?: ReactNode;
+    footerProps?: Omit<ComponentProps<typeof AppFooter>, 'children'>;
+    layoutProps?: Omit<ComponentPropsWithRef<'div'>, 'children'>;
+    tooltipProviderProps?: Omit<TooltipProviderProps, 'children'>;
+} & Omit<ComponentPropsWithRef<'main'>, 'children'>;
+/**
+ * Native props target `<main>`. `layoutProps` targets the outer wrapper; `footer` replaces the
+ * default footer, while `footerActions` fills it.
+ */
+export declare function AppLayout({ children, footerActions, footer, footerProps, layoutProps, tooltipProviderProps, className, ...props }: AppLayoutProps): import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type AppScopeProps = {
+    organization: string;
+    environment: string;
+    children?: ReactNode;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+export declare function AppScope({ organization, environment, children, className, ...props }: AppScopeProps): import("react").JSX.Element;

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

@@ -0,0 +1,32 @@
+import type { ComponentProps, ComponentPropsWithRef, ReactNode } from 'react';
+import type { DataView } from '../../core/data-view.js';
+import { type LiveControlProps } from './LiveControl.js';
+import { PresentStory } from './PresentStory.js';
+import { RefreshControl } from './RefreshControl.js';
+
+export type AppToolbarProps = {
+    children?: ReactNode;
+    end?: ReactNode;
+    controlsProps?: Omit<ComponentPropsWithRef<'div'>, 'children'>;
+    updatedAt?: ReactNode;
+    initialLoading?: boolean;
+    requestState?: DataView<unknown, unknown>['kind'];
+    refresh?: {
+        refreshing: boolean;
+        onRefresh: () => void;
+        onCancel?: () => void;
+        label?: string;
+        tooltip?: ReactNode;
+        buttonProps?: Omit<ComponentPropsWithRef<'button'>, 'children' | 'onClick'>;
+        statusProps?: ComponentProps<typeof RefreshControl>['statusProps'];
+    };
+    live?: LiveControlProps;
+    aboutData?: ReactNode;
+    story?: ComponentProps<typeof PresentStory>;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** Header actions only. Put reader-controlled inputs in DataApp.variables below the header.
+ * Observation time, or an initial loading status, sits before Refresh. Children prepend app controls in the right
+ * cluster; end follows the built-in actions. Live sits beside Refresh when supplied. Refresh also
+ * answers Alt/Option+R and uses the button to cancel a running request when onCancel is provided;
+ * refresh.tooltip overrides its static label. All built-in controls are optional. */
+export declare function AppToolbar({ children, updatedAt, initialLoading, requestState, refresh, live, aboutData, story, end, controlsProps, className, role, 'aria-label': ariaLabel, ...props }: AppToolbarProps): import("react").JSX.Element;

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

@@ -0,0 +1,14 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type BreakdownItem = {
+    id: string;
+    label: ReactNode;
+    value: number;
+};
+export type BreakdownProps = {
+    total: number;
+    items: readonly BreakdownItem[];
+    formatValue?: (value: number) => ReactNode;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** Mutually exclusive parts of one observed whole. Every share uses the supplied total. */
+export declare function Breakdown({ total, items, formatValue, className, ...props }: BreakdownProps): import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+import type { ComponentPropsWithRef } from 'react';
+import { type ButtonProps as AriaButtonProps } from 'react-aria-components';
+
+export type ButtonProps = ComponentPropsWithRef<'button'> & {
+    variant?: 'elevated' | 'outline' | 'ghost';
+    size?: 'default' | 'compact' | 'icon' | 'icon-compact';
+};
+export declare function Button({ className, type, variant, size, disabled, ...props }: ButtonProps): import("react").JSX.Element;
+/** React Aria trigger behavior with the same presentation as the native Button. */
+export declare function PressButton({ variant, size, className, ...props }: Omit<AriaButtonProps, 'className'> & Pick<ButtonProps, 'variant' | 'size'> & {
+    className?: string;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,11 @@
+import { type ReactNode } from 'react';
+
+export type CheckboxProps = {
+    label: string;
+    description?: ReactNode;
+    checked: boolean;
+    onChange: (checked: boolean) => void;
+    disabled?: boolean;
+    className?: string;
+};
+export declare function Checkbox({ label, description, checked, onChange, disabled, className, }: CheckboxProps): import("react").JSX.Element;

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

@@ -0,0 +1,43 @@
+
+/** IDs are nonempty and unique across ordinary and missing options. */
+export type ComboboxOption = {
+    id: string;
+    label: string;
+    description?: string;
+};
+type SharedProps = {
+    label: string;
+    options: ComboboxOption[];
+    /** Separate source state, rendered last with a divider and the shared option component. */
+    missingOption?: ComboboxOption;
+    disabled?: boolean;
+    placeholder?: string;
+    emptyMessage?: string;
+    /** Known options remain selectable while refreshing; unavailable selected IDs are retained. */
+    loading?: boolean;
+    /** Shows failure feedback without removing known options or unavailable selections. */
+    error?: boolean;
+    onRetry?: () => void;
+};
+export type SingleComboboxProps = SharedProps & {
+    value: string;
+    onChange: (value: string) => void;
+    resetValue?: string;
+    values?: never;
+    maxSelected?: never;
+    emptySelectionLabel?: never;
+};
+export type MultiComboboxProps = SharedProps & {
+    values: readonly string[];
+    onChange: (values: string[]) => void;
+    /** Positive integer; at capacity, only unselected options are disabled. */
+    maxSelected: number;
+    /** Meaning of an empty selection belongs to the caller, e.g. All or Select a value. */
+    emptySelectionLabel: string;
+    value?: never;
+    resetValue?: never;
+};
+export type ComboboxProps = SingleComboboxProps | MultiComboboxProps;
+/** Searchable selection picker with one focus and popup model for single and multiple values. */
+export declare function Combobox(props: ComboboxProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,15 @@
+import { type MetricComparison } from './comparison.js';
+import type { MetricDefinition } from './metric.js';
+import type { MetricReading } from '../../core/reading.js';
+
+type UnboundComparisonProps = MetricComparison & {
+    label: string;
+    emphasis?: 'standard' | 'story';
+};
+export type ComparisonVisualProps = UnboundComparisonProps | {
+    metric: MetricDefinition;
+    reading: MetricReading;
+    emphasis?: 'standard' | 'story';
+};
+export declare function ComparisonVisual(props: ComparisonVisualProps): import("react").JSX.Element | null;
+export {};

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

@@ -0,0 +1,8 @@
+import type { ComponentPropsWithRef } from 'react';
+
+export type ContentSkeletonProps = {
+    rows?: number;
+    variant: 'metric' | 'panel' | 'ranking';
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** A metric, panel, or ranking placeholder to compose in the same layout as live content. */
+export declare function ContentSkeleton({ variant, rows, className, ...props }: ContentSkeletonProps): import("react").JSX.Element;

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

@@ -0,0 +1,56 @@
+import { type ComponentProps, type ReactNode } from 'react';
+import type { DisclosedQuery } from '../../core/contract.js';
+import type { DataAppConfig } from '../../core/config.js';
+import { type AboutEmpty } from './AboutData.js';
+import { AppLayout } from './AppLayout.js';
+import { type AppToolbarProps } from './AppToolbar.js';
+import type { DataContext } from './data-context.js';
+import type { BoundStory } from './story.js';
+import { type SectionResult } from './DataSection.js';
+import type { EmptyStateProps } from './EmptyState.js';
+type DataAppBaseProps = {
+    config: DataAppConfig;
+    dataContext: DataContext;
+    aboutEmpty?: AboutEmpty;
+    description?: ReactNode;
+    /** Display names only; config.scope remains the connection identity. */
+    scopeLabels?: {
+        organization?: string;
+        environment?: string;
+    };
+    toolbarActions?: ReactNode;
+    footerActions?: ReactNode;
+    layoutProps?: Omit<ComponentProps<typeof AppLayout>, 'children' | 'footerActions'>;
+};
+export type DataAppRequest<Data, Input> = SectionResult<Data, Input> & {
+    queries?: DisclosedQuery[];
+    refresh?: AppToolbarProps['refresh'];
+    empty: Pick<EmptyStateProps, 'title' | 'description'>;
+    controls?: ReactNode;
+};
+export type DataAppProps<Data = unknown, Input = unknown> = DataAppBaseProps & ({
+    request: DataAppRequest<Data, Input>;
+    /** Findings are always derived from the result currently visible to the reader. */
+    story?: BoundStory<Data, Input>;
+    children: (data: Data, displayedInput: Input) => ReactNode;
+    loading?: ReactNode;
+    label?: string;
+    queries?: never;
+    refresh?: never;
+    variables?: never;
+} | {
+    request?: never;
+    story?: never;
+    children: ReactNode;
+    queries?: DisclosedQuery[];
+    refresh?: AppToolbarProps['refresh'];
+    variables?: ReactNode;
+    loading?: never;
+    empty?: never;
+    label?: never;
+});
+/** Owns the page title, header, gutter, and width; body content uses section headings.
+ * The primary request owns controls, empty state, displayed input, refresh, and inspection.
+ * Without a request, the shell accepts authored children for setup or static views. */
+export declare function DataApp<Data, Input>(props: DataAppProps<Data, Input>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,16 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+import type { DataView } from '../../core/data-view.js';
+export type DataBoundaryProps<T, Input = unknown> = {
+    view: DataView<T, Input>;
+    loading: ReactNode;
+    empty: ReactNode;
+    error: (error: Error) => ReactNode;
+    staleError?: (error: Error) => ReactNode;
+    notice?: 'inline' | 'none';
+    dimOnUpdate?: boolean;
+    children: (data: T, displayedInput: Input) => ReactNode;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** Render one request state at a time. Prior content remains readable during an update.
+ * Local boundaries can opt into an inline notice and delayed dimming. */
+export declare function DataBoundary<T, Input>({ view, loading, empty, error, staleError, notice, dimOnUpdate, children, className, ...props }: DataBoundaryProps<T, Input>): import("react").JSX.Element;

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

@@ -0,0 +1,28 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+import type { DataView } from '../../core/data-view.js';
+import { type EmptyStateProps } from './EmptyState.js';
+type SectionEmpty = Pick<EmptyStateProps, 'title' | 'description'>;
+export type SectionResult<Data, Input> = {
+    view: DataView<Data, Input>;
+    refetch: () => unknown;
+};
+export type DataSectionProps<Data, Input = unknown> = {
+    result: SectionResult<Data, Input>;
+    empty: SectionEmpty;
+    children: (data: Data, displayedInput: Input) => ReactNode;
+    /** Placeholder layout for an initial request; use the ready view's grid without copied values. */
+    loading?: ReactNode;
+    error?: {
+        title: ReactNode;
+        description?: ReactNode;
+        onRetry?: () => void;
+    };
+    label?: string;
+    /** DataApp suppresses this local notice in favor of its page-level toast. */
+    notice?: 'inline' | 'none';
+    dimOnUpdate?: boolean;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** One request boundary for any number of cards. `DataBoundary` exposes the lower-level
+ * view-state slots for custom composition. */
+export declare function DataSection<Data, Input>({ result, children, empty, loading, error, label, notice, dimOnUpdate, ...props }: DataSectionProps<Data, Input>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,28 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+import { type EmptyStateProps } from './EmptyState.js';
+import { type SearchFieldProps } from './SearchField.js';
+
+export type DataTableSearch = Pick<SearchFieldProps, 'label' | 'placeholder' | 'value' | 'onChange' | 'resetValue'> & {
+    /** Number of available records before filtering or a display limit. */
+    itemCount: number;
+};
+export type DataTableProps = ComponentPropsWithRef<'table'> & {
+    searchable?: DataTableSearch;
+};
+/** Scrollable native table. Mark quantitative th/td cells with data-type="number";
+ * the runtime aligns them to the end and uses tabular digits. */
+export declare function DataTable({ className, ref, searchable, ...props }: DataTableProps): import("react").JSX.Element;
+/** Accepts a fraction of the stated whole, using `formatPercent` semantics. */
+export declare function DataTableShare({ value }: {
+    value: number;
+}): import("react").JSX.Element;
+export type DataTableEmptyRowProps = Pick<EmptyStateProps, 'title' | 'description'> & {
+    colSpan: number;
+};
+export declare function DataTableEmptyRow({ colSpan, title, description, }: DataTableEmptyRowProps): import("react").JSX.Element;
+export type DataTableTimestampProps = {
+    value: string | Date;
+    children?: ReactNode;
+    timeZone?: string;
+};
+export declare function DataTableTimestamp({ value, children, timeZone, }: DataTableTimestampProps): import("react").JSX.Element;

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

@@ -0,0 +1,12 @@
+import { type ReactNode } from 'react';
+import type { DataView } from '../../core/data-view.js';
+
+export type DataViewToastProps<Data, Input> = {
+    view: DataView<Data, Input>;
+    message?: ReactNode;
+    notice?: ReactNode;
+    onRetry?: () => void;
+};
+/** One page-level refresh status. Updating waits briefly; a failed refresh waits
+ * long enough to avoid interrupting the displayed result before showing retry. */
+export declare function DataViewToast<Data, Input>({ view, message, notice, onRetry, }: DataViewToastProps<Data, Input>): import("react").JSX.Element | null;

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

@@ -0,0 +1,39 @@
+import { type ComponentPropsWithRef, type ReactNode } from 'react';
+import type { DataReading } from '../../core/reading.js';
+import { type WidgetStatus } from './RequestHint.js';
+import { type ContentSkeletonProps } from './ContentSkeleton.js';
+import { type EmptyStateProps } from './EmptyState.js';
+import type { WidgetEvidence } from './WidgetEvidence.js';
+
+
+type Empty = Pick<EmptyStateProps, 'title' | 'description'>;
+type DataWidgetBaseProps = {
+    title: ReactNode;
+    count?: number;
+    description?: ReactNode;
+    evidence?: WidgetEvidence;
+    action?: ReactNode;
+    /** Reserved feedback slot; retain displayed content while refreshing or after failure. */
+    status?: WidgetStatus;
+    footer?: ReactNode;
+    bodyPadding?: 'inset' | 'flush';
+} & Omit<ComponentPropsWithRef<'section'>, 'about' | 'title' | 'children'>;
+/** Owns loading, empty content, actions, and inspection. Page and sheet mount the same
+ * body and footer; hold interactive child state above the widget to share it across mounts.
+ * A bound reading requires evidence; its child renderer runs only for nonempty ready data. */
+export type DataWidgetProps<Data = unknown> = DataWidgetBaseProps & ({
+    reading: DataReading<Data>;
+    isEmpty: (data: Data) => boolean;
+    empty: Empty;
+    evidence: WidgetEvidence;
+    skeleton?: Pick<ContentSkeletonProps, 'variant' | 'rows'>;
+    children: (data: Data) => ReactNode;
+} | {
+    reading?: never;
+    isEmpty?: never;
+    skeleton?: never;
+    empty?: Empty;
+    children: ReactNode;
+});
+export declare function DataWidget<Data>(props: DataWidgetProps<Data>): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,29 @@
+import { type ComponentProps, type ReactNode } from 'react';
+import { type CalendarDate } from '@internationalized/date';
+import { DateRangePicker as AriaDateRangePicker } from 'react-aria-components';
+
+import { type DatePresetId, type DateRange } from '../../core/date-range.js';
+export type { DatePresetId, DateRange } from '../../core/date-range.js';
+export type DateRangePickerProps = {
+    label?: string;
+    value: DateRange | null;
+    onChange: (range: DateRange | null) => void;
+    minDate?: string;
+    maxDate?: string;
+    maxRangeDays?: number;
+    timeZone?: string;
+    /** Used to display the reset affordance. The app variable owns the URL and reset meaning. */
+    resetValue?: DateRange;
+    isDefault?: boolean;
+    onReset?: () => void;
+    onPresetChange?: (id: DatePresetId) => void;
+    selectedPresetId?: DatePresetId | null;
+    calendarFooter?: ReactNode;
+    comparison?: {
+        enabled: boolean;
+        range: DateRange | null;
+        onChange: (enabled: boolean) => void;
+    };
+} & Omit<ComponentProps<typeof AriaDateRangePicker<CalendarDate>>, 'children' | 'value' | 'onChange' | 'minValue' | 'maxValue' | 'isOpen' | 'onOpenChange' | 'defaultValue' | 'defaultOpen'>;
+/** The app owns URL state; `dateRangeControl` binds a date variable to this picker. */
+export declare function DateRangePicker({ label, value, onChange, minDate, maxDate, maxRangeDays, timeZone, resetValue, isDefault, onReset, onPresetChange, selectedPresetId, calendarFooter, comparison, className, ...props }: DateRangePickerProps): import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+import { type ReactNode } from 'react';
+import { type HelpPopoverProps } from './HelpPopover.js';
+
+export type DateTimeTooltipProps = {
+    date: Date;
+    timeZone?: string;
+    children?: ReactNode;
+} & Omit<HelpPopoverProps, 'trigger' | 'triggerLabel' | 'label' | 'children'>;
+/** Pass the viewer's account time zone when known; the popover also exposes UTC and Unix time. */
+export declare function DateTimeTooltip({ date, timeZone, children, triggerClassName, panelClassName, ...props }: DateTimeTooltipProps): import("react").JSX.Element;

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

@@ -0,0 +1,11 @@
+import type { DimensionOption, DimensionSelection, DimensionValue, DimensionVariable } from '../../core/dimension.js';
+/** Adapts the typed dimension contract to the shared Combobox control. */
+export declare function DimensionPicker<T extends DimensionValue>({ filter, value, onChange, options: suppliedOptions, loading, error, onRetry, }: {
+    filter: DimensionVariable<T>;
+    value: DimensionSelection<T>;
+    onChange: (value: DimensionSelection<T>) => void;
+    options?: readonly DimensionOption<T>[];
+    loading?: boolean;
+    error?: boolean;
+    onRetry?: () => void;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+import type { ReactNode } from 'react';
+
+export type EmptyStateProps = {
+    title: ReactNode;
+    description?: ReactNode;
+    variant?: 'visual' | 'table';
+    className?: string;
+};
+export declare function EmptyState({ title, description, variant, className, }: EmptyStateProps): import("react").JSX.Element;

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

@@ -0,0 +1,9 @@
+import type { DataAppConfig } from '../../core/config.js';
+import type { DataContext } from './data-context.js';
+
+/** Query-backed connection state and next steps for a newly created app. Mount within
+ * `DataAppProvider` and register `connection: connectionCheck()` on the server. */
+export declare function GettingStarted({ config, dataContext, }: {
+    config: DataAppConfig;
+    dataContext: DataContext;
+}): import("react").JSX.Element;

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

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+import type { GlossaryEntry } from './data-context.js';
+
+export type GlossaryDefinitionProps = {
+    entry: GlossaryEntry;
+    children?: ReactNode;
+};
+export declare function GlossaryDefinition({ entry, children, }: GlossaryDefinitionProps): import("react").JSX.Element;

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

@@ -0,0 +1,17 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+import type { DisclosedQuery } from '../../core/contract.js';
+import type { DataContext, GlossaryEntry } from './data-context.js';
+import { type AboutEmpty } from './AboutData.js';
+
+export type GlossaryExplanationProps = {
+    entry: GlossaryEntry;
+    empty?: AboutEmpty;
+    title?: ReactNode;
+    description?: ReactNode;
+    visual?: ReactNode;
+    queries?: DisclosedQuery[];
+    dataContext?: DataContext;
+} & Omit<ComponentPropsWithRef<'button'>, 'children' | 'title'>;
+/** Opens the inspect sheet for one glossary term. Prefer a card's evidence slot
+ * when the surface already has a title, description, and visual. */
+export declare function GlossaryExplanation({ entry, empty, title, description, visual, queries, dataContext, className, ...props }: GlossaryExplanationProps): import("react").JSX.Element;

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

@@ -0,0 +1,16 @@
+import { type ComponentPropsWithRef } from 'react';
+
+export type GradientScrollProps = ComponentPropsWithRef<'div'> & {
+    axis?: 'vertical' | 'horizontal';
+    /** Disable the start fade when sticky controls share the scrollport. */
+    fadeStart?: boolean;
+};
+type ScrollMetrics = Pick<HTMLElement, 'scrollTop' | 'scrollHeight' | 'clientHeight' | 'scrollLeft' | 'scrollWidth' | 'clientWidth'>;
+/** The visible edges that still have content beyond them. */
+export declare function scrollFadeEdges(metrics: ScrollMetrics, axis: 'vertical' | 'horizontal'): {
+    start: boolean;
+    end: boolean;
+};
+/** Fades only scrollable edges; content, size, and scroll changes update the mask. */
+export declare function GradientScroll({ axis, fadeStart, className, children, ref, ...props }: GradientScrollProps): import("react").JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+
+export type GridProps = {
+    children: ReactNode;
+    /** Maximum columns; cards wrap sooner when the container cannot fit their minimum width. */
+    columns?: 1 | 2 | 3 | 4;
+    minItemWidth?: 'compact' | 'regular' | 'wide';
+    gap?: 'sm' | 'md' | 'lg';
+    /** Stretch peer cards to the tallest item in their row only when needed. */
+    align?: 'stretch' | 'start';
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+/** Responsive layout for peer cards and panels. Cards keep their content height by default. */
+export declare function Grid({ children, columns, minItemWidth, gap, align, className, ...props }: GridProps): import("react").JSX.Element;

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

@@ -0,0 +1,7 @@
+import type { ComponentPropsWithRef, ReactNode } from 'react';
+export type GridItemProps = {
+    children: ReactNode;
+    /** Maximum tracks occupied; collapses to one when the grid container is narrow. */
+    span?: 1 | 2;
+} & Omit<ComponentPropsWithRef<'div'>, 'children'>;
+export declare function GridItem({ children, span, className, ...props }: GridItemProps): import("react").JSX.Element;