@larose-ui/react 0.1.1 → 0.1.2

package/dist/index.d.ts

@@ -1,18 +1,36 @@
 import * as react from 'react';
-import { ButtonHTMLAttributes, ReactNode, InputHTMLAttributes, TextareaHTMLAttributes, SelectHTMLAttributes } from 'react';
-import { Variant, Size, UIState, ThemeMode, Density } from '@larose-ui/core';
+import { ButtonHTMLAttributes, ReactNode, CSSProperties, InputHTMLAttributes, TextareaHTMLAttributes, SelectHTMLAttributes, ElementType, ImgHTMLAttributes, IframeHTMLAttributes, ReactElement, MouseEvent } from 'react';
+import { Variant, Size, ButtonRole, UIState, MotionSemanticPreset, ReducedMotionPolicy, ThemeMode, Density, SpringPresetName, TypographyRole } from '@larose-ui/core';
 export { ApiError, AsyncState, Density, Environment, LAROSE_VERSION, Permission, Size, ThemeMode, UIState, Variant } from '@larose-ui/core';
 import { ColorTokens } from '@larose-ui/tokens';
-export { ColorTokens, TokenSet, applyTokensToElement, getTokens, tokensToCSSVariables } from '@larose-ui/tokens';
+export { ColorTokens, DRAG_START_THRESHOLD_PX, MAX_HOME_SCREEN_QUICK_ACTIONS, MAX_ORNAMENTS, TokenSet, applyTokensToElement, getTokens, tokensToCSSVariables } from '@larose-ui/tokens';
+
+type ButtonShape = 'capsule' | 'circle' | 'roundedRect';
+type ButtonPlatformSize = 'mini' | 'sm' | 'md' | 'lg' | 'xl';
 
 interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
     variant?: Variant;
     size?: Size;
+    /** Apple HIG semantic role — affects appearance in alerts and sheets. */
+    buttonRole?: ButtonRole;
+    /** Capsule (default), circle (icon-only), or roundedRect (vertical stacks). */
+    shape?: ButtonShape;
     state?: UIState;
     loading?: boolean;
+    /** Alternative label shown while loading (Apple HIG activity indicator pattern). */
+    loadingLabel?: string;
     error?: string | null;
     leftIcon?: ReactNode;
     rightIcon?: ReactNode;
+    /** macOS: append trailing ellipsis when the button opens another view. */
+    opensAnotherView?: boolean;
+    /** macOS flexible-height push button for multi-line content. */
+    flexible?: boolean;
+    iconOnly?: boolean;
+    /** watchOS-style full-width primary actions. */
+    fullWidth?: boolean;
+    /** macOS / visionOS hover tooltip. */
+    tooltip?: string;
 }
 declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
 
@@ -26,17 +44,163 @@ interface AsyncButtonProps extends Omit<ButtonProps, 'onClick' | 'loading' | 'er
 }
 declare function AsyncButton({ action, onSuccess, onError, children, variant, size, disabled, ...props }: AsyncButtonProps): react.JSX.Element;
 
+type PresencePhase = 'mounting' | 'entering' | 'entered' | 'exiting' | 'exited';
+type MotionVariant = 'fade' | 'fade-scale' | 'fade-slide-up' | 'fade-slide-down' | 'fade-slide-left' | 'fade-slide-right' | 'modal' | 'backdrop' | 'toast' | 'popover' | 'drawer-left' | 'drawer-right';
+interface MotionConfig {
+    /** Global motion preset. `none` disables animations. */
+    preset?: MotionSemanticPreset;
+    /** How to respect system reduced-motion. */
+    reducedMotion?: ReducedMotionPolicy;
+}
+
+interface MotionContextValue {
+    preset: MotionSemanticPreset;
+    reducedMotion: ReducedMotionPolicy;
+    prefersReducedMotion: boolean;
+    motionEnabled: boolean;
+}
+declare function useMotion(): MotionContextValue;
+interface MotionProviderProps extends MotionConfig {
+    children: ReactNode;
+}
+declare function MotionProvider({ children, preset, reducedMotion, }: MotionProviderProps): react.JSX.Element;
+/** Returns whether a specific animation should run. */
+declare function useMotionEnabled(): boolean;
+declare function useSkipMotion(): boolean;
+
 interface LaRoseConfig {
     theme?: ThemeMode;
     density?: Density;
     tenantId?: string;
     brandColors?: Partial<ColorTokens>;
+    motion?: MotionConfig;
 }
 declare function useLaRose(): LaRoseConfig;
 interface LaRoseProviderProps extends LaRoseConfig {
     children: ReactNode;
 }
-declare function LaRoseProvider({ children, theme, density, tenantId, brandColors, }: LaRoseProviderProps): react.JSX.Element;
+declare function LaRoseProvider({ children, theme, density, tenantId, brandColors, motion, }: LaRoseProviderProps): react.JSX.Element;
+
+interface PresenceProps {
+    present: boolean;
+    children: ReactNode;
+    variant?: MotionVariant;
+    /** Placement hint for spatial variants (toast, popover). */
+    placement?: string;
+    className?: string;
+    style?: CSSProperties;
+    onExitComplete?: () => void;
+    /** When true, skip exit animation and unmount immediately. */
+    immediate?: boolean;
+}
+/**
+ * Keeps children mounted during exit animations and applies motion CSS classes.
+ * Pass a single React element child to merge props onto it.
+ */
+declare function Presence({ present, children, variant, placement, className, style, onExitComplete, immediate, }: PresenceProps): react.JSX.Element | null;
+
+interface UsePresenceOptions {
+    present: boolean;
+    onExitComplete?: () => void;
+}
+interface UsePresenceResult {
+    phase: PresencePhase;
+    shouldRender: boolean;
+    onAnimationEnd: (event: React.AnimationEvent) => void;
+}
+/**
+ * Manages mount/unmount lifecycle with enter and exit animation phases.
+ * Uses a mounting frame so CSS keyframe animations can run from their `from` state.
+ */
+declare function usePresence({ present, onExitComplete, }: UsePresenceOptions): UsePresenceResult;
+
+interface UseSpringAnimationOptions {
+    target: number;
+    preset?: SpringPresetName;
+    enabled?: boolean;
+    onSettle?: () => void;
+}
+/**
+ * RAF-driven spring animation for interruptible gesture release (drawers, sheets).
+ * Continues from current position and velocity when target changes.
+ */
+declare function useSpringAnimation({ target, preset, enabled, onSettle, }: UseSpringAnimationOptions): {
+    value: number;
+    setValue: (value: number, velocity?: number) => void;
+    style: CSSProperties;
+};
+interface CollapseProps {
+    open: boolean;
+    children: ReactNode;
+    className?: string;
+    duration?: string;
+}
+/**
+ * Height-based expand/collapse with measured content height.
+ * Uses transform-friendly opacity + grid technique where possible.
+ */
+declare function Collapse({ open, children, className, duration }: CollapseProps): react.JSX.Element;
+
+interface HelpButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Brief phrase explaining what help covers (macOS / visionOS tooltip). */
+    helpTopic?: string;
+}
+/**
+ * Circular help button — one per window, lower corner of dialogs/settings.
+ * @see https://developer.apple.com/design/human-interface-guidelines/buttons
+ */
+declare const HelpButton: react.ForwardRefExoticComponent<HelpButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface SquareButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Symbol or icon — square buttons use icons, not text labels. */
+    icon: ReactNode;
+    tooltip?: string;
+    /** Toggle or pop-up behavior is handled by the parent; appearance only. */
+    pressed?: boolean;
+}
+/**
+ * Small square button for in-view actions (add/remove rows, etc.).
+ * @see https://developer.apple.com/design/human-interface-guidelines/buttons
+ */
+declare const SquareButton: react.ForwardRefExoticComponent<SquareButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface ButtonGroupProps {
+    children: ReactNode;
+    /** Horizontal row (default) or vertical stack for visionOS guidance. */
+    orientation?: 'horizontal' | 'vertical';
+    /** Full-width buttons for watchOS-style primary actions. */
+    fullWidth?: boolean;
+    className?: string;
+    'aria-label'?: string;
+}
+/**
+ * Same-size button set — use style, not size, to distinguish the preferred option.
+ */
+declare function ButtonGroup({ children, orientation, fullWidth, className, 'aria-label': ariaLabel, }: ButtonGroupProps): react.JSX.Element;
+
+declare function formatButtonLabel(label: string, opensAnotherView?: boolean): string;
+declare function resolveButtonShape(options: {
+    shape?: ButtonShape;
+    iconOnly?: boolean;
+    hasText: boolean;
+    hasIcon: boolean;
+}): ButtonShape;
+
+type FieldFormat = 'number' | 'currency' | 'percent';
+type FieldValidator = (value: string) => string | null;
+interface FormatFieldOptions {
+    locale?: string;
+    currency?: string;
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}
+declare function createRequiredValidator(message?: string): FieldValidator;
+declare function createEmailValidator(message?: string): FieldValidator;
+declare function combineValidators(...validators: FieldValidator[]): FieldValidator;
+declare function parseNumericInput(value: string): number | null;
+declare function formatFieldValue(value: string, format: FieldFormat, options?: FormatFieldOptions): string;
+declare function isFormComplete(values: Record<string, string>, requiredKeys: string[]): boolean;
+declare function fieldIdFromLabel(label: string): string;
 
 interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
     label?: string;
@@ -45,9 +209,38 @@ interface InputProps extends InputHTMLAttributes<HTMLInputElement> {
     loading?: boolean;
     error?: string | null;
     inputSize?: Size;
+    /** Shows a required indicator and sets the native required attribute. */
+    required?: boolean;
+    /** Validates on blur or change and surfaces inline feedback immediately. */
+    validate?: FieldValidator;
+    validateOn?: 'blur' | 'change';
+    /** Formats numeric values on blur (currency, percent, number). */
+    format?: FieldFormat;
+    formatOptions?: FormatFieldOptions;
+    /** macOS-style expansion tooltip when truncated text overflows the field. */
+    expansionTooltip?: boolean;
+    /** Accept plain-text drops into the field. */
+    acceptDrop?: boolean;
 }
 declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
 
+type SecureFieldProps = Omit<InputProps, 'type' | 'defaultValue'>;
+/**
+ * Password entry that follows Apple HIG: never prepopulate sensitive fields.
+ * @see https://developer.apple.com/design/human-interface-guidelines/entering-data
+ */
+declare const SecureField: react.ForwardRefExoticComponent<SecureFieldProps & react.RefAttributes<HTMLInputElement>>;
+
+interface FormContinueProps extends ButtonProps {
+    /** When false, Continue stays disabled until required data is entered. */
+    complete: boolean;
+}
+/**
+ * Continue/Next control that stays disabled until required fields are filled.
+ * @see https://developer.apple.com/design/human-interface-guidelines/entering-data
+ */
+declare function FormContinue({ complete, disabled, children, ...props }: FormContinueProps): react.JSX.Element;
+
 interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
     label?: string;
     hint?: string;
@@ -55,6 +248,7 @@ interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
     loading?: boolean;
     error?: string | null;
     inputSize?: Size;
+    required?: boolean;
 }
 declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
 
@@ -71,6 +265,7 @@ interface SelectProps extends SelectHTMLAttributes<HTMLSelectElement> {
     loading?: boolean;
     error?: string | null;
     inputSize?: Size;
+    required?: boolean;
 }
 declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLSelectElement>>;
 
@@ -126,6 +321,66 @@ interface AlertProps {
 }
 declare function Alert({ variant, title, children, onDismiss, }: AlertProps): react.JSX.Element;
 
+/** Visual and interaction preset for modal alerts. */
+type AlertDialogPresentation = 'compact' | 'tablet' | 'desktop' | 'spatial' | 'tv' | 'wearable';
+type AlertDialogActionRole = 'default' | 'cancel' | 'destructive';
+interface AlertDialogAction {
+    id: string;
+    label: string;
+    role?: AlertDialogActionRole;
+    /** Deliberate destructive actions omit emphasized destructive styling. */
+    deliberate?: boolean;
+    onSelect?: () => void;
+}
+interface AlertDialogTextField {
+    label?: string;
+    placeholder?: string;
+    secure?: boolean;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+}
+interface AlertDialogSuppression {
+    label: string;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onChange?: (checked: boolean) => void;
+}
+interface AlertDialogProps {
+    open: boolean;
+    onOpenChange: (open: boolean) => void;
+    title: string;
+    message?: string;
+    actions: AlertDialogAction[];
+    presentation?: AlertDialogPresentation;
+    icon?: ReactNode;
+    /** Use sparingly for unexpected data loss. */
+    showCautionIcon?: boolean;
+    textField?: AlertDialogTextField;
+    suppression?: AlertDialogSuppression;
+    helpUrl?: string;
+    accessory?: ReactNode;
+    /** When unset, no button receives default keyboard focus styling. */
+    defaultActionId?: string;
+    className?: string;
+}
+interface AlertDialogButtonLayout {
+    ordered: AlertDialogAction[];
+    layout: 'row' | 'stack';
+}
+
+declare const MAX_ALERT_BUTTONS = 3;
+declare function warnIfAlertTitleTooLong(title: string): void;
+declare function validateAlertActions(actions: AlertDialogAction[]): void;
+declare function orderAlertActions(actions: AlertDialogAction[], presentation: 'compact' | 'tablet' | 'desktop' | 'spatial' | 'tv' | 'wearable'): AlertDialogButtonLayout;
+declare function resolveCancelAction(actions: AlertDialogAction[]): AlertDialogAction | undefined;
+declare function shouldStyleDestructive(action: AlertDialogAction): boolean;
+
+/**
+ * Modal alert — critical, actionable interruption with up to three buttons.
+ */
+declare function AlertDialog({ open, onOpenChange, title, message, actions, presentation, icon, showCautionIcon, textField, suppression, helpUrl, accessory, defaultActionId, className, }: AlertDialogProps): react.ReactPortal | null;
+
 interface ModalProps {
     open: boolean;
     onClose: () => void;
@@ -150,6 +405,311 @@ interface DialogProps {
 }
 declare function Dialog({ open, onClose, title, description, children, confirmLabel, cancelLabel, onConfirm, loading, variant, }: DialogProps): react.JSX.Element;
 
+type ChartMark = 'bar' | 'line' | 'point';
+type PointShape = 'circle' | 'diamond' | 'square';
+interface ChartDataPoint {
+    x: string | number;
+    y: number;
+    accessibilityLabel?: string;
+}
+interface ChartSeries {
+    id: string;
+    label: string;
+    data: ChartDataPoint[];
+    color?: string;
+    pointShape?: PointShape;
+}
+interface ChartAxisConfig {
+    label?: string;
+    /** Fixed lower bound. Omit with `max` for dynamic range. */
+    min?: number;
+    /** Fixed upper bound. Omit with `min` for dynamic range. */
+    max?: number;
+    /** Hide axis line and ticks. */
+    hidden?: boolean;
+    /** Number of tick marks (approximate). */
+    tickCount?: number;
+    formatValue?: (value: number) => string;
+    formatCategory?: (value: string | number) => string;
+}
+interface ChartLegendItem {
+    id: string;
+    label: string;
+    color: string;
+    shape?: PointShape;
+}
+
+interface ChartProps {
+    /** Chart mark type — bar, line, or point. */
+    mark?: ChartMark;
+    /** Single-series shorthand. */
+    data?: ChartDataPoint[];
+    /** One or more data series. */
+    series?: ChartSeries[];
+    title?: string;
+    subtitle?: string;
+    annotation?: string;
+    /** High-level summary for assistive technologies (Apple Audio Graphs pattern). */
+    accessibilitySummary?: string;
+    xAxis?: ChartAxisConfig;
+    yAxis?: ChartAxisConfig;
+    /** Combine line marks with point marks. Default true for line charts. */
+    showPoints?: boolean;
+    /** Stack bar marks when multiple series are present. */
+    stacked?: boolean;
+    /** Gap between stacked bar segments (Apple HIG visual separation). */
+    stackGap?: number;
+    /** Plot height in CSS pixels. */
+    height?: number;
+    /** Enable plot-area scrubbing with crosshair. */
+    interactive?: boolean;
+    /** Y axis on trailing edge (right in LTR) for layout alignment. */
+    yAxisTrailing?: boolean;
+    showLegend?: boolean;
+    className?: string;
+    onPointFocus?: (point: ChartDataPoint, seriesId: string, index: number) => void;
+}
+declare function Chart({ mark, data, series: seriesProp, title, subtitle, annotation, accessibilitySummary, xAxis, yAxis, showPoints, stacked, stackGap, height, interactive, yAxisTrailing, showLegend, className, onPointFocus, }: ChartProps): react.JSX.Element;
+
+interface ShareButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    label?: string;
+}
+/** Toolbar share control — Apple HIG placement next to document actions. */
+declare const ShareButton: react.ForwardRefExoticComponent<ShareButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+type SharePermission = 'view' | 'edit';
+type ShareAudience = 'invited' | 'everyone';
+type ActivityKind = 'app' | 'share' | 'action';
+type SystemActivityId = 'copy' | 'print' | 'add-to-files' | 'markup' | 'airplay' | 'save-to-photos' | 'assign-to-contact';
+type ActivityPresentation = 'sheet' | 'popover';
+interface Collaborator {
+    id: string;
+    name: string;
+    avatarUrl?: string;
+    initials?: string;
+}
+interface ShareDestination {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    onSelect?: () => void;
+}
+interface SharePermissionOption {
+    id: string;
+    audience: ShareAudience;
+    permission: SharePermission;
+    label: string;
+    description?: string;
+}
+interface CollaborationAction {
+    id: string;
+    label: string;
+    description?: string;
+    onSelect?: () => void;
+}
+interface ShareSettings {
+    audience: ShareAudience;
+    permission: SharePermission;
+    allowInvites?: boolean;
+}
+interface ActivityItem {
+    id: string;
+    title: string;
+    /** Share destinations show a subtitle (e.g. app or service name) below the icon. */
+    subtitle?: string;
+    icon?: ReactNode;
+    kind: ActivityKind;
+    /** Marks built-in system activities that can be excluded per context. */
+    system?: boolean;
+    disabled?: boolean;
+    hidden?: boolean;
+    onSelect?: () => void;
+}
+
+interface ShareSheetProps {
+    open: boolean;
+    onClose: () => void;
+    title?: string;
+    settings: ShareSettings;
+    onSettingsChange?: (settings: ShareSettings) => void;
+    destinations?: ShareDestination[];
+    permissionOptions?: SharePermissionOption[];
+    footer?: ReactNode;
+}
+declare function ShareSheet({ open, onClose, title, settings, onSettingsChange, destinations, permissionOptions, footer, }: ShareSheetProps): react.ReactPortal | null;
+
+interface CollaborationButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    collaborators: Collaborator[];
+    label?: string;
+    maxVisible?: number;
+}
+/** Displays active collaborators — Apple HIG Collaboration button pattern. */
+declare const CollaborationButton: react.ForwardRefExoticComponent<CollaborationButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface CollaborationPopoverProps {
+    trigger: ReactNode;
+    collaborators: Collaborator[];
+    actions?: CollaborationAction[];
+    manageLabel?: string;
+    onManage?: () => void;
+    onMessage?: () => void;
+    onVideo?: () => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+/**
+ * Three-section collaboration popover per Apple HIG:
+ * collaborators + communication, custom actions, manage shared file.
+ */
+declare function CollaborationPopover({ trigger, collaborators, actions, manageLabel, onManage, onMessage, onVideo, open, defaultOpen, onOpenChange, }: CollaborationPopoverProps): react.JSX.Element;
+
+interface ShareToolbarProps {
+    /** Document or item title shown in the share sheet. */
+    shareTitle?: string;
+    /** When true, shows the Collaboration button beside Share. */
+    collaborating?: boolean;
+    collaborators?: Collaborator[];
+    shareSettings?: ShareSettings;
+    onShareSettingsChange?: (settings: ShareSettings) => void;
+    destinations?: ShareDestination[];
+    permissionOptions?: SharePermissionOption[];
+    collaborationActions?: CollaborationAction[];
+    onManageSharedFile?: () => void;
+    manageLabel?: string;
+    onMessage?: () => void;
+    onVideo?: () => void;
+    trailing?: ReactNode;
+}
+declare function ShareToolbar({ shareTitle, collaborating, collaborators, shareSettings, onShareSettingsChange, destinations, permissionOptions, collaborationActions, onManageSharedFile, manageLabel, onMessage, onVideo, trailing, }: ShareToolbarProps): react.JSX.Element;
+
+interface ActivityViewProps {
+    open: boolean;
+    onClose: () => void;
+    activities: ActivityItem[];
+    excludedActivityIds?: string[];
+    presentation?: ActivityPresentation;
+    title?: string;
+    onActivitySelect?: (activity: ActivityItem) => void;
+    footer?: ReactNode;
+    /** Used for popover positioning when presentation is popover. */
+    anchorRef?: React.RefObject<HTMLElement | null>;
+}
+/**
+ * Activity view (share sheet) with sharing destinations and contextual actions.
+ * @see https://developer.apple.com/design/human-interface-guidelines/activity-views
+ */
+declare function ActivityView({ open, onClose, activities, excludedActivityIds, presentation, title, onActivitySelect, footer, anchorRef, }: ActivityViewProps): react.ReactPortal | null;
+
+interface ActivityShareButtonProps {
+    activities: ActivityItem[];
+    excludedActivityIds?: string[];
+    label?: string;
+    title?: string;
+    onActivitySelect?: (activity: ActivityItem) => void;
+    /** Uses popover on wide viewports and sheet on compact widths when auto. */
+    presentation?: 'sheet' | 'popover' | 'auto';
+}
+/**
+ * Share button that opens an activity view — the standard HIG entry point.
+ */
+declare function ActivityShareButton({ activities, excludedActivityIds, label, title, onActivitySelect, presentation, }: ActivityShareButtonProps): react.JSX.Element;
+
+/** Default share and action activities for demos and baselines. */
+declare function createDefaultActivities(handlers?: Partial<Record<string, () => void>>): ActivityItem[];
+/** Photos-style app-specific activities shown before system actions. */
+declare function createPhotoActivities(handlers?: Partial<Record<string, () => void>>): ActivityItem[];
+
+/** Succinct permission summary per Apple HIG collaboration guidance. */
+declare function formatSharePermissionSummary(audience: ShareAudience, permission: SharePermission): string;
+
+/** Built-in system activities available across apps. */
+declare const SYSTEM_ACTIVITY_IDS: SystemActivityId[];
+declare function formatActivityTitle(title: string): string;
+declare function filterActivities(activities: ActivityItem[], excludedIds?: string[]): ActivityItem[];
+/** App-specific activities appear before share destinations and system actions. */
+declare function sortActivities(activities: ActivityItem[]): ActivityItem[];
+declare function prepareActivities(activities: ActivityItem[], excludedIds?: string[]): ActivityItem[];
+
+type DropOperation = 'move' | 'copy';
+interface DragItem<T = unknown> {
+    id: string;
+    type?: string;
+    data: T;
+    sourceId: string;
+    preview?: ReactNode;
+    label?: string;
+}
+interface DragSession<T = unknown> {
+    items: DragItem<T>[];
+    sourceId: string;
+    pointerId: number;
+    startX: number;
+    startY: number;
+    x: number;
+    y: number;
+}
+interface DropTargetState {
+    zoneId: string;
+    valid: boolean;
+}
+interface DropResult<T = unknown> {
+    items: DragItem<T>[];
+    sourceId: string;
+    destinationId: string;
+    operation: DropOperation;
+}
+
+interface DragDropProviderProps {
+    children: ReactNode;
+}
+declare function DragDropProvider({ children }: DragDropProviderProps): react.JSX.Element;
+
+interface DraggableProps<T = unknown> {
+    id: string;
+    sourceId: string;
+    data: T;
+    type?: string;
+    label?: string;
+    preview?: ReactNode;
+    disabled?: boolean;
+    children: ReactNode;
+    className?: string;
+}
+declare function Draggable<T>({ id, sourceId, data, type, label, preview, disabled, children, className, }: DraggableProps<T>): react.JSX.Element;
+
+interface DropZoneProps<T = unknown> {
+    id: string;
+    accepts?: string | string[];
+    disabled?: boolean;
+    canDrop?: (items: DragItem<T>[]) => boolean;
+    onDrop: (result: DropResult<T>) => void | Promise<void>;
+    children: ReactNode;
+    className?: string;
+    showInvalidIndicator?: boolean;
+    transferring?: boolean;
+    transferringLabel?: string;
+}
+declare function DropZone<T>({ id, accepts, disabled, canDrop, onDrop, children, className, showInvalidIndicator, transferring, transferringLabel, }: DropZoneProps<T>): react.JSX.Element;
+
+interface DragDropListItem {
+    id: string;
+    label: string;
+    type?: string;
+}
+interface DragDropListProps {
+    zoneId?: string;
+    items: DragDropListItem[];
+    onReorder: (items: DragDropListItem[]) => void;
+    renderItem?: (item: DragDropListItem) => ReactNode;
+}
+/** Reorderable list with Apple HIG drag feedback (same-container move). */
+declare function DragDropList(props: DragDropListProps): react.JSX.Element;
+
+/** Same container → move; different container → copy (Option forces copy). */
+declare function resolveDropOperation(sourceId: string, destinationId: string, optionKey?: boolean): DropOperation;
+declare function acceptsDragType(accepts: string | string[] | undefined, itemType: string | undefined): boolean;
+
 interface CardProps {
     title?: string;
     description?: string;
@@ -159,6 +719,349 @@ interface CardProps {
 }
 declare function Card({ title, description, children, footer, padding, }: CardProps): react.JSX.Element;
 
+type BoxVariant = 'secondary' | 'tertiary';
+type BoxTitlePosition = 'inside' | 'above';
+interface CollectionItem {
+    id: string;
+    label?: string;
+    imageUrl?: string;
+    content?: ReactNode;
+}
+type CollectionLayout = 'row' | 'grid';
+interface ColumnViewNode {
+    id: string;
+    label: string;
+    children?: ColumnViewNode[];
+    detail?: ReactNode;
+    meta?: Record<string, string>;
+}
+
+interface BoxProps {
+    title?: string;
+    /** macOS settings panes append a colon to the title. */
+    settingsStyle?: boolean;
+    titlePosition?: BoxTitlePosition;
+    variant?: BoxVariant;
+    padding?: 'sm' | 'md' | 'lg';
+    children: ReactNode;
+    className?: string;
+    'aria-label'?: string;
+}
+/**
+ * Groups related content with secondary/tertiary background — keep compact vs its container.
+ * @see https://developer.apple.com/design/human-interface-guidelines/boxes
+ */
+declare function Box({ title, settingsStyle, titlePosition, variant, padding, children, className, 'aria-label': ariaLabel, }: BoxProps): react.JSX.Element;
+
+interface CollectionProps {
+    items: CollectionItem[];
+    layout?: CollectionLayout;
+    columns?: number;
+    selectedId?: string;
+    onSelect?: (item: CollectionItem) => void;
+    ariaLabel?: string;
+}
+/**
+ * Visual row or grid of image-based items with comfortable padding.
+ * @see https://developer.apple.com/design/human-interface-guidelines/collections
+ */
+declare function Collection({ items, layout, columns, selectedId, onSelect, ariaLabel, }: CollectionProps): react.JSX.Element;
+
+declare function formatBoxTitle(title: string, settingsStyle?: boolean): string;
+
+interface ColumnViewProps {
+    data: ColumnViewNode[];
+    initialPath?: string[];
+    onPathChange?: (path: string[]) => void;
+    ariaLabel?: string;
+}
+/**
+ * Hierarchical browser with resizable columns and optional detail pane.
+ * @see https://developer.apple.com/design/human-interface-guidelines/column-views
+ */
+declare function ColumnView({ data, initialPath, onPathChange, ariaLabel, }: ColumnViewProps): react.JSX.Element;
+
+type LockupAxis = 'horizontal' | 'vertical' | 'grid';
+type CaptionButtonContent = 'image' | 'text';
+
+interface LockupProps {
+    header?: ReactNode;
+    footer?: ReactNode;
+    children: ReactNode;
+    axis?: LockupAxis;
+    focused?: boolean;
+    onFocus?: () => void;
+    onBlur?: () => void;
+    onClick?: () => void;
+    className?: string;
+    'aria-label'?: string;
+}
+/**
+ * Header + content + footer unit that expands together on focus.
+ * @see https://developer.apple.com/design/human-interface-guidelines/lockups
+ */
+declare function Lockup({ header, footer, children, axis, focused, onFocus, onBlur, onClick, className, 'aria-label': ariaLabel, }: LockupProps): react.JSX.Element;
+
+interface LockupCardProps extends Omit<LockupProps, 'children'> {
+    rating: number;
+    review: string;
+    title?: string;
+}
+/** Card lockup for ratings and reviews. */
+declare function LockupCard({ rating, review, title, header, ...props }: LockupCardProps): react.JSX.Element;
+interface CaptionButtonProps extends Omit<LockupProps, 'children'> {
+    title: string;
+    subtitle?: string;
+    imageUrl?: string;
+    label?: string;
+}
+/** Caption button with optional image or text surface. */
+declare function CaptionButton({ title, subtitle, imageUrl, label, footer, ...props }: CaptionButtonProps): react.JSX.Element;
+interface MonogramProps extends Omit<LockupProps, 'children'> {
+    name: string;
+    imageUrl?: string;
+    role?: string;
+}
+/** Circular cast/crew monogram with image or initials fallback. */
+declare function Monogram({ name, imageUrl, role, footer, ...props }: MonogramProps): react.JSX.Element;
+interface PosterProps extends Omit<LockupProps, 'children'> {
+    imageUrl: string;
+    title?: string;
+    subtitle?: string;
+}
+/** Poster lockup — title/subtitle appear on focus. */
+declare function Poster({ imageUrl, title, subtitle, ...props }: PosterProps): react.JSX.Element;
+interface LockupRowProps {
+    children: ReactNode;
+    itemWidth?: string;
+    axis?: LockupAxis;
+}
+/** Row of equally sized lockups with adequate spacing. */
+declare function LockupRow({ children, itemWidth, axis }: LockupRowProps): react.JSX.Element;
+
+declare function getInitials(name: string): string;
+declare function formatRating(value: number, max?: number): string;
+
+interface TypographyProps {
+    role?: TypographyRole;
+    as?: ElementType;
+    children: ReactNode;
+    className?: string;
+    muted?: boolean;
+}
+declare function Typography({ role, as, children, className, muted, }: TypographyProps): react.JSX.Element;
+
+type LabelImportance = 'primary' | 'secondary' | 'tertiary' | 'quaternary';
+
+interface LabelProps {
+    /** System label color indicating relative importance. */
+    importance?: LabelImportance;
+    /** Allow selecting/copying useful static text. */
+    selectable?: boolean;
+    children: ReactNode;
+    as?: ElementType;
+    className?: string;
+    mono?: boolean;
+}
+/**
+ * Static, non-editable text with system label colors.
+ * @see https://developer.apple.com/design/human-interface-guidelines/labels
+ */
+declare function Label({ importance, selectable, children, as: Component, className, mono, }: LabelProps): react.JSX.Element;
+
+interface DisclosureTriangleProps {
+    /** Describes what is disclosed, e.g. "Advanced options". */
+    label: string;
+    expanded?: boolean;
+    defaultExpanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+    children?: ReactNode;
+    disabled?: boolean;
+}
+/**
+ * Leading-edge disclosure triangle — right when collapsed, down when expanded.
+ * @see https://developer.apple.com/design/human-interface-guidelines/disclosure-controls
+ */
+declare function DisclosureTriangle({ label, expanded, defaultExpanded, onExpandedChange, children, disabled, }: DisclosureTriangleProps): react.JSX.Element;
+
+interface DisclosureButtonProps {
+    /** Visible label for the adjacent control region. */
+    label?: string;
+    expanded?: boolean;
+    defaultExpanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+    /** Control placed beside the disclosure button, e.g. Save As field. */
+    children: ReactNode;
+    /** Content revealed when expanded. Use only one disclosure button per view. */
+    detail?: ReactNode;
+    disabled?: boolean;
+    'aria-label'?: string;
+}
+/**
+ * Push disclosure button — down when collapsed, up when expanded (macOS Save sheet pattern).
+ * @see https://developer.apple.com/design/human-interface-guidelines/disclosure-controls
+ */
+declare function DisclosureButton({ label, expanded, defaultExpanded, onExpandedChange, children, detail, disabled, 'aria-label': ariaLabel, }: DisclosureButtonProps): react.JSX.Element;
+
+interface DisclosureGroupProps {
+    label: string;
+    expanded?: boolean;
+    defaultExpanded?: boolean;
+    onExpandedChange?: (expanded: boolean) => void;
+    children: ReactNode;
+    disabled?: boolean;
+}
+/**
+ * SwiftUI DisclosureGroup-style wrapper for progressive reveal.
+ * @see https://developer.apple.com/design/human-interface-guidelines/disclosure-controls
+ */
+declare function DisclosureGroup(props: DisclosureGroupProps): react.JSX.Element;
+interface DisclosureListItem {
+    id: string;
+    label: string;
+    children?: DisclosureListItem[];
+    content?: ReactNode;
+}
+interface DisclosureListProps {
+    items: DisclosureListItem[];
+    defaultExpandedIds?: string[];
+}
+/** Finder-style hierarchical list with disclosure triangles. */
+declare function DisclosureList({ items, defaultExpandedIds }: DisclosureListProps): react.JSX.Element;
+
+type ImageFit = 'fill' | 'contain' | 'cover' | 'scale-down' | 'none';
+type ImageBackground = 'transparent' | 'opaque';
+interface ImageFrameSequence {
+    /** URLs for each frame — use consistent dimensions for best performance. */
+    frames: string[];
+    /** Interval between frames in milliseconds. */
+    intervalMs?: number;
+}
+
+interface ImageViewProps extends Omit<ImgHTMLAttributes<HTMLImageElement>, 'src'> {
+    src?: string;
+    alt: string;
+    fit?: ImageFit;
+    objectPosition?: string;
+    background?: ImageBackground;
+    /** Animated image sequence — frames should share dimensions when possible. */
+    sequence?: ImageFrameSequence;
+    frameClassName?: string;
+    frameStyle?: CSSProperties;
+}
+/**
+ * Non-interactive image display with Apple HIG fit modes.
+ * @see https://developer.apple.com/design/human-interface-guidelines/image-views
+ */
+declare function ImageView({ src, alt, fit, objectPosition, background, sequence, className, frameClassName, frameStyle, style, ...props }: ImageViewProps): react.JSX.Element | null;
+
+interface ImageOverlayProps extends Omit<ImageViewProps, 'children'> {
+    overlay: ReactNode;
+}
+/**
+ * Image with legible text overlay — scrim improves contrast per Apple HIG.
+ * @see https://developer.apple.com/design/human-interface-guidelines/image-views
+ */
+declare function ImageOverlay({ overlay, alt, ...imageProps }: ImageOverlayProps): react.JSX.Element;
+
+interface ImageWellProps {
+    label?: string;
+    src?: string;
+    onImageChange?: (file: File | null, previewUrl: string | null) => void;
+    accept?: string;
+    placeholder?: string;
+    disabled?: boolean;
+}
+/**
+ * Editable image well — supports paste, drag-and-drop, and Delete to clear (macOS HIG).
+ * @see https://developer.apple.com/design/human-interface-guidelines/image-views
+ */
+declare function ImageWell({ label, src, onImageChange, accept, placeholder, disabled, }: ImageWellProps): react.JSX.Element;
+
+interface ImageButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    src: string;
+    alt: string;
+    imageProps?: Omit<ImgHTMLAttributes<HTMLImageElement>, 'src' | 'alt'>;
+}
+/**
+ * Clickable image — use instead of adding button behavior to a plain image view.
+ * @see https://developer.apple.com/design/human-interface-guidelines/image-views
+ */
+declare function ImageButton({ src, alt, imageProps, className, ...props }: ImageButtonProps): react.JSX.Element;
+
+interface TextViewProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'readOnly'> {
+    /** When true, shows a keyboard-capable editor. */
+    editable?: boolean;
+    /** Allows selecting/copying useful text in read-only mode. */
+    selectable?: boolean;
+    maxHeight?: string;
+    typographyRole?: TypographyRole;
+    children?: ReactNode;
+}
+/**
+ * Multiline styled text for long, editable, or specially formatted content.
+ * @see https://developer.apple.com/design/human-interface-guidelines/text-views
+ */
+declare const TextView: react.ForwardRefExoticComponent<TextViewProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+interface WebViewProps extends Omit<IframeHTMLAttributes<HTMLIFrameElement>, 'src' | 'srcDoc'> {
+    /** Remote URL to load — use for brief in-app website access, not a full browser replacement. */
+    src?: string;
+    /** Embedded HTML content, e.g. rich email bodies. */
+    html?: string;
+    title: string;
+    height?: string | number;
+    /** When true, omits outer frame styling (used inside {@link WebViewShell}). */
+    embedded?: boolean;
+    /** Restrict iframe capabilities; enabled by default for untrusted content. */
+    sandboxed?: boolean;
+    allowScripts?: boolean;
+    allowForms?: boolean;
+}
+/**
+ * Displays rich web content inside your app — not a standalone browser.
+ * @see https://developer.apple.com/design/human-interface-guidelines/web-views
+ */
+declare function WebView({ src, html, title, height, embedded, sandboxed, allowScripts, allowForms, className, style, ...props }: WebViewProps): react.JSX.Element | null;
+
+interface WebViewNavigationProps {
+    canGoBack?: boolean;
+    canGoForward?: boolean;
+    onBack?: () => void;
+    onForward?: () => void;
+    title?: string;
+    backLabel?: string;
+    forwardLabel?: string;
+}
+declare function WebViewNavigation({ canGoBack, canGoForward, onBack, onForward, title, backLabel, forwardLabel, }: WebViewNavigationProps): react.JSX.Element;
+
+interface WebViewShellProps extends WebViewProps {
+    navigation?: WebViewNavigationProps;
+    footer?: ReactNode;
+}
+/**
+ * Web view with optional back/forward navigation for multi-page in-app browsing.
+ * @see https://developer.apple.com/design/human-interface-guidelines/web-views
+ */
+declare function WebViewShell({ navigation, footer, className, ...webViewProps }: WebViewShellProps): react.JSX.Element;
+
+declare function useWebViewHistory(initialUrl: string): {
+    currentUrl: string;
+    canGoBack: boolean;
+    canGoForward: boolean;
+    navigate: (url: string) => void;
+    back: () => void;
+    forward: () => void;
+};
+
+interface WebViewHistoryState {
+    stack: string[];
+    index: number;
+    canGoBack: boolean;
+    canGoForward: boolean;
+    current: string;
+}
+
 type BadgeVariant = 'default' | 'success' | 'warning' | 'error' | 'info';
 interface BadgeProps {
     variant?: BadgeVariant;
@@ -199,16 +1102,20 @@ interface ToastInput {
     variant?: ToastVariant;
     duration?: number;
 }
-interface ToastItem extends ToastInput {
+type ToastPlacement = 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+interface ToastRecord extends ToastInput {
     id: string;
+    exiting?: boolean;
 }
+/** @internal persisted toast shape */
+type ToastItem = ToastRecord;
 interface ToastContextValue {
     toast: (input: ToastInput) => string;
     dismiss: (id: string) => void;
 }
 interface ToastProviderProps {
     children: ReactNode;
-    placement?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    placement?: ToastPlacement;
 }
 declare function ToastProvider({ children, placement, }: ToastProviderProps): react.JSX.Element;
 declare function useToast(): ToastContextValue;
@@ -238,8 +1145,89 @@ interface TabsPanelProps {
 }
 declare function TabsPanel({ value, children }: TabsPanelProps): react.JSX.Element | null;
 
-type DrawerSide = 'left' | 'right';
-interface DrawerProps {
+type SplitOrientation = 'horizontal' | 'vertical';
+type SplitCompactMode = 'side-by-side' | 'stack';
+
+interface SplitViewContextValue {
+    showPane: (id: string) => void;
+    hidePane: (id: string) => void;
+    hiddenPanes: Array<{
+        id: string;
+        label: string;
+    }>;
+}
+declare function useSplitView(): SplitViewContextValue;
+interface SplitViewPaneProps {
+    id: string;
+    label?: string;
+    children: ReactNode;
+    minSize?: number;
+    maxSize?: number;
+    defaultSize?: number;
+    collapsible?: boolean;
+    visible?: boolean;
+    defaultVisible?: boolean;
+    onVisibleChange?: (visible: boolean) => void;
+    className?: string;
+    'aria-label'?: string;
+}
+declare function SplitViewPane(_props: SplitViewPaneProps): null;
+declare namespace SplitViewPane {
+    var displayName: string;
+}
+interface SplitViewProps {
+    children: ReactNode;
+    orientation?: SplitOrientation;
+    compactMode?: SplitCompactMode;
+    storageKey?: string;
+    toolbar?: ReactNode;
+    onSizesChange?: (sizes: number[]) => void;
+    className?: string;
+    'aria-label'?: string;
+}
+declare function SplitView({ children, orientation, compactMode, storageKey, toolbar, onSizesChange, className, 'aria-label': ariaLabel, }: SplitViewProps): react.JSX.Element;
+
+interface SplitViewToolbarProps {
+    /** Optional actions rendered before pane restore buttons. */
+    actions?: ReactNode;
+}
+/** Toolbar with buttons to reveal hidden split view panes. */
+declare function SplitViewToolbar({ actions }: SplitViewToolbarProps): react.JSX.Element | null;
+
+type TabViewVariant = 'bordered' | 'borderless' | 'bezeled';
+declare const MAX_TAB_VIEW_TABS = 6;
+
+interface TabViewProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    variant?: TabViewVariant;
+    showTabs?: boolean;
+    inset?: boolean;
+    children: ReactNode;
+    className?: string;
+    'aria-label'?: string;
+}
+declare function TabView({ value, defaultValue, onValueChange, variant, showTabs, inset, children, className, 'aria-label': ariaLabel, }: TabViewProps): react.JSX.Element;
+interface TabViewListProps {
+    children: ReactNode;
+    'aria-label'?: string;
+}
+declare function TabViewList({ children, 'aria-label': listLabel }: TabViewListProps): react.JSX.Element;
+interface TabViewTabProps {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+declare function TabViewTab({ value, label, disabled }: TabViewTabProps): react.JSX.Element;
+interface TabViewPanelProps {
+    value: string;
+    children: ReactNode;
+}
+declare function TabViewPanel({ value, children }: TabViewPanelProps): react.JSX.Element | null;
+
+type DrawerSide = 'left' | 'right';
+interface DrawerProps {
     open: boolean;
     onClose: () => void;
     children: ReactNode;
@@ -258,9 +1246,716 @@ interface PopoverProps {
     defaultOpen?: boolean;
     onOpenChange?: (open: boolean) => void;
     side?: PopoverSide;
+    /** Extra class names for the floating panel element. */
+    panelClassName?: string;
+    'aria-label'?: string;
+}
+declare function Popover({ trigger, content, open, defaultOpen, onOpenChange, side, panelClassName, 'aria-label': ariaLabel, }: PopoverProps): react.JSX.Element;
+
+interface ContextMenuItemConfig {
+    type?: 'item';
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    destructive?: boolean;
+    /** Hide unavailable items instead of dimming them (HIG default). */
+    hidden?: boolean;
+    /** Clipboard commands may appear disabled when unavailable (macOS). */
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+interface ContextMenuSubmenuConfig {
+    type: 'submenu';
+    id: string;
+    label: string;
+    items: ContextMenuItemConfig[];
+}
+type ContextMenuSeparatorConfig = {
+    type: 'separator';
+    id?: string;
+};
+type ContextMenuEntry = ContextMenuItemConfig | ContextMenuSubmenuConfig | ContextMenuSeparatorConfig;
+interface ContextMenuPosition {
+    x: number;
+    y: number;
+    placement: 'above' | 'below';
+}
+
+declare const MAX_CONTEXT_MENU_GROUPS = 3;
+declare function formatContextMenuTitle(count: number, noun: string): string;
+declare function prepareContextMenuEntries(entries: ContextMenuEntry[]): ContextMenuEntry[];
+
+interface ContextMenuProps {
+    children: ReactElement;
+    entries: ContextMenuEntry[];
+    title?: string;
+    preview?: ReactNode;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onEntrySelect?: (entry: ContextMenuItemConfig) => void;
+    /** Enable long-press / touch-and-hold in addition to secondary click. */
+    longPress?: boolean;
+    dimBackground?: boolean;
+}
+/**
+ * Context menu for contextual commands on views and content.
+ * @see https://developer.apple.com/design/human-interface-guidelines/context-menus
+ */
+declare function ContextMenu({ children, entries, title, preview, open, onOpenChange, onEntrySelect, longPress, dimBackground, }: ContextMenuProps): react.JSX.Element;
+
+type QuickActionIconPlacement = 'leading' | 'trailing';
+interface QuickActionItem {
+    id: string;
+    /** Succinct action title (HIG: avoid app name or extraneous info). */
+    label: string;
+    subtitle?: string;
+    icon?: ReactNode;
+    destructive?: boolean;
+    hidden?: boolean;
+    disabled?: boolean;
+    /** System-provided actions like Remove App or Edit Home Screen. */
+    system?: boolean;
+    onSelect?: () => void;
+}
+interface QuickActionMenuPosition {
+    x: number;
+    y: number;
+}
+
+interface DockWindow {
+    id: string;
+    title: string;
+    subtitle?: string;
+}
+type DockMenuEntry = ContextMenuEntry;
+interface DockMenuPosition {
+    x: number;
+    y: number;
+}
+
+declare function buildDockMenuEntries(options: {
+    isRunning: boolean;
+    openWindows?: DockWindow[];
+    runningEntries?: ContextMenuEntry[];
+    closedEntries?: ContextMenuEntry[];
+    onWindowSelect?: (window: DockWindow) => void;
+}): ContextMenuEntry[];
+declare function resolveDockMenuPosition(anchorRect: DOMRect, menuWidth: number, menuHeight: number, viewportWidth?: number): DockMenuPosition;
+declare function quickActionsToEntries(actions: QuickActionItem[]): ContextMenuEntry[];
+
+interface DockMenuProps {
+    appName: string;
+    icon: ReactNode;
+    /** Whether the app is currently running (shows window list + running actions). */
+    isRunning?: boolean;
+    openWindows?: DockWindow[];
+    /** High-value actions when the app is running (e.g. New Window, Get New Mail). */
+    runningEntries?: ContextMenuEntry[];
+    /** Actions when the app is not running (e.g. Open). */
+    closedEntries?: ContextMenuEntry[];
+    onWindowSelect?: (window: DockWindow) => void;
+    onEntrySelect?: (entry: ContextMenuItemConfig) => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+/**
+ * macOS Dock menu — secondary-click an app icon for open windows and high-value actions.
+ * @see https://developer.apple.com/design/human-interface-guidelines/dock-menus
+ */
+declare function DockMenu({ appName, icon, isRunning, openWindows, runningEntries, closedEntries, onWindowSelect, onEntrySelect, open, onOpenChange, }: DockMenuProps): react.JSX.Element;
+interface DockBarProps {
+    children: ReactNode;
+    'aria-label'?: string;
+}
+/** Visual dock strip for grouping app icons in demos. */
+declare function DockBar({ children, 'aria-label': ariaLabel }: DockBarProps): react.JSX.Element;
+
+interface HomeScreenQuickActionsProps {
+    appName: string;
+    icon: ReactNode;
+    actions: QuickActionItem[];
+    /** Icon appears on leading or trailing edge depending on Home Screen position. */
+    iconPlacement?: QuickActionIconPlacement;
+    includeSystemActions?: boolean;
+    systemActions?: QuickActionItem[];
+    onActionSelect?: (action: QuickActionItem) => void;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+/**
+ * iOS/iPadOS Home Screen quick actions — touch and hold an app icon for high-value tasks.
+ * @see https://developer.apple.com/design/human-interface-guidelines/home-screen-quick-actions
+ */
+declare function HomeScreenQuickActions({ appName, icon, actions, iconPlacement, includeSystemActions, systemActions, onActionSelect, open, onOpenChange, }: HomeScreenQuickActionsProps): react.JSX.Element;
+
+declare const DEFAULT_SYSTEM_QUICK_ACTIONS: QuickActionItem[];
+
+declare function prepareQuickActions(actions: QuickActionItem[], options?: {
+    includeSystemActions?: boolean;
+    systemActions?: QuickActionItem[];
+}): QuickActionItem[];
+declare function resolveQuickActionMenuPosition(anchorRect: DOMRect, menuWidth: number, menuHeight: number, viewportWidth?: number): QuickActionMenuPosition;
+
+type MenuLayout = 'small' | 'medium' | 'large';
+interface MenuItemConfig {
+    type?: 'item';
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    /** Label shown when Option (Alt) is held — dynamic menu bar item. */
+    alternateLabel?: string;
+    alternateShortcut?: string;
+    destructive?: boolean;
+    hidden?: boolean;
+    disabled?: boolean;
+    /** Shows a checkmark for toggled/selected state. */
+    selected?: boolean;
+    onSelect?: () => void;
+}
+interface MenuSubmenuConfig {
+    type: 'submenu';
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    shortcut?: string;
+    disabled?: boolean;
+    hidden?: boolean;
+    items: MenuItemConfig[];
+}
+type MenuSeparatorConfig = {
+    type: 'separator';
+    id?: string;
+};
+type MenuEntry = MenuItemConfig | MenuSubmenuConfig | MenuSeparatorConfig;
+
+declare const MAX_SUBMENU_ITEMS = 5;
+declare function prepareMenuEntries(entries: MenuEntry[]): MenuEntry[];
+declare function splitCompactAndList(entries: MenuEntry[], layout: MenuLayout): {
+    compact: MenuItemConfig[];
+    list: MenuEntry[];
+};
+
+interface MenuProps {
+    children?: ReactElement;
+    entries: MenuEntry[];
+    layout?: MenuLayout;
+    title?: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onEntrySelect?: (entry: MenuItemConfig) => boolean | void;
+    dimBackground?: boolean;
+}
+/**
+ * General-purpose menu with small, medium, and large iOS/iPadOS layouts.
+ * @see https://developer.apple.com/design/human-interface-guidelines/menus
+ */
+declare function Menu({ children, entries, layout, title, open, onOpenChange, onEntrySelect, dimBackground, }: MenuProps): react.JSX.Element;
+
+type OrnamentEdge = 'top' | 'bottom' | 'leading' | 'trailing';
+type OrnamentVisibility = 'visible' | 'hidden' | 'automatic';
+type OrnamentContentAlignment = 'center' | 'leading' | 'trailing';
+interface OrnamentConfig {
+    id: string;
+    content: ReactNode;
+    edge?: OrnamentEdge;
+    alignment?: OrnamentContentAlignment;
+    /** Hide during immersive content (video, photo). */
+    autoHideImmersive?: boolean;
+}
+
+declare function resolveOrnamentVisibility(visibility: OrnamentVisibility, immersive: boolean): boolean;
+declare function clampOrnamentWidth(windowWidth: number, ornamentWidth: number): number;
+declare function warnIfTooManyOrnaments(ornaments: OrnamentConfig[]): void;
+
+interface OrnamentWindowProps {
+    children: ReactNode;
+    /** Single ornament content (shortcut for one bottom ornament). */
+    ornament?: ReactNode;
+    edge?: OrnamentEdge;
+    alignment?: OrnamentContentAlignment;
+    visibility?: OrnamentVisibility;
+    /** When true, automatic visibility hides ornaments (e.g. full-screen media). */
+    immersive?: boolean;
+    ornaments?: OrnamentConfig[];
+    className?: string;
+    'aria-label'?: string;
+}
+interface OrnamentProps {
+    children: ReactNode;
+    className?: string;
+}
+interface OrnamentButtonProps extends React.ButtonHTMLAttributes<HTMLButtonElement> {
+    active?: boolean;
+}
+/**
+ * visionOS ornament — floating glass controls parallel to a window edge.
+ * @see https://developer.apple.com/design/human-interface-guidelines/ornaments
+ */
+declare function OrnamentWindow({ children, ornament, edge, alignment, visibility, immersive, ornaments, className, 'aria-label': ariaLabel, }: OrnamentWindowProps): react.JSX.Element;
+/** Glass ornament container for custom controls. */
+declare function Ornament({ children, className }: OrnamentProps): react.JSX.Element;
+/** Borderless button styled for ornament glass backgrounds. */
+declare function OrnamentButton({ active, className, children, ...rest }: OrnamentButtonProps): react.JSX.Element;
+
+interface PopUpOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface PopUpCustomOption {
+    value: string;
+    label: string;
+    onSelect?: () => void;
+}
+
+declare function resolvePopUpLabel(options: PopUpOption[], value: string | undefined, placeholder: string): string;
+declare function resolveDefaultValue(options: PopUpOption[], defaultValue?: string): string | undefined;
+declare function buildPopUpMenuEntries(options: PopUpOption[], value: string | undefined, customOption?: PopUpCustomOption): MenuEntry[];
+
+interface PopUpButtonProps {
+    /** Introductory label describing the control (Calendar-style). */
+    label?: string;
+    options: PopUpOption[];
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    customOption?: PopUpCustomOption;
+    /** Optional explanatory text below the control. */
+    explanatoryText?: string;
+    disabled?: boolean;
+    id?: string;
+}
+/**
+ * Pop-up button — flat list of mutually exclusive options in a menu.
+ * @see https://developer.apple.com/design/human-interface-guidelines/pop-up-buttons
+ */
+declare function PopUpButton({ label, options, value, defaultValue, onValueChange, placeholder, customOption, explanatoryText, disabled, id, }: PopUpButtonProps): react.JSX.Element;
+
+declare const MIN_PULLDOWN_ITEMS = 3;
+declare function countPullDownActions(entries: MenuEntry[]): number;
+declare function warnIfTooFewPullDownItems(entries: MenuEntry[]): void;
+declare function defaultDestructiveConfirmation(label: string): {
+    title: string;
+    description: string;
+    confirmLabel: string;
+};
+
+type PullDownEntry = MenuEntry;
+type PullDownButtonVariant = 'default' | 'more';
+interface PullDownDestructiveConfirmation {
+    title?: string;
+    description?: string;
+    confirmLabel?: string;
+    cancelLabel?: string;
+}
+interface PullDownButtonProps {
+    /** Button label (required unless variant is "more"). */
+    label?: string;
+    entries: PullDownEntry[];
+    variant?: PullDownButtonVariant;
+    /** Optional menu title — use only when it adds meaning. */
+    menuTitle?: string;
+    onAction?: (entry: MenuItemConfig) => void;
+    destructiveConfirmation?: PullDownDestructiveConfirmation;
+    disabled?: boolean;
+    /** Safari-style touch-and-hold to reveal the menu. */
+    longPress?: boolean;
+    icon?: ReactNode;
+}
+/**
+ * Pull-down button — menu of commands related to the button’s action.
+ * @see https://developer.apple.com/design/human-interface-guidelines/pull-down-buttons
+ */
+declare function PullDownButton({ label, entries, variant, menuTitle, onAction, destructiveConfirmation, disabled, longPress, icon, }: PullDownButtonProps): react.JSX.Element;
+/** Notes-style More pull-down button. */
+declare function MorePullDownButton(props: Omit<PullDownButtonProps, 'variant' | 'label'> & {
+    'aria-label'?: string;
+}): react.JSX.Element;
+
+type MenuBarPlatform = 'macos' | 'ipados';
+interface MenuBarMenuConfig {
+    id: string;
+    title: string;
+    entries: MenuEntry[];
+    /** App menu title appears bold on macOS. */
+    emphasized?: boolean;
+    /** Optional icon or symbol shown instead of the title (e.g. Apple menu). */
+    trigger?: ReactNode;
+    /** Accessible name when `trigger` replaces visible title text. */
+    ariaLabel?: string;
+}
+interface MenuBarExtraConfig {
+    id: string;
+    label: string;
+    icon: ReactNode;
+    entries: MenuEntry[];
+}
+interface MenuBarDocumentContext {
+    isDocumentOpen?: boolean;
+    isDirty?: boolean;
+    hasTabs?: boolean;
+    toolbarVisible?: boolean;
+    sidebarVisible?: boolean;
+    isFullScreen?: boolean;
+    canUndo?: boolean;
+    canRedo?: boolean;
+    hasSelection?: boolean;
+    canPaste?: boolean;
+    undoLabel?: string;
+    redoLabel?: string;
+}
+interface StandardMenuBarHandlers {
+    about?: () => void;
+    settings?: () => void;
+    quit?: () => void;
+    new?: () => void;
+    open?: () => void;
+    close?: () => void;
+    save?: () => void;
+    undo?: () => void;
+    redo?: () => void;
+    cut?: () => void;
+    copy?: () => void;
+    paste?: () => void;
+    delete?: () => void;
+    selectAll?: () => void;
+    help?: () => void;
+    feedback?: () => void;
+    minimize?: () => void;
+    zoom?: () => void;
+    toggleToolbar?: () => void;
+    toggleSidebar?: () => void;
+    toggleFullScreen?: () => void;
+}
+interface StandardMenuBarOptions {
+    appName: string;
+    platform?: MenuBarPlatform;
+    context?: MenuBarDocumentContext;
+    handlers?: Partial<StandardMenuBarHandlers>;
+    appSpecificMenus?: MenuBarMenuConfig[];
+    openWindows?: string[];
+    recentDocuments?: string[];
+}
+interface MenuBarProps {
+    appName: string;
+    menus?: MenuBarMenuConfig[];
+    /** Used when `menus` is omitted to build the standard HIG menu set. */
+    standardOptions?: StandardMenuBarOptions;
+    appSpecificMenus?: MenuBarMenuConfig[];
+    extras?: MenuBarExtraConfig[];
+    platform?: MenuBarPlatform;
+    /** iPadOS: bar hidden until revealed at the top edge. */
+    revealed?: boolean;
+    onRevealChange?: (revealed: boolean) => void;
+    /** macOS: show a read-only Apple menu stub (system-provided on real macOS). */
+    showAppleMenu?: boolean;
+    className?: string;
+    onMenuAction?: (menuId: string, entryId: string) => void;
+}
+
+/**
+ * macOS and iPadOS menu bar with standard menu ordering and dynamic Option-key items.
+ * @see https://developer.apple.com/design/human-interface-guidelines/the-menu-bar
+ */
+declare function MenuBar({ appName, menus: menusProp, standardOptions, appSpecificMenus, extras, platform, revealed, onRevealChange, showAppleMenu, className, onMenuAction, }: MenuBarProps): react.JSX.Element;
+
+interface MenuBarExtraProps extends MenuBarExtraConfig {
+    isOpen: boolean;
+    onOpenChange: (open: boolean) => void;
+    optionKey: boolean;
+    onAction?: (entry: MenuItemConfig) => void;
+}
+/**
+ * Trailing menu bar extra — exposes app functionality via an icon and menu (not a popover).
+ * @see https://developer.apple.com/design/human-interface-guidelines/the-menu-bar#Menu-bar-extras
+ */
+declare function MenuBarExtra({ id, label, icon, entries, isOpen, onOpenChange, optionKey, onAction, }: MenuBarExtraProps): react.JSX.Element;
+
+declare const STANDARD_MENU_SLOTS: readonly ["app", "file", "edit", "format", "view", "window", "help"];
+declare function resolveDynamicMenuEntries(entries: MenuEntry[], modifiers: {
+    optionKey: boolean;
+}): MenuEntry[];
+declare function validateMenuBarOrder(menus: MenuBarMenuConfig[]): void;
+declare function buildStandardMenuBar(options: StandardMenuBarOptions): MenuBarMenuConfig[];
+declare function createAppleMenuStub(): MenuEntry[];
+declare function resolveMenuBarAlignment(platform: MenuBarPlatform): 'start' | 'center';
+
+declare const STANDARD_SHORTCUTS: {
+    readonly new: "⌘N";
+    readonly open: "⌘O";
+    readonly close: "⌘W";
+    readonly save: "⌘S";
+    readonly saveAll: "⇧⌘S";
+    readonly undo: "⌘Z";
+    readonly redo: "⇧⌘Z";
+    readonly cut: "⌘X";
+    readonly copy: "⌘C";
+    readonly paste: "⌘V";
+    readonly selectAll: "⌘A";
+    readonly find: "⌘F";
+    readonly settings: "⌘,";
+    readonly quit: "⌘Q";
+    readonly minimize: "⌘M";
+    readonly help: "⌘?";
+};
+declare function createAppMenu(appName: string, platform: MenuBarPlatform, handlers: {
+    onAbout?: () => void;
+    onSettings?: () => void;
+    onQuit?: () => void;
+}): MenuEntry[];
+declare function createFileMenu(context: MenuBarDocumentContext, handlers: {
+    onNew?: () => void;
+    onOpen?: () => void;
+    onClose?: () => void;
+    onSave?: () => void;
+}, recentDocuments?: string[]): MenuEntry[];
+declare function createEditMenu(context: MenuBarDocumentContext, handlers: {
+    onUndo?: () => void;
+    onRedo?: () => void;
+    onCut?: () => void;
+    onCopy?: () => void;
+    onPaste?: () => void;
+    onDelete?: () => void;
+    onSelectAll?: () => void;
+}): MenuEntry[];
+declare function createFormatMenu(): MenuEntry[];
+declare function createViewMenu(context: MenuBarDocumentContext, handlers: {
+    onToggleToolbar?: () => void;
+    onToggleSidebar?: () => void;
+    onToggleFullScreen?: () => void;
+}): MenuEntry[];
+declare function createWindowMenu(context: MenuBarDocumentContext, openWindows: string[], handlers: {
+    onMinimize?: () => void;
+    onZoom?: () => void;
+    onToggleFullScreen?: () => void;
+}): MenuEntry[];
+declare function createHelpMenu(appName: string, handlers: {
+    onHelp?: () => void;
+    onFeedback?: () => void;
+}): MenuEntry[];
+
+type ToolbarPlatform = 'ios' | 'ipados' | 'macos' | 'visionos' | 'watchos';
+type ToolbarPlacement = 'top' | 'bottom';
+type ToolbarSectionPlacement = 'leading' | 'center' | 'trailing';
+interface ToolbarAction {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    showLabel?: boolean;
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+interface ToolbarProps {
+    /** Concise view title — aim for under 15 characters. */
+    title?: string;
+    platform?: ToolbarPlatform;
+    /** iOS large title that collapses when scrolling. */
+    largeTitle?: boolean;
+    /** visionOS and watchOS placement. */
+    placement?: ToolbarPlacement;
+    /** Hide toolbar for distraction-free experience. */
+    hidden?: boolean;
+    className?: string;
+    children?: ReactNode;
+    'aria-label'?: string;
+}
+interface ToolbarSectionProps {
+    placement: ToolbarSectionPlacement;
+    /** Center items collapse into the system overflow menu when space is tight. */
+    collapsible?: boolean;
+    className?: string;
+    children?: ReactNode;
+}
+interface ToolbarItemProps {
+    id?: string;
+    label: string;
+    icon?: ReactNode;
+    showLabel?: boolean;
+    prominent?: boolean;
+    disabled?: boolean;
+    onClick?: () => void;
+    collapsible?: boolean;
+    className?: string;
+}
+interface ToolbarGroupProps {
+    className?: string;
+    children?: ReactNode;
+}
+interface ToolbarTitleProps {
+    children: string;
+    large?: boolean;
+    className?: string;
+}
+interface ToolbarSearchProps {
+    value?: string;
+    placeholder?: string;
+    onChange?: (value: string) => void;
+    'aria-label'?: string;
+    className?: string;
+}
+interface ToolbarMoreButtonProps {
+    entries: MenuEntry[];
     'aria-label'?: string;
+    onAction?: (entryId: string) => void;
+    disabled?: boolean;
+}
+interface ToolbarDocumentMenuProps {
+    entries: MenuEntry[];
+    label?: string;
+    onAction?: (entryId: string) => void;
+    disabled?: boolean;
+}
+interface ToolbarProminentButtonProps {
+    children: string;
+    onClick?: () => void;
+    disabled?: boolean;
+    className?: string;
+}
+interface ToolbarBackButtonProps {
+    onClick?: () => void;
+    disabled?: boolean;
+    /** visionOS reveals label on look — optional visible companion text. */
+    companionLabel?: string;
+}
+interface ToolbarCloseButtonProps {
+    onClick?: () => void;
+    disabled?: boolean;
+}
+
+declare function ToolbarFixedSpace(): react.JSX.Element;
+declare function ToolbarGroup({ children, className }: ToolbarGroupProps): react.JSX.Element;
+declare function ToolbarTitle({ children, large, className }: ToolbarTitleProps): react.JSX.Element;
+declare function ToolbarItem({ label, icon, showLabel, prominent, disabled, onClick, className, }: ToolbarItemProps): react.JSX.Element;
+declare function ToolbarBackButton({ onClick, disabled, companionLabel }: ToolbarBackButtonProps): react.JSX.Element;
+declare function ToolbarCloseButton({ onClick, disabled }: ToolbarCloseButtonProps): react.JSX.Element;
+declare function ToolbarSearch({ value, placeholder, onChange, 'aria-label': ariaLabel, className, }: ToolbarSearchProps): react.JSX.Element;
+declare function ToolbarProminentButton({ children, onClick, disabled, className, }: ToolbarProminentButtonProps): react.JSX.Element;
+declare function ToolbarMoreButton({ entries, 'aria-label': ariaLabel, onAction, disabled, }: ToolbarMoreButtonProps): react.JSX.Element;
+declare function ToolbarDocumentMenu({ entries, label, onAction, disabled, }: ToolbarDocumentMenuProps): react.JSX.Element;
+declare function ToolbarSection({ placement, collapsible, children, className }: ToolbarSectionProps): react.JSX.Element;
+/**
+ * Toolbar — navigation, titles, search, and frequent actions along an edge of the view.
+ * @see https://developer.apple.com/design/human-interface-guidelines/toolbars
+ */
+declare function Toolbar({ title, platform, largeTitle, placement, hidden, className, children, 'aria-label': ariaLabel, }: ToolbarProps): react.JSX.Element;
+declare namespace Toolbar {
+    var Leading: (props: Omit<ToolbarSectionProps, "placement">) => react.JSX.Element;
+    var Center: (props: Omit<ToolbarSectionProps, "placement">) => react.JSX.Element;
+    var Trailing: (props: Omit<ToolbarSectionProps, "placement">) => react.JSX.Element;
+    var Item: typeof ToolbarItem;
+    var Group: typeof ToolbarGroup;
+    var Title: typeof ToolbarTitle;
+    var Back: typeof ToolbarBackButton;
+    var Close: typeof ToolbarCloseButton;
+    var Search: typeof ToolbarSearch;
+    var More: typeof ToolbarMoreButton;
+    var DocumentMenu: typeof ToolbarDocumentMenu;
+    var Prominent: typeof ToolbarProminentButton;
+    var Spacer: typeof ToolbarFixedSpace;
+}
+
+declare const MAX_TOOLBAR_TITLE_LENGTH = 15;
+declare const MAX_TOOLBAR_GROUPS = 3;
+declare function warnIfToolbarTitleTooLong(title: string): void;
+declare function warnIfTooManyToolbarGroups(groupCount: number): void;
+declare function warnIfMixedLabelStyles(hasTextButton: boolean, hasSymbolButton: boolean): void;
+declare function computeVisibleToolbarItemCount(containerWidth: number, itemWidths: number[], options?: {
+    overflowButtonWidth?: number;
+    gap?: number;
+}): number;
+declare function toolbarActionsFromEntries(entries: MenuEntry[]): ToolbarAction[];
+declare function entriesFromToolbarActions(actions: ToolbarAction[]): MenuEntry[];
+declare function resolveToolbarPlacement(platform: 'ios' | 'ipados' | 'macos' | 'visionos' | 'watchos', placement?: 'top' | 'bottom'): 'top' | 'bottom';
+declare function shouldUseSystemOverflow(platform: 'ios' | 'ipados' | 'macos' | 'visionos' | 'watchos'): boolean;
+declare function truncateToolbarTitle(title: string, maxLength?: number): string;
+
+declare function BackChevronIcon(): react.JSX.Element;
+declare function CloseIcon(): react.JSX.Element;
+declare function ComposeIcon(): react.JSX.Element;
+declare function ShareIcon(): react.JSX.Element;
+declare function SidebarIcon(): react.JSX.Element;
+declare function DocumentMenuIcon(): react.JSX.Element;
+declare function SearchIcon(): react.JSX.Element;
+declare function OverflowIcon(): react.JSX.Element;
+
+/** Standard UIResponder-style edit actions. */
+type StandardEditActionId = 'cut' | 'copy' | 'paste' | 'select' | 'selectAll' | 'delete' | 'translate' | 'lookUp';
+type EditMenuVariant = 'compact' | 'context' | 'auto';
+type EditMenuInputMode = 'touch' | 'pointer' | 'auto';
+type EditMenuContentType = 'text' | 'image' | 'address' | 'link' | 'file';
+interface EditMenuContext {
+    /** Whether content is currently selected. */
+    hasSelection: boolean;
+    /** Whether pasteboard content can be pasted. */
+    canPaste: boolean;
+    /** Whether the target supports editing (cut/delete). */
+    isEditable?: boolean;
+    /** Allow copying noneditable static text (captions, labels excluded). */
+    allowsCopy?: boolean;
+    contentType?: EditMenuContentType;
+}
+interface EditMenuItemConfig {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+    /** Group with standard clipboard, selection, intelligence, or format commands. */
+    group?: 'clipboard' | 'selection' | 'intelligence' | 'format' | 'other';
+    destructive?: boolean;
+    hidden?: boolean;
+    disabled?: boolean;
+    onSelect?: () => void;
+}
+interface EditMenuPosition {
+    x: number;
+    y: number;
+    placement: 'above' | 'below';
+    /** Horizontal offset for the pointer relative to menu left edge. */
+    pointerOffset: number;
 }
-declare function Popover({ trigger, content, open, defaultOpen, onOpenChange, side, 'aria-label': ariaLabel, }: PopoverProps): react.JSX.Element;
+interface EditMenuResolvedAction extends EditMenuItemConfig {
+    standard?: boolean;
+}
+
+declare function resolveEditMenuVariant(variant: EditMenuVariant, inputMode: EditMenuInputMode, pointerType?: string): 'compact' | 'context';
+declare function isStandardActionAvailable(id: StandardEditActionId, context: EditMenuContext): boolean;
+declare function buildEditMenuActions(context: EditMenuContext, customActions?: EditMenuItemConfig[], options?: {
+    includeStandard?: boolean;
+    onStandardAction?: (id: StandardEditActionId) => void;
+}): EditMenuResolvedAction[];
+declare function filterVisibleEditMenuActions(actions: EditMenuResolvedAction[]): EditMenuResolvedAction[];
+declare function resolveEditMenuPosition(anchorRect: DOMRect, menuWidth: number, menuHeight: number, preferredPlacement?: 'above' | 'below' | 'auto', viewportHeight?: number, viewportWidth?: number): EditMenuPosition;
+
+interface EditMenuProps {
+    children: ReactElement;
+    context: EditMenuContext;
+    /** Custom commands listed near related system-provided ones. */
+    customActions?: EditMenuItemConfig[];
+    /** Include standard Cut, Copy, Paste, etc. Defaults to true. */
+    includeStandardActions?: boolean;
+    variant?: EditMenuVariant;
+    inputMode?: EditMenuInputMode;
+    placement?: 'above' | 'below' | 'auto';
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onAction?: (actionId: string) => void;
+    onStandardAction?: (actionId: StandardEditActionId) => void;
+    /** Touch-and-hold / long-press to reveal compact edit menu. */
+    longPress?: boolean;
+    dimBackground?: boolean;
+}
+/**
+ * Edit menu for changing selected content — compact horizontal bar or vertical context menu.
+ * @see https://developer.apple.com/design/human-interface-guidelines/edit-menus
+ */
+declare function EditMenu({ children, context, customActions, includeStandardActions, variant, inputMode, placement, open, onOpenChange, onAction, onStandardAction, longPress, dimBackground, }: EditMenuProps): react.JSX.Element;
+/** Read-only selectable text region for edit menu demos. */
+declare function EditMenuSelection({ children, selected, className, ...rest }: {
+    children: ReactNode;
+    selected?: boolean;
+    className?: string;
+} & React.HTMLAttributes<HTMLDivElement>): react.JSX.Element;
 
 interface BreadcrumbItem {
     label: string;
@@ -333,6 +2028,122 @@ interface DataTableProps<T> {
 }
 declare function DataTable<T>({ data, columns, keyExtractor, caption, 'aria-label': ariaLabel, loading, emptyTitle, emptyDescription, emptyMessage, striped, skeletonRows, className, }: DataTableProps<T>): react.JSX.Element;
 
+type ListVariant = 'plain' | 'grouped';
+type ListAccessory = 'none' | 'disclosure' | 'info' | 'checkmark';
+type TableSelectionMode = 'none' | 'navigation' | 'options';
+type SortDirection = 'asc' | 'desc';
+interface OutlineNode {
+    id: string;
+    label: string;
+    values?: Record<string, string>;
+    children?: OutlineNode[];
+}
+interface OutlineColumn {
+    key: string;
+    header: string;
+    sortable?: boolean;
+    width?: number;
+}
+
+interface ListProps {
+    variant?: ListVariant;
+    children: ReactNode;
+    className?: string;
+    'aria-label'?: string;
+}
+declare function List({ variant, children, className, 'aria-label': ariaLabel, }: ListProps): react.JSX.Element;
+
+interface ListSectionProps {
+    header?: string;
+    footer?: string;
+    children: ReactNode;
+}
+declare function ListSection({ header, footer, children }: ListSectionProps): react.JSX.Element;
+
+interface ListRowProps {
+    title: string;
+    subtitle?: string;
+    leading?: ReactNode;
+    accessory?: ListAccessory;
+    selected?: boolean;
+    disabled?: boolean;
+    truncate?: 'end' | 'middle';
+    onPress?: () => void;
+    onInfo?: (event: MouseEvent<HTMLButtonElement>) => void;
+}
+declare function ListRow({ title, subtitle, leading, accessory, selected, disabled, truncate, onPress, onInfo, }: ListRowProps): react.JSX.Element;
+
+interface TableColumn<T> {
+    key: string;
+    header: string;
+    render: (row: T) => ReactNode;
+    sortValue?: (row: T) => string;
+    sortable?: boolean;
+    width?: number;
+}
+interface TableProps<T> {
+    data: T[];
+    columns: TableColumn<T>[];
+    keyExtractor: (row: T) => string;
+    caption?: string;
+    'aria-label'?: string;
+    selectionMode?: TableSelectionMode;
+    selectedKey?: string;
+    onSelectRow?: (row: T) => void;
+    defaultSortKey?: string;
+    defaultSortDirection?: SortDirection;
+    alternatingRows?: boolean;
+    resizableColumns?: boolean;
+}
+declare function Table<T>({ data, columns, keyExtractor, caption, 'aria-label': ariaLabel, selectionMode, selectedKey, onSelectRow, defaultSortKey, defaultSortDirection, alternatingRows, resizableColumns, }: TableProps<T>): react.JSX.Element;
+
+interface OutlineViewProps {
+    data: OutlineNode[];
+    primaryColumnHeader?: string;
+    columns?: Array<string | OutlineColumn>;
+    defaultExpandedIds?: string[];
+    expandedIds?: string[];
+    onExpandedChange?: (expandedIds: string[]) => void;
+    /** Persist expansion state across sessions (localStorage). */
+    storageKey?: string;
+    selectedId?: string;
+    onSelect?: (node: OutlineNode) => void;
+    onRowDoubleClick?: (node: OutlineNode) => void;
+    sortable?: boolean;
+    defaultSortKey?: string;
+    defaultSortDirection?: SortDirection;
+    resizableColumns?: boolean;
+    alternatingRows?: boolean;
+    truncate?: 'middle' | 'end';
+    editableColumns?: string[];
+    onCellEdit?: (nodeId: string, columnKey: string, value: string) => void;
+    searchQuery?: string;
+    'aria-label'?: string;
+}
+declare function OutlineView({ data, primaryColumnHeader, columns, defaultExpandedIds, expandedIds, onExpandedChange, storageKey, selectedId, onSelect, onRowDoubleClick, sortable, defaultSortKey, defaultSortDirection, resizableColumns, alternatingRows, truncate, editableColumns, onCellEdit, searchQuery, 'aria-label': ariaLabel, }: OutlineViewProps): react.JSX.Element;
+
+interface OutlineViewToolbarProps {
+    searchQuery: string;
+    onSearchChange: (query: string) => void;
+    placeholder?: string;
+    'aria-label'?: string;
+}
+/** Toolbar search field for lengthy outline views. */
+declare function OutlineViewToolbar({ searchQuery, onSearchChange, placeholder, 'aria-label': ariaLabel, }: OutlineViewToolbarProps): react.JSX.Element;
+
+declare function formatColumnHeader(header: string): string;
+declare function truncateMiddle(text: string, maxLength?: number): string;
+declare function sortRows<T>(rows: T[], accessor: (row: T) => string, direction: SortDirection): T[];
+declare function flattenOutline(nodes: OutlineNode[], expanded: Set<string>, depth?: number): Array<{
+    node: OutlineNode;
+    depth: number;
+}>;
+declare function sortOutlineNodes(nodes: OutlineNode[], sortKey: string, direction: SortDirection): OutlineNode[];
+/** IDs of a node and every expandable descendant (Option-click expand all). */
+declare function collectExpandableSubtree(node: OutlineNode): string[];
+declare function filterOutline(nodes: OutlineNode[], query: string): OutlineNode[];
+declare function normalizeOutlineColumns(columns: Array<string | OutlineColumn> | undefined): OutlineColumn[];
+
 interface FileUploadProps {
     label?: string;
     hint?: string;
@@ -346,16 +2157,192 @@ interface FileUploadProps {
 }
 declare function FileUpload({ label, hint, error, accept, multiple, disabled, buttonLabel, onFilesChange, className, }: FileUploadProps): react.JSX.Element;
 
+interface DocumentToolbarProps {
+    onNew?: () => void;
+    onOpen?: () => void;
+    onSave?: () => void;
+    newLabel?: string;
+    openLabel?: string;
+    saveLabel?: string;
+    canSave?: boolean;
+    showAddButton?: boolean;
+}
+/**
+ * New, Open, and Save actions for document-based apps.
+ * @see https://developer.apple.com/design/human-interface-guidelines/file-management
+ */
+declare function DocumentToolbar({ onNew, onOpen, onSave, newLabel, openLabel, saveLabel, canSave, showAddButton, }: DocumentToolbarProps): react.JSX.Element;
+
+type FileSyncStatus = 'synced' | 'syncing' | 'error' | 'offline';
+type FileLocation = 'local' | 'remote' | 'icloud';
+type FileBrowserTab = 'recents' | 'shared' | 'browse';
+interface FileBrowserItem {
+    id: string;
+    name: string;
+    extension?: string;
+    size?: number;
+    modifiedAt?: Date | string;
+    location?: FileLocation;
+    syncStatus?: FileSyncStatus;
+    thumbnailUrl?: string;
+    /** MIME type or category used for filtering (e.g. pdf, image). */
+    type?: string;
+    shared?: boolean;
+}
+interface FilePreviewSource {
+    name: string;
+    url?: string;
+    textContent?: string;
+    type?: string;
+    extension?: string;
+}
+
+interface FileBrowserProps {
+    files: FileBrowserItem[];
+    activeTab?: FileBrowserTab;
+    onTabChange?: (tab: FileBrowserTab) => void;
+    showExtensions?: boolean;
+    onShowExtensionsChange?: (show: boolean) => void;
+    selectedId?: string;
+    onSelect?: (file: FileBrowserItem) => void;
+    onOpen?: (file: FileBrowserItem) => void;
+    acceptTypes?: string[];
+    emptyLabel?: string;
+    toolbar?: ReactNode;
+}
+declare function FileBrowser({ files, activeTab, onTabChange, showExtensions, onShowExtensionsChange, selectedId, onSelect, onOpen, acceptTypes, emptyLabel, toolbar, }: FileBrowserProps): react.JSX.Element;
+
+interface FilePreviewProps {
+    source: FilePreviewSource;
+    onClose?: () => void;
+    closeLabel?: string;
+}
+/**
+ * Quick Look-style preview for supported file types.
+ * @see https://developer.apple.com/design/human-interface-guidelines/file-management
+ */
+declare function FilePreview({ source, onClose, closeLabel }: FilePreviewProps): react.JSX.Element;
+
+interface UnsavedIndicatorProps {
+    title: string;
+    edited?: boolean;
+    /** When false, show the unsaved dot (manual save mode). */
+    autosaveEnabled?: boolean;
+}
+/**
+ * Shows unsaved-change feedback per Apple HIG autosave guidance.
+ * @see https://developer.apple.com/design/human-interface-guidelines/file-management
+ */
+declare function UnsavedIndicator({ title, edited, autosaveEnabled, }: UnsavedIndicatorProps): react.JSX.Element;
+
+interface DocumentLauncherProps extends Omit<FileBrowserProps, 'toolbar'> {
+    appTitle: string;
+    primaryActionLabel?: string;
+    secondaryActionLabel?: string;
+    onPrimaryAction?: () => void;
+    onSecondaryAction?: () => void;
+    background?: ReactNode;
+    accessories?: ReactNode;
+}
+/**
+ * Document launcher pattern: hero title card + file browser sheet.
+ * @see https://developer.apple.com/design/human-interface-guidelines/file-management
+ */
+declare function DocumentLauncher({ appTitle, primaryActionLabel, secondaryActionLabel, onPrimaryAction, onSecondaryAction, background, accessories, ...browserProps }: DocumentLauncherProps): react.JSX.Element;
+
+declare function formatDisplayName(name: string, showExtensions: boolean): string;
+declare function formatFileSize(bytes?: number): string;
+declare function formatFileDate(value?: Date | string): string;
+declare function filterFilesByType(items: FileBrowserItem[], acceptTypes?: string[]): FileBrowserItem[];
+declare function documentTitleWithEditedSuffix(title: string, edited: boolean, autosaveEnabled: boolean): string;
+declare function canPreviewFile(source: {
+    type?: string;
+    extension?: string;
+    url?: string;
+    textContent?: string;
+}): boolean;
+
+type SearchFieldPlacement = 'toolbar-trailing' | 'sidebar-top' | 'inline' | 'tab-dedicated' | 'bottom-toolbar';
+type SearchFieldPlatform = 'ios' | 'ipados' | 'macos' | 'tvos' | 'visionos' | 'watchos';
+interface SearchToken {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+}
+interface SearchScopeOption {
+    id: string;
+    label: string;
+}
+interface SearchFieldProps {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    onSearch?: (value: string) => void;
+    placeholder?: string;
+    platform?: SearchFieldPlatform;
+    placement?: SearchFieldPlacement;
+    /** Search while typing (default true). */
+    immediate?: boolean;
+    suggestions?: string[];
+    recentSearches?: string[];
+    scope?: {
+        options: SearchScopeOption[];
+        value: string;
+        onChange: (scopeId: string) => void;
+    };
+    tokens?: SearchToken[];
+    onTokenRemove?: (tokenId: string) => void;
+    onTokenSelect?: (tokenId: string) => void;
+    showDictation?: boolean;
+    autoFocus?: boolean;
+    className?: string;
+    'aria-label'?: string;
+}
+interface SearchScopeBarProps {
+    options: SearchScopeOption[];
+    value: string;
+    onChange: (scopeId: string) => void;
+    className?: string;
+}
+interface SearchTokenChipProps {
+    token: SearchToken;
+    onRemove?: () => void;
+    onSelect?: () => void;
+}
+
+declare const DEFAULT_SEARCH_PLACEHOLDER = "Search";
+declare function warnIfSearchPlacementMismatch(placement: SearchFieldPlacement, platform: string): void;
+declare function filterSuggestions(query: string, suggestions: string[], limit?: number): string[];
+declare function resolveSearchFieldPlacement(platform: 'ios' | 'ipados' | 'macos' | 'tvos' | 'visionos' | 'watchos', placement?: SearchFieldPlacement): SearchFieldPlacement;
+
+declare function SearchScopeBar({ options, value, onChange, className }: SearchScopeBarProps): react.JSX.Element;
+declare function SearchTokenChip({ token, onRemove, onSelect }: SearchTokenChipProps): react.JSX.Element;
+/**
+ * Search field with scope bar, tokens, and suggestions.
+ * @see https://developer.apple.com/design/human-interface-guidelines/search-fields
+ */
+declare function SearchField({ value, defaultValue, onChange, onSearch, placeholder, platform, placement, immediate, suggestions, recentSearches, scope, tokens, onTokenRemove, onTokenSelect, showDictation, autoFocus, className, 'aria-label': ariaLabel, }: SearchFieldProps): react.JSX.Element;
+
+type SidebarPlatform = 'ios' | 'ipados' | 'macos' | 'visionos';
+type SidebarSize = 'small' | 'medium' | 'large';
 interface SidebarProps {
     children: ReactNode;
+    platform?: SidebarPlatform;
+    size?: SidebarSize;
+    hidden?: boolean;
+    onHiddenChange?: (hidden: boolean) => void;
+    /** Allow content to extend beneath the sidebar (Liquid Glass). */
+    glass?: boolean;
     'aria-label'?: string;
     className?: string;
 }
-declare function Sidebar({ children, 'aria-label': ariaLabel, className, }: SidebarProps): react.JSX.Element;
+declare function Sidebar({ children, platform, size, hidden, glass, 'aria-label': ariaLabel, className, }: SidebarProps): react.JSX.Element | null;
 interface SidebarHeaderProps {
     children: ReactNode;
 }
 declare function SidebarHeader({ children }: SidebarHeaderProps): react.JSX.Element;
+type SidebarSearchProps = Omit<SearchFieldProps, 'placement'>;
+declare function SidebarSearch(props: SidebarSearchProps): react.JSX.Element;
 interface SidebarNavProps {
     children: ReactNode;
     'aria-label'?: string;
@@ -366,14 +2353,141 @@ interface SidebarGroupProps {
     children: ReactNode;
 }
 declare function SidebarGroup({ label, children }: SidebarGroupProps): react.JSX.Element;
+interface SidebarDisclosureSectionProps {
+    label: string;
+    defaultExpanded?: boolean;
+    children: ReactNode;
+}
+declare function SidebarDisclosureSection({ label, defaultExpanded, children, }: SidebarDisclosureSectionProps): react.JSX.Element;
 interface SidebarItemProps {
     children: ReactNode;
     href?: string;
     active?: boolean;
     disabled?: boolean;
+    icon?: ReactNode;
+    badge?: number | '!';
+    /** Fixed accent color for special icons (e.g. VIP in Mail). Use sparingly. */
+    accentColor?: string;
     onClick?: () => void;
 }
-declare function SidebarItem({ children, href, active, disabled, onClick, }: SidebarItemProps): react.JSX.Element;
+declare function SidebarItem({ children, href, active, disabled, icon, badge, accentColor, onClick, }: SidebarItemProps): react.JSX.Element;
+declare function SidebarToggle({ hidden, onToggle, label, }: {
+    hidden?: boolean;
+    onToggle?: () => void;
+    label?: string;
+}): react.JSX.Element;
+
+type PathControlVariant = 'standard' | 'popup';
+interface PathSegment {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+}
+interface PathControlProps {
+    segments: PathSegment[];
+    selectedId?: string;
+    variant?: PathControlVariant;
+    /** macOS: allow drag-and-drop to select a new path item. */
+    editable?: boolean;
+    onSegmentSelect?: (segment: PathSegment) => void;
+    onChoose?: () => void;
+    onDropPath?: (segments: PathSegment[]) => void;
+    className?: string;
+    'aria-label'?: string;
+}
+
+declare const PATH_SEPARATOR = "\u203A";
+/** Collapse middle segment labels when the path is too long (Finder-style). */
+declare function collapsePathSegments(segments: PathSegment[], maxVisible?: number): Array<PathSegment | {
+    type: 'ellipsis';
+    id: string;
+}>;
+declare function resolveSelectedSegment(segments: PathSegment[], selectedId?: string): PathSegment;
+declare function warnIfPathControlInToolbar(location: string): void;
+
+/**
+ * macOS path control — standard linear or pop-up style.
+ * @see https://developer.apple.com/design/human-interface-guidelines/path-controls
+ */
+declare function PathControl({ segments, selectedId, variant, editable, onSegmentSelect, onChoose, onDropPath, className, 'aria-label': ariaLabel, }: PathControlProps): react.JSX.Element | null;
+
+type TabBarPlatform = 'ios' | 'ipados' | 'visionos' | 'tvos';
+type TabBarVariant = 'tabBarOnly' | 'sidebarAdaptable';
+type TabBarSearchStyle = 'standard' | 'button';
+interface TabBarProps {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    platform?: TabBarPlatform;
+    variant?: TabBarVariant;
+    /** iOS: search as trailing tab. */
+    searchTab?: {
+        style?: TabBarSearchStyle;
+        label?: string;
+        icon?: ReactNode;
+    };
+    className?: string;
+    children: ReactNode;
+    'aria-label'?: string;
+}
+interface TabBarListProps {
+    children: ReactNode;
+}
+interface TabBarItemProps {
+    value: string;
+    label: string;
+    icon?: ReactNode;
+    badge?: number | '!';
+    disabled?: boolean;
+}
+interface TabBarPanelProps {
+    value: string;
+    children: ReactNode;
+}
+
+declare const MAX_TAB_BAR_ITEMS = 5;
+declare function warnIfTooManyTabs(count: number): void;
+declare function formatTabBarBadge(badge?: number | '!'): string | undefined;
+declare function resolveTabBarPlacement(platform: 'ios' | 'ipados' | 'visionos' | 'tvos'): 'bottom' | 'top' | 'leading';
+
+declare function TabBarList({ children }: TabBarListProps): react.JSX.Element;
+declare function TabBarItem({ value, label, icon, badge, disabled }: TabBarItemProps): react.JSX.Element;
+declare function TabBarPanel({ value, children }: TabBarPanelProps): react.JSX.Element | null;
+/**
+ * Tab bar for top-level app navigation (iOS, iPadOS, visionOS).
+ * @see https://developer.apple.com/design/human-interface-guidelines/tab-bars
+ */
+declare function TabBar({ value, defaultValue, onValueChange, platform, variant, searchTab, className, children, 'aria-label': ariaLabel, }: TabBarProps): react.JSX.Element;
+
+interface TokenFieldToken {
+    id: string;
+    label: string;
+    icon?: ReactNode;
+}
+interface TokenFieldProps {
+    tokens?: TokenFieldToken[];
+    defaultTokens?: TokenFieldToken[];
+    onTokensChange?: (tokens: TokenFieldToken[]) => void;
+    suggestions?: TokenFieldToken[];
+    suggestionDelayMs?: number;
+    placeholder?: string;
+    /** Keys that convert current text into a token (default: comma). */
+    delimiters?: string[];
+    onContextMenuEntries?: (token: TokenFieldToken) => MenuEntry[];
+    className?: string;
+    'aria-label'?: string;
+}
+
+declare const DEFAULT_SUGGESTION_DELAY_MS = 250;
+declare function tokenizeInput(value: string, delimiters: string[]): TokenFieldToken[];
+declare function mergeUniqueTokens(existing: TokenFieldToken[], incoming: TokenFieldToken[]): TokenFieldToken[];
+declare function filterTokenSuggestions(query: string, suggestions: TokenFieldToken[]): TokenFieldToken[];
+
+/**
+ * macOS token field — converts text into selectable, draggable tokens.
+ * @see https://developer.apple.com/design/human-interface-guidelines/token-fields
+ */
+declare function TokenField({ tokens: tokensProp, defaultTokens, onTokensChange, suggestions, suggestionDelayMs, placeholder, delimiters, onContextMenuEntries, className, 'aria-label': ariaLabel, }: TokenFieldProps): react.JSX.Element;
 
 interface HeaderProps {
     children: ReactNode;
@@ -459,4 +2573,131 @@ interface DateRangePickerProps {
 }
 declare function DateRangePicker({ label, startLabel, endLabel, hint, state, loading, error, inputSize, value, onChange, min, max, disabled, readOnly, className, id, }: DateRangePickerProps): react.JSX.Element;
 
-export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, Alert, type AlertProps, type AlertVariant, AsyncButton, type AsyncButtonProps, Badge, type BadgeProps, type BadgeVariant, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, type ButtonProps, Card, type CardProps, Checkbox, type CheckboxProps, CommandPalette, type CommandPaletteItem, type CommandPaletteProps, DataTable, type DataTableColumn, type DataTableProps, DatePicker, type DatePickerProps, type DateRange, DateRangePicker, type DateRangePickerProps, Dialog, type DialogProps, Drawer, type DrawerProps, type DrawerSide, EmptyState, type EmptyStateProps, FileUpload, type FileUploadProps, Header, HeaderActions, type HeaderActionsProps, HeaderBrand, type HeaderBrandProps, type HeaderProps, HeaderTitle, type HeaderTitleProps, Input, type InputProps, type LaRoseConfig, LaRoseProvider, type LaRoseProviderProps, Modal, type ModalProps, Pagination, type PaginationProps, Popover, type PopoverProps, type PopoverSide, Progress, type ProgressProps, type ProgressVariant, Radio, type RadioProps, Select, type SelectOption, type SelectProps, Sidebar, SidebarGroup, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarItem, type SidebarItemProps, SidebarNav, type SidebarNavProps, type SidebarProps, Skeleton, type SkeletonProps, Spinner, type SpinnerProps, Switch, type SwitchProps, Tabs, TabsList, type TabsListProps, TabsPanel, type TabsPanelProps, type TabsProps, TabsTrigger, type TabsTriggerProps, Textarea, type TextareaProps, TimePicker, type TimePickerProps, type ToastInput, type ToastItem, ToastProvider, type ToastProviderProps, type ToastVariant, Tooltip, type TooltipProps, type TooltipSide, useCommandPaletteShortcut, useLaRose, useToast };
+interface PickerOption {
+    value: string;
+    label: string;
+    disabled?: boolean;
+}
+interface PickerColumn {
+    id: string;
+    /** Accessible name for the column (e.g. "Month"). */
+    label?: string;
+    options: PickerOption[];
+    flex?: number;
+}
+type PickerStyle = 'wheels' | 'compact';
+type DateTimePickerStyle = 'compact' | 'wheels' | 'inline' | 'automatic';
+type DateTimePickerMode = 'date' | 'time' | 'datetime' | 'countdown';
+interface DateTimeValue {
+    /** ISO date string `YYYY-MM-DD`. */
+    date?: string;
+    /** 24-hour time string `HH:mm`. */
+    time?: string;
+    /** Countdown duration in minutes (0–1439). */
+    countdownMinutes?: number;
+}
+type PickerValue = Record<string, string>;
+
+interface PickerProps {
+    columns: PickerColumn[];
+    value: PickerValue;
+    onChange: (value: PickerValue) => void;
+    style?: PickerStyle;
+    label?: string;
+    hint?: string;
+    error?: string | null;
+    state?: UIState;
+    loading?: boolean;
+    disabled?: boolean;
+    inputSize?: Size;
+    /** Shown on the compact trigger when no selection exists. */
+    placeholder?: string;
+    /** Formats the compact trigger label from the current value. */
+    formatValue?: (value: PickerValue, columns: PickerColumn[]) => string;
+    'aria-label'?: string;
+}
+/**
+ * Multipart picker with scrollable wheel columns — Apple HIG picker pattern.
+ * @see https://developer.apple.com/design/human-interface-guidelines/pickers
+ */
+declare function Picker({ columns, value, onChange, style, label, hint, error, state, loading, disabled, placeholder, formatValue, 'aria-label': ariaLabel, }: PickerProps): react.JSX.Element;
+
+interface WheelPickerProps {
+    columns: PickerColumn[];
+    value: PickerValue;
+    onChange: (value: PickerValue) => void;
+    disabled?: boolean;
+    /** Removes chrome for embedding in inline layouts. */
+    inline?: boolean;
+    /** Compact popover presentation — wheels fill the panel edge-to-edge. */
+    compact?: boolean;
+    'aria-label'?: string;
+}
+declare function WheelPicker({ columns, value, onChange, disabled, inline, compact, 'aria-label': ariaLabel, }: WheelPickerProps): react.JSX.Element;
+
+interface WheelColumnProps {
+    id: string;
+    label?: string;
+    options: PickerOption[];
+    value: string;
+    onChange: (value: string) => void;
+    disabled?: boolean;
+    columnFlex?: number;
+}
+declare function WheelColumn({ id, label, options, value, onChange, disabled, columnFlex, }: WheelColumnProps): react.JSX.Element;
+
+interface DateTimePickerProps {
+    value?: DateTimeValue;
+    onChange?: (value: DateTimeValue) => void;
+    mode?: DateTimePickerMode;
+    style?: DateTimePickerStyle;
+    label?: string;
+    hint?: string;
+    error?: string | null;
+    state?: UIState;
+    loading?: boolean;
+    disabled?: boolean;
+    inputSize?: Size;
+    locale?: string;
+    minuteInterval?: number;
+    use12Hour?: boolean;
+    minDate?: string;
+    maxDate?: string;
+    yearRange?: {
+        start: number;
+        end: number;
+    };
+}
+/**
+ * Date and time picker with compact, inline, and wheel styles.
+ * @see https://developer.apple.com/design/human-interface-guidelines/pickers
+ */
+declare function DateTimePicker({ value, onChange, mode, style, label, hint, error, state, loading, disabled, locale, minuteInterval, use12Hour, minDate, maxDate, yearRange, }: DateTimePickerProps): react.JSX.Element;
+
+interface CalendarGridProps {
+    value?: string;
+    onChange: (isoDate: string) => void;
+    locale?: string;
+    minDate?: string;
+    maxDate?: string;
+}
+declare function CalendarGrid({ value, onChange, locale, minDate, maxDate, }: CalendarGridProps): react.JSX.Element;
+
+declare function buildMinuteOptions(interval?: number): PickerOption[];
+declare function buildMonthOptions(locale?: string): PickerOption[];
+declare function buildDayOptions(year: number, month: number): PickerOption[];
+declare function parseISODate(value?: string): {
+    year: number;
+    month: number;
+    day: number;
+};
+declare function toISODate(year: number, month: number, day: number): string;
+declare function snapMinuteToInterval(minute: number, interval: number): number;
+declare function resolveAutomaticPickerStyle(mode: 'date' | 'time' | 'datetime' | 'countdown'): 'compact' | 'wheels' | 'inline';
+declare function formatDateTimeLabel(value: {
+    date?: string;
+    time?: string;
+    countdownMinutes?: number;
+}, mode: 'date' | 'time' | 'datetime' | 'countdown', locale?: string): string;
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemProps, type AccordionProps, AccordionTrigger, type AccordionTriggerProps, type ActivityItem, type ActivityKind, type ActivityPresentation, ActivityShareButton, type ActivityShareButtonProps, ActivityView, type ActivityViewProps, Alert, AlertDialog, type AlertDialogAction, type AlertDialogPresentation, type AlertDialogProps, type AlertDialogSuppression, type AlertDialogTextField, type AlertProps, type AlertVariant, AsyncButton, type AsyncButtonProps, BackChevronIcon, Badge, type BadgeProps, type BadgeVariant, Box, type BoxProps, type BoxTitlePosition, type BoxVariant, Breadcrumb, type BreadcrumbItem, type BreadcrumbProps, Button, ButtonGroup, type ButtonGroupProps, type ButtonPlatformSize, type ButtonProps, type ButtonShape, CalendarGrid, type CalendarGridProps, CaptionButton, type CaptionButtonContent, type CaptionButtonProps, Card, type CardProps, Chart, type ChartAxisConfig, type ChartDataPoint, type ChartLegendItem, type ChartMark, type ChartProps, type ChartSeries, Checkbox, type CheckboxProps, CloseIcon, type CollaborationAction, CollaborationButton, type CollaborationButtonProps, CollaborationPopover, type CollaborationPopoverProps, type Collaborator, Collapse, type CollapseProps, Collection, type CollectionItem, type CollectionLayout, type CollectionProps, ColumnView, type ColumnViewNode, type ColumnViewProps, CommandPalette, type CommandPaletteItem, type CommandPaletteProps, ComposeIcon, ContextMenu, type ContextMenuEntry, type ContextMenuItemConfig, type ContextMenuPosition, type ContextMenuProps, type ContextMenuSeparatorConfig, type ContextMenuSubmenuConfig, DEFAULT_SEARCH_PLACEHOLDER, DEFAULT_SUGGESTION_DELAY_MS, DEFAULT_SYSTEM_QUICK_ACTIONS, DataTable, type DataTableColumn, type DataTableProps, DatePicker, type DatePickerProps, type DateRange, DateRangePicker, type DateRangePickerProps, DateTimePicker, type DateTimePickerMode, type DateTimePickerProps, type DateTimePickerStyle, type DateTimeValue, Dialog, type DialogProps, DisclosureButton, type DisclosureButtonProps, DisclosureGroup, type DisclosureGroupProps, DisclosureList, type DisclosureListItem, type DisclosureListProps, DisclosureTriangle, type DisclosureTriangleProps, DockBar, type DockBarProps, DockMenu, type DockMenuEntry, type DockMenuProps, type DockWindow, DocumentLauncher, type DocumentLauncherProps, DocumentMenuIcon, DocumentToolbar, type DocumentToolbarProps, DragDropList, type DragDropListItem, type DragDropListProps, DragDropProvider, type DragItem, type DragSession, Draggable, type DraggableProps, Drawer, type DrawerProps, type DrawerSide, type DropOperation, type DropResult, type DropTargetState, DropZone, type DropZoneProps, EditMenu, type EditMenuContentType, type EditMenuContext, type EditMenuInputMode, type EditMenuItemConfig, type EditMenuProps, EditMenuSelection, type EditMenuVariant, EmptyState, type EmptyStateProps, type FieldFormat, type FieldValidator, FileBrowser, type FileBrowserItem, type FileBrowserProps, type FileBrowserTab, type FileLocation, FilePreview, type FilePreviewProps, type FilePreviewSource, type FileSyncStatus, FileUpload, type FileUploadProps, FormContinue, type FormContinueProps, type FormatFieldOptions, Header, HeaderActions, type HeaderActionsProps, HeaderBrand, type HeaderBrandProps, type HeaderProps, HeaderTitle, type HeaderTitleProps, HelpButton, type HelpButtonProps, HomeScreenQuickActions, type HomeScreenQuickActionsProps, type ImageBackground, ImageButton, type ImageButtonProps, type ImageFit, type ImageFrameSequence, ImageOverlay, type ImageOverlayProps, ImageView, type ImageViewProps, ImageWell, type ImageWellProps, Input, type InputProps, type LaRoseConfig, LaRoseProvider, type LaRoseProviderProps, Label, type LabelImportance, type LabelProps, List, type ListAccessory, type ListProps, ListRow, type ListRowProps, ListSection, type ListSectionProps, type ListVariant, Lockup, type LockupAxis, LockupCard, type LockupCardProps, type LockupProps, LockupRow, type LockupRowProps, MAX_ALERT_BUTTONS, MAX_CONTEXT_MENU_GROUPS, MAX_SUBMENU_ITEMS, MAX_TAB_BAR_ITEMS, MAX_TAB_VIEW_TABS, MAX_TOOLBAR_GROUPS, MAX_TOOLBAR_TITLE_LENGTH, MIN_PULLDOWN_ITEMS, Menu, MenuBar, type MenuBarDocumentContext, MenuBarExtra, type MenuBarExtraConfig, type MenuBarMenuConfig, type MenuBarPlatform, type MenuBarProps, type MenuEntry, type MenuItemConfig, type MenuLayout, type MenuProps, type MenuSubmenuConfig, Modal, type ModalProps, Monogram, type MonogramProps, MorePullDownButton, type MotionConfig, MotionProvider, type MotionProviderProps, type MotionVariant, Ornament, OrnamentButton, type OrnamentButtonProps, type OrnamentConfig, type OrnamentContentAlignment, type OrnamentEdge, type OrnamentProps, type OrnamentVisibility, OrnamentWindow, type OrnamentWindowProps, type OutlineColumn, type OutlineNode, OutlineView, type OutlineViewProps, OutlineViewToolbar, type OutlineViewToolbarProps, OverflowIcon, PATH_SEPARATOR, Pagination, type PaginationProps, PathControl, type PathControlProps, type PathControlVariant, type PathSegment, Picker, type PickerColumn, type PickerOption, type PickerProps, type PickerStyle, type PickerValue, type PointShape, PopUpButton, type PopUpButtonProps, type PopUpCustomOption, type PopUpOption, Popover, type PopoverProps, type PopoverSide, Poster, type PosterProps, Presence, type PresencePhase, type PresenceProps, Progress, type ProgressProps, type ProgressVariant, PullDownButton, type PullDownButtonProps, type PullDownButtonVariant, type PullDownDestructiveConfirmation, type PullDownEntry, type QuickActionIconPlacement, type QuickActionItem, Radio, type RadioProps, STANDARD_MENU_SLOTS, STANDARD_SHORTCUTS, SYSTEM_ACTIVITY_IDS, SearchField, type SearchFieldPlacement, type SearchFieldPlatform, type SearchFieldProps, SearchIcon, SearchScopeBar, type SearchScopeBarProps, type SearchScopeOption, type SearchToken, SearchTokenChip, type SearchTokenChipProps, SecureField, type SecureFieldProps, Select, type SelectOption, type SelectProps, type ShareAudience, ShareButton, type ShareButtonProps, type ShareDestination, ShareIcon, type SharePermission, type SharePermissionOption, type ShareSettings, ShareSheet, type ShareSheetProps, ShareToolbar, type ShareToolbarProps, Sidebar, SidebarDisclosureSection, type SidebarDisclosureSectionProps, SidebarGroup, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarIcon, SidebarItem, type SidebarItemProps, SidebarNav, type SidebarNavProps, type SidebarPlatform, type SidebarProps, SidebarSearch, type SidebarSearchProps, type SidebarSize, SidebarToggle, Skeleton, type SkeletonProps, type SortDirection, Spinner, type SpinnerProps, type SplitCompactMode, type SplitOrientation, SplitView, SplitViewPane, type SplitViewPaneProps, type SplitViewProps, SplitViewToolbar, type SplitViewToolbarProps, SquareButton, type SquareButtonProps, type StandardEditActionId, type StandardMenuBarHandlers, type StandardMenuBarOptions, Switch, type SwitchProps, type SystemActivityId, TabBar, TabBarItem, type TabBarItemProps, TabBarList, type TabBarListProps, TabBarPanel, type TabBarPanelProps, type TabBarPlatform, type TabBarProps, type TabBarSearchStyle, type TabBarVariant, TabView, TabViewList, type TabViewListProps, TabViewPanel, type TabViewPanelProps, type TabViewProps, TabViewTab, type TabViewTabProps, type TabViewVariant, Table, type TableColumn, type TableProps, type TableSelectionMode, Tabs, TabsList, type TabsListProps, TabsPanel, type TabsPanelProps, type TabsProps, TabsTrigger, type TabsTriggerProps, TextView, type TextViewProps, Textarea, type TextareaProps, TimePicker, type TimePickerProps, type ToastInput, type ToastItem, ToastProvider, type ToastProviderProps, type ToastVariant, TokenField, type TokenFieldProps, type TokenFieldToken, Toolbar, type ToolbarAction, ToolbarBackButton, type ToolbarBackButtonProps, ToolbarCloseButton, type ToolbarCloseButtonProps, ToolbarDocumentMenu, type ToolbarDocumentMenuProps, ToolbarFixedSpace, ToolbarGroup, type ToolbarGroupProps, ToolbarItem, type ToolbarItemProps, ToolbarMoreButton, type ToolbarMoreButtonProps, type ToolbarPlacement, type ToolbarPlatform, ToolbarProminentButton, type ToolbarProminentButtonProps, type ToolbarProps, ToolbarSearch, type ToolbarSearchProps, ToolbarSection, type ToolbarSectionPlacement, type ToolbarSectionProps, ToolbarTitle, type ToolbarTitleProps, Tooltip, type TooltipProps, type TooltipSide, Typography, type TypographyProps, UnsavedIndicator, type UnsavedIndicatorProps, type UsePresenceOptions, type UsePresenceResult, type UseSpringAnimationOptions, WebView, type WebViewHistoryState, WebViewNavigation, type WebViewNavigationProps, type WebViewProps, WebViewShell, type WebViewShellProps, WheelColumn, type WheelColumnProps, WheelPicker, type WheelPickerProps, acceptsDragType, buildDayOptions, buildDockMenuEntries, buildEditMenuActions, buildMinuteOptions, buildMonthOptions, buildPopUpMenuEntries, buildStandardMenuBar, canPreviewFile, clampOrnamentWidth, collapsePathSegments, collectExpandableSubtree, combineValidators, computeVisibleToolbarItemCount, countPullDownActions, createAppMenu, createAppleMenuStub, createDefaultActivities, createEditMenu, createEmailValidator, createFileMenu, createFormatMenu, createHelpMenu, createPhotoActivities, createRequiredValidator, createViewMenu, createWindowMenu, defaultDestructiveConfirmation, documentTitleWithEditedSuffix, entriesFromToolbarActions, fieldIdFromLabel, filterActivities, filterFilesByType, filterOutline, filterSuggestions, filterTokenSuggestions, filterVisibleEditMenuActions, flattenOutline, formatActivityTitle, formatBoxTitle, formatButtonLabel, formatColumnHeader, formatContextMenuTitle, formatDateTimeLabel, formatDisplayName, formatFieldValue, formatFileDate, formatFileSize, formatRating, formatSharePermissionSummary, formatTabBarBadge, getInitials, isFormComplete, isStandardActionAvailable, mergeUniqueTokens, normalizeOutlineColumns, orderAlertActions, parseISODate, parseNumericInput, prepareActivities, prepareContextMenuEntries, prepareMenuEntries, prepareQuickActions, quickActionsToEntries, resolveAutomaticPickerStyle, resolveButtonShape, resolveCancelAction, resolveDefaultValue, resolveDockMenuPosition, resolveDropOperation, resolveDynamicMenuEntries, resolveEditMenuPosition, resolveEditMenuVariant, resolveMenuBarAlignment, resolveOrnamentVisibility, resolvePopUpLabel, resolveQuickActionMenuPosition, resolveSearchFieldPlacement, resolveSelectedSegment, resolveTabBarPlacement, resolveToolbarPlacement, shouldStyleDestructive, shouldUseSystemOverflow, snapMinuteToInterval, sortActivities, sortOutlineNodes, sortRows, splitCompactAndList, toISODate, tokenizeInput, toolbarActionsFromEntries, truncateMiddle, truncateToolbarTitle, useCommandPaletteShortcut, useLaRose, useMotion, useMotionEnabled, usePresence, useSkipMotion, useSplitView, useSpringAnimation, useToast, useWebViewHistory, validateAlertActions, validateMenuBarOrder, warnIfAlertTitleTooLong, warnIfMixedLabelStyles, warnIfPathControlInToolbar, warnIfSearchPlacementMismatch, warnIfTooFewPullDownItems, warnIfTooManyOrnaments, warnIfTooManyTabs, warnIfTooManyToolbarGroups, warnIfToolbarTitleTooLong };