@pstdio/ui 0.26.0 → 0.36.0

package/dist/index.d.ts

@@ -1,40 +1,1504 @@
-export { ChakraProvider } from '@chakra-ui/react';
-export type { ActivityActor, ActivityAvatarProps, ActivityCommentProps, ActivityComposerProps, ActivityEventProps, ActivityFeedProps, ActivityHeaderProps, ActivityReplyProps, ActivityRootProps, ActivityTimelineProps, } from './components/activity';
-export { Activity, ActivityAvatar, ActivityComment, ActivityComposer, ActivityEvent, ActivityFeed, ActivityHeader, ActivityReply, ActivityRoot, ActivityTimeline, } from './components/activity';
-export * from './components/command-palette';
-export * from './components/layout';
-export { ListRow } from './components/list-row/list-row';
-export type { ListRowAction, ListRowActionContext, ListRowActionMenuItem, ListRowItem, ListRowNavigationIntent, } from './components/list-row/list-row.types';
-export type { NotificationCenterAction, NotificationCenterItem, NotificationCenterPriority, NotificationCenterProps, NotificationCenterStatus, } from './components/notification-center';
-export { NotificationCenter } from './components/notification-center';
-export * from './components/overlays';
-export * from './components/primitives';
-export { Sidenav } from './components/sidenav/sidenav';
-export { useSidenavStore } from './components/sidenav/sidenav.store';
-export type { SidenavProps } from './components/sidenav/sidenav.types';
-export { getTabVisibilityStore, useTabVisibilityStore } from './components/tab-strip/tab-visibility.store';
-export type { TabVisibilityPlacement } from './components/tab-strip/tab-visibility-filter';
-export { buildTabVisibilityMenuActions, filterVisibleTabs } from './components/tab-strip/tab-visibility-filter';
-export { type WindowTab, WindowTabs, type WindowTabsProps } from './components/tab-strip/window-tabs';
-export { WindowTitleBar, type WindowTitleBarProps } from './components/tab-strip/window-title-bar';
-export type { SaveTagSettingsInput, TagEditorAction, TagEditorHeadingProps, TagEditorProps, TagEditorSaveBarProps, TagEditorValue, TagSettingsPanelProps, } from './components/tag-editor';
-export { TagEditor, TagEditorHeading, TagEditorSaveBar, TagSettingsPanel } from './components/tag-editor';
-export { TreeList } from './components/tree-list/tree-list';
-export type { TreeListAction, TreeListActionContext, TreeListActionMenuItem, TreeListInlineInput, TreeListLinkComponent, TreeListNavigateEvent, TreeListNavigationIntent, TreeListNode, TreeListSection, } from './components/tree-list/tree-list.types';
-export { TreeListDragProvider } from './components/tree-list/tree-list-drag-provider';
-export { getTreeListOrderStore, useTreeListOrderStore } from './components/tree-list/tree-list-order.store';
-export { applyTreeListOrder } from './components/tree-list/tree-list-order-filter';
-export type { TreeListMove, TreeListMoveEndpoint, TreeListMovePolicy } from './components/tree-list/tree-list-reorder';
-export type { VisibilityOverride } from './components/tree-list/tree-list-visibility.store';
-export { getTreeListVisibilityStore, useTreeListVisibilityStore, } from './components/tree-list/tree-list-visibility.store';
-export type { TreeVisibilityMenuItems } from './components/tree-list/tree-list-visibility-filter';
-export { buildTreeVisibilityMenuActions, filterVisibleNodes, filterVisibleSections, resolveVisibility, } from './components/tree-list/tree-list-visibility-filter';
-export type { MonacoThemeData, VsCodeColorTheme } from './theme';
-export { createMonacoThemeFromVsCodeTheme, createThemePreferenceFromVsCodeTheme, psTheme } from './theme';
-export { applyFileIconThemePreference, defaultFileIconThemePreferences, type FileIconThemeFont, type FileIconThemePreferenceOption, isFileIconThemePreference, resolveFileIconGlyph, } from './utils/apply-file-icon-theme-preference';
-export { applyThemePreference, defaultThemePreferences, getThemePreferenceClassName, getThemePreferenceClassNames, getThemePreferenceMode, isThemePreference, type ThemePreference, type ThemePreferenceMode, type ThemePreferenceOption, type ThemePreferenceTokens, } from './utils/apply-theme-preference';
-export { FileIconThemePreferenceProvider, useFileIconThemePreference } from './utils/file-icon-theme-preference';
-export { getFileTypeIcon } from './utils/get-file-type-icon';
-export { installPrismGlobal } from './utils/prism';
-export { resolveFileIconElement } from './utils/resolve-file-icon-element';
-export { getInitialThemePreference, ThemePreferenceProvider, useThemePreference } from './utils/theme-preference';
+import { i as ScrollAreaProps, r as ScrollArea, t as ResourceBadge } from "./resource-badge-95WPVlZf.js";
+import { _ as ActivityHeader, a as ActivityComposerProps, b as ActivityRootProps, c as ActivityReply, d as ActivityEventProps, f as ActivityActor, g as ActivityFeedProps, h as ActivityFeed, i as ActivityComposer, l as ActivityReplyProps, m as ActivityTimelineProps, n as ActivityAvatar, o as ActivityComment, p as ActivityTimeline, r as ActivityAvatarProps, s as ActivityCommentProps, t as Activity, u as ActivityEvent, v as ActivityHeaderProps, y as ActivityRoot } from "./index-DlmvvQ6x.js";
+import { a as resolveSessionIndicatorColor, c as ResourceActionMenu, d as ResourceContextMenu, i as SessionIndicator, l as ResourceActionMenuProps, n as WorkspaceBadgeProps, o as resolveSessionIndicatorIcon, r as SessionCompletionStatus, s as sessionCompletionStatuses, t as WorkspaceBadge, u as ResourceContextAction } from "./workspace-badge-Brm3Xr3m.js";
+import { a as createThemePreferenceFromVsCodeTheme, c as ThemePreferenceOption, d as defaultThemePreferences, f as getThemePreferenceClassName, h as isThemePreference, i as createMonacoThemeFromVsCodeTheme, l as ThemePreferenceTokens, m as getThemePreferenceMode, n as MonacoThemeData, o as ThemePreference, p as getThemePreferenceClassNames, r as VsCodeColorTheme, s as ThemePreferenceMode, t as _default, u as applyThemePreference } from "./index-Dd6e8lU_.js";
+import { Alert, BadgeProps, BoxProps, Breadcrumb as Breadcrumb$1, CenterProps, ChakraProvider, Checkbox as Checkbox$1, ConditionalValue, EmptyState as EmptyState$1, FlexProps, HTMLChakraProps, IconButtonProps, IconProps, Menu, RadioGroup as RadioGroup$1, RecipeVariantProps, Slider as Slider$1, StackProps, Switch as Switch$1, SystemStyleObject, TextProps, Tooltip as Tooltip$1, chakra, createToaster } from "@chakra-ui/react";
+import * as React$2 from "react";
+import { Component, ComponentPropsWithoutRef, ComponentType, DragEvent, ElementType, ErrorInfo, HTMLAttributes, KeyboardEventHandler, MouseEvent, PointerEvent, ReactNode, Ref, RefObject, SetStateAction } from "react";
+import { LucideIcon } from "lucide-react";
+//#region src/components/command-palette/palette-filter.d.ts
+export declare const DEFAULT_PALETTE_ASSET_LIMIT = 48;
+interface PaletteSearchEntry {
+  id: string;
+  mode?: string;
+  label: ReactNode;
+  searchText?: string;
+  secondaryLabel?: ReactNode;
+  assetType?: string;
+}
+interface PaletteMode {
+  id: string;
+  inputPrefix?: string;
+}
+interface FilterPaletteEntriesOptions {
+  query: string;
+  mode?: string;
+  getEffectiveQuery?: (query: string) => string;
+  defaultAssetLimit?: number;
+}
+export declare const filterPaletteEntries: <T extends PaletteSearchEntry>(entries: T[], options: FilterPaletteEntriesOptions) => T[];
+//#endregion
+//#region src/components/command-palette/palette.d.ts
+interface PaletteEntry extends PaletteSearchEntry {
+  description?: ReactNode;
+  icon?: ReactNode;
+  shortcut?: ReactNode;
+  endContent?: ReactNode;
+  group?: string;
+  isSelected?: boolean;
+  onActivate: () => void;
+}
+interface PaletteState<T extends PaletteEntry> {
+  query: string;
+  mode?: string;
+  activeIndex: number;
+  entries: T[];
+}
+interface PaletteEscapeContext<T extends PaletteEntry> extends PaletteState<T> {
+  activeEntry: T | null;
+  entryCount: number;
+  setQuery: (query: string) => void;
+  setActiveIndex: (index: SetStateAction<number>) => void;
+  runActiveEntry: () => void;
+  closePalette: () => void;
+}
+type PaletteStateValue<T extends PaletteEntry, TValue> = TValue | ((state: PaletteState<T>) => TValue);
+interface PaletteProps<T extends PaletteEntry = PaletteEntry> {
+  open: boolean;
+  entries: T[];
+  initialQuery?: string;
+  initialActiveIndex?: number;
+  mode?: string;
+  modes?: PaletteMode[];
+  resetKey?: string;
+  inputIcon?: PaletteStateValue<T, ReactNode>;
+  placeholder?: PaletteStateValue<T, string>;
+  emptyLabel?: string;
+  footerStart?: ReactNode;
+  footerEnd?: ReactNode;
+  filterEntries?: (entries: T[], query: string, mode?: string) => T[];
+  onActiveEntryChange?: (entry: T | null, index: number) => void;
+  onQueryChange?: (query: string) => void;
+  onClose: () => void;
+  onEscape?: (ctx: PaletteEscapeContext<T>) => boolean | undefined;
+}
+export declare const Palette: <T extends PaletteEntry>(props: PaletteProps<T>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/command-palette/palette-shortcut.d.ts
+type PaletteShortcutBinding = string | string[];
+export declare const PaletteShortcut: (props: {
+  binding: PaletteShortcutBinding;
+}) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/layout/header.d.ts
+type HeaderVariant = "main" | "narrow" | "input";
+interface HeaderProps extends Omit<StackProps, "variant"> {
+  variant?: HeaderVariant;
+}
+export declare const Header: React$2.ForwardRefExoticComponent<HeaderProps & React$2.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/layout/horizontal-menu-stack.d.ts
+interface HorizontalMenuStackProps extends StackProps {
+  children?: StackProps["children"];
+}
+export declare function HorizontalMenuStack(props: HorizontalMenuStackProps): import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/layout/item-section.d.ts
+interface ItemSectionProps {
+  children: ReactNode;
+  title?: string;
+  defaultOpen?: boolean;
+  action?: ReactNode;
+}
+/**
+ * A collapsible section wrapper with a title trigger and optional action.
+ */
+export declare const ItemSection: (props: ItemSectionProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/layout/panel-header.constants.d.ts
+export declare const PANEL_HEADER_HEIGHT = "2.5rem";
+export declare const PANEL_HEADER_CONTROL_SIZE: "2xs";
+export declare const PANEL_HEADER_TAB_SIZE: "sm";
+//#endregion
+//#region src/components/layout/resizable-split-layout.geometry.d.ts
+type ResizableSplitSide = "left" | "right" | "top" | "bottom";
+//#endregion
+//#region src/components/layout/resizable-split-layout.handle.d.ts
+type ResizableSplitSeparator = "gap" | "line";
+//#endregion
+//#region src/components/layout/resizable-split-layout.d.ts
+interface ResizableSplitLayoutProps extends Omit<FlexProps, "children" | "onResize"> {
+  resizablePanel: ReactNode;
+  contentPanel: ReactNode;
+  resizableSide?: ResizableSplitSide;
+  defaultSizePx?: number;
+  minSizePx?: number;
+  maxSizePx?: number;
+  contentMinSizePx?: number;
+  collapsed?: boolean;
+  collapsible?: boolean;
+  resizeLabel?: string;
+  separator?: ResizableSplitSeparator;
+  layout?: ConditionalValue<"split" | "stacked" | "stacked-reverse" | "content">;
+  onSizeChange?: (size: number) => void;
+  onCollapsedChange?: (collapsed: boolean) => void;
+}
+export declare const ResizableSplitLayout: (props: ResizableSplitLayoutProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/list-row/list-row.types.d.ts
+interface ListRowNavigationIntent {
+  id?: string;
+  payload?: unknown;
+}
+/** Context passed to row-level actions so hosts know which section or node triggered the action. */
+interface ListRowActionContext {
+  sectionId?: string;
+  nodeId?: string;
+}
+/** Menu item used by row overflow menus and context menus. */
+interface ListRowActionMenuItem {
+  id: string;
+  label: string;
+  commandId?: string;
+  description?: string;
+  icon?: ReactNode | ComponentType<{
+    size?: number | string;
+  }>;
+  disabled?: boolean;
+  readOnly?: boolean;
+  /** Render a separator before this item when it follows a different action group. */
+  separatorBefore?: boolean;
+  /** Trailing content rendered after the label. Use for Kbd shortcuts, counts, or badges. */
+  endContent?: ReactNode;
+  onAction?: () => void;
+}
+/** Inline action rendered on a row, optionally backed by a menu. */
+interface ListRowAction {
+  id: string;
+  label: string;
+  icon?: ReactNode;
+  /** Tooltip shown when the action button is hovered or focused. Can include label + Kbd hint. */
+  tooltip?: ReactNode;
+  searchPlaceholder?: string;
+  emptyMenuLabel?: string;
+  menuItems?: ListRowActionMenuItem[];
+  onAction?: (context: ListRowActionContext) => void;
+}
+type ListRowVariant = "default" | "compact" | "collection" | "full-width" | "tree" | "empty-state";
+type ListRowTone = "default" | "danger";
+type ListRowMenuPlacement = "top" | "top-start" | "top-end" | "bottom" | "bottom-start" | "bottom-end" | "right" | "right-start" | "right-end" | "left" | "left-start" | "left-end";
+/** Data model for one reusable row, including labels, icons, menus, actions, and children. */
+interface ListRowItem {
+  id?: string;
+  label: ReactNode;
+  description?: ReactNode;
+  icon?: ReactNode;
+  iconColor?: IconProps["color"];
+  indicator?: {
+    icon: ReactNode;
+    color?: IconProps["color"];
+    tooltip?: string | null;
+  };
+  /** Custom content rendered on the right, before any hover actions. Use for Kbd shortcuts, counts, or badges. */
+  endContent?: ReactNode;
+  /** Tooltip shown on hover. Can be a string or ReactNode (e.g. Kbd shortcut hint). */
+  tooltip?: ReactNode;
+  disabled?: boolean;
+  /** Force chevron rendering even when children is empty (e.g. lazy-loaded folders). */
+  isContainer?: boolean;
+  isNavigable?: boolean;
+  href?: string;
+  navigationIntent?: ListRowNavigationIntent;
+  onActivate?: () => void;
+  /** Left-click menu opened from the row surface. */
+  menuItems?: ListRowActionMenuItem[];
+  menuPlacement?: ListRowMenuPlacement;
+  contextMenuItems?: ListRowActionMenuItem[];
+  actions?: ListRowAction[];
+  children?: ListRowItem[];
+}
+type ListRowRootProps = ComponentPropsWithoutRef<typeof chakra.div>;
+/** Props for the row surface used by lists, trees, menus, and dense navigation UIs. */
+interface ListRowProps extends ListRowItem, Omit<ListRowRootProps, "as" | "asChild" | "children" | "draggable" | "onClick" | "onDragEnd" | "onDragOver" | "onDragStart" | "onDrop" | "onPointerMove" | keyof ListRowItem> {
+  depth?: number;
+  /** Applies selected styling without owning selection state. */
+  isSelected?: boolean;
+  /** Controls child expansion styling and chevron state. */
+  isExpanded?: boolean;
+  /** Forces the expand affordance when children are lazy-loaded or externally controlled. */
+  showExpandToggle?: boolean;
+  /** Shows context-menu actions from an inline trigger in addition to right-click access. */
+  showContextMenuTrigger?: boolean;
+  variant?: ListRowVariant;
+  tone?: ListRowTone;
+  selectedBg?: ListRowRootProps["bg"];
+  hoverBg?: ListRowRootProps["bg"];
+  /** Wrap content into a single child element. Used for `<Menu.Item asChild><ListRow asChild>…</ListRow></Menu.Item>` and link components. */
+  asChild?: boolean;
+  onToggleExpand?: () => void;
+  onClick?: (event: MouseEvent<HTMLElement>) => void;
+  onPointerMove?: (event: PointerEvent<HTMLElement>) => void;
+  draggable?: boolean;
+  onDragStart?: (event: DragEvent<HTMLElement>) => void;
+  onDragOver?: (event: DragEvent<HTMLElement>) => void;
+  onDragEnd?: (event: DragEvent<HTMLElement>) => void;
+  onDrop?: (event: DragEvent<HTMLElement>) => void;
+}
+//#endregion
+//#region src/components/list-row/list-row.d.ts
+export declare const ListRow: import("react").ForwardRefExoticComponent<ListRowProps & import("react").RefAttributes<HTMLElement>>;
+//#endregion
+//#region src/components/notification-center/notification-center.types.d.ts
+type NotificationCenterPriority = "low" | "normal" | "high" | "urgent";
+type NotificationCenterStatus = "open" | "read" | "snoozed" | "done" | "dismissed" | "expired";
+interface NotificationCenterAction {
+  id: string;
+  label: string;
+  primary?: boolean;
+  destructive?: boolean;
+}
+interface NotificationCenterItem {
+  id: string;
+  title: string;
+  body?: string | null;
+  kind?: string;
+  priority: NotificationCenterPriority;
+  status: NotificationCenterStatus;
+  sourceLabel?: string | null;
+  targetLabel?: string | null;
+  timeLabel?: string | null;
+  actions?: NotificationCenterAction[];
+  searchText?: string;
+}
+interface NotificationCenterProps {
+  items: NotificationCenterItem[];
+  loading?: boolean;
+  error?: string | null;
+  autoFocus?: boolean;
+  emptyLabel?: string;
+  query?: string;
+  onQueryChange?: (query: string) => void;
+  onActivateItem?: (item: NotificationCenterItem) => void;
+  onRunAction?: (item: NotificationCenterItem, action: NotificationCenterAction) => void;
+  onDismiss?: (item: NotificationCenterItem) => void;
+  onEscape?: () => void;
+  footerStart?: ReactNode;
+  footerEnd?: ReactNode;
+}
+//#endregion
+//#region src/components/notification-center/notification-center.d.ts
+export declare const NotificationCenter: (props: NotificationCenterProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/overlays/attached-menu.d.ts
+interface AttachedMenuProps extends Omit<FlexProps, "children"> {
+  children?: ReactNode;
+}
+export declare const AttachedMenu: (props: AttachedMenuProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/overlays/attached-panel.d.ts
+interface AttachedPanelProps extends Omit<FlexProps, "children"> {
+  children?: ReactNode;
+  header?: ReactNode;
+  resizable?: boolean;
+}
+export declare const AttachedPanel: (props: AttachedPanelProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/overlays/attachment-chip.d.ts
+interface AttachmentChipProps {
+  file: File;
+  /** Accessible label for the remove control; the caller owns translation. */
+  removeLabel: string;
+  disabled?: boolean;
+  onRemove: () => void;
+}
+/**
+ * A file queued for upload, before the resource it belongs to exists. Removal
+ * lives on the chip because there is no other surface between picking a file
+ * and submitting where a mistaken attachment can be taken back.
+ */
+export declare const AttachmentChip: (props: AttachmentChipProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/overlays/bubble-button.d.ts
+type BubbleButtonStyleProps = "transition" | "_hover" | "_active" | "borderColor" | "borderWidth";
+interface BubbleButtonProps extends Omit<IconButtonProps, BubbleButtonStyleProps> {
+  containerProps?: HTMLChakraProps<"div">;
+  isOpen?: boolean;
+  tooltip?: ReactNode;
+}
+export declare const BubbleButton: import("react").ForwardRefExoticComponent<BubbleButtonProps & import("react").RefAttributes<HTMLButtonElement>>;
+//#endregion
+//#region src/components/overlays/bubble-panel.d.ts
+interface BubblePanelProps {
+  isOpen?: boolean;
+  title?: string;
+  menu?: ReactNode;
+  onClose?: () => void;
+  closeLabel?: string;
+  onPopOut?: (() => void) | null;
+  popOutLabel?: string;
+  width?: string;
+  height?: string;
+  containerProps?: HTMLChakraProps<"section">;
+  testId?: string;
+  "aria-label"?: string;
+  children?: ReactNode;
+}
+export declare const BubblePanel: import("react").ForwardRefExoticComponent<BubblePanelProps & import("react").RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/overlays/delete-confirmation-modal.d.ts
+interface DeleteConfirmationModalProps {
+  open: boolean;
+  onClose: () => void;
+  onDelete: () => void | Promise<void>;
+  headline?: string;
+  notificationText?: string;
+  buttonText?: string;
+  /** Extra controls rendered below the message, e.g. an opt-in checkbox. */
+  children?: ReactNode;
+}
+export declare const DeleteConfirmationModal: (props: DeleteConfirmationModalProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/overlays/dialog-accept-shortcut.d.ts
+interface DialogAcceptShortcutEvent {
+  key: string;
+  ctrlKey: boolean;
+  metaKey: boolean;
+  shiftKey: boolean;
+  altKey: boolean;
+  defaultPrevented: boolean;
+  preventDefault: () => void;
+  stopPropagation: () => void;
+}
+export declare const handleDialogAcceptShortcut: (event: DialogAcceptShortcutEvent, accept: () => void, enabled?: boolean) => void;
+//#endregion
+//#region src/components/overlays/folder-picker-dialog.d.ts
+interface FolderPickerEntry {
+  name: string;
+  path: string;
+  isDirectory: boolean;
+}
+interface FolderPickerProps {
+  currentPath: string;
+  entries: FolderPickerEntry[];
+  isLoading?: boolean;
+  isOpening?: boolean;
+  error?: string;
+  onClose: () => void;
+  onSelect: () => void;
+  onNavigate: (path: string) => void;
+  onCreateFolder: (name: string) => Promise<void>;
+}
+export declare const FolderPicker: (props: FolderPickerProps) => import("react/jsx-runtime").JSX.Element;
+export declare const FolderPickerDialog: (props: FolderPickerProps & {
+  open: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/overlays/search-modal-content.d.ts
+interface SearchModalContentProps {
+  children: ReactNode;
+  searchValue: string;
+  searchPlaceholder: string;
+  searchAriaLabel?: string;
+  searchIcon?: ReactNode;
+  searchInputRef?: Ref<HTMLInputElement>;
+  searchAutoFocus?: boolean;
+  showCloseButton?: boolean;
+  closeButtonLabel?: string;
+  bodyBefore?: ReactNode;
+  footerStart?: ReactNode;
+  footerEnd?: ReactNode;
+  scrollAreaProps?: Omit<ScrollAreaProps, "children">;
+  onSearchChange: (value: string) => void;
+  onSearchKeyDown?: KeyboardEventHandler<HTMLInputElement>;
+}
+export declare const SearchModalContent: (props: SearchModalContentProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/overlays/searchable-menu.d.ts
+type MenuRootProps = React.ComponentProps<typeof Menu.Root>;
+type MenuContentProps = React.ComponentProps<typeof Menu.Content>;
+interface SearchableMenuItem {
+  id: string;
+  label: string;
+  searchText?: string;
+  secondaryLabel?: string;
+  tooltipLabel?: ReactNode;
+  icon?: ElementType;
+  variant?: "default" | "compact" | "full-width";
+  isDisabled?: boolean;
+  isSelected?: boolean;
+  onSelect?: () => void;
+}
+interface SearchableMenuParentList<T extends SearchableMenuItem> {
+  items: T[];
+  selectedLabel: string;
+  selectedIcon?: ElementType;
+  ariaLabel?: string;
+  disabled?: boolean;
+  emptyState?: ReactNode;
+  filterItems?: (items: T[], query: string) => T[];
+  searchPlaceholder?: string;
+  showSearch?: boolean;
+  contentTestId?: string;
+  onSelect?: (item: T) => void;
+}
+interface SearchableMenuProps<T extends SearchableMenuItem> {
+  trigger: ReactNode;
+  items: T[];
+  searchPlaceholder: string;
+  emptyState: ReactNode;
+  filterItems?: (items: T[], query: string) => T[];
+  listId?: string;
+  header?: ReactNode;
+  width?: MenuContentProps["width"];
+  maxListHeight?: string;
+  showSearch?: boolean;
+  closeOnSelect?: MenuRootProps["closeOnSelect"];
+  lazyMount?: MenuRootProps["lazyMount"];
+  open?: MenuRootProps["open"];
+  positioning?: MenuRootProps["positioning"];
+  onOpenChange?: MenuRootProps["onOpenChange"];
+  onFocusOutside?: MenuRootProps["onFocusOutside"];
+  contentTestId?: string;
+  portalled?: boolean;
+  parentList?: SearchableMenuParentList<T>;
+}
+export declare const SearchableMenu: <T extends SearchableMenuItem>(props: SearchableMenuProps<T>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/primitives/alert.d.ts
+interface AlertProps extends Omit<Alert.RootProps, "title"> {
+  startElement?: React$2.ReactNode;
+  endElement?: React$2.ReactNode;
+  title?: React$2.ReactNode;
+  icon?: React$2.ReactElement;
+}
+export declare const AlertMessage: React$2.ForwardRefExoticComponent<AlertProps & React$2.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/primitives/breadcrumb.d.ts
+interface BreadcrumbItem {
+  title: React$2.ReactNode;
+  url?: string;
+  onClick?: () => void;
+  contextMenuActions?: ResourceContextAction[];
+}
+interface BreadcrumbLinkProps {
+  to: string;
+  children: React$2.ReactNode;
+}
+interface BreadcrumbProps extends Breadcrumb$1.RootProps {
+  separator?: React$2.ReactNode;
+  separatorGap?: SystemStyleObject["gap"];
+  items: BreadcrumbItem[];
+  linkComponent?: React$2.ComponentType<BreadcrumbLinkProps>;
+}
+export declare const Breadcrumb: React$2.ForwardRefExoticComponent<BreadcrumbProps & React$2.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/primitives/checkbox.d.ts
+interface CheckboxProps extends Checkbox$1.RootProps {
+  icon?: React$2.ReactNode;
+  inputProps?: React$2.InputHTMLAttributes<HTMLInputElement>;
+  rootRef?: React$2.RefObject<HTMLLabelElement | null>;
+}
+export declare const Checkbox: React$2.ForwardRefExoticComponent<CheckboxProps & React$2.RefAttributes<HTMLInputElement>>;
+//#endregion
+//#region src/components/primitives/chip.d.ts
+interface ChipProps extends Omit<BadgeProps, "size" | "variant"> {}
+export declare const Chip: (props: ChipProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/primitives/content-placeholder.d.ts
+interface ContentPlaceholderProps extends BoxProps {}
+export declare const ContentPlaceholder: (props: ContentPlaceholderProps) => import("react/jsx-runtime").JSX.Element;
+declare const Label: (props: TextProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/primitives/empty-state.d.ts
+/** Centered empty-state message with optional icon, description, and follow-up actions. */
+interface EmptyStateProps extends EmptyState$1.RootProps {
+  /** Primary empty-state message. */
+  title: string;
+  /** Supporting explanation shown below the title. */
+  description?: string;
+  /** Decorative or semantic icon shown above the message. */
+  icon?: React$2.ReactNode;
+}
+export declare const EmptyState: React$2.ForwardRefExoticComponent<EmptyStateProps & React$2.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/primitives/error-boundary.d.ts
+interface ErrorBoundaryProps {
+  children: ReactNode;
+  fallback?: ReactNode;
+  label?: string;
+  onReset?: () => void;
+}
+interface ErrorBoundaryState {
+  error: Error | null;
+}
+export declare class ErrorBoundary extends Component<ErrorBoundaryProps, ErrorBoundaryState> {
+  state: ErrorBoundaryState;
+  static getDerivedStateFromError(error: Error): {
+    error: Error;
+  };
+  componentDidCatch(error: Error, info: ErrorInfo): void;
+  handleReset: () => void;
+  render(): string | number | bigint | boolean | import("react/jsx-runtime").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;
+}
+//#endregion
+//#region src/components/primitives/glyph-icon.d.ts
+type GlyphIconProps = Omit<HTMLAttributes<HTMLSpanElement>, "children">;
+interface GlyphIconOptions {
+  /**
+   * Optical size relative to a round glyph. Every glyph is normalised to the same
+   * ink box, so square marks such as the level bars need trimming to carry the
+   * same visual weight as the status rings.
+   */
+  scale?: number;
+}
+/**
+ * Builds a component for one `prompt-studio-icons` glyph so lucide icons and
+ * font glyphs share a single component type in the icon registry.
+ */
+export declare const createGlyphIcon: (glyph: string, options?: GlyphIconOptions) => ComponentType<GlyphIconProps>;
+//#endregion
+//#region src/components/primitives/icon-options.d.ts
+interface IconColorPickerIconOption {
+  value: string | null;
+  label: string;
+  icon: ComponentType;
+}
+export declare const optionColors: readonly ["gray", "red", "orange", "yellow", "green", "teal", "blue", "cyan", "purple", "pink"];
+export declare const optionIcons: ({
+  value: string;
+  label: string;
+  icon: ComponentType<{
+    onChange?: import("react").ChangeEventHandler<HTMLSpanElement, Element> | undefined;
+    onError?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onSubmit?: import("react").SubmitEventHandler<HTMLSpanElement> | undefined;
+    slot?: string | undefined | undefined;
+    style?: import("react").CSSProperties | undefined;
+    title?: string | undefined | undefined;
+    color?: string | undefined | undefined;
+    content?: string | undefined | undefined;
+    translate?: "yes" | "no" | undefined | undefined;
+    hidden?: boolean | undefined | undefined;
+    "aria-roledescription"?: string | undefined | undefined;
+    role?: import("react").AriaRole | undefined;
+    defaultChecked?: boolean | undefined | undefined;
+    defaultValue?: string | number | readonly string[] | undefined;
+    suppressContentEditableWarning?: boolean | undefined | undefined;
+    suppressHydrationWarning?: boolean | undefined | undefined;
+    accessKey?: string | undefined | undefined;
+    autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+    autoFocus?: boolean | undefined | undefined;
+    className?: string | undefined | undefined;
+    contentEditable?: "inherit" | (boolean | "true" | "false") | "plaintext-only" | undefined;
+    contextMenu?: string | undefined | undefined;
+    dir?: string | undefined | undefined;
+    draggable?: (boolean | "true" | "false") | undefined;
+    enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+    id?: string | undefined | undefined;
+    lang?: string | undefined | undefined;
+    nonce?: string | undefined | undefined;
+    spellCheck?: (boolean | "true" | "false") | undefined;
+    tabIndex?: number | undefined | undefined;
+    radioGroup?: string | undefined | undefined;
+    about?: string | undefined | undefined;
+    datatype?: string | undefined | undefined;
+    inlist?: any;
+    prefix?: string | undefined | undefined;
+    property?: string | undefined | undefined;
+    rel?: string | undefined | undefined;
+    resource?: string | undefined | undefined;
+    rev?: string | undefined | undefined;
+    typeof?: string | undefined | undefined;
+    vocab?: string | undefined | undefined;
+    autoCorrect?: string | undefined | undefined;
+    autoSave?: string | undefined | undefined;
+    itemProp?: string | undefined | undefined;
+    itemScope?: boolean | undefined | undefined;
+    itemType?: string | undefined | undefined;
+    itemID?: string | undefined | undefined;
+    itemRef?: string | undefined | undefined;
+    results?: number | undefined | undefined;
+    security?: string | undefined | undefined;
+    unselectable?: "on" | "off" | undefined | undefined;
+    popover?: "" | "auto" | "manual" | "hint" | undefined | undefined;
+    popoverTargetAction?: "toggle" | "show" | "hide" | undefined | undefined;
+    popoverTarget?: string | undefined | undefined;
+    inert?: boolean | undefined | undefined;
+    inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+    is?: string | undefined | undefined;
+    exportparts?: string | undefined | undefined;
+    part?: string | undefined | undefined;
+    "aria-activedescendant"?: string | undefined | undefined;
+    "aria-atomic"?: (boolean | "true" | "false") | undefined;
+    "aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+    "aria-braillelabel"?: string | undefined | undefined;
+    "aria-brailleroledescription"?: string | undefined | undefined;
+    "aria-busy"?: (boolean | "true" | "false") | undefined;
+    "aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-colcount"?: number | undefined | undefined;
+    "aria-colindex"?: number | undefined | undefined;
+    "aria-colindextext"?: string | undefined | undefined;
+    "aria-colspan"?: number | undefined | undefined;
+    "aria-controls"?: string | undefined | undefined;
+    "aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+    "aria-describedby"?: string | undefined | undefined;
+    "aria-description"?: string | undefined | undefined;
+    "aria-details"?: string | undefined | undefined;
+    "aria-disabled"?: (boolean | "true" | "false") | undefined;
+    "aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+    "aria-errormessage"?: string | undefined | undefined;
+    "aria-expanded"?: (boolean | "true" | "false") | undefined;
+    "aria-flowto"?: string | undefined | undefined;
+    "aria-grabbed"?: (boolean | "true" | "false") | undefined;
+    "aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+    "aria-hidden"?: (boolean | "true" | "false") | undefined;
+    "aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+    "aria-keyshortcuts"?: string | undefined | undefined;
+    "aria-label"?: string | undefined | undefined;
+    "aria-labelledby"?: string | undefined | undefined;
+    "aria-level"?: number | undefined | undefined;
+    "aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+    "aria-modal"?: (boolean | "true" | "false") | undefined;
+    "aria-multiline"?: (boolean | "true" | "false") | undefined;
+    "aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+    "aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+    "aria-owns"?: string | undefined | undefined;
+    "aria-placeholder"?: string | undefined | undefined;
+    "aria-posinset"?: number | undefined | undefined;
+    "aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+    "aria-readonly"?: (boolean | "true" | "false") | undefined;
+    "aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+    "aria-required"?: (boolean | "true" | "false") | undefined;
+    "aria-rowcount"?: number | undefined | undefined;
+    "aria-rowindex"?: number | undefined | undefined;
+    "aria-rowindextext"?: string | undefined | undefined;
+    "aria-rowspan"?: number | undefined | undefined;
+    "aria-selected"?: (boolean | "true" | "false") | undefined;
+    "aria-setsize"?: number | undefined | undefined;
+    "aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+    "aria-valuemax"?: number | undefined | undefined;
+    "aria-valuemin"?: number | undefined | undefined;
+    "aria-valuenow"?: number | undefined | undefined;
+    "aria-valuetext"?: string | undefined | undefined;
+    dangerouslySetInnerHTML?: {
+      __html: string | TrustedHTML;
+    } | undefined | undefined;
+    onCopy?: import("react").ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onCopyCapture?: import("react").ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onCut?: import("react").ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onCutCapture?: import("react").ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onPaste?: import("react").ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onPasteCapture?: import("react").ClipboardEventHandler<HTMLSpanElement> | undefined;
+    onCompositionEnd?: import("react").CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionEndCapture?: import("react").CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionStart?: import("react").CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionStartCapture?: import("react").CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionUpdate?: import("react").CompositionEventHandler<HTMLSpanElement> | undefined;
+    onCompositionUpdateCapture?: import("react").CompositionEventHandler<HTMLSpanElement> | undefined;
+    onFocus?: import("react").FocusEventHandler<HTMLSpanElement> | undefined;
+    onFocusCapture?: import("react").FocusEventHandler<HTMLSpanElement> | undefined;
+    onBlur?: import("react").FocusEventHandler<HTMLSpanElement> | undefined;
+    onBlurCapture?: import("react").FocusEventHandler<HTMLSpanElement> | undefined;
+    onChangeCapture?: import("react").ChangeEventHandler<HTMLSpanElement, Element> | undefined;
+    onBeforeInput?: import("react").InputEventHandler<HTMLSpanElement> | undefined;
+    onBeforeInputCapture?: import("react").InputEventHandler<HTMLSpanElement> | undefined;
+    onInput?: import("react").InputEventHandler<HTMLSpanElement> | undefined;
+    onInputCapture?: import("react").InputEventHandler<HTMLSpanElement> | undefined;
+    onReset?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onResetCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onSubmitCapture?: import("react").SubmitEventHandler<HTMLSpanElement> | undefined;
+    onInvalid?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onInvalidCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoad?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onErrorCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onKeyDown?: import("react").KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyDownCapture?: import("react").KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyPress?: import("react").KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyPressCapture?: import("react").KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyUp?: import("react").KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onKeyUpCapture?: import("react").KeyboardEventHandler<HTMLSpanElement> | undefined;
+    onAbort?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onAbortCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onCanPlay?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onCanPlayCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onCanPlayThrough?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onCanPlayThroughCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onDurationChange?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onDurationChangeCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onEmptied?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onEmptiedCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onEncrypted?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onEncryptedCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onEnded?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onEndedCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadedData?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadedDataCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadedMetadata?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadedMetadataCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadStart?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onLoadStartCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onPause?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onPauseCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onPlay?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onPlayCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onPlaying?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onPlayingCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onProgress?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onProgressCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onRateChange?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onRateChangeCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onSeeked?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onSeekedCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onSeeking?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onSeekingCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onStalled?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onStalledCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onSuspend?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onSuspendCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onTimeUpdate?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onTimeUpdateCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onVolumeChange?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onVolumeChangeCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onWaiting?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onWaitingCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onAuxClick?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onAuxClickCapture?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onClick?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onClickCapture?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onContextMenu?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onContextMenuCapture?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onDoubleClick?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onDoubleClickCapture?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onDrag?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragCapture?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragEnd?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragEndCapture?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragEnter?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragEnterCapture?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragExit?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragExitCapture?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragLeave?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragLeaveCapture?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragOver?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragOverCapture?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragStart?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDragStartCapture?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDrop?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onDropCapture?: import("react").DragEventHandler<HTMLSpanElement> | undefined;
+    onMouseDown?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseDownCapture?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseEnter?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseLeave?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseMove?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseMoveCapture?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseOut?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseOutCapture?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseOver?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseOverCapture?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseUp?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onMouseUpCapture?: import("react").MouseEventHandler<HTMLSpanElement> | undefined;
+    onSelect?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onSelectCapture?: import("react").ReactEventHandler<HTMLSpanElement> | undefined;
+    onTouchCancel?: import("react").TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchCancelCapture?: import("react").TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchEnd?: import("react").TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchEndCapture?: import("react").TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchMove?: import("react").TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchMoveCapture?: import("react").TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchStart?: import("react").TouchEventHandler<HTMLSpanElement> | undefined;
+    onTouchStartCapture?: import("react").TouchEventHandler<HTMLSpanElement> | undefined;
+    onPointerDown?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerDownCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerMove?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerMoveCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerUp?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerUpCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerCancel?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerCancelCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerEnter?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerLeave?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerOver?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerOverCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerOut?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onPointerOutCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onGotPointerCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onGotPointerCaptureCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onLostPointerCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onLostPointerCaptureCapture?: import("react").PointerEventHandler<HTMLSpanElement> | undefined;
+    onScroll?: import("react").UIEventHandler<HTMLSpanElement> | undefined;
+    onScrollCapture?: import("react").UIEventHandler<HTMLSpanElement> | undefined;
+    onScrollEnd?: import("react").UIEventHandler<HTMLSpanElement> | undefined;
+    onScrollEndCapture?: import("react").UIEventHandler<HTMLSpanElement> | undefined;
+    onWheel?: import("react").WheelEventHandler<HTMLSpanElement> | undefined;
+    onWheelCapture?: import("react").WheelEventHandler<HTMLSpanElement> | undefined;
+    onAnimationStart?: import("react").AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationStartCapture?: import("react").AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationEnd?: import("react").AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationEndCapture?: import("react").AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationIteration?: import("react").AnimationEventHandler<HTMLSpanElement> | undefined;
+    onAnimationIterationCapture?: import("react").AnimationEventHandler<HTMLSpanElement> | undefined;
+    onToggle?: import("react").ToggleEventHandler<HTMLSpanElement> | undefined;
+    onBeforeToggle?: import("react").ToggleEventHandler<HTMLSpanElement> | undefined;
+    onTransitionCancel?: import("react").TransitionEventHandler<HTMLSpanElement> | undefined;
+    onTransitionCancelCapture?: import("react").TransitionEventHandler<HTMLSpanElement> | undefined;
+    onTransitionEnd?: import("react").TransitionEventHandler<HTMLSpanElement> | undefined;
+    onTransitionEndCapture?: import("react").TransitionEventHandler<HTMLSpanElement> | undefined;
+    onTransitionRun?: import("react").TransitionEventHandler<HTMLSpanElement> | undefined;
+    onTransitionRunCapture?: import("react").TransitionEventHandler<HTMLSpanElement> | undefined;
+    onTransitionStart?: import("react").TransitionEventHandler<HTMLSpanElement> | undefined;
+    onTransitionStartCapture?: import("react").TransitionEventHandler<HTMLSpanElement> | undefined;
+  }>;
+} | {
+  value: null;
+  label: string;
+  icon: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+} | {
+  value: string;
+  label: string;
+  icon: import("react").ForwardRefExoticComponent<Omit<import("lucide-react").LucideProps, "ref"> & import("react").RefAttributes<SVGSVGElement>>;
+})[];
+export declare const getIconComponent: (name: string | null | undefined, iconOptions?: readonly IconColorPickerIconOption[]) => ComponentType;
+//#endregion
+//#region src/components/primitives/icon-color-picker.d.ts
+interface IconColorPickerProps {
+  color: string;
+  colorOptions?: readonly string[];
+  icon?: string | null;
+  iconOptions?: readonly IconColorPickerIconOption[];
+  onColorChange: (color: string) => void;
+  onIconChange?: (icon: string | null) => void;
+  disabled?: boolean;
+  showIcons?: boolean;
+  colorLabel?: string;
+  iconLabel?: string;
+  "aria-label"?: string;
+}
+export declare const IconColorPicker: (props: IconColorPickerProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/primitives/integration-card.d.ts
+interface IntegrationCardProps {
+  icon: ReactNode;
+  name: string;
+  description: string;
+  id: string;
+  version?: string;
+  category?: string;
+  active?: boolean;
+  actionLabel?: string;
+}
+export declare const IntegrationCard: (props: IntegrationCardProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/primitives/radio.d.ts
+interface RadioProps extends RadioGroup$1.ItemProps {
+  rootRef?: React$2.RefObject<HTMLDivElement | null>;
+  inputProps?: React$2.InputHTMLAttributes<HTMLInputElement>;
+}
+export declare const Radio: React$2.ForwardRefExoticComponent<RadioProps & React$2.RefAttributes<HTMLInputElement>>;
+export declare const RadioGroup: React$2.ForwardRefExoticComponent<RadioGroup$1.RootProps & React$2.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/theme/recipes/segmented-control.d.ts
+declare const segmentedControlSlotRecipe: import("@chakra-ui/react").SlotRecipeDefinition<"root" | "item", {
+  size: {
+    sm: {
+      root: {
+        height: "segmented-control-sm";
+      };
+      item: {
+        height: "segmented-control-item-sm";
+        paddingInline: "compact";
+      };
+    };
+    xs: {
+      root: {
+        height: "segmented-control-xs";
+      };
+      item: {
+        height: "segmented-control-item-xs";
+        paddingInline: "xs";
+      };
+    };
+  };
+}>;
+//#endregion
+//#region src/components/primitives/segmented-control.d.ts
+type VariantProps = RecipeVariantProps<typeof segmentedControlSlotRecipe>;
+interface SegmentedControlRootProps extends HTMLChakraProps<"div">, VariantProps {}
+interface SegmentedControlOption {
+  value: string;
+  label: string;
+}
+interface SegmentedControlProps extends Omit<SegmentedControlRootProps, "onChange"> {
+  options: SegmentedControlOption[];
+  value: string;
+  onValueChange: (value: string) => void;
+  disabled?: boolean;
+  "aria-label"?: string;
+}
+export declare const SegmentedControl: (props: SegmentedControlProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/primitives/simple-card.d.ts
+type SimpleCardProps = BoxProps;
+export declare const SimpleCard: (props: SimpleCardProps) => import("react/jsx-runtime").JSX.Element;
+type SimpleCardBodyProps = BoxProps;
+export declare const SimpleCardBody: (props: SimpleCardBodyProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/primitives/slider.d.ts
+interface SliderProps extends Slider$1.RootProps {}
+export declare const Slider: React$2.ForwardRefExoticComponent<SliderProps & React$2.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/primitives/switch.d.ts
+interface SwitchProps extends Switch$1.RootProps {
+  inputProps?: React$2.InputHTMLAttributes<HTMLInputElement>;
+  rootRef?: React$2.RefObject<HTMLLabelElement | null>;
+  trackLabel?: {
+    on: React$2.ReactNode;
+    off: React$2.ReactNode;
+  };
+  thumbLabel?: {
+    on: React$2.ReactNode;
+    off: React$2.ReactNode;
+  };
+}
+export declare const Switch: React$2.ForwardRefExoticComponent<SwitchProps & React$2.RefAttributes<HTMLInputElement>>;
+//#endregion
+//#region src/components/primitives/tag-swatch.d.ts
+interface TagSwatchProps extends Omit<CenterProps, "color"> {
+  color: string;
+  icon?: string | null;
+  iconOptions?: readonly IconColorPickerIconOption[];
+  /** Renders the icon glyph instead of a plain colour dot when the value carries an icon. */
+  showIcon?: boolean;
+}
+export declare const TagSwatch: (props: TagSwatchProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/primitives/toaster.d.ts
+export declare const toaster: ReturnType<typeof createToaster>;
+export declare const Toaster: () => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/primitives/tooltip.d.ts
+interface TooltipProps extends Tooltip$1.RootProps {
+  children?: React$2.ReactElement;
+  portalled?: boolean;
+  portalRef?: React$2.RefObject<HTMLElement>;
+  content: React$2.ReactNode;
+  contentProps?: Tooltip$1.ContentProps;
+  disabled?: boolean;
+}
+export declare const Tooltip: React$2.ForwardRefExoticComponent<TooltipProps & React$2.RefAttributes<HTMLDivElement>>;
+//#endregion
+//#region src/components/tree-list/tree-list.types.d.ts
+type TreeListNavigationIntent = ListRowNavigationIntent;
+type TreeListActionContext = ListRowActionContext;
+type TreeListActionMenuItem = ListRowActionMenuItem;
+type TreeListAction = ListRowAction;
+type TreeListNodeRowVariant = Extract<ListRowVariant, "empty-state">;
+interface TreeListInlineInput {
+  ariaLabel: string;
+  defaultValue?: string;
+  placeholder?: string;
+  onCommit(value: string): Promise<void> | void;
+  onCancel?(): void;
+}
+/** Tree node data rendered by `TreeList`; extends the row API used by `ListRow`. */
+type TreeListNode = ListRowItem & {
+  id: string;
+  /** Opaque host scope passed to a configurable move policy. */
+  moveScope?: string;
+  children?: TreeListNode[];
+  /** Per-node visual row variant. Used for non-interactive placeholder rows. */
+  rowVariant?: TreeListNodeRowVariant;
+  inlineInput?: TreeListInlineInput;
+  showContextMenuTrigger?: boolean;
+  hiddenByDefault?: boolean;
+  /** Opt in to the tree-customization (hide/show) menu. Items are non-hideable unless this is true. */
+  canHide?: boolean;
+  /** Opt out of reordering while keeping the node visible in its group. */
+  canReorder?: boolean;
+  /** Allow this node to be moved to another tree location. */
+  canDrag?: boolean;
+  /** Allow movable nodes to be dropped on this node. */
+  canDrop?: boolean;
+};
+/** Top-level tree section with optional header, actions, empty state, and child nodes. */
+interface TreeListSection {
+  id: string;
+  /** Opaque host scope passed to a configurable move policy. */
+  moveScope?: string;
+  label?: string;
+  collapsible?: boolean;
+  actions?: TreeListAction[];
+  emptyState?: ReactNode;
+  nodes: TreeListNode[];
+  hiddenByDefault?: boolean;
+  /** Opt in to the tree-customization (hide/show) menu. Sections are non-hideable unless this is true. */
+  canHide?: boolean;
+  /** Opt out of reordering while keeping the section visible in its group. */
+  canReorder?: boolean;
+}
+/** Navigation payload emitted when a navigable tree node is activated. */
+interface TreeListNavigateEvent {
+  sectionId: string;
+  nodeId: string;
+  node: TreeListNode;
+  intent?: TreeListNavigationIntent;
+}
+/** Props passed to the host-provided tree link component. */
+interface TreeListLinkProps {
+  to: string;
+  children: ReactNode;
+}
+type TreeListLinkComponent = ComponentType<TreeListLinkProps>;
+//#endregion
+//#region src/components/sidenav/sidenav.types.d.ts
+interface SidenavProps {
+  storageKey: string;
+  sections: TreeListSection[];
+  activeNodeId?: string | string[] | null;
+  header?: ReactNode;
+  footer?: ReactNode;
+  /** Right-click menu available from every point in the Sidenav. */
+  contextActions?: ResourceContextAction[];
+  /** Initial width when resizable. Set explicitly to override the persisted width. */
+  width?: string | number;
+  emptyLabel?: string;
+  defaultExpandedSections?: string[];
+  linkComponent?: TreeListLinkComponent;
+  onNavigate?: (event: TreeListNavigateEvent) => void;
+  closable?: boolean;
+  onOpenChange?: (open: boolean) => void;
+  /** Allow split layouts to resize the sidenav. Defaults to `true`. */
+  resizable?: boolean;
+  defaultWidth?: number;
+  minWidth?: number;
+  maxWidth?: number;
+  /**
+   * When enabled, the scroll content is virtualized — only nodes near the viewport
+   * are mounted. Use for sidenavs that may contain hundreds of entries. Requires
+   * sections with flat nodes (no expandable children).
+   */
+  virtualize?: boolean;
+}
+//#endregion
+//#region src/components/sidenav/sidenav.d.ts
+export declare const Sidenav: (props: SidenavProps) => import("react/jsx-runtime").JSX.Element | null;
+//#endregion
+//#region src/components/sidenav/sidenav.store.d.ts
+interface SidenavSnapshot {
+  open: boolean;
+  expandedSections: string[];
+  expandedNodes: string[];
+  width: number | null;
+}
+interface SidenavState extends SidenavSnapshot {
+  openSidenav: () => void;
+  closeSidenav: () => void;
+  toggleSidenav: () => void;
+  toggleSection: (sectionId: string) => void;
+  toggleNode: (nodeId: string) => void;
+  setSectionExpanded: (sectionId: string, expanded: boolean) => void;
+  setNodeExpanded: (nodeId: string, expanded: boolean) => void;
+  setWidth: (width: number) => void;
+  reset: () => void;
+}
+export declare const useSidenavStore: <T>(storageKey: string, selector: (state: SidenavState) => T, initialState?: Partial<SidenavSnapshot>) => T;
+//#endregion
+//#region src/components/tree-list/tree-list-visibility.store.d.ts
+type VisibilityOverride = "hidden" | "shown";
+interface TreeListVisibilitySnapshot {
+  sectionOverrides: Record<string, VisibilityOverride>;
+  nodeOverrides: Record<string, VisibilityOverride>;
+}
+interface TreeListVisibilityState extends TreeListVisibilitySnapshot {
+  setSection: (id: string, value: VisibilityOverride | undefined) => void;
+  setNode: (id: string, value: VisibilityOverride | undefined) => void;
+  toggleSection: (id: string, hiddenByDefault: boolean) => void;
+  toggleNode: (id: string, hiddenByDefault: boolean) => void;
+  clearSection: (id: string) => void;
+  clearNode: (id: string) => void;
+  reset: () => void;
+}
+export declare const getTreeListVisibilityStore: (storageKey: string) => Omit<import("zustand").StoreApi<TreeListVisibilityState>, "setState" | "persist"> & {
+  setState(partial: TreeListVisibilityState | Partial<TreeListVisibilityState> | ((state: TreeListVisibilityState) => TreeListVisibilityState | Partial<TreeListVisibilityState>), replace?: false | undefined): unknown;
+  setState(state: TreeListVisibilityState | ((state: TreeListVisibilityState) => TreeListVisibilityState), replace: true): unknown;
+  persist: {
+    setOptions: (options: Partial<import("zustand/middleware").PersistOptions<TreeListVisibilityState, unknown, unknown>>) => void;
+    clearStorage: () => void;
+    rehydrate: () => Promise<void> | void;
+    hasHydrated: () => boolean;
+    onHydrate: (fn: (state: TreeListVisibilityState) => void) => () => void;
+    onFinishHydration: (fn: (state: TreeListVisibilityState) => void) => () => void;
+    getOptions: () => Partial<import("zustand/middleware").PersistOptions<TreeListVisibilityState, unknown, unknown>>;
+  };
+};
+export declare const useTreeListVisibilityStore: <T>(storageKey: string, selector: (state: TreeListVisibilityState) => T) => T;
+//#endregion
+//#region src/components/tab-strip/tab-visibility.store.d.ts
+interface TabVisibilitySnapshot {
+  tabOverrides: Record<string, VisibilityOverride>;
+}
+interface TabVisibilityState extends TabVisibilitySnapshot {
+  setTab: (key: string, value: VisibilityOverride | undefined) => void;
+  toggleTab: (key: string, hiddenByDefault: boolean) => void;
+  clearTab: (key: string) => void;
+  reset: () => void;
+}
+export declare const getTabVisibilityStore: (storageKey: string) => Omit<import("zustand").StoreApi<TabVisibilityState>, "setState" | "persist"> & {
+  setState(partial: TabVisibilityState | Partial<TabVisibilityState> | ((state: TabVisibilityState) => TabVisibilityState | Partial<TabVisibilityState>), replace?: false | undefined): unknown;
+  setState(state: TabVisibilityState | ((state: TabVisibilityState) => TabVisibilityState), replace: true): unknown;
+  persist: {
+    setOptions: (options: Partial<import("zustand/middleware").PersistOptions<TabVisibilityState, unknown, unknown>>) => void;
+    clearStorage: () => void;
+    rehydrate: () => Promise<void> | void;
+    hasHydrated: () => boolean;
+    onHydrate: (fn: (state: TabVisibilityState) => void) => () => void;
+    onFinishHydration: (fn: (state: TabVisibilityState) => void) => () => void;
+    getOptions: () => Partial<import("zustand/middleware").PersistOptions<TabVisibilityState, unknown, unknown>>;
+  };
+};
+export declare const useTabVisibilityStore: <T>(storageKey: string, selector: (state: TabVisibilityState) => T) => T;
+//#endregion
+//#region src/components/tab-strip/tab-visibility-filter.d.ts
+interface TabVisibilityPlacement {
+  closable?: boolean;
+  hiddenByDefault?: boolean;
+  pinned?: boolean;
+  title?: string;
+  contributionId: string;
+}
+export declare const filterVisibleTabs: <T extends TabVisibilityPlacement>(placements: T[], tabOverrides: Record<string, VisibilityOverride>, getKey: (placement: T) => string) => T[];
+interface TabVisibilityMenuActions {
+  onToggleTab: (key: string, hiddenByDefault: boolean) => void;
+  onResetAll: () => void;
+}
+interface BuildTabMenuOptions {
+  visibleIcon: ReactNode;
+  hiddenIcon: ReactNode;
+  resetIcon?: ReactNode;
+}
+export declare const buildTabVisibilityMenuActions: <T extends TabVisibilityPlacement>(placements: T[], tabOverrides: Record<string, VisibilityOverride>, actions: TabVisibilityMenuActions, getKey: (placement: T) => string, options: BuildTabMenuOptions, getIcon?: (placement: T) => ReactNode) => ResourceContextAction[];
+//#endregion
+//#region src/components/tab-strip/window-tabs.d.ts
+interface WindowTab {
+  id: string;
+  label: string;
+  icon?: ReactNode;
+}
+interface WindowTabsProps {
+  tabs: WindowTab[];
+  selectedId?: string;
+  onSelect: (id: string) => void;
+  onClose: (id: string) => void;
+  onReorder?: (id: string, targetId: string) => void;
+  "aria-label": string;
+}
+export declare const WindowTabs: (props: WindowTabsProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/tab-strip/window-title-bar.d.ts
+interface WindowTitleBarProps {
+  platform: string;
+  children?: ReactNode;
+}
+export declare const WindowTitleBar: (props: WindowTitleBarProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/tag-editor/tag-editor.types.d.ts
+interface TagEditorValue {
+  id: string;
+  name: string;
+  color: string;
+  sortOrder: number;
+  actions?: string[];
+  icon?: string | null;
+  isDefault?: boolean;
+  isNew?: boolean;
+}
+interface TagEditorAction {
+  value: string;
+  label: string;
+  /** Rendered before the label in the trigger and the menu row. */
+  icon?: ReactNode;
+}
+interface TagEditorProps {
+  values: TagEditorValue[];
+  onValuesChange: (values: TagEditorValue[]) => void;
+  onDeleteValue?: (value: TagEditorValue) => void;
+  onSetDefault?: (value: TagEditorValue) => void;
+  /** Enables inline renaming of the tag definition itself. */
+  onTitleChange?: (title: string) => void;
+  title?: string;
+  description?: string;
+  /** Rendered on the right of the header row, e.g. a mode toggle and a delete action. */
+  headerActions?: ReactNode;
+  /** Marks the heading with the unsaved-changes asterisk. */
+  hasChanges?: boolean;
+  isSaving?: boolean;
+  readOnly?: boolean;
+  addLabel?: string;
+  /** Name given to a freshly added option before it is renamed inline. */
+  addName?: string;
+  actionOptions?: TagEditorAction[];
+  /** Names the per-row action control, e.g. "Commands". Used in its label and aria-label. */
+  actionsLabel?: string;
+  /** Names the default-value control shown under the list when showDefault is set. */
+  defaultValueLabel?: string;
+  defaultAddColor?: string;
+  defaultAddIcon?: string | null;
+  deleteButtonText?: string;
+  deleteHeadline?: string;
+  deleteNotificationText?: (value: TagEditorValue) => string;
+  colorOptions?: readonly string[];
+  iconOptions?: readonly IconColorPickerIconOption[];
+  showDefault?: boolean;
+  showIcons?: boolean;
+  /** Draws the list as a bordered card, so the header and footer bands read as one panel. */
+  framed?: boolean;
+  /** Renders a column header band above the rows. Needs `framed` to look right. */
+  showColumnHeaders?: boolean;
+  /** Header label above the option names, e.g. "State". */
+  valueColumnLabel?: string;
+}
+//#endregion
+//#region src/components/tag-editor/tag-editor.d.ts
+export declare const TagEditor: (props: TagEditorProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/tag-editor/tag-editor-heading.d.ts
+interface TagEditorHeadingProps {
+  children: ReactNode;
+  /** Appends the unsaved-changes marker. */
+  hasChanges?: boolean;
+}
+/**
+ * Screen heading for a tag settings panel. The asterisk stays quiet on purpose —
+ * the enabled Save button in the same header is the loud signal.
+ */
+export declare const TagEditorHeading: (props: TagEditorHeadingProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/tag-editor/tag-editor-save-bar.d.ts
+interface TagEditorSaveBarProps {
+  onSave: () => void;
+  onReset: () => void;
+  hasChanges?: boolean;
+  isSaving?: boolean;
+  resetLabel?: string;
+  saveLabel?: string;
+}
+/**
+ * The single commit point for a tag settings screen, anchored in its header.
+ * Reset only appears while edits are pending, so the resting state stays quiet.
+ */
+export declare const TagEditorSaveBar: (props: TagEditorSaveBarProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/tag-editor/tag-settings-panel.d.ts
+interface SaveTagSettingsInput<TValue> {
+  deletedIds: Set<string>;
+  drafts: TagEditorValue[];
+  values: TValue[];
+}
+type EditorLabels = Pick<TagEditorProps, "actionOptions" | "actionsLabel" | "addLabel" | "addName" | "colorOptions" | "deleteButtonText" | "deleteHeadline" | "defaultValueLabel" | "deleteNotificationText" | "description" | "framed" | "iconOptions" | "readOnly" | "showDefault" | "onSetDefault" | "showColumnHeaders" | "showIcons" | "title" | "valueColumnLabel">;
+type SortableValue = {
+  id: string;
+  sortOrder: number;
+};
+interface TagSettingsPanelProps<TValue extends SortableValue> extends EditorLabels {
+  errorTitle: string;
+  loadingText?: string;
+  resetLabel?: string;
+  saveLabel?: string;
+  /** Loaded values; pass undefined while the initial load is pending. */
+  values: TValue[] | undefined;
+  /** Load/save error surfaced by the host's data layer. */
+  loadError?: unknown;
+  /**
+   * Persists the pending edits. The host owns fetching and cache invalidation;
+   * the panel resets its delete tracking once the returned promise resolves.
+   */
+  onSave: (input: SaveTagSettingsInput<TValue>) => Promise<void>;
+  toEditorValue: (value: TValue) => TagEditorValue;
+  valueNeedsUpdate: (original: TValue, draft: TagEditorValue) => boolean;
+}
+export declare const TagSettingsPanel: <TValue extends SortableValue>(props: TagSettingsPanelProps<TValue>) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/tree-list/tree-list-reorder.d.ts
+interface TreeListMoveEndpoint {
+  kind: "section" | "node";
+  sectionId: string;
+  id: string;
+  moveScope?: string;
+}
+interface TreeListMove {
+  source: TreeListMoveEndpoint;
+  destination: TreeListMoveEndpoint;
+}
+type TreeListMovePolicy = (move: TreeListMove) => boolean;
+//#endregion
+//#region src/components/tree-list/tree-list.d.ts
+type TreeListRowVariant = "compact" | "tree";
+/** Sectioned hierarchical list for files, resources, navigation, and customizable sidenavs. */
+interface TreeListProps {
+  /** Ordered sections to render, each containing nested tree nodes. */
+  sections: TreeListSection[];
+  /** Controlled section ids that are currently expanded. */
+  expandedSectionIds?: string[];
+  /** Controlled node ids that are currently expanded. */
+  expandedNodeIds?: string[];
+  /** Active node id, or ids, used for selection styling. */
+  activeNodeId?: string | string[] | null;
+  /** Compact rows suit app navigation; tree rows suit file/resource hierarchies. */
+  rowVariant?: TreeListRowVariant;
+  sectionGap?: StackProps["gap"];
+  nodeGap?: StackProps["gap"];
+  /** Link renderer used when nodes provide `href`. */
+  linkComponent?: TreeListLinkComponent;
+  /** Called when a navigable node is activated. */
+  onNavigate?: (event: TreeListNavigateEvent) => void;
+  onToggleSection?: (sectionId: string) => void;
+  onToggleNode?: (nodeId: string) => void;
+  onSectionContextMenu?: (event: MouseEvent<HTMLElement>, sectionId: string) => void;
+  /** Render large trees with virtual rows. Disable when using drag ordering. */
+  virtualize?: boolean;
+  scrollRef?: RefObject<HTMLDivElement | null>;
+  draggable?: boolean;
+  onReorderSections?: (nextSectionIds: string[]) => void;
+  onReorderNodes?: (sectionId: string, nextNodeIds: string[]) => void;
+  /** Decide whether a proposed customization move is valid. */
+  canMove?: TreeListMovePolicy;
+  /** Move a node onto another node, or onto the tree root when the target is omitted. */
+  onMoveNode?: (sourceNodeId: string, targetNodeId?: string) => void;
+  backgroundContextActions?: ResourceContextAction[];
+}
+export declare const TreeList: (props: TreeListProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/tree-list/tree-list-drag-provider.d.ts
+interface TreeListDragProviderProps {
+  sections: TreeListSection[];
+  canMove?: TreeListMovePolicy;
+  onReorderSections?: (nextSectionIds: string[], sourceSectionId: string, destinationSectionId: string) => void;
+  onReorderNodes?: (sectionId: string, nextNodeIds: string[]) => void;
+  children: ReactNode;
+}
+export declare const TreeListDragProvider: (props: TreeListDragProviderProps) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/components/tree-list/tree-list-order.store.d.ts
+interface TreeListOrderSnapshot {
+  sectionOrder: string[];
+  nodeOrderBySection: Record<string, string[]>;
+  sectionSlotById: Record<string, TreeListOrderSlot>;
+}
+type TreeListOrderSlot = "header" | "content" | "footer";
+interface TreeListOrderState extends TreeListOrderSnapshot {
+  setSectionOrder: (nextSectionIds: string[]) => void;
+  setNodeOrder: (sectionId: string, nextNodeIds: string[]) => void;
+  setSectionSlot: (sectionId: string, slot: TreeListOrderSlot) => void;
+  resetSectionOrder: () => void;
+  resetNodeOrder: (sectionId: string) => void;
+  reset: () => void;
+}
+export declare const getTreeListOrderStore: (storageKey: string) => Omit<import("zustand").StoreApi<TreeListOrderState>, "setState" | "persist"> & {
+  setState(partial: TreeListOrderState | Partial<TreeListOrderState> | ((state: TreeListOrderState) => TreeListOrderState | Partial<TreeListOrderState>), replace?: false | undefined): unknown;
+  setState(state: TreeListOrderState | ((state: TreeListOrderState) => TreeListOrderState), replace: true): unknown;
+  persist: {
+    setOptions: (options: Partial<import("zustand/middleware").PersistOptions<TreeListOrderState, unknown, unknown>>) => void;
+    clearStorage: () => void;
+    rehydrate: () => Promise<void> | void;
+    hasHydrated: () => boolean;
+    onHydrate: (fn: (state: TreeListOrderState) => void) => () => void;
+    onFinishHydration: (fn: (state: TreeListOrderState) => void) => () => void;
+    getOptions: () => Partial<import("zustand/middleware").PersistOptions<TreeListOrderState, unknown, unknown>>;
+  };
+};
+export declare const useTreeListOrderStore: <T>(storageKey: string, selector: (state: TreeListOrderState) => T) => T;
+//#endregion
+//#region src/components/tree-list/tree-list-order-filter.d.ts
+export declare const applyTreeListOrder: (sections: TreeListSection[], sectionOrder: string[], nodeOrderBySection: Record<string, string[]>) => TreeListSection[];
+//#endregion
+//#region src/components/tree-list/tree-list-visibility-filter.d.ts
+export declare const resolveVisibility: (override: VisibilityOverride | undefined, hiddenByDefault: boolean | undefined) => VisibilityOverride;
+export declare const filterVisibleNodes: (nodes: TreeListNode[], nodeOverrides: Record<string, VisibilityOverride>) => TreeListNode[];
+export declare const filterVisibleSections: (sections: TreeListSection[], sectionOverrides: Record<string, VisibilityOverride>, nodeOverrides: Record<string, VisibilityOverride>) => TreeListSection[];
+interface TreeVisibilityMenuActions {
+  onToggleSection: (id: string, hiddenByDefault: boolean) => void;
+  onToggleNode: (id: string, hiddenByDefault: boolean) => void;
+  onResetAll: () => void;
+}
+interface BuildMenuOptions {
+  visibleIcon: ReactNode;
+  hiddenIcon: ReactNode;
+  resetIcon?: ReactNode;
+}
+interface TreeVisibilityMenuItems {
+  headerSections?: TreeListSection[];
+  sections: TreeListSection[];
+  footerSections?: TreeListSection[];
+}
+export declare const buildTreeVisibilityMenuActions: (items: TreeVisibilityMenuItems, sectionOverrides: Record<string, VisibilityOverride>, nodeOverrides: Record<string, VisibilityOverride>, actions: TreeVisibilityMenuActions, options: BuildMenuOptions) => ResourceContextAction[];
+//#endregion
+//#region src/utils/apply-file-icon-theme-preference.d.ts
+interface FileIconThemeFont {
+  fontFamily: string;
+  src: {
+    url: string;
+    format?: string;
+  }[];
+  weight?: string;
+  style?: string;
+}
+interface FileIconThemePreferenceOption {
+  id: string;
+  title?: string;
+  definitions: Record<string, unknown>;
+  fileExtensions: Record<string, string>;
+  fileNames: Record<string, string>;
+  defaults: {
+    file?: string;
+    folder?: string;
+  };
+  fonts: FileIconThemeFont[];
+}
+export declare const defaultFileIconThemePreferences: FileIconThemePreferenceOption[];
+export declare const isFileIconThemePreference: (value: string | null, themes: readonly FileIconThemePreferenceOption[]) => value is string;
+interface ResolvedFileIconGlyph {
+  fontFamily: string;
+  fontCharacter: string;
+  fontColor?: string;
+}
+export declare const resolveFileIconGlyph: (theme: FileIconThemePreferenceOption | undefined, filename: string, isDirectory?: boolean) => ResolvedFileIconGlyph | undefined;
+export declare const applyFileIconThemePreference: (themeId: string | null, themes: readonly FileIconThemePreferenceOption[]) => void;
+//#endregion
+//#region src/utils/file-icon-theme-preference.d.ts
+interface FileIconThemePreferenceContextValue {
+  fileIconThemePreference: string | null;
+  fileIconThemePreferences: readonly FileIconThemePreferenceOption[];
+  activeFileIconTheme: FileIconThemePreferenceOption | undefined;
+  setFileIconThemePreference: (preference: string) => void;
+}
+interface FileIconThemePreferenceProviderProps {
+  children: ReactNode;
+  themePreferences?: readonly FileIconThemePreferenceOption[];
+}
+export declare const FileIconThemePreferenceProvider: (props: FileIconThemePreferenceProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useFileIconThemePreference: () => FileIconThemePreferenceContextValue;
+//#endregion
+//#region src/utils/get-file-type-icon.d.ts
+export declare const getFileTypeIcon: (filename: string) => LucideIcon;
+//#endregion
+//#region src/utils/prism.d.ts
+export declare const installPrismGlobal: () => Promise<void>;
+//#endregion
+//#region src/utils/resolve-file-icon-element.d.ts
+interface ResolveFileIconElementOptions {
+  isDirectory?: boolean;
+  theme?: FileIconThemePreferenceOption;
+  size?: number;
+}
+export declare const resolveFileIconElement: (filename: string, options?: ResolveFileIconElementOptions) => import("react/jsx-runtime").JSX.Element;
+//#endregion
+//#region src/utils/theme-preference.d.ts
+interface ThemePreferenceContextValue {
+  themePreference: ThemePreference;
+  themePreferences: readonly ThemePreferenceOption[];
+  setThemePreference: (preference: ThemePreference) => void;
+  toggleThemePreference: () => void;
+}
+interface ThemePreferenceProviderProps {
+  children: ReactNode;
+  initialPreference?: ThemePreference;
+  /** A default used only when the user has not chosen a theme in this scope. */
+  defaultPreference?: ThemePreference;
+  preferenceScope?: string;
+  themePreferences?: readonly ThemePreferenceOption[];
+}
+export declare const getInitialThemePreference: (themePreferences?: readonly ThemePreferenceOption[]) => string;
+export declare const ThemePreferenceProvider: (props: ThemePreferenceProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useThemePreference: () => ThemePreferenceContextValue;
+//#endregion
+export { Activity, type ActivityActor, ActivityAvatar, type ActivityAvatarProps, ActivityComment, type ActivityCommentProps, ActivityComposer, type ActivityComposerProps, ActivityEvent, type ActivityEventProps, ActivityFeed, type ActivityFeedProps, ActivityHeader, type ActivityHeaderProps, ActivityReply, type ActivityReplyProps, ActivityRoot, type ActivityRootProps, ActivityTimeline, type ActivityTimelineProps, type AlertProps, type AttachedMenuProps, type AttachmentChipProps, type BreadcrumbItem, ChakraProvider, type CheckboxProps, type ChipProps, Label as ContentPlaceholderLabel, type EmptyStateProps, type FileIconThemeFont, type FileIconThemePreferenceOption, type FilterPaletteEntriesOptions, type FolderPickerEntry, type FolderPickerProps, type HeaderProps, type HeaderVariant, type IconColorPickerIconOption, type IconColorPickerProps, type IntegrationCardProps, type ItemSectionProps, type ListRowAction, type ListRowActionContext, type ListRowActionMenuItem, type ListRowItem, type ListRowNavigationIntent, type MonacoThemeData, type NotificationCenterAction, type NotificationCenterItem, type NotificationCenterPriority, type NotificationCenterProps, type NotificationCenterStatus, type PaletteEntry, type PaletteEscapeContext, type PaletteMode, type PaletteProps, type PaletteSearchEntry, type PaletteShortcutBinding, type PaletteState, type PaletteStateValue, type RadioProps, type ResizableSplitSeparator, ResourceActionMenu, type ResourceActionMenuProps, ResourceBadge, type ResourceContextAction, ResourceContextMenu, type SaveTagSettingsInput, ScrollArea, type SearchModalContentProps, type SearchableMenuItem, type SearchableMenuParentList, type SegmentedControlOption, type SegmentedControlProps, type SessionCompletionStatus, SessionIndicator, type SidenavProps, type SimpleCardBodyProps, type SimpleCardProps, type SliderProps, type SwitchProps, type TabVisibilityPlacement, type TagEditorAction, type TagEditorHeadingProps, type TagEditorProps, type TagEditorSaveBarProps, type TagEditorValue, type TagSettingsPanelProps, type TagSwatchProps, type ThemePreference, type ThemePreferenceMode, type ThemePreferenceOption, type ThemePreferenceTokens, type TreeListAction, type TreeListActionContext, type TreeListActionMenuItem, type TreeListInlineInput, type TreeListLinkComponent, type TreeListMove, type TreeListMoveEndpoint, type TreeListMovePolicy, type TreeListNavigateEvent, type TreeListNavigationIntent, type TreeListNode, type TreeListSection, type TreeVisibilityMenuItems, type VisibilityOverride, type VsCodeColorTheme, type WindowTab, type WindowTabsProps, type WindowTitleBarProps, WorkspaceBadge, type WorkspaceBadgeProps, applyThemePreference, createMonacoThemeFromVsCodeTheme, createThemePreferenceFromVsCodeTheme, defaultThemePreferences, getThemePreferenceClassName, getThemePreferenceClassNames, getThemePreferenceMode, isThemePreference, _default as psTheme, resolveSessionIndicatorColor, resolveSessionIndicatorIcon, sessionCompletionStatuses };
+export {};