@surrealdb/ui 1.2.11 → 1.2.13

package/dist/ui.d.ts

@@ -6,6 +6,7 @@ import { ButtonProps } from '@mantine/core';
 import { CodeProps } from '@mantine/core';
 import { Command } from '@codemirror/view';
 import { ComponentType } from 'react';
+import { CSSProperties } from 'react';
 import { default as default_2 } from 'github-slugger';
 import { EditorSelection } from '@codemirror/state';
 import { EditorState } from '@codemirror/state';
@@ -24,8 +25,10 @@ import { MantineColor } from '@mantine/core';
 import { MantineColorScheme } from '@mantine/core';
 import { MantineFontSize } from '@mantine/core';
 import { MantineSize } from '@mantine/core';
+import { MantineSpacing } from '@mantine/core';
 import { MantineThemeOverride } from '@mantine/core';
 import { PaperProps } from '@mantine/core';
+import * as portals from 'react-reverse-portal';
 import { PropsWithChildren } from 'react';
 import { ReactElement } from 'react';
 import { ReactNode } from 'react';
@@ -152,6 +155,12 @@ export declare const brandDynamiqLight: string;
 
 export declare const brandElixir: string;
 
+export declare const brandEveDark: string;
+
+export declare const brandEveLight: string;
+
+export declare const brandFacebookMessenger: string;
+
 export declare const brandFeastDark: string;
 
 export declare const brandFeastLight: string;
@@ -248,6 +257,8 @@ export declare const brandPolyAIDark: string;
 
 export declare const brandPolyAILight: string;
 
+export declare const brandPydantic: string;
+
 export declare const brandPython: string;
 
 export declare const brandReact: string;
@@ -270,12 +281,16 @@ export declare const brandSlack: string;
 
 export declare const brandSmolAgents: string;
 
+export declare const brandSMS: string;
+
 export declare const brandSnowflake: string;
 
 export declare const brandSolidJS: string;
 
 export declare const brandStackOverflow: string;
 
+export declare const brandStrands: string;
+
 export declare const brandStripe: string;
 
 export declare const brandSurrealDB: string;
@@ -286,6 +301,8 @@ export declare const brandTanStackDark: string;
 
 export declare const brandTanStackLight: string;
 
+export declare const brandTelegram: string;
+
 export declare const brandTencentDark: string;
 
 export declare const brandTencentLight: string;
@@ -312,6 +329,8 @@ export declare const brandVSCode: string;
 
 export declare const brandWebAssembly: string;
 
+export declare const brandWhatsApp: string;
+
 export declare const brandWindows: string;
 
 export declare const brandXDark: string;
@@ -330,6 +349,28 @@ export declare const brandZedLight: string;
 
 export declare const BreadcrumbButton: FC<ButtonProps & ElementProps<"button">>;
 
+/**
+ * Builds the ordered list of rows RichTimeline renders.
+ *
+ * With no active filter (or no `filter` at all) this is just the sorted entries. When a
+ * filter is active AND `getIndex` is supplied, contiguous runs of hidden entries are
+ * collapsed into gap rows so the reader can see that history was skipped. Without
+ * `getIndex` the hidden entries are simply dropped (no gap markers).
+ */
+export declare function buildTimelineDisplayList<T>(options: BuildTimelineDisplayListOptions<T>): RichTimelineDisplayItem<T>[];
+
+/** Inputs to {@link buildTimelineDisplayList}. */
+export declare interface BuildTimelineDisplayListOptions<T> {
+    entries: T[];
+    getKey: (entry: T) => string;
+    filter?: (entry: T) => boolean;
+    /** Stable position within the source sequence. Required to collapse hidden runs into gaps. */
+    getIndex?: (entry: T) => number;
+    order?: RichTimelineOrder;
+    /** Sort value; takes precedence over `getIndex` when both are provided. */
+    getSortKey?: (entry: T) => number;
+}
+
 /**
  * GitHub-flavoured markdown alert kinds (`> [!kind]`, see GitHub docs).
  * Other spellings in source are normalised onto this set.
@@ -375,7 +416,6 @@ export declare interface CodeEditorProps extends BoxProps {
     autoFocus?: boolean;
     innerProps?: BoxProps;
     withPadding?: boolean;
-    ref?: RefObject<EditorView>;
 }
 
 /** React component keyed by lower-cased fenced-code info string. */
@@ -426,6 +466,12 @@ export declare interface ConfirmOptions<T> {
     onConfirm: (value: T) => void;
 }
 
+/**
+ * Open ephemeral overlays that would be covered by `topId` — they should close
+ * instead of staying mounted behind the new top.
+ */
+export declare function coveredEphemeral(items: StackerItem[], topId: string): StackerItem[];
+
 /**
  * Get a cached style highlighter for the given color scheme
  */
@@ -471,6 +517,8 @@ export declare const DEFAULT_MARKDOWN_MODE: MarkdownEditMode;
  */
 export declare const DEFAULT_SLASH_COMMANDS: readonly SlashCommand[];
 
+export declare function defaultGapLabel(count: number): string;
+
 export declare type DefaultSort = {
     [key: string]: unknown;
 };
@@ -493,6 +541,77 @@ export declare interface DiagramNode {
     children: RailroadNode[];
 }
 
+export declare const Drawer: DrawerCompound;
+
+declare function DrawerBody({ lane, children, className, ...rest }: DrawerBodyProps): ReactNode;
+
+export declare interface DrawerBodyProps extends Omit<BoxProps, "children"> {
+    lane: string;
+    children: ReactNode;
+}
+
+export declare interface DrawerCompound {
+    (props: DrawerProps): ReactNode;
+    Lanes: typeof DrawerLanes;
+    Lane: typeof DrawerLane;
+    Body: typeof DrawerBody;
+}
+
+export declare interface DrawerConfig {
+    lanes: string[];
+    defaultCurrentLane: string;
+    pinnedLane?: string;
+}
+
+/**
+ * Depth transform for a drawer sheet covered by `depth` sheets above it. The
+ * transform-origin sits at the free edge and the sheet is pushed outward, so
+ * scaling never eats the peek strip and lower sheets stick out from behind.
+ */
+export declare function drawerDepthStyle(side: StackerSide, depth: number): CSSProperties;
+
+declare function DrawerLane({ lane, label, icon, className, ...rest }: DrawerLaneProps): ReactNode;
+
+export declare interface DrawerLaneProps extends Omit<BoxProps, "children"> {
+    lane: string;
+    label: string;
+    icon: string;
+    children?: ReactNode;
+}
+
+declare function DrawerLanes({ children, className, ...rest }: DrawerLanesProps): ReactNode;
+
+export declare interface DrawerLanesProps extends Omit<BoxProps, "children"> {
+    children: ReactNode;
+}
+
+export declare interface DrawerProps {
+    children: ReactNode;
+}
+
+export declare function DrawerProvider({ children, state }: DrawerProviderProps): ReactNode;
+
+export declare interface DrawerProviderProps {
+    children: ReactNode;
+    state: DrawerState;
+}
+
+export declare interface DrawerState {
+    open: boolean;
+    currentLane: string;
+    activeLane: string;
+    progress: number;
+    dragging: boolean;
+    translate: number;
+    expandedHeight: number;
+    maxTranslate: number;
+    config: DrawerConfig;
+    dragRef: (node: HTMLDivElement | null) => void;
+    selectLane: (lane: string) => void;
+    collapse: () => void;
+    portal: portals.HtmlPortalNode;
+}
+
 declare type DynamicNode<T> = ReactNode | ((value: T) => ReactNode);
 
 export declare interface EditorController {
@@ -2618,6 +2737,19 @@ export declare function resolveHeadingId(node: SyntaxNode, source: MarkdownSourc
  */
 export declare function resolveImageDescriptor(url: string, alt: string, title?: string, onResolveMedia?: (node: MediaDescriptor) => MediaDescriptor): MediaDescriptor;
 
+/**
+ * Resolve overlay kind from an explicit variant hint or the viewport.
+ */
+export declare function resolveKind(variant: StackerKind | undefined, isMobile: boolean): StackerKind;
+
+/**
+ * Live render kind for the current stack. Empty stacks render nothing. Otherwise:
+ * stack-level `forcedKind` (from the founding overlay's `variant`) → first item's
+ * `variant` → viewport. `forcedKind` keeps a forced kind after the founding
+ * overlay is removed (e.g. ephemeral covered by a push).
+ */
+export declare function resolveLiveKind(items: StackerItem[], isMobile: boolean, forcedKind?: StackerKind | null): StackerKind | null;
+
 /** Normalise a component registration into its `{ component, block, preserveNewlines }` form. */
 export declare function resolveMarkdownComponent(def: MarkdownComponentDef | undefined): MarkdownComponentConfig | undefined;
 
@@ -2643,6 +2775,286 @@ export declare interface ResponsiveTabsProps extends Omit<TabsProps_2, "children
     selectProps?: Omit<SelectProps, "data" | "value" | "defaultValue" | "onChange">;
 }
 
+export declare const RichTimeline: RichTimelineCompound;
+
+export declare const RichTimelineActions: FC<{
+    children: ReactNode;
+}>;
+
+export declare const RichTimelineBadge: FC<RichTimelineBadgeProps>;
+
+declare interface RichTimelineBadgeProps {
+    children: ReactNode;
+    color?: string;
+}
+
+export declare const RichTimelineCard: FC<RichTimelineCardProps>;
+
+/** Card density: `stacked` is a padded multi-line card, `compact` is a single dense row. */
+export declare type RichTimelineCardLayout = "stacked" | "compact";
+
+declare interface RichTimelineCardProps {
+    children: ReactNode;
+    layout?: RichTimelineCardLayout;
+    selected?: boolean;
+    invalid?: boolean;
+    staggerIndex?: number;
+    onClick?: () => void;
+    className?: string;
+    padding?: "sm" | "md" | false;
+}
+
+/**
+ * RichTimeline children is a render-prop: it receives each display item (entry or gap) plus its
+ * context and returns the row to render. Compose the row from the exported slots, or use the
+ * ready-made `RichTimeline.Event`.
+ */
+declare type RichTimelineChildren<T> = (props: RichTimelineRenderProps<T>) => ReactNode;
+
+/**
+ * Public type of the `RichTimeline` compound: callable as a component, with the ready-made
+ * `RichTimeline.Event` and the neutral layout slots attached as static members (`RichTimeline.Card`,
+ * `RichTimeline.Row`, …).
+ */
+export declare interface RichTimelineCompound {
+    <T>(props: RichTimelineProps<T>): ReactNode;
+    Event: typeof RichTimelineEvent;
+    Marker: typeof RichTimelineMarker;
+    StatusMarker: typeof RichTimelineStatusMarker;
+    IndexMarker: typeof RichTimelineIndexMarker;
+    Card: typeof RichTimelineCard;
+    Gap: typeof RichTimelineGap;
+    Row: typeof RichTimelineRow;
+    Header: typeof RichTimelineHeader;
+    Title: typeof RichTimelineTitle;
+    Badge: typeof RichTimelineBadge;
+    Description: typeof RichTimelineDescription;
+    Meta: typeof RichTimelineMeta;
+    Actions: typeof RichTimelineActions;
+    RowPrimary: typeof RichTimelineRowPrimary;
+    Details: typeof RichTimelineDetails;
+    DetailsToggle: typeof RichTimelineDetailsToggle;
+    Summary: typeof RichTimelineSummary;
+}
+
+export declare const RichTimelineDescription: FC<RichTimelineDescriptionProps>;
+
+declare interface RichTimelineDescriptionProps {
+    children: ReactNode;
+    mono?: boolean;
+}
+
+/** Expandable detail region; renders nothing until its row's context is expanded. An inset
+ divider separates it from the card body for manual compositions. */
+export declare const RichTimelineDetails: FC<RichTimelineDetailsProps>;
+
+declare interface RichTimelineDetailsProps {
+    children: ReactNode;
+    label?: ReactNode;
+    ctx: RichTimelineItemContext;
+}
+
+/** Full-width disclosure control for the foot of an event card — an unmistakable target. */
+export declare const RichTimelineDetailsToggle: FC<RichTimelineDetailsToggleProps>;
+
+declare interface RichTimelineDetailsToggleProps {
+    expanded: boolean;
+    onToggle: () => void;
+    /** Label shown while collapsed. */
+    showLabel?: string;
+    /** Label shown while expanded. */
+    hideLabel?: string;
+    className?: string;
+}
+
+/** A real data row in the display list. */
+export declare interface RichTimelineDisplayEntry<T> {
+    kind: "entry";
+    entry: T;
+    key: string;
+    /** Position used to stagger the entrance animation; capped so late rows don't lag. */
+    staggerIndex: number;
+}
+
+/**
+ * A collapsed placeholder standing in for a contiguous run of entries that a filter
+ * hid. Only produced when `getIndex` is supplied (see {@link BuildTimelineDisplayListOptions}).
+ */
+export declare interface RichTimelineDisplayGap {
+    kind: "gap";
+    key: string;
+    hiddenCount: number;
+    /** Inclusive index range the gap covers, when known. */
+    fromIndex?: number;
+    toIndex?: number;
+}
+
+/** A row to render: either a real entry or a gap placeholder. */
+export declare type RichTimelineDisplayItem<T> = RichTimelineDisplayEntry<T> | RichTimelineDisplayGap;
+
+/**
+ * Stacked event card: a square status marker, a title/badge/summary header, and — when the item
+ * carries `details` — a divider-separated details panel revealed by a full-width footer toggle.
+ */
+export declare const RichTimelineEvent: FC<RichTimelineEventProps>;
+
+/** Status badge shown alongside an event's title. */
+export declare interface RichTimelineEventBadge {
+    label: string;
+    color: string;
+}
+
+/** Data model for a {@link RichTimelineEvent} (`RichTimeline.Event`) row. */
+export declare interface RichTimelineEventItem {
+    id: string;
+    variant: StatusVariant;
+    /** Accessible label for the status marker; falls back to the badge label. */
+    markerLabel?: string;
+    title: ReactNode;
+    badge?: RichTimelineEventBadge;
+    summary?: ReactNode;
+    meta?: ReactNode;
+    actions?: ReactNode;
+    body?: ReactNode;
+    /** Expandable detail content; its presence adds the footer disclosure toggle. */
+    details?: ReactNode;
+    detailsLabel?: string;
+    defaultExpanded?: boolean;
+    /** Activates the whole row (e.g. navigate/select); independent of expanding details. */
+    onActivate?: () => void;
+}
+
+export declare interface RichTimelineEventProps {
+    item: RichTimelineEventItem;
+    ctx: RichTimelineItemContext;
+    /** Entrance-animation stagger position; pass `item.staggerIndex` from the RichTimeline render-prop. */
+    staggerIndex?: number;
+}
+
+export declare const RichTimelineGap: FC<RichTimelineGapProps>;
+
+declare interface RichTimelineGapProps {
+    count: number;
+    label?: ReactNode;
+    ariaLabel?: string;
+    hideMarkerOnMobile?: boolean;
+}
+
+export declare const RichTimelineHeader: FC<{
+    children: ReactNode;
+    interactive?: boolean;
+    onClick?: () => void;
+    onKeyDown?: (e: React.KeyboardEvent) => void;
+    role?: string;
+    tabIndex?: number;
+    ariaExpanded?: boolean;
+}>;
+
+export declare const RichTimelineIndexMarker: FC<RichTimelineIndexMarkerProps>;
+
+/** Square, monospaced marker showing an entry's position — used by the explorer-style rows. */
+declare interface RichTimelineIndexMarkerProps {
+    label: ReactNode;
+    selected?: boolean;
+    className?: string;
+}
+
+/** Per-row state handed to render-prop children and slot renderers. */
+export declare interface RichTimelineItemContext {
+    selected: boolean;
+    invalid: boolean;
+    expanded: boolean;
+    toggleExpanded: () => void;
+    cardLayout: RichTimelineCardLayout;
+    /** True when a filter is active anywhere in the list (not whether this row is filtered out). */
+    filtered: boolean;
+}
+
+export declare const RichTimelineMarker: FC<RichTimelineMarkerProps>;
+
+declare interface RichTimelineMarkerProps {
+    children: ReactNode;
+    className?: string;
+    hideOnMobile?: boolean;
+}
+
+export declare const RichTimelineMeta: FC<{
+    children: ReactNode;
+}>;
+
+/** Direction the display list is sorted in: most recent at the top or at the bottom. */
+export declare type RichTimelineOrder = "newest-first" | "oldest-first";
+
+export declare interface RichTimelineProps<T> {
+    /** Source data; sorting, filtering and gap insertion are derived from these. */
+    entries: T[];
+    /** Stable React key for an entry. */
+    getKey: (entry: T) => string;
+    order?: RichTimelineOrder;
+    /** Sort value; takes precedence over `getIndex`. */
+    getSortKey?: (entry: T) => number;
+    /** Returns `true` for entries that should stay visible. */
+    filter?: (entry: T) => boolean;
+    /** Positional index; supplying it lets filtered-out runs collapse into gap rows. */
+    getIndex?: (entry: T) => number;
+    selectedKey?: string;
+    /** Keys to render with the "invalid" treatment. */
+    invalidKeys?: ReadonlySet<string>;
+    /** Keys expanded on first render (expansion is uncontrolled thereafter). */
+    initialExpandedKeys?: ReadonlySet<string>;
+    /** `true`/options forces windowing; omitted, it auto-enables past 100 rows. */
+    virtualize?: boolean | VirtualizeOptions;
+    cardLayout?: RichTimelineCardLayout;
+    hideMarkerOnMobile?: boolean;
+    emptyMessage?: ReactNode;
+    className?: string;
+    /** Render-prop returning the row for each display item (entry or gap). */
+    children: RichTimelineChildren<T>;
+}
+
+/** Arguments to the RichTimeline render-prop. */
+export declare interface RichTimelineRenderProps<T> {
+    item: RichTimelineDisplayItem<T>;
+    ctx: RichTimelineItemContext;
+}
+
+export declare const RichTimelineRow: FC<RichTimelineRowProps>;
+
+export declare const RichTimelineRowPrimary: FC<{
+    children: ReactNode;
+}>;
+
+declare interface RichTimelineRowProps {
+    children: ReactNode;
+    staggerIndex?: number;
+    align?: "start" | "center";
+    hideMarkerOnMobile?: boolean;
+    className?: string;
+}
+
+export declare const RichTimelineStatusMarker: FC<RichTimelineStatusMarkerProps>;
+
+/** Square, opaque status chip (success/warning/error/neutral) — the marker for event rows. */
+declare interface RichTimelineStatusMarkerProps {
+    variant: StatusVariant;
+    /** Accessible name. When omitted the chip is treated as decorative (`aria-hidden`). */
+    label?: string;
+    className?: string;
+}
+
+/** Optional "Showing N of M" / "N entries" caption; hidden when there's nothing useful to say. */
+export declare const RichTimelineSummary: FC<RichTimelineSummaryProps>;
+
+declare interface RichTimelineSummaryProps {
+    filtered: boolean;
+    matchCount: number;
+    totalCount: number;
+}
+
+export declare const RichTimelineTitle: FC<{
+    children: ReactNode;
+}>;
+
 export declare function SectionTitle({ order, kicker, description, kickerProps, titleProps, descriptionProps, children, ...boxProps }: PropsWithChildren<SectionTitle>): ReactElement;
 
 export declare interface SectionTitle extends BoxProps {
@@ -2678,6 +3090,12 @@ export declare const setMarkdownEditorReady: StateEffectType<boolean>;
  */
 export declare const setMarkdownMode: StateEffectType<MarkdownEditMode>;
 
+/**
+ * Decide whether a released drag should dismiss the drawer: either a fast flick
+ * towards the edge, or dragged past halfway.
+ */
+export declare function shouldDismiss(closeAmount: number, extent: number, towardsVelocity: number): boolean;
+
 export declare function Since({ v, prefix, ...props }: SinceProps): ReactNode;
 
 export declare interface SinceProps extends Omit<BadgeProps, "children"> {
@@ -2796,10 +3214,146 @@ export declare interface SpinnerProps extends BoxProps {
     title?: string;
 }
 
+export declare const STACKER_INITIAL_STATE: StackerState;
+
+export declare type StackerAction = {
+    type: "OPEN";
+    item: StackerItem;
+} | {
+    type: "CLOSE";
+    id: string;
+} | {
+    type: "CLOSE_ALL";
+} | {
+    type: "REMOVE";
+    id: string;
+} | {
+    type: "UPDATE";
+    id: string;
+    patch: Partial<StackerSettings>;
+};
+
+/** Value exposed by {@link useStacker}. */
+export declare interface StackerContextValue {
+    /** Push an overlay onto the stack. Returns the overlay id. */
+    open: (settings?: StackerSettings) => string;
+    /** Close an overlay by id, or the top overlay when the id is omitted. */
+    close: (id?: string) => void;
+    /** Close every open overlay. */
+    closeAll: () => void;
+    /** Merge new settings into an overlay on the stack. */
+    update: (id: string, patch: Partial<StackerSettings>) => void;
+    /** Current stack, ordered bottom-to-top. */
+    stack: StackerItem[];
+    /** Live render kind from the viewport and first stack item, or null when empty. */
+    kind: StackerKind | null;
+}
+
+/** A single entry on the stack. */
+export declare interface StackerItem {
+    id: string;
+    /** False while the overlay plays its exit transition before removal. */
+    opened: boolean;
+    settings: StackerSettings;
+}
+
+/** How an overlay is rendered: a centered modal or an edge-anchored drawer. */
+export declare type StackerKind = "modal" | "drawer";
+
+/**
+ * Provides {@link useStacker}. Overlays render as modals on desktop and drawers
+ * on mobile (or the forced `variant`), stack like Mantine's modal manager, and
+ * the page content scales back slightly while a drawer stack is open.
+ */
+export declare function StackerProvider({ children, mobileQuery, zIndex, }: StackerProviderProps): ReactNode;
+
+export declare interface StackerProviderProps {
+    children?: ReactNode;
+    /** Viewport query selecting the drawer kind. @default "(max-width: 48em)" */
+    mobileQuery?: string;
+    /** Base z-index for the stack. @default 200 */
+    zIndex?: number;
+}
+
+/**
+ * Pure state transitions for the stack. Closing an overlay flips its `opened`
+ * flag (so it can play an exit transition); a later `REMOVE` drops it once the
+ * transition finishes.
+ */
+export declare function stackerReducer(state: StackerState, action: StackerAction): StackerState;
+
+/** Options accepted by {@link StackerContextValue.open}. */
+export declare interface StackerSettings {
+    /** Explicit id. Defaults to a random id. Opening an id already on the stack is a no-op. */
+    id?: string;
+    /** Heading rendered in the overlay header. */
+    title?: ReactNode;
+    /** Secondary text rendered underneath the title. */
+    subtitle?: ReactNode;
+    /** Overlay body content. */
+    children?: ReactNode;
+    /**
+     * Force this overlay kind instead of choosing from the viewport. When set on
+     * the founding overlay of a stack, the kind is remembered for the whole stack
+     * even if that overlay is later removed (e.g. ephemeral). Later items' hints
+     * are ignored while the stack is non-empty.
+     */
+    variant?: StackerKind;
+    /** Edge the drawer is anchored to. Ignored for modals. @default "right" */
+    side?: StackerSide;
+    /** Allow dragging the drawer towards its edge to dismiss it. Ignored for modals. @default false */
+    draggable?: boolean;
+    /** Content area size — modal width or drawer extent. Defaults: modal `"lg"`, drawer `"md"`. */
+    size?: MantineSize | (string & {}) | number;
+    /** Header/body padding. @default "xl" */
+    padding?: MantineSpacing;
+    /** Render the header close button. @default true */
+    withCloseButton?: boolean;
+    /** Close this overlay with Escape while it is on top. @default true */
+    closeOnEscape?: boolean;
+    /** Close this overlay by clicking the scrim while it is on top. @default true */
+    closeOnClickOutside?: boolean;
+    /**
+     * When true, this overlay is closed (and removed after its exit) as soon as
+     * another overlay is pushed on top of it — it never stays covered/peeking.
+     * @default false
+     */
+    ephemeral?: boolean;
+    /** Called when the overlay begins closing. */
+    onClose?: () => void;
+}
+
+/** Edge a drawer is anchored to. */
+export declare type StackerSide = "left" | "right" | "top" | "bottom";
+
+export declare interface StackerState {
+    /**
+     * Forced kind from the stack-founding overlay's `variant`. Survives removal of
+     * that overlay (e.g. ephemeral covered) until the stack is empty.
+     */
+    forcedKind: StackerKind | null;
+    /** Stack entries, ordered bottom-to-top. `opened: false` = playing exit. */
+    items: StackerItem[];
+}
+
 export declare type StateFields = {
     [prop: string]: StateField<any>;
 };
 
+/** A circular, tinted status badge — a status glyph (success/warning/error/neutral) on a tone chip. */
+export declare const StatusIcon: FC<StatusIconProps>;
+
+export declare interface StatusIconProps extends Omit<BoxProps, "children"> {
+    variant: StatusVariant;
+    size?: StatusIconSize;
+    /** Accessible name. When omitted the icon is treated as decorative (`aria-hidden`). */
+    label?: string;
+}
+
+export declare type StatusIconSize = "sm" | "md" | "xl";
+
+export declare type StatusVariant = "success" | "warning" | "error" | "neutral";
+
 /**
  * A vertical timeline whose steps expand one at a time. Each step shows a
  * numbered bullet and a clickable title; activating a step collapses the others
@@ -2887,6 +3441,9 @@ export declare interface ThemedImageProps extends ImageProps {
     darkSrc?: string;
 }
 
+/** The top-most open item, or undefined when nothing is open. */
+export declare function topOpened(items: StackerItem[]): StackerItem | undefined;
+
 /** Trim `{#id}` from the end of a heading source range (returns new exclusive `titleTo`). */
 export declare function trimCustomHeadingIdFromRange(source: {
     slice(from: number, to: number): string;
@@ -2900,6 +3457,10 @@ export declare function trimCustomHeadingIdFromRange(source: {
  */
 export declare function useConfirmation<T = void>(options: ConfirmOptions<T>): (value?: T) => void;
 
+export declare function useDrawer(config: DrawerConfig): DrawerState;
+
+export declare function useDrawerState(): DrawerState;
+
 export declare function useEditor(options?: EditorOptions): EditorController;
 
 /**
@@ -2951,6 +3512,12 @@ export declare function useSort<T = DefaultSort>(options?: SortOptions<T>): Sort
  */
 export declare function useStable<T extends AnyFn>(callback: T): T;
 
+/**
+ * Access the nearest {@link StackerProvider}. Multiple providers can be nested;
+ * each hook call resolves to the closest one.
+ */
+export declare function useStacker(): StackerContextValue;
+
 /**
  * A state used to track an active/inactive switch state (boolean)
  *
@@ -2984,6 +3551,17 @@ export declare interface VideoPlayerProps extends BoxProps {
     videoProps?: Omit<VideoHTMLAttributes<HTMLVideoElement>, "autoPlay" | "loop" | "poster" | "controls" | "src" | "muted">;
 }
 
+/** Tuning passed through to TanStack Virtual when the list is windowed. */
+export declare interface VirtualizeOptions {
+    /** Estimated px height of an entry row. */
+    estimateSize?: number;
+    /** Estimated px height of a gap row. */
+    gapEstimateSize?: number;
+    overscan?: number;
+    /** Height of the scroll viewport. */
+    scrollHeight?: number | string;
+}
+
 /**
  * The default UI Kit editor theme
  */