@oprt/react 0.0.0-stage → 0.2.0

package/dist/index.d.cts

@@ -0,0 +1,2330 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, ComponentPropsWithoutRef, RefObject, ButtonHTMLAttributes, TableHTMLAttributes, InputHTMLAttributes, AnchorHTMLAttributes, TextareaHTMLAttributes, FieldsetHTMLAttributes, ReactElement } from 'react';
+import * as class_variance_authority_types from 'class-variance-authority/types';
+import { VariantProps } from 'class-variance-authority';
+import * as RadixToast from '@radix-ui/react-toast';
+
+declare const containerStyles: (props?: ({
+    variant?: "info" | "success" | "warning" | "error" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AlertProps = Omit<HTMLAttributes<HTMLDivElement>, "title"> & VariantProps<typeof containerStyles> & {
+    variant: "info" | "success" | "warning" | "error";
+    title?: string;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    children?: ReactNode;
+};
+declare const Alert: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "title"> & VariantProps<(props?: ({
+    variant?: "info" | "success" | "warning" | "error" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    variant: "info" | "success" | "warning" | "error";
+    title?: string;
+    dismissible?: boolean;
+    onDismiss?: () => void;
+    children?: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+type Prop = {
+    type: "enum";
+    values: string[];
+    default?: string | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+} | {
+    type: "boolean";
+    default?: boolean | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+} | {
+    type: "string";
+    default?: string | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+} | {
+    type: "number";
+    default?: number | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+} | {
+    type: "function";
+    required?: boolean | undefined;
+    description?: string | undefined;
+} | {
+    type: "array";
+    items?: Record<string, unknown> | undefined;
+    required?: boolean | undefined;
+    description?: string | undefined;
+} | {
+    type: "node";
+    required?: boolean | undefined;
+    description?: string | undefined;
+} | {
+    type: "union";
+    types: ("boolean" | "string" | "number" | "function" | "array" | "node")[];
+    required?: boolean | undefined;
+    description?: string | undefined;
+};
+type Slot = {
+    type: string;
+    required?: boolean | undefined;
+};
+type Component = {
+    description: string;
+    props: Record<string, Prop>;
+    slots?: Record<string, Slot> | undefined;
+    composable_with?: string[] | undefined;
+    never_inside?: string[] | undefined;
+    example: string;
+};
+
+declare const AlertManifest: Record<string, Component>;
+
+declare const rootStyles$3: (props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type AvatarProps = Omit<ComponentPropsWithoutRef<"span">, "size"> & VariantProps<typeof rootStyles$3> & {
+    /** Person/entity name — drives the initials fallback and the accessible name. */
+    name: string;
+    /** Optional image source. When absent, initials render immediately. */
+    src?: string;
+    /**
+     * Accessible name of the avatar. Defaults to `name`. An empty string marks the avatar
+     * decorative and hides it from assistive technology, as it should be beside a visible name.
+     */
+    alt?: string;
+    /** Delay (ms) before the initials show while the image loads. They show at once if it fails. */
+    delayMs?: number;
+};
+declare const Avatar: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, "ref">, "size"> & VariantProps<(props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    /** Person/entity name — drives the initials fallback and the accessible name. */
+    name: string;
+    /** Optional image source. When absent, initials render immediately. */
+    src?: string;
+    /**
+     * Accessible name of the avatar. Defaults to `name`. An empty string marks the avatar
+     * decorative and hides it from assistive technology, as it should be beside a visible name.
+     */
+    alt?: string;
+    /** Delay (ms) before the initials show while the image loads. They show at once if it fails. */
+    delayMs?: number;
+} & react.RefAttributes<HTMLSpanElement>>;
+
+declare const AvatarManifest: Record<string, Component>;
+
+declare const badgeStyles: (props?: ({
+    variant?: "info" | "success" | "warning" | "error" | "neutral" | null | undefined;
+    appearance?: "text" | "outlined" | null | undefined;
+    size?: "md" | "sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type BadgeProps = HTMLAttributes<HTMLSpanElement> & VariantProps<typeof badgeStyles> & {
+    indicator?: "dot" | "icon" | "none";
+    icon?: ReactNode;
+};
+declare const Badge: react.ForwardRefExoticComponent<HTMLAttributes<HTMLSpanElement> & VariantProps<(props?: ({
+    variant?: "info" | "success" | "warning" | "error" | "neutral" | null | undefined;
+    appearance?: "text" | "outlined" | null | undefined;
+    size?: "md" | "sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    indicator?: "dot" | "icon" | "none";
+    icon?: ReactNode;
+} & react.RefAttributes<HTMLSpanElement>>;
+
+declare const BadgeManifest: Record<string, Component>;
+
+type TagItem = {
+    id: string;
+    label: string;
+    disabled?: boolean;
+};
+type TagGroupProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    items: readonly TagItem[];
+    label: string;
+    onRemove?: (id: string) => void;
+    disabled?: boolean;
+    emptyMessage?: string;
+    returnFocusRef?: RefObject<HTMLElement | null>;
+    className?: string;
+};
+declare const TagGroup: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    items: readonly TagItem[];
+    label: string;
+    onRemove?: (id: string) => void;
+    disabled?: boolean;
+    emptyMessage?: string;
+    returnFocusRef?: RefObject<HTMLElement | null>;
+    className?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const TagGroupManifest: Record<string, Component>;
+
+type PropertyFilterOperator = {
+    key: string;
+    label: string;
+    requiresValue: boolean;
+};
+type PropertyFilterField = {
+    key: string;
+    label: string;
+    operators: readonly PropertyFilterOperator[];
+    options?: readonly {
+        value: string;
+        label: string;
+        disabled?: boolean;
+    }[];
+};
+type PropertyFilterToken = {
+    id: string;
+    field: string;
+    operator: string;
+    value: string | null;
+};
+type PropertyFilterValue = {
+    match: "all" | "any";
+    tokens: readonly PropertyFilterToken[];
+};
+/** Why a clause does not fit the fields, or null when it does. */
+declare function getPropertyFilterTokenError(token: PropertyFilterToken, fields: readonly PropertyFilterField[]): string | null;
+
+type PropertyFilterProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> & {
+    fields: readonly PropertyFilterField[];
+    value: PropertyFilterValue;
+    onValueChange: (value: PropertyFilterValue) => void;
+    label?: string;
+    disabled?: boolean;
+    className?: string;
+};
+declare const PropertyFilter: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children" | "defaultValue" | "onChange"> & {
+    fields: readonly PropertyFilterField[];
+    value: PropertyFilterValue;
+    onValueChange: (value: PropertyFilterValue) => void;
+    label?: string;
+    disabled?: boolean;
+    className?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const PropertyFilterManifest: Record<string, Component>;
+
+type CollectionStateProps = Omit<HTMLAttributes<HTMLDivElement>, "title" | "children"> & {
+    variant: "empty" | "no-results" | "error" | "access-denied";
+    title: string;
+    description?: ReactNode;
+    actions?: ReactNode;
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+};
+/** Supplied collection state. Recovery actions and announcement timing belong to the caller. */
+declare const CollectionState: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "title" | "children"> & {
+    variant: "empty" | "no-results" | "error" | "access-denied";
+    title: string;
+    description?: ReactNode;
+    actions?: ReactNode;
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const CollectionStateManifest: Record<string, Component>;
+
+type BreadcrumbItem = {
+    label: string;
+    href?: string;
+    current?: boolean;
+};
+type BreadcrumbProps = Omit<ComponentPropsWithoutRef<"nav">, "children"> & {
+    items: BreadcrumbItem[];
+    separator?: ReactNode;
+};
+declare const Breadcrumb: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLElement>, HTMLElement>, "ref">, "children"> & {
+    items: BreadcrumbItem[];
+    separator?: ReactNode;
+} & react.RefAttributes<HTMLElement>>;
+
+declare const BreadcrumbManifest: Record<string, Component>;
+
+type MotionMode = "auto" | "none";
+
+declare const buttonStyles: (props?: ({
+    variant?: "primary" | "danger" | "secondary" | "tertiary" | "ghost" | null | undefined;
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonProps = ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<typeof buttonStyles> & {
+    asChild?: boolean;
+    motion?: MotionMode;
+};
+declare const Button: react.ForwardRefExoticComponent<ButtonHTMLAttributes<HTMLButtonElement> & VariantProps<(props?: ({
+    variant?: "primary" | "danger" | "secondary" | "tertiary" | "ghost" | null | undefined;
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    asChild?: boolean;
+    motion?: MotionMode;
+} & react.RefAttributes<HTMLButtonElement>>;
+
+declare const ButtonManifest: Record<string, Component>;
+
+declare const groupStyles$1: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+    attached?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ButtonGroupProps = HTMLAttributes<HTMLDivElement> & VariantProps<typeof groupStyles$1>;
+declare const ButtonGroup: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & VariantProps<(props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+    attached?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & react.RefAttributes<HTMLDivElement>>;
+
+declare const ButtonGroupManifest: Record<string, Component>;
+
+type CardProps = HTMLAttributes<HTMLDivElement>;
+declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>>;
+/** Short section title. Use `normal-case tracking-normal` on any nested name or value. */
+type CardHeaderProps = HTMLAttributes<HTMLDivElement>;
+declare const CardHeader: react.ForwardRefExoticComponent<CardHeaderProps & react.RefAttributes<HTMLDivElement>>;
+type CardBodyProps = HTMLAttributes<HTMLDivElement>;
+declare const CardBody: react.ForwardRefExoticComponent<CardBodyProps & react.RefAttributes<HTMLDivElement>>;
+type CardFooterProps = HTMLAttributes<HTMLDivElement>;
+declare const CardFooter: react.ForwardRefExoticComponent<CardFooterProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const CardManifest: Record<string, Component>;
+declare const CardCompositionRules: {
+    Card: {
+        allowed_children: string[];
+        children: {
+            CardHeader: {
+                allowed_children: string[];
+            };
+            CardBody: {
+                allowed_children: string[];
+            };
+            CardFooter: {
+                allowed_children: string[];
+            };
+        };
+    };
+};
+
+declare const rootStyles$2: (props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type CheckboxProps = VariantProps<typeof rootStyles$2> & {
+    motion?: MotionMode;
+    checked?: boolean | "indeterminate";
+    defaultChecked?: boolean | "indeterminate";
+    onCheckedChange?: (checked: boolean | "indeterminate") => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    value?: string;
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+};
+declare const Checkbox: react.ForwardRefExoticComponent<VariantProps<(props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    motion?: MotionMode;
+    checked?: boolean | "indeterminate";
+    defaultChecked?: boolean | "indeterminate";
+    onCheckedChange?: (checked: boolean | "indeterminate") => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    value?: string;
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+} & react.RefAttributes<HTMLInputElement>>;
+
+declare const CheckboxManifest: Record<string, Component>;
+
+type CollapsibleProps = Omit<ComponentPropsWithoutRef<"div">, "type" | "value" | "defaultValue" | "onValueChange"> & {
+    motion?: MotionMode;
+    type?: "single" | "multiple";
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    /** single-type only: allow the open item to collapse. Default true. */
+    collapsible?: boolean;
+    children: ReactNode;
+};
+declare const Collapsible: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "value" | "type" | "defaultValue" | "onValueChange"> & {
+    motion?: MotionMode;
+    type?: "single" | "multiple";
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    /** single-type only: allow the open item to collapse. Default true. */
+    collapsible?: boolean;
+    children: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+type CollapsibleItemProps = Omit<ComponentPropsWithoutRef<"div">, "value" | "title"> & {
+    value: string;
+    title: string;
+    disabled?: boolean;
+    children: ReactNode;
+};
+declare const CollapsibleItem: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title" | "value"> & {
+    value: string;
+    title: string;
+    disabled?: boolean;
+    children: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const CollapsibleManifest: Record<string, Component>;
+declare const CollapsibleCompositionRules: {
+    Collapsible: {
+        allowed_children: string[];
+    };
+};
+
+type Command = {
+    id: string;
+    label: string;
+    group?: string;
+    shortcut?: string;
+    icon?: ReactNode;
+    onSelect: () => void;
+    disabled?: boolean;
+};
+type CommandPaletteProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    commands: Command[];
+    placeholder?: string;
+    emptyMessage?: string;
+    className?: string;
+};
+/**
+ * The forwarded ref receives the `<section role="dialog">` React Aria renders, so it is typed
+ * HTMLElement (it was HTMLDivElement, which never matched; object and callback refs typed for a
+ * div are still accepted).
+ */
+declare const CommandPalette: react.ForwardRefExoticComponent<CommandPaletteProps & react.RefAttributes<HTMLElement>>;
+
+declare const CommandPaletteManifest: Record<string, Component>;
+
+type ConfirmDialogProps = {
+    trigger?: ReactNode;
+    title: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+    confirmVariant?: "primary" | "danger";
+    /** When set, the user must type this phrase exactly to enable Confirm. */
+    confirmPhrase?: string;
+    onConfirm: () => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    size?: "sm" | "md" | "lg";
+    className?: string;
+};
+/** The ref receives Dialog's `<section role="dialog">`, so it is typed HTMLElement. */
+declare const ConfirmDialog: react.ForwardRefExoticComponent<ConfirmDialogProps & react.RefAttributes<HTMLElement>>;
+
+declare const ConfirmDialogManifest: Record<string, Component>;
+
+type DataTableVirtualization = {
+    /** Scroll viewport height in CSS pixels. */
+    height: number;
+    /** Fixed row height; omit to measure wrapped/variable-height rows. Minimum 24. */
+    rowHeight?: number;
+    /** Initial estimate for measured rows, refined with ResizeObserver. */
+    estimateRowHeight?: number;
+    overscan?: number;
+};
+
+type DataTableColumn = {
+    key: string;
+    label: string;
+    as?: "text" | "number" | "code" | "timestamp" | "badge";
+    highlight?: boolean;
+    sortable?: boolean;
+    width?: string;
+    align?: "left" | "right";
+    render?: (value: unknown, row: DataTableRow) => ReactNode;
+};
+type DataTableRow = Record<string, unknown>;
+type DataTableSortDescriptor = {
+    key: string;
+    direction: "asc" | "desc";
+};
+type DataTableProps = Omit<TableHTMLAttributes<HTMLTableElement>, "children"> & {
+    columns: DataTableColumn[];
+    data: DataTableRow[];
+    sortable?: boolean;
+    /** Read-only metadata for rows already sorted by the caller. Null means source order. */
+    sortDescriptor?: DataTableSortDescriptor | null;
+    dense?: boolean;
+    onRowClick?: (row: DataTableRow, index: number) => void;
+    getRowId?: (row: DataTableRow, index: number) => string;
+    caption?: string;
+    emptyMessage?: string;
+    columnWidths?: Record<string, number>;
+    pinnedColumnKeys?: readonly string[];
+    virtualization?: DataTableVirtualization;
+    /** Zero-based offset in the complete result set, excluding the header. */
+    rowIndexOffset?: number;
+    /** Complete data-row count, excluding the header. */
+    totalRowCount?: number;
+};
+declare const DataTable: react.ForwardRefExoticComponent<Omit<TableHTMLAttributes<HTMLTableElement>, "children"> & {
+    columns: DataTableColumn[];
+    data: DataTableRow[];
+    sortable?: boolean;
+    /** Read-only metadata for rows already sorted by the caller. Null means source order. */
+    sortDescriptor?: DataTableSortDescriptor | null;
+    dense?: boolean;
+    onRowClick?: (row: DataTableRow, index: number) => void;
+    getRowId?: (row: DataTableRow, index: number) => string;
+    caption?: string;
+    emptyMessage?: string;
+    columnWidths?: Record<string, number>;
+    pinnedColumnKeys?: readonly string[];
+    virtualization?: DataTableVirtualization;
+    /** Zero-based offset in the complete result set, excluding the header. */
+    rowIndexOffset?: number;
+    /** Complete data-row count, excluding the header. */
+    totalRowCount?: number;
+} & react.RefAttributes<HTMLTableElement>>;
+
+declare const DataTableManifest: Record<string, Component>;
+
+declare const surfaceStyles: (props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type DialogProps = Omit<ComponentPropsWithoutRef<"div">, "size" | "title"> & VariantProps<typeof surfaceStyles> & {
+    motion?: MotionMode;
+    title: string;
+    description?: string;
+    trigger?: ReactNode;
+    footer?: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+/**
+ * The forwarded ref receives the `<section role="dialog">` React Aria renders, so it is typed
+ * HTMLElement (it was HTMLDivElement, which never matched; object and callback refs typed for a
+ * div are still accepted).
+ */
+declare const Dialog: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "title" | "size"> & VariantProps<(props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    motion?: MotionMode;
+    title: string;
+    description?: string;
+    trigger?: ReactNode;
+    footer?: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+} & react.RefAttributes<HTMLElement>>;
+
+declare const DialogManifest: Record<string, Component>;
+
+type DividerProps = Omit<ComponentPropsWithoutRef<"div">, "children"> & {
+    /** Visual only when true (role="none"); exposes role="separator" when false. */
+    decorative?: boolean;
+    /**
+     * The direction of the rule. A horizontal rule takes the width of its container; a vertical one
+     * takes the height of its flex row, so it needs a flex row (or a height of its own) to show.
+     */
+    orientation?: "horizontal" | "vertical";
+    /** Centered uppercase label. Horizontal orientation only. */
+    label?: string;
+};
+declare const Divider: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children"> & {
+    /** Visual only when true (role="none"); exposes role="separator" when false. */
+    decorative?: boolean;
+    /**
+     * The direction of the rule. A horizontal rule takes the width of its container; a vertical one
+     * takes the height of its flex row, so it needs a flex row (or a height of its own) to show.
+     */
+    orientation?: "horizontal" | "vertical";
+    /** Centered uppercase label. Horizontal orientation only. */
+    label?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const DividerManifest: Record<string, Component>;
+
+type DropdownMenuProps = {
+    motion?: MotionMode;
+    trigger: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    align?: "start" | "center" | "end";
+    side?: "top" | "right" | "bottom" | "left";
+    className?: string;
+    children: ReactNode;
+};
+declare const DropdownMenu: react.ForwardRefExoticComponent<DropdownMenuProps & react.RefAttributes<HTMLDivElement>>;
+type DropdownMenuItemProps = Omit<ComponentPropsWithoutRef<"div">, "onSelect" | "children"> & {
+    disabled?: boolean;
+    textValue?: string;
+    /** Fired when the item is activated. Call `event.preventDefault()` to keep the menu open. */
+    onSelect?: (event: Event) => void;
+    shortcut?: string;
+    danger?: boolean;
+    children: ReactNode;
+};
+declare const DropdownMenuItem: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "children" | "onSelect"> & {
+    disabled?: boolean;
+    textValue?: string;
+    /** Fired when the item is activated. Call `event.preventDefault()` to keep the menu open. */
+    onSelect?: (event: Event) => void;
+    shortcut?: string;
+    danger?: boolean;
+    children: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+type DropdownMenuSeparatorProps = ComponentPropsWithoutRef<"div">;
+declare const DropdownMenuSeparator: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+type DropdownMenuLabelProps = ComponentPropsWithoutRef<"div">;
+declare const DropdownMenuLabel: react.ForwardRefExoticComponent<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & react.RefAttributes<HTMLDivElement>>;
+
+declare const DropdownMenuManifest: Record<string, Component>;
+declare const DropdownMenuCompositionRules: {
+    DropdownMenu: {
+        allowed_children: string[];
+    };
+};
+
+/** What a Field hands the control inside it. */
+type FieldContextValue = {
+    id: string;
+    /** id of the rendered <label>. Composite controls whose root is a container
+     *  element (role="radiogroup", role="group", a slider group) cannot be named
+     *  by `<label htmlFor>` — htmlFor only labels form elements. Those components
+     *  must consume this as aria-labelledby instead, or they ship with no
+     *  accessible name at all. */
+    labelId: string;
+    describedBy: string | undefined;
+    invalid: boolean;
+    /** A required Field makes its control required (coordinator ruling, following DC-10). */
+    required: boolean;
+};
+
+declare function useFieldContext(): FieldContextValue;
+declare function useOptionalFieldContext(): FieldContextValue | null;
+type FieldProps = HTMLAttributes<HTMLDivElement> & {
+    /** Stable ID for the child control; the native `id` still identifies the wrapper. */
+    controlId?: string;
+    label: string;
+    help?: string;
+    error?: string;
+    required?: boolean;
+    children: ReactNode;
+};
+declare const Field: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    /** Stable ID for the child control; the native `id` still identifies the wrapper. */
+    controlId?: string;
+    label: string;
+    help?: string;
+    error?: string;
+    required?: boolean;
+    children: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const FieldManifest: Record<string, Component>;
+
+type FilterBarBaseProps = Omit<ComponentPropsWithoutRef<"div">, "value" | "defaultValue" | "onChange"> & {
+    /** Filter labels rendered as toggle buttons. Each label appears once. */
+    filters: readonly string[];
+    /** Accessible name for the toggle-button group. */
+    ariaLabel?: string;
+    /** Disable the entire filter group without discarding its selection. */
+    disabled?: boolean;
+};
+type SingleFilterBarProps = {
+    multiple?: false;
+    /** Controlled active filter, or an empty string for no selection. */
+    value?: string;
+    /** Uncontrolled initial active filter value. */
+    defaultValue?: string;
+    /** Fires with the newly active filter value. */
+    onValueChange?: (value: string) => void;
+};
+type MultipleFilterBarProps = {
+    multiple: true;
+    /** Controlled active filters, or an empty array for no selection. */
+    value?: readonly string[];
+    /** Uncontrolled initial active filters. */
+    defaultValue?: readonly string[];
+    /** Fires with all active filters after a selection changes. */
+    onValueChange?: (value: string[]) => void;
+};
+type FilterBarProps = FilterBarBaseProps & (SingleFilterBarProps | MultipleFilterBarProps);
+declare const FilterBar: react.ForwardRefExoticComponent<FilterBarProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const FilterBarManifest: Record<string, Component>;
+
+declare const wrapperStyles: (props?: ({
+    invalid?: boolean | null | undefined;
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type InputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "prefix"> & Pick<VariantProps<typeof wrapperStyles>, "size"> & {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    promptSymbol?: boolean;
+    /**
+     * Marks the field invalid: the error border and aria-invalid, as on Textarea, Select and
+     * ComboBox. Wins over aria-invalid, which wins over a surrounding Field's error.
+     */
+    invalid?: boolean;
+};
+declare const Input: react.ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "prefix" | "size"> & Pick<VariantProps<(props?: ({
+    invalid?: boolean | null | undefined;
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string>, "size"> & {
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    promptSymbol?: boolean;
+    /**
+     * Marks the field invalid: the error border and aria-invalid, as on Textarea, Select and
+     * ComboBox. Wins over aria-invalid, which wins over a surrounding Field's error.
+     */
+    invalid?: boolean;
+} & react.RefAttributes<HTMLInputElement>>;
+
+declare const InputManifest: Record<string, Component>;
+
+declare const rootStyles$1: (props?: ({
+    size?: "md" | "sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ProgressProps = Omit<ComponentPropsWithoutRef<"div">, "value" | "size"> & VariantProps<typeof rootStyles$1> & {
+    value?: number;
+    max?: number;
+    label?: string;
+    showValue?: boolean;
+    variant?: "bar" | "blocks";
+};
+declare const Progress: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "value" | "size"> & VariantProps<(props?: ({
+    size?: "md" | "sm" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    value?: number;
+    max?: number;
+    label?: string;
+    showValue?: boolean;
+    variant?: "bar" | "blocks";
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const ProgressManifest: Record<string, Component>;
+
+type Size$1 = "sm" | "md" | "lg";
+declare const groupStyles: (props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type RadioGroupProps = VariantProps<typeof groupStyles> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    size?: Size$1;
+    className?: string;
+    id?: string;
+    children: ReactNode;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+};
+declare const RadioGroup: react.ForwardRefExoticComponent<VariantProps<(props?: ({
+    orientation?: "horizontal" | "vertical" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    size?: Size$1;
+    className?: string;
+    id?: string;
+    children: ReactNode;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+} & react.RefAttributes<HTMLDivElement>>;
+type RadioProps = {
+    value: string;
+    disabled?: boolean;
+    className?: string;
+    id?: string;
+    children: ReactNode;
+    "aria-label"?: string;
+};
+declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;
+
+declare const RadioGroupManifest: Record<string, Component>;
+declare const RadioGroupCompositionRules: {
+    RadioGroup: {
+        allowed_children: string[];
+    };
+};
+
+declare const triggerStyles: (props?: ({
+    invalid?: boolean | null | undefined;
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SelectProps = VariantProps<typeof triggerStyles> & {
+    motion?: MotionMode;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    placeholder?: string;
+    /** What the list says when there are no options to choose from. */
+    emptyMessage?: string;
+    className?: string;
+    children: ReactNode;
+    "aria-label"?: string;
+    /** Names the Select by another element (a visible heading); wins over a Field's label. */
+    "aria-labelledby"?: string;
+    /** Describes the Select by other elements; replaces a Field's help or error. */
+    "aria-describedby"?: string;
+    id?: string;
+};
+declare const Select: react.ForwardRefExoticComponent<VariantProps<(props?: ({
+    invalid?: boolean | null | undefined;
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    motion?: MotionMode;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    placeholder?: string;
+    /** What the list says when there are no options to choose from. */
+    emptyMessage?: string;
+    className?: string;
+    children: ReactNode;
+    "aria-label"?: string;
+    /** Names the Select by another element (a visible heading); wins over a Field's label. */
+    "aria-labelledby"?: string;
+    /** Describes the Select by other elements; replaces a Field's help or error. */
+    "aria-describedby"?: string;
+    id?: string;
+} & react.RefAttributes<HTMLButtonElement>>;
+type SelectOptionProps = {
+    value: string;
+    disabled?: boolean;
+    className?: string;
+    children: ReactNode;
+};
+declare const SelectOption: react.ForwardRefExoticComponent<SelectOptionProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const SelectManifest: Record<string, Component>;
+declare const SelectCompositionRules: {
+    Select: {
+        allowed_children: string[];
+    };
+};
+
+type SidebarProps = HTMLAttributes<HTMLElement>;
+/**
+ * The rail: never wider than its container. In a host of bounded height its item list scrolls in
+ * place while the logo and the footer stay put (design call DC-15): the sections between a leading
+ * SidebarLogo and a trailing SidebarFooter go in one list that takes the height left and scrolls.
+ * The items are links and buttons, so a keyboard reaches the list and it scrolls to the focused one.
+ * For the frame of a whole app, pass the rail to AppShell as its `navigation`.
+ *
+ * Standing alone the rail is a navigation landmark named "Sidebar". Inside AppShell's `navigation`
+ * the shell's landmark, named for the workspace, already holds it, so the rail is a plain block
+ * and the navigation is announced once.
+ */
+declare const Sidebar: react.ForwardRefExoticComponent<SidebarProps & react.RefAttributes<HTMLElement>>;
+type SidebarLogoProps = HTMLAttributes<HTMLDivElement>;
+declare const SidebarLogo: react.ForwardRefExoticComponent<SidebarLogoProps & react.RefAttributes<HTMLDivElement>>;
+type SidebarSectionProps = HTMLAttributes<HTMLDivElement> & {
+    label?: string;
+};
+/** A labeled section is a group named by its label, so its items are announced with it. */
+declare const SidebarSection: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    label?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+type SidebarItemProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+    icon?: ReactNode;
+    active?: boolean;
+    href?: string;
+    asChild?: boolean;
+    children: ReactNode;
+};
+declare const SidebarItem: react.ForwardRefExoticComponent<Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+    icon?: ReactNode;
+    active?: boolean;
+    href?: string;
+    asChild?: boolean;
+    children: ReactNode;
+} & react.RefAttributes<HTMLAnchorElement & HTMLButtonElement>>;
+type SidebarFooterProps = HTMLAttributes<HTMLDivElement>;
+declare const SidebarFooter: react.ForwardRefExoticComponent<SidebarFooterProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const SidebarManifest: Record<string, Component>;
+declare const SidebarCompositionRules: {
+    Sidebar: {
+        allowed_children: string[];
+        children: {
+            SidebarSection: {
+                allowed_children: string[];
+            };
+        };
+    };
+};
+
+declare const barStyles: (props?: ({
+    variant?: "text" | "block" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type SkeletonProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & VariantProps<typeof barStyles> & {
+    width?: string | number;
+    height?: string | number;
+    lines?: number;
+};
+declare const Skeleton: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & VariantProps<(props?: ({
+    variant?: "text" | "block" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    width?: string | number;
+    height?: string | number;
+    lines?: number;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const SkeletonManifest: Record<string, Component>;
+
+declare const thumbStyles: (props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type Size = NonNullable<VariantProps<typeof thumbStyles>["size"]>;
+type SliderBase = Omit<HTMLAttributes<HTMLSpanElement>, "defaultValue" | "onChange"> & {
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    orientation?: "horizontal" | "vertical";
+    size?: Size;
+    showValue?: boolean;
+    formatValue?: (value: number) => string;
+    name?: string;
+};
+type SingleSlider = SliderBase & {
+    value?: number;
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+};
+type RangeSlider = SliderBase & {
+    value?: [number, number];
+    defaultValue?: [number, number];
+    onValueChange?: (value: [number, number]) => void;
+};
+type SliderProps = SingleSlider | RangeSlider;
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLSpanElement>>;
+
+declare const SliderManifest: Record<string, Component>;
+
+type Trend = "up" | "down" | "flat";
+type TrendIntent = "positive" | "negative" | "neutral";
+type StatCardProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    value: string | number;
+    unit?: string;
+    delta?: number;
+    trend?: Trend;
+    /**
+     * Whether the change is good, bad or neither, which sets the color of the trend independently of
+     * its direction: a fall in errors is `positive`, a rise in alarms is `negative`. Without it the
+     * color follows the direction (up is success, down is error).
+     */
+    trendIntent?: TrendIntent;
+    deltaLabel?: string;
+    caption?: string;
+};
+declare const StatCard: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    value: string | number;
+    unit?: string;
+    delta?: number;
+    trend?: Trend;
+    /**
+     * Whether the change is good, bad or neither, which sets the color of the trend independently of
+     * its direction: a fall in errors is `positive`, a rise in alarms is `negative`. Without it the
+     * color follows the direction (up is success, down is error).
+     */
+    trendIntent?: TrendIntent;
+    deltaLabel?: string;
+    caption?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const StatCardManifest: Record<string, Component>;
+
+type TabsProps = Omit<ComponentPropsWithoutRef<"div">, "dir" | "value" | "defaultValue" | "onChange"> & {
+    motion?: MotionMode;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: "horizontal" | "vertical";
+    children: ReactNode;
+};
+declare const Tabs: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "value" | "defaultValue" | "dir" | "onChange"> & {
+    motion?: MotionMode;
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: "horizontal" | "vertical";
+    children: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+type TabsListProps = Omit<ComponentPropsWithoutRef<"div">, "id">;
+declare const TabsList: react.ForwardRefExoticComponent<TabsListProps & react.RefAttributes<HTMLDivElement>>;
+type TabsTriggerProps = Omit<ComponentPropsWithoutRef<"div">, "id"> & {
+    value: string;
+    disabled?: boolean;
+};
+declare const TabsTrigger: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "id"> & {
+    value: string;
+    disabled?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+type TabsContentProps = Omit<ComponentPropsWithoutRef<"div">, "id"> & {
+    value: string;
+};
+declare const TabsContent: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "id"> & {
+    value: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const TabsManifest: Record<string, Component>;
+declare const TabsCompositionRules: {
+    Tabs: {
+        allowed_children: string[];
+        children: {
+            TabsList: {
+                allowed_children: string[];
+            };
+        };
+    };
+};
+
+type TextareaProps = TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    invalid?: boolean;
+};
+declare const Textarea: react.ForwardRefExoticComponent<TextareaHTMLAttributes<HTMLTextAreaElement> & {
+    invalid?: boolean;
+} & react.RefAttributes<HTMLTextAreaElement>>;
+
+declare const TextareaManifest: Record<string, Component>;
+
+type SwipeDirection = "right" | "left" | "up" | "down";
+type ToastProviderProps = {
+    children: ReactNode;
+    /**
+     * Names the notification region (`<label> (F8)`, F8 being the key that moves focus to it) and
+     * is spoken before each announcement.
+     */
+    label?: string;
+    swipeDirection?: SwipeDirection;
+    duration?: number;
+};
+declare const ToastProvider: react.ForwardRefExoticComponent<ToastProviderProps & react.RefAttributes<HTMLOListElement>>;
+declare const rootStyles: (props?: ({
+    variant?: "info" | "success" | "warning" | "error" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ToastProps = Omit<ComponentPropsWithoutRef<typeof RadixToast.Root>, "title" | "children"> & VariantProps<typeof rootStyles> & {
+    title: string;
+    description?: string | undefined;
+    persistent?: boolean;
+};
+declare const Toast: react.ForwardRefExoticComponent<Omit<Omit<RadixToast.ToastProps & react.RefAttributes<HTMLLIElement>, "ref">, "title" | "children"> & VariantProps<(props?: ({
+    variant?: "info" | "success" | "warning" | "error" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    title: string;
+    description?: string | undefined;
+    persistent?: boolean;
+} & react.RefAttributes<HTMLLIElement>>;
+
+declare const ToastManifest: Record<string, Component>;
+declare const ToastCompositionRules: {
+    ToastProvider: {
+        allowed_children: string[];
+    };
+};
+
+declare const trackStyles: (props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ToggleProps = VariantProps<typeof trackStyles> & {
+    motion?: MotionMode;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    value?: string;
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+};
+declare const Toggle: react.ForwardRefExoticComponent<VariantProps<(props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    motion?: MotionMode;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    disabled?: boolean;
+    required?: boolean;
+    name?: string;
+    value?: string;
+    className?: string;
+    id?: string;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+    "aria-invalid"?: boolean | "true" | "false";
+} & react.RefAttributes<HTMLInputElement>>;
+
+declare const ToggleManifest: Record<string, Component>;
+
+type Orientation = "horizontal" | "vertical";
+type ToolbarProps = Omit<ComponentPropsWithoutRef<"div">, "orientation"> & {
+    orientation?: Orientation;
+    /** The toolbar's accessible name. `aria-label` works too; `ariaLabel` wins when both are given. */
+    ariaLabel?: string;
+};
+declare const Toolbar: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "orientation"> & {
+    orientation?: Orientation;
+    /** The toolbar's accessible name. `aria-label` works too; `ariaLabel` wins when both are given. */
+    ariaLabel?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+type ToolbarSeparatorProps = Omit<ComponentPropsWithoutRef<"div">, "orientation"> & {
+    /**
+     * The axis of the toolbar this separator is in, so the rule runs across it. It follows its
+     * Toolbar when omitted; pass it to say otherwise.
+     */
+    orientation?: Orientation;
+};
+declare const ToolbarSeparator: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "orientation"> & {
+    /**
+     * The axis of the toolbar this separator is in, so the rule runs across it. It follows its
+     * Toolbar when omitted; pass it to say otherwise.
+     */
+    orientation?: Orientation;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const ToolbarManifest: Record<string, Component>;
+declare const ToolbarCompositionRules: {
+    Toolbar: {
+        allowed_children: string[];
+    };
+};
+
+type TooltipProps = Omit<ComponentPropsWithoutRef<"div">, "content"> & {
+    /** Tooltip body — text or any node. */
+    content: ReactNode;
+    /** Trigger element. Wrapped in a React Aria Focusable. */
+    children: ReactNode;
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    delayDuration?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+declare const Tooltip: react.ForwardRefExoticComponent<Omit<Omit<react.DetailedHTMLProps<react.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref">, "content"> & {
+    /** Tooltip body — text or any node. */
+    content: ReactNode;
+    /** Trigger element. Wrapped in a React Aria Focusable. */
+    children: ReactNode;
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    delayDuration?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const TooltipManifest: Record<string, Component>;
+
+type ChartVariant = "line" | "area" | "bar" | "scatter" | "histogram" | "heatmap";
+interface ChartPoint {
+    x: number;
+    y: number | null;
+    label?: string;
+}
+interface ChartSeries {
+    id: string;
+    label: string;
+    data: readonly ChartPoint[];
+    color?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+}
+interface ChartRange {
+    start: number;
+    end: number;
+}
+type ChartProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    series: readonly ChartSeries[];
+    variant?: ChartVariant;
+    fill?: "solid" | "hatched";
+    description?: string;
+    xLabel?: string;
+    xUnit?: string;
+    yLabel?: string;
+    unit?: string;
+    hiddenSeries?: readonly string[];
+    onHiddenSeriesChange?: (ids: string[]) => void;
+    disabled?: boolean;
+    bins?: number;
+    formatX?: (value: number) => string;
+    threshold?: {
+        value: number;
+        label: string;
+    };
+    rangeSelection?: boolean;
+    xDomain?: ChartRange;
+    range?: ChartRange;
+    onRangeChange?: (range: ChartRange) => void;
+    /** Supplied x-axis position, independent of local sample inspection. */
+    cursor?: number | null;
+    cursorLabel?: string;
+};
+declare const Chart: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    series: readonly ChartSeries[];
+    variant?: ChartVariant;
+    fill?: "solid" | "hatched";
+    description?: string;
+    xLabel?: string;
+    xUnit?: string;
+    yLabel?: string;
+    unit?: string;
+    hiddenSeries?: readonly string[];
+    onHiddenSeriesChange?: (ids: string[]) => void;
+    disabled?: boolean;
+    bins?: number;
+    formatX?: (value: number) => string;
+    threshold?: {
+        value: number;
+        label: string;
+    };
+    rangeSelection?: boolean;
+    xDomain?: ChartRange;
+    range?: ChartRange;
+    onRangeChange?: (range: ChartRange) => void;
+    /** Supplied x-axis position, independent of local sample inspection. */
+    cursor?: number | null;
+    cursorLabel?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const ChartManifest: Record<string, Component>;
+
+/** A categorical color token, 1 to 8. */
+type CategoryColor = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8;
+
+type SparklineProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "color"> & {
+    label: string;
+    data: readonly (number | null)[];
+    unit?: string;
+    /** Match the stable categorical identity of a Chart series with this ID. */
+    seriesId?: string;
+    /** The categorical token 1 to 8, as a Chart series' `color`; it wins over `seriesId`. */
+    color?: CategoryColor;
+    variant?: "line" | "area";
+};
+/** A compact trend; sample order is the x axis and missing values remain gaps. */
+declare const Sparkline: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children" | "color"> & {
+    label: string;
+    data: readonly (number | null)[];
+    unit?: string;
+    /** Match the stable categorical identity of a Chart series with this ID. */
+    seriesId?: string;
+    /** The categorical token 1 to 8, as a Chart series' `color`; it wins over `seriesId`. */
+    color?: CategoryColor;
+    variant?: "line" | "area";
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const SparklineManifest: Record<string, Component>;
+
+type DataGridSort = DataTableSortDescriptor;
+type DataGridColumnWidths = Record<string, number>;
+type DataGridVirtualization = DataTableVirtualization;
+type DataGridViewMode = "paginated" | "virtualized";
+type DataGridColumn = DataTableColumn & {
+    render?: (value: unknown, row: DataTableRow) => ReactNode;
+    compare?: (a: unknown, b: unknown) => number;
+    minWidth?: number;
+    maxWidth?: number;
+};
+type DataGridProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "onSelect"> & {
+    columns: DataGridColumn[];
+    data: DataTableRow[];
+    getRowId: (row: DataTableRow) => string;
+    caption?: string;
+    selectedRowIds?: readonly string[];
+    onSelectionChange?: (ids: string[]) => void;
+    sort?: DataGridSort | null;
+    onSortChange?: (sort: DataGridSort | null) => void;
+    page?: number;
+    onPageChange?: (page: number) => void;
+    pageSize?: number;
+    mode?: "client" | "server";
+    rowCount?: number;
+    visibleColumnKeys?: readonly string[];
+    onVisibleColumnsChange?: (keys: string[]) => void;
+    columnWidths?: DataGridColumnWidths;
+    onColumnWidthsChange?: (widths: DataGridColumnWidths) => void;
+    pinnedColumnKeys?: readonly string[];
+    onPinnedColumnsChange?: (keys: string[]) => void;
+    virtualization?: DataGridVirtualization;
+    viewMode?: DataGridViewMode;
+    onViewModeChange?: (mode: DataGridViewMode) => void;
+    loading?: boolean;
+    disabled?: boolean;
+    dense?: boolean;
+    emptyMessage?: string;
+    onRowClick?: (row: DataTableRow, index: number) => void;
+};
+declare const DataGrid: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children" | "onSelect"> & {
+    columns: DataGridColumn[];
+    data: DataTableRow[];
+    getRowId: (row: DataTableRow) => string;
+    caption?: string;
+    selectedRowIds?: readonly string[];
+    onSelectionChange?: (ids: string[]) => void;
+    sort?: DataGridSort | null;
+    onSortChange?: (sort: DataGridSort | null) => void;
+    page?: number;
+    onPageChange?: (page: number) => void;
+    pageSize?: number;
+    mode?: "client" | "server";
+    rowCount?: number;
+    visibleColumnKeys?: readonly string[];
+    onVisibleColumnsChange?: (keys: string[]) => void;
+    columnWidths?: DataGridColumnWidths;
+    onColumnWidthsChange?: (widths: DataGridColumnWidths) => void;
+    pinnedColumnKeys?: readonly string[];
+    onPinnedColumnsChange?: (keys: string[]) => void;
+    virtualization?: DataGridVirtualization;
+    viewMode?: DataGridViewMode;
+    onViewModeChange?: (mode: DataGridViewMode) => void;
+    loading?: boolean;
+    disabled?: boolean;
+    dense?: boolean;
+    emptyMessage?: string;
+    onRowClick?: (row: DataTableRow, index: number) => void;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const DataGridManifest: Record<string, Component>;
+
+declare const inputStyles: (props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+    invalid?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string;
+type ComboBoxOption = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+type ComboBoxProps = VariantProps<typeof inputStyles> & {
+    motion?: MotionMode;
+    options: ComboBoxOption[];
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (value: string | null) => void;
+    inputValue?: string;
+    onInputChange?: (value: string) => void;
+    label?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    loading?: boolean;
+    filter?: boolean;
+    emptyMessage?: string;
+    name?: string;
+    id?: string;
+    className?: string;
+};
+declare const ComboBox: react.ForwardRefExoticComponent<VariantProps<(props?: ({
+    size?: "md" | "sm" | "lg" | null | undefined;
+    invalid?: boolean | null | undefined;
+} & class_variance_authority_types.ClassProp) | undefined) => string> & {
+    motion?: MotionMode;
+    options: ComboBoxOption[];
+    value?: string | null;
+    defaultValue?: string | null;
+    onValueChange?: (value: string | null) => void;
+    inputValue?: string;
+    onInputChange?: (value: string) => void;
+    label?: string;
+    "aria-label"?: string;
+    "aria-describedby"?: string;
+    placeholder?: string;
+    disabled?: boolean;
+    required?: boolean;
+    loading?: boolean;
+    filter?: boolean;
+    emptyMessage?: string;
+    name?: string;
+    id?: string;
+    className?: string;
+} & react.RefAttributes<HTMLInputElement>>;
+
+declare const ComboBoxManifest: Record<string, Component>;
+
+type SplitPaneProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    primary: ReactNode;
+    secondary: ReactNode;
+    size?: number;
+    defaultSize?: number;
+    onSizeChange?: (percent: number) => void;
+    minSize?: number;
+    maxSize?: number;
+    step?: number;
+    orientation?: "horizontal" | "vertical";
+    disabled?: boolean;
+    label?: string;
+    stackBelow?: number;
+    /** The primary panel's name while its content scrolls, when it is a focusable region. */
+    primaryLabel?: string;
+    /** The secondary panel's name while its content scrolls, when it is a focusable region. */
+    secondaryLabel?: string;
+};
+/** A percentage of the available pane space, excluding the resize handle. */
+declare const SplitPane: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    primary: ReactNode;
+    secondary: ReactNode;
+    size?: number;
+    defaultSize?: number;
+    onSizeChange?: (percent: number) => void;
+    minSize?: number;
+    maxSize?: number;
+    step?: number;
+    orientation?: "horizontal" | "vertical";
+    disabled?: boolean;
+    label?: string;
+    stackBelow?: number;
+    /** The primary panel's name while its content scrolls, when it is a focusable region. */
+    primaryLabel?: string;
+    /** The secondary panel's name while its content scrolls, when it is a focusable region. */
+    secondaryLabel?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const SplitPaneManifest: Record<string, Component>;
+
+interface TimeRangeValue {
+    start: number;
+    end: number;
+}
+interface TimeRangePreset {
+    id: string;
+    label: string;
+    value: TimeRangeValue;
+}
+type TimeRangeProps = Omit<HTMLAttributes<HTMLDivElement>, "onChange"> & {
+    value: TimeRangeValue;
+    onValueChange: (value: TimeRangeValue) => void;
+    /**
+     * Reports whether the range in the fields can be used as it stands, and whether it is an edit
+     * the application has not applied yet: `(valid, { pending })`, on mount and whenever either
+     * changes, as DateRangePicker and DateTimePicker do. `valid` is false while the fields hold an
+     * error or an unapplied edit.
+     */
+    onDraftValidityChange?: (valid: boolean, details: {
+        pending: boolean;
+    }) => void;
+    presets?: readonly TimeRangePreset[];
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    label?: string;
+};
+declare const TimeRange: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "onChange"> & {
+    value: TimeRangeValue;
+    onValueChange: (value: TimeRangeValue) => void;
+    /**
+     * Reports whether the range in the fields can be used as it stands, and whether it is an edit
+     * the application has not applied yet: `(valid, { pending })`, on mount and whenever either
+     * changes, as DateRangePicker and DateTimePicker do. `valid` is false while the fields hold an
+     * error or an unapplied edit.
+     */
+    onDraftValidityChange?: (valid: boolean, details: {
+        pending: boolean;
+    }) => void;
+    presets?: readonly TimeRangePreset[];
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    label?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const TimeRangeManifest: Record<string, Component>;
+
+interface TimelineEvent {
+    id: string;
+    label: string;
+    start: number;
+    end?: number;
+    lane?: string;
+    description?: string;
+    severity?: "neutral" | "info" | "success" | "warning" | "error";
+}
+type EventTimelineProps = HTMLAttributes<HTMLDivElement> & {
+    events: readonly TimelineEvent[];
+    start: number;
+    end: number;
+    selectedId?: string | null;
+    onSelectionChange?: (id: string) => void;
+    disabled?: boolean;
+    label?: string;
+    emptyMessage?: string;
+};
+declare const EventTimeline: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    events: readonly TimelineEvent[];
+    start: number;
+    end: number;
+    selectedId?: string | null;
+    onSelectionChange?: (id: string) => void;
+    disabled?: boolean;
+    label?: string;
+    emptyMessage?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const EventTimelineManifest: Record<string, Component>;
+
+type WorkspaceMode = "live" | "paused" | "replay" | "training";
+type WorkspaceConnection = "connected" | "connecting" | "reconnecting" | "offline" | "unknown";
+type AppShellProps = Omit<HTMLAttributes<HTMLDivElement>, "title"> & {
+    title?: string;
+    identity: string;
+    mode?: WorkspaceMode;
+    connection?: WorkspaceConnection;
+    time?: number | null;
+    markings?: ReactNode;
+    navigation?: ReactNode;
+    toolbar?: ReactNode;
+    footer?: ReactNode;
+};
+/** In-page workspace; the host owns document landmarks and policy markings. */
+declare const AppShell: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "title"> & {
+    title?: string;
+    identity: string;
+    mode?: WorkspaceMode;
+    connection?: WorkspaceConnection;
+    time?: number | null;
+    markings?: ReactNode;
+    navigation?: ReactNode;
+    toolbar?: ReactNode;
+    footer?: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const AppShellManifest: Record<string, Component>;
+
+type InspectorProps = Omit<HTMLAttributes<HTMLElement>, "title"> & {
+    open?: boolean;
+    title: string;
+    description?: string;
+    onClose?: () => void;
+};
+/** Modeless details. Does not move or trap focus; the caller owns return focus. */
+declare const Inspector: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLElement>, "title"> & {
+    open?: boolean;
+    title: string;
+    description?: string;
+    onClose?: () => void;
+} & react.RefAttributes<HTMLElement>>;
+
+declare const InspectorManifest: Record<string, Component>;
+
+interface TreeViewItem {
+    id: string;
+    label: string;
+    children?: readonly TreeViewItem[];
+    disabled?: boolean;
+}
+/** The attributes React Aria's tree renders on the treegrid. */
+type TreeViewAttributes = Pick<HTMLAttributes<HTMLDivElement>, "id" | "style" | "aria-labelledby" | "aria-describedby" | "aria-details">;
+interface TreeViewProps extends TreeViewAttributes {
+    items: readonly TreeViewItem[];
+    label?: string;
+    selectedId?: string | null;
+    onSelectionChange?: (id: string | null) => void;
+    expandedIds?: readonly string[];
+    defaultExpandedIds?: readonly string[];
+    onExpandedChange?: (ids: string[]) => void;
+    disabled?: boolean;
+    emptyMessage?: string;
+    className?: string;
+}
+declare const TreeView: react.ForwardRefExoticComponent<TreeViewProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const TreeViewManifest: Record<string, Component>;
+
+type OperationalState = "current" | "stale" | "partial" | "unavailable" | "unknown";
+type OperationalStatusProps = HTMLAttributes<HTMLDivElement> & {
+    state?: OperationalState;
+    source?: string;
+    updatedAt?: number | null;
+    detail?: string;
+};
+/** Freshness is an application assertion; no wall-clock or transport inference. */
+declare const OperationalStatus: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    state?: OperationalState;
+    source?: string;
+    updatedAt?: number | null;
+    detail?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const OperationalStatusManifest: Record<string, Component>;
+
+type ActionState = "submitted" | "accepted" | "rejected" | "in-progress" | "complete" | "partial" | "failed" | "timeout" | "queued" | "running" | "cancel-requested" | "canceled";
+type ActionStatusProps = HTMLAttributes<HTMLDivElement> & {
+    state: ActionState;
+    label: string;
+    message?: string;
+    requestId?: string;
+    onRetry?: (() => void) | undefined;
+    onCancel?: (() => void) | undefined;
+    retryLabel?: string;
+    cancelLabel?: string;
+    disabled?: boolean;
+};
+/** Stateless authoritative result: clicking recovery never changes supplied state. */
+declare const ActionStatus: react.ForwardRefExoticComponent<HTMLAttributes<HTMLDivElement> & {
+    state: ActionState;
+    label: string;
+    message?: string;
+    requestId?: string;
+    onRetry?: (() => void) | undefined;
+    onCancel?: (() => void) | undefined;
+    retryLabel?: string;
+    cancelLabel?: string;
+    disabled?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const ActionStatusManifest: Record<string, Component>;
+
+type MultiSelectOption = {
+    value: string;
+    label: string;
+    disabled?: boolean;
+};
+type MultiSelectProps = Omit<FieldsetHTMLAttributes<HTMLFieldSetElement>, "onChange" | "children" | "value" | "defaultValue"> & {
+    label: string;
+    options: readonly MultiSelectOption[];
+    value?: readonly string[];
+    defaultValue?: readonly string[];
+    onValueChange?: (value: string[]) => void;
+    name?: string;
+    description?: string;
+    error?: string;
+};
+/** An always-visible native checkbox group. Values omitted from options survive updates. */
+declare const MultiSelect: react.ForwardRefExoticComponent<Omit<FieldsetHTMLAttributes<HTMLFieldSetElement>, "children" | "value" | "defaultValue" | "onChange"> & {
+    label: string;
+    options: readonly MultiSelectOption[];
+    value?: readonly string[];
+    defaultValue?: readonly string[];
+    onValueChange?: (value: string[]) => void;
+    name?: string;
+    description?: string;
+    error?: string;
+} & react.RefAttributes<HTMLFieldSetElement>>;
+
+declare const MultiSelectManifest: Record<string, Component>;
+
+type NumberInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "value" | "defaultValue" | "onChange" | "min" | "max" | "step" | "size"> & {
+    label: string;
+    unit: string;
+    value?: number | null;
+    defaultValue?: number | null;
+    onValueChange?: (value: number | null) => void;
+    onValidationChange?: (error: string | null) => void;
+    min?: number;
+    max?: number;
+    step?: number | "any";
+    size?: "sm" | "md" | "lg";
+    description?: string;
+    error?: string;
+};
+declare const NumberInput: react.ForwardRefExoticComponent<Omit<InputHTMLAttributes<HTMLInputElement>, "value" | "type" | "defaultValue" | "onChange" | "step" | "max" | "min" | "size"> & {
+    label: string;
+    unit: string;
+    value?: number | null;
+    defaultValue?: number | null;
+    onValueChange?: (value: number | null) => void;
+    onValidationChange?: (error: string | null) => void;
+    min?: number;
+    max?: number;
+    step?: number | "any";
+    size?: "sm" | "md" | "lg";
+    description?: string;
+    error?: string;
+} & react.RefAttributes<HTMLInputElement>>;
+
+declare const NumberInputManifest: Record<string, Component>;
+
+type CoordinateValue = {
+    latitude: number | null;
+    longitude: number | null;
+};
+type CoordinateInputProps = Omit<FieldsetHTMLAttributes<HTMLFieldSetElement>, "onChange" | "children" | "value" | "defaultValue"> & {
+    label?: string;
+    value?: CoordinateValue;
+    defaultValue?: CoordinateValue;
+    onValueChange?: (value: CoordinateValue) => void;
+    onValidationChange?: (invalid: boolean) => void;
+    description?: string;
+    error?: string;
+    latitudeName?: string;
+    longitudeName?: string;
+};
+declare const CoordinateInput: react.ForwardRefExoticComponent<Omit<FieldsetHTMLAttributes<HTMLFieldSetElement>, "children" | "value" | "defaultValue" | "onChange"> & {
+    label?: string;
+    value?: CoordinateValue;
+    defaultValue?: CoordinateValue;
+    onValueChange?: (value: CoordinateValue) => void;
+    onValidationChange?: (invalid: boolean) => void;
+    description?: string;
+    error?: string;
+    latitudeName?: string;
+    longitudeName?: string;
+} & react.RefAttributes<HTMLFieldSetElement>>;
+
+declare const CoordinateInputManifest: Record<string, Component>;
+
+type LinkProps = Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+    /**
+     * Native navigation destination. Use Button for actions. Only http, https, mailto, tel, relative
+     * and hash destinations are rendered; any other scheme renders as plain text, not a link.
+     */
+    href: string;
+};
+/** A native anchor: the browser owns navigation, modifiers, and context menus. */
+declare const Link: react.ForwardRefExoticComponent<Omit<AnchorHTMLAttributes<HTMLAnchorElement>, "href"> & {
+    /**
+     * Native navigation destination. Use Button for actions. Only http, https, mailto, tel, relative
+     * and hash destinations are rendered; any other scheme renders as plain text, not a link.
+     */
+    href: string;
+} & react.RefAttributes<HTMLAnchorElement>>;
+
+declare const LinkManifest: Record<string, Component>;
+
+type DescriptionListItem = {
+    id: string;
+    label: ReactNode;
+    value: ReactNode;
+    mono?: boolean;
+};
+type DescriptionListProps = Omit<HTMLAttributes<HTMLDListElement>, "children"> & {
+    items: readonly DescriptionListItem[];
+    layout?: "stacked" | "aligned" | "details";
+};
+declare const DescriptionList: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDListElement>, "children"> & {
+    items: readonly DescriptionListItem[];
+    layout?: "stacked" | "aligned" | "details";
+} & react.RefAttributes<HTMLDListElement>>;
+
+declare const DescriptionListManifest: Record<string, Component>;
+
+type CopyResult = {
+    value: string;
+};
+type CopyError = {
+    value: string;
+    error: unknown;
+};
+type CopyButtonProps = {
+    /** Exact string passed to clipboard.writeText, including whitespace. */
+    value: string;
+    /** Accessible action name identifying the supplied value. */
+    label: string;
+    onCopy?: (result: CopyResult) => void;
+    onCopyError?: (result: CopyError) => void;
+    disabled?: boolean;
+    size?: ButtonProps["size"];
+    /** Classes applied to the native action button. */
+    className?: string;
+};
+/** Copies only on activation; clipboard outcomes remain tied to the requested context. */
+declare const CopyButton: react.ForwardRefExoticComponent<CopyButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+declare const CopyButtonManifest: Record<string, Component>;
+
+type PopoverName = {
+    title: string;
+    "aria-label"?: string;
+} | {
+    title?: string;
+    "aria-label": string;
+};
+type PopoverProps = Omit<ComponentPropsWithoutRef<"div">, "children" | "content" | "title" | "aria-label"> & PopoverName & {
+    children: ReactElement;
+    content: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    side?: "top" | "right" | "bottom" | "left";
+    align?: "start" | "center" | "end";
+    disabled?: boolean;
+    motion?: MotionMode;
+    /**
+     * Short summary: previewed in a tooltip on hover or keyboard focus of the trigger (suppressed
+     * while the details are open), and shown as a line under the title of the open surface, which
+     * it describes. A disabled trigger stays focusable, so focus or a tap shows it.
+     */
+    description?: string;
+    returnFocusRef?: RefObject<HTMLElement | null>;
+    /** Cancelable native Event; fires only after an accepted close or open unmount. */
+    onCloseAutoFocus?: (event: Event) => void;
+};
+declare const Popover: react.ForwardRefExoticComponent<PopoverProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const PopoverManifest: Record<string, Component>;
+
+type EntityPreviewRecord = {
+    id: string;
+    name: string;
+    typeLabel?: string;
+    summary?: string;
+    facts: readonly DescriptionListItem[];
+    condition?: {
+        label: string;
+        variant: BadgeProps["variant"];
+    };
+    quality: Pick<OperationalStatusProps, "state" | "source" | "updatedAt" | "detail">;
+};
+type EntityPreviewProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    entity: EntityPreviewRecord;
+    media?: ReactNode;
+    actions?: ReactNode;
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+};
+/** Supplied record content; its hosting surface owns selection and focus. */
+declare const EntityPreview: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    entity: EntityPreviewRecord;
+    media?: ReactNode;
+    actions?: ReactNode;
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const EntityPreviewManifest: Record<string, Component>;
+
+type FormSectionProps = FieldsetHTMLAttributes<HTMLFieldSetElement> & {
+    legend: string;
+    description?: ReactNode;
+    children: ReactNode;
+};
+/** A native group. Field values and validation remain with the caller. */
+declare const FormSection: react.ForwardRefExoticComponent<FieldsetHTMLAttributes<HTMLFieldSetElement> & {
+    legend: string;
+    description?: ReactNode;
+    children: ReactNode;
+} & react.RefAttributes<HTMLFieldSetElement>>;
+
+declare const FormSectionManifest: Record<string, Component>;
+
+interface FormErrorSummaryError {
+    id: string;
+    message: string;
+    targetId: string;
+}
+type FormErrorSummaryProps = Omit<HTMLAttributes<HTMLElement>, "title" | "children"> & {
+    errors: readonly FormErrorSummaryError[];
+    title?: string;
+    onErrorSelect?: (error: FormErrorSummaryError) => void;
+};
+/** Callers choose when to focus the summary and how to reveal hidden fields. */
+declare const FormErrorSummary: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLElement>, "title" | "children"> & {
+    errors: readonly FormErrorSummaryError[];
+    title?: string;
+    onErrorSelect?: (error: FormErrorSummaryError) => void;
+} & react.RefAttributes<HTMLElement>>;
+
+declare const FormErrorSummaryManifest: Record<string, Component>;
+
+type CalendarProps = {
+    label: string;
+    value: string | null;
+    onValueChange: (value: string | null) => void;
+    min?: string;
+    max?: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    id?: string;
+    className?: string;
+};
+declare const Calendar: react.ForwardRefExoticComponent<CalendarProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const CalendarManifest: Record<string, Component>;
+
+type DatePickerProps = CalendarProps & {
+    onDraftValidityChange?: (valid: boolean, details: {
+        pending: boolean;
+    }) => void;
+    motion?: MotionMode;
+};
+declare const DatePicker: react.ForwardRefExoticComponent<CalendarProps & {
+    onDraftValidityChange?: (valid: boolean, details: {
+        pending: boolean;
+    }) => void;
+    motion?: MotionMode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const DatePickerManifest: Record<string, Component>;
+
+type InlineEditProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    value: string;
+    onSave: (value: string) => void | Promise<void>;
+    disabled?: boolean;
+    readOnly?: boolean;
+    validate?: (value: string) => string | undefined;
+};
+declare const InlineEdit: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    value: string;
+    onSave: (value: string) => void | Promise<void>;
+    disabled?: boolean;
+    readOnly?: boolean;
+    validate?: (value: string) => string | undefined;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const InlineEditManifest: Record<string, Component>;
+
+interface ContextMenuItem {
+    id: string;
+    label: string;
+    shortcut?: string;
+    disabled?: boolean;
+    danger?: boolean;
+}
+type ContextMenuProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    items: readonly ContextMenuItem[];
+    onAction: (id: string) => void;
+    disabled?: boolean;
+    /** Shown as a non-interactive row when `items` is empty. */
+    emptyMessage?: string;
+    children: ReactNode;
+};
+declare const ContextMenu: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    items: readonly ContextMenuItem[];
+    onAction: (id: string) => void;
+    disabled?: boolean;
+    /** Shown as a non-interactive row when `items` is empty. */
+    emptyMessage?: string;
+    children: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const ContextMenuManifest: Record<string, Component>;
+
+type TimeFieldProps = CalendarProps & {
+    onDraftValidityChange?: (valid: boolean, details: {
+        pending: boolean;
+    }) => void;
+};
+declare const TimeField: react.ForwardRefExoticComponent<CalendarProps & {
+    onDraftValidityChange?: (valid: boolean, details: {
+        pending: boolean;
+    }) => void;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const TimeFieldManifest: Record<string, Component>;
+
+type DateTimePickerProps = {
+    label: string;
+    value: number | null;
+    onValueChange: (value: number | null) => void;
+    onDraftValidityChange?: (valid: boolean, details: {
+        pending: boolean;
+    }) => void;
+    timeZone: string;
+    min?: number;
+    max?: number;
+    disabled?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    id?: string;
+    className?: string;
+};
+declare const DateTimePicker: react.ForwardRefExoticComponent<DateTimePickerProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const DateTimePickerManifest: Record<string, Component>;
+
+type DateRangeValue = {
+    start: string;
+    end: string;
+};
+type DateRangePickerProps = Omit<CalendarProps, "value" | "onValueChange"> & {
+    value: DateRangeValue | null;
+    onValueChange: (value: DateRangeValue | null) => void;
+    onDraftValidityChange?: (valid: boolean, details: {
+        pending: boolean;
+    }) => void;
+    startLabel?: string;
+    endLabel?: string;
+};
+declare const DateRangePicker: react.ForwardRefExoticComponent<Omit<CalendarProps, "value" | "onValueChange"> & {
+    value: DateRangeValue | null;
+    onValueChange: (value: DateRangeValue | null) => void;
+    onDraftValidityChange?: (valid: boolean, details: {
+        pending: boolean;
+    }) => void;
+    startLabel?: string;
+    endLabel?: string;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const DateRangePickerManifest: Record<string, Component>;
+
+type FileRejection = {
+    name: string;
+    code: "type" | "size" | "count" | "directory" | "unsupported" | "read";
+    message: string;
+};
+type FileUploadProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    description?: ReactNode;
+    accept?: readonly string[];
+    multiple?: boolean;
+    maxFiles?: number;
+    maxFileSizeBytes?: number;
+    disabled?: boolean;
+    onFiles: (files: readonly File[]) => void;
+    onReject?: (issues: readonly FileRejection[]) => void;
+};
+/** Selection only. Every input path is validated before application callbacks run. */
+declare const FileUpload: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    description?: ReactNode;
+    accept?: readonly string[];
+    multiple?: boolean;
+    maxFiles?: number;
+    maxFileSizeBytes?: number;
+    disabled?: boolean;
+    onFiles: (files: readonly File[]) => void;
+    onReject?: (issues: readonly FileRejection[]) => void;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const FileUploadManifest: Record<string, Component>;
+
+type UploadQueueItem = {
+    id: string;
+    name: string;
+    sizeBytes: number;
+    state: "ready" | "queued" | "uploading" | "cancel-requested" | "uploaded" | "failed" | "canceled";
+    loadedBytes?: number;
+    totalBytes?: number;
+    message?: string;
+    cancelable?: boolean;
+    retryable?: boolean;
+    removable?: boolean;
+};
+type UploadQueueProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    items: readonly UploadQueueItem[];
+    disabled?: boolean;
+    onCancel?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    onRemove?: (id: string) => void;
+};
+declare const UploadQueue: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    items: readonly UploadQueueItem[];
+    disabled?: boolean;
+    onCancel?: (id: string) => void;
+    onRetry?: (id: string) => void;
+    onRemove?: (id: string) => void;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const UploadQueueManifest: Record<string, Component>;
+
+type AttachmentMetadata = {
+    id: string;
+    name: string;
+    sizeBytes: number;
+    mediaType?: string;
+};
+type AttachmentPreviewContent = {
+    kind: "image";
+    src: string;
+    alt: string;
+} | {
+    kind: "text";
+    text: string;
+} | {
+    kind: "unavailable";
+    message: string;
+};
+type AttachmentPreviewProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    attachment: AttachmentMetadata;
+    preview: AttachmentPreviewContent;
+    disabled?: boolean;
+    onDownload?: (id: string) => void;
+    onRemove?: (id: string) => void;
+};
+declare const AttachmentPreview: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    attachment: AttachmentMetadata;
+    preview: AttachmentPreviewContent;
+    disabled?: boolean;
+    onDownload?: (id: string) => void;
+    onRemove?: (id: string) => void;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const AttachmentPreviewManifest: Record<string, Component>;
+
+type JobState = "queued" | "running" | "cancel-requested" | "canceled" | "complete" | "partial" | "failed";
+type JobStatusProps = Omit<HTMLAttributes<HTMLDivElement>, "children" | "role"> & {
+    jobId: string;
+    label: string;
+    state: JobState;
+    message?: string;
+    progress?: {
+        completed: number;
+        total: number | null;
+    };
+    requestPending?: "cancel" | "retry" | null;
+    requestError?: string;
+    onCancelRequest?: (jobId: string) => void;
+    onRetryRequest?: (jobId: string) => void;
+    disabled?: boolean;
+};
+declare const JobStatus: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children" | "role"> & {
+    jobId: string;
+    label: string;
+    state: JobState;
+    message?: string;
+    progress?: {
+        completed: number;
+        total: number | null;
+    };
+    requestPending?: "cancel" | "retry" | null;
+    requestError?: string;
+    onCancelRequest?: (jobId: string) => void;
+    onRetryRequest?: (jobId: string) => void;
+    disabled?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const JobStatusManifest: Record<string, Component>;
+
+type BulkSelectionSnapshot = {
+    id: string;
+    scope: "visible" | "selected" | "all-matching";
+    ids: readonly string[];
+    sourceId: string;
+    sourceRevision: string;
+    filterDescription: string;
+    capturedAt: number;
+};
+type BulkAction = {
+    id: string;
+    label: string;
+    disabled?: boolean;
+    disabledReason?: string;
+    danger?: boolean;
+};
+type BulkActionBarProps = {
+    label: string;
+    selection: BulkSelectionSnapshot;
+    visibleIds: readonly string[];
+    actions: readonly BulkAction[];
+    onAction: (actionId: string, selection: BulkSelectionSnapshot) => void;
+    onClearSelection?: () => void;
+    disabled?: boolean;
+    /** The heading level of the label, for the hosting surface's outline. Default 3. */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+    className?: string;
+};
+declare const BulkActionBar: react.ForwardRefExoticComponent<BulkActionBarProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const BulkActionBarManifest: Record<string, Component>;
+
+type BulkItemResult = {
+    id: string;
+    label: string;
+    state: "queued" | "running" | "succeeded" | "failed" | "canceled" | "skipped";
+    message?: string;
+    retryable?: boolean;
+};
+type BulkResultsProps = {
+    label: string;
+    selection: BulkSelectionSnapshot;
+    items: readonly BulkItemResult[];
+    pendingRetryIds?: readonly string[];
+    onRetryRequest?: (id: string) => void;
+    disabled?: boolean;
+    /**
+     * Rows per page. A request with more IDs than this is shown a page at a time, with DataGrid's
+     * paging controls; the summary still counts every ID. Default 100.
+     */
+    pageSize?: number;
+    /** The heading level of the label, for the hosting surface's outline. Default 3. */
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+    className?: string;
+};
+declare const BulkResults: react.ForwardRefExoticComponent<BulkResultsProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const BulkResultsManifest: Record<string, Component>;
+
+type MapAction = "zoom-in" | "zoom-out" | "pan-north" | "pan-east" | "pan-south" | "pan-west" | "reset-north" | "fit";
+type MapControlsProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label?: string;
+    zoom?: number | null;
+    bearing?: number | null;
+    minZoom?: number;
+    maxZoom?: number;
+    onAction?: (action: MapAction) => void;
+    disabled?: boolean;
+};
+/** Navigation requests; only supplied engine feedback changes the readouts. */
+declare const MapControls: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label?: string;
+    zoom?: number | null;
+    bearing?: number | null;
+    minZoom?: number;
+    maxZoom?: number;
+    onAction?: (action: MapAction) => void;
+    disabled?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const MapControlsManifest: Record<string, Component>;
+
+interface LayerControlItem {
+    id: string;
+    label: string;
+    visible: boolean;
+    opacity: number;
+    description?: string;
+    disabled?: boolean;
+}
+type LayerControlProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label?: string;
+    layers: readonly LayerControlItem[];
+    onLayersChange?: (layers: readonly LayerControlItem[]) => void;
+    disabled?: boolean;
+};
+/** Controlled top-first layer list; disabled rows retain their fixed positions. */
+declare const LayerControl: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label?: string;
+    layers: readonly LayerControlItem[];
+    onLayersChange?: (layers: readonly LayerControlItem[]) => void;
+    disabled?: boolean;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const LayerControlManifest: Record<string, Component>;
+
+interface MapLegendItem {
+    id: string;
+    label: string;
+    kind: "point" | "line" | "area";
+    variant?: "neutral" | "success" | "warning" | "error" | "info" | "accent";
+    pattern?: "solid" | "dashed";
+    description?: string;
+}
+type MapLegendProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label?: string;
+    items: readonly MapLegendItem[];
+};
+declare const MapLegend: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label?: string;
+    items: readonly MapLegendItem[];
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const MapLegendManifest: Record<string, Component>;
+
+type MapScaleProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label?: string;
+    metersPerPixel?: number | null;
+    maxWidth?: number;
+    units?: "metric" | "imperial";
+};
+/** Ground scale at the adapter's supplied location; never infers DPI or projection. */
+declare const MapScale: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label?: string;
+    metersPerPixel?: number | null;
+    maxWidth?: number;
+    units?: "metric" | "imperial";
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const MapScaleManifest: Record<string, Component>;
+
+type MediaFrameState = "live" | "delayed" | "paused" | "recorded" | "reconnecting" | "unavailable";
+type MediaFrameProps = Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    state: MediaFrameState;
+    capturedAt: number | null;
+    source?: string;
+    latencyMs?: number | null;
+    retained?: boolean;
+    detail?: string;
+    aspectRatio?: number;
+    children?: ReactNode;
+    actions?: ReactNode;
+};
+declare const MediaFrame: react.ForwardRefExoticComponent<Omit<HTMLAttributes<HTMLDivElement>, "children"> & {
+    label: string;
+    state: MediaFrameState;
+    capturedAt: number | null;
+    source?: string;
+    latencyMs?: number | null;
+    retained?: boolean;
+    detail?: string;
+    aspectRatio?: number;
+    children?: ReactNode;
+    actions?: ReactNode;
+} & react.RefAttributes<HTMLDivElement>>;
+
+declare const MediaFrameManifest: Record<string, Component>;
+
+/** Native div attributes reach the root group; `aria-describedby` joins the unavailable message. */
+interface PlaybackControlsProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "onChange"> {
+    start: number;
+    end: number;
+    value: number;
+    playing: boolean;
+    onValueChange: (value: number) => void;
+    onPlayingChange: (playing: boolean) => void;
+    playbackRate?: number;
+    playbackRates?: readonly number[];
+    onPlaybackRateChange?: (rate: number) => void;
+    eventTimes?: readonly number[];
+    liveTime?: number;
+    followingLive?: boolean;
+    onReturnToLive?: () => void;
+    disabled?: boolean;
+    label?: string;
+    className?: string;
+}
+declare const PlaybackControls: react.ForwardRefExoticComponent<PlaybackControlsProps & react.RefAttributes<HTMLDivElement>>;
+
+declare const PlaybackControlsManifest: Record<string, Component>;
+
+/**
+ * This package's version, read from its package.json when the package is built, so it is the
+ * version that was published and cannot be left behind by a release.
+ */
+declare const VERSION: string;
+
+export { type ActionState, ActionStatus, ActionStatusManifest, type ActionStatusProps, Alert, AlertManifest, type AlertProps, AppShell, AppShellManifest, type AppShellProps, type AttachmentMetadata, AttachmentPreview, type AttachmentPreviewContent, AttachmentPreviewManifest, type AttachmentPreviewProps, Avatar, AvatarManifest, type AvatarProps, Badge, BadgeManifest, type BadgeProps, Breadcrumb, type BreadcrumbItem, BreadcrumbManifest, type BreadcrumbProps, type BulkAction, BulkActionBar, BulkActionBarManifest, type BulkActionBarProps, type BulkItemResult, BulkResults, BulkResultsManifest, type BulkResultsProps, type BulkSelectionSnapshot, Button, ButtonGroup, ButtonGroupManifest, type ButtonGroupProps, ButtonManifest, type ButtonProps, Calendar, CalendarManifest, type CalendarProps, Card, CardBody, type CardBodyProps, CardCompositionRules, CardFooter, type CardFooterProps, CardHeader, type CardHeaderProps, CardManifest, type CardProps, Chart, ChartManifest, type ChartPoint, type ChartProps, type ChartRange, type ChartSeries, type ChartVariant, Checkbox, CheckboxManifest, type CheckboxProps, Collapsible, CollapsibleCompositionRules, CollapsibleItem, type CollapsibleItemProps, CollapsibleManifest, type CollapsibleProps, CollectionState, CollectionStateManifest, type CollectionStateProps, ComboBox, ComboBoxManifest, type ComboBoxOption, type ComboBoxProps, type Command, CommandPalette, CommandPaletteManifest, type CommandPaletteProps, type Component, ConfirmDialog, ConfirmDialogManifest, type ConfirmDialogProps, ContextMenu, type ContextMenuItem, ContextMenuManifest, type ContextMenuProps, CoordinateInput, CoordinateInputManifest, type CoordinateInputProps, type CoordinateValue, CopyButton, CopyButtonManifest, type CopyButtonProps, type CopyError, type CopyResult, DataGrid, type DataGridColumn, type DataGridColumnWidths, DataGridManifest, type DataGridProps, type DataGridSort, type DataGridViewMode, type DataGridVirtualization, DataTable, type DataTableColumn, DataTableManifest, type DataTableProps, type DataTableRow, type DataTableSortDescriptor, type DataTableVirtualization, DatePicker, DatePickerManifest, type DatePickerProps, DateRangePicker, DateRangePickerManifest, type DateRangePickerProps, type DateRangeValue, DateTimePicker, DateTimePickerManifest, type DateTimePickerProps, DescriptionList, type DescriptionListItem, DescriptionListManifest, type DescriptionListProps, Dialog, DialogManifest, type DialogProps, Divider, DividerManifest, type DividerProps, DropdownMenu, DropdownMenuCompositionRules, DropdownMenuItem, type DropdownMenuItemProps, DropdownMenuLabel, type DropdownMenuLabelProps, DropdownMenuManifest, type DropdownMenuProps, DropdownMenuSeparator, type DropdownMenuSeparatorProps, EntityPreview, EntityPreviewManifest, type EntityPreviewProps, type EntityPreviewRecord, EventTimeline, EventTimelineManifest, type EventTimelineProps, Field, FieldManifest, type FieldProps, type FileRejection, FileUpload, FileUploadManifest, type FileUploadProps, FilterBar, FilterBarManifest, type FilterBarProps, FormErrorSummary, type FormErrorSummaryError, FormErrorSummaryManifest, type FormErrorSummaryProps, FormSection, FormSectionManifest, type FormSectionProps, InlineEdit, InlineEditManifest, type InlineEditProps, Input, InputManifest, type InputProps, Inspector, InspectorManifest, type InspectorProps, type JobState, JobStatus, JobStatusManifest, type JobStatusProps, LayerControl, type LayerControlItem, LayerControlManifest, type LayerControlProps, Link, LinkManifest, type LinkProps, type MapAction, MapControls, MapControlsManifest, type MapControlsProps, MapLegend, type MapLegendItem, MapLegendManifest, type MapLegendProps, MapScale, MapScaleManifest, type MapScaleProps, MediaFrame, MediaFrameManifest, type MediaFrameProps, type MediaFrameState, MultiSelect, MultiSelectManifest, type MultiSelectOption, type MultiSelectProps, NumberInput, NumberInputManifest, type NumberInputProps, type OperationalState, OperationalStatus, OperationalStatusManifest, type OperationalStatusProps, PlaybackControls, PlaybackControlsManifest, type PlaybackControlsProps, Popover, PopoverManifest, type PopoverProps, Progress, ProgressManifest, type ProgressProps, type Prop, PropertyFilter, type PropertyFilterField, PropertyFilterManifest, type PropertyFilterOperator, type PropertyFilterProps, type PropertyFilterToken, type PropertyFilterValue, Radio, RadioGroup, RadioGroupCompositionRules, RadioGroupManifest, type RadioGroupProps, type RadioProps, Select, SelectCompositionRules, SelectManifest, SelectOption, type SelectOptionProps, type SelectProps, Sidebar, SidebarCompositionRules, SidebarFooter, type SidebarFooterProps, SidebarItem, type SidebarItemProps, SidebarLogo, type SidebarLogoProps, SidebarManifest, type SidebarProps, SidebarSection, type SidebarSectionProps, Skeleton, SkeletonManifest, type SkeletonProps, Slider, SliderManifest, type SliderProps, type Slot, Sparkline, SparklineManifest, type SparklineProps, SplitPane, SplitPaneManifest, type SplitPaneProps, StatCard, StatCardManifest, type StatCardProps, Tabs, TabsCompositionRules, TabsContent, type TabsContentProps, TabsList, type TabsListProps, TabsManifest, type TabsProps, TabsTrigger, type TabsTriggerProps, TagGroup, TagGroupManifest, type TagGroupProps, type TagItem, Textarea, TextareaManifest, type TextareaProps, TimeField, TimeFieldManifest, type TimeFieldProps, TimeRange, TimeRangeManifest, type TimeRangePreset, type TimeRangeProps, type TimeRangeValue, type TimelineEvent, Toast, ToastCompositionRules, ToastManifest, type ToastProps, ToastProvider, type ToastProviderProps, Toggle, ToggleManifest, type ToggleProps, Toolbar, ToolbarCompositionRules, ToolbarManifest, type ToolbarProps, ToolbarSeparator, type ToolbarSeparatorProps, Tooltip, TooltipManifest, type TooltipProps, TreeView, type TreeViewItem, TreeViewManifest, type TreeViewProps, UploadQueue, type UploadQueueItem, UploadQueueManifest, type UploadQueueProps, VERSION, type WorkspaceConnection, type WorkspaceMode, getPropertyFilterTokenError, useFieldContext, useOptionalFieldContext };