@refineui/react 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,3905 @@
+import { SemanticColorName, SemanticTextName, SpacingTokens, BorderRadiusTokens, StrokeWidthTokens, FoundationSizeName } from '@refineui/tokens';
+export { FoundationTypographyName, SEMANTIC_TEXT, SemanticTextName, componentSizeFoundationKeys, componentSizes, foundationSizes } from '@refineui/tokens';
+import { SemanticTextTokenRef } from '@refineui/utilities';
+import * as react from 'react';
+import { CSSProperties, ReactNode, ButtonHTMLAttributes, InputHTMLAttributes, HTMLAttributes, ElementType, TextareaHTMLAttributes, ImgHTMLAttributes, LiHTMLAttributes, OlHTMLAttributes, TableHTMLAttributes, TdHTMLAttributes, ThHTMLAttributes, AnchorHTMLAttributes, LabelHTMLAttributes, SVGAttributes } from 'react';
+
+/**
+ * Component Color Tokens (Web Kit language layer)
+ *
+ * Primitive (global/colors) -> Semantic (semantic/colors) ->
+ * Component Token (this file) -> Component implementation.
+ *
+ * This file declares token refs only (no raw color strings).
+ * `@refineui/utilities` resolves CSS variables.
+ */
+
+declare const componentColorTokens: {
+    readonly webIcon: {
+        readonly default: "currentColor";
+        readonly primary: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly secondary: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly disabled: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly inversed: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+    };
+    readonly button: {
+        readonly primary: {
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly appearance: {
+                readonly background: Readonly<{
+                    type: "semantic";
+                    name: SemanticColorName;
+                }>;
+                readonly foreground: Readonly<{
+                    type: "semantic";
+                    name: SemanticColorName;
+                }>;
+            };
+            readonly states: {
+                readonly hover: {
+                    readonly background: Readonly<{
+                        type: "semantic";
+                        name: SemanticColorName;
+                    }>;
+                };
+                readonly pressed: {
+                    readonly background: Readonly<{
+                        type: "semantic";
+                        name: SemanticColorName;
+                    }>;
+                };
+                readonly disabled: {
+                    readonly background: Readonly<{
+                        type: "semantic";
+                        name: SemanticColorName;
+                    }>;
+                    readonly foreground: Readonly<{
+                        type: "semantic";
+                        name: SemanticColorName;
+                    }>;
+                };
+            };
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly secondary: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly outline: {
+            readonly background: "transparent";
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly ghost: {
+            readonly background: "transparent";
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly input: {
+        readonly text: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly placeholder: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly background: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly disabledBackground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly border: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly focus: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly error: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly success: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabled: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly textarea: {
+        readonly text: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly placeholder: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly background: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly disabledBackground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly border: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly focus: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly error: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly success: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabled: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly pagination: {
+        readonly navIcon: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabled: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly page: {
+            readonly text: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly selectedBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly selectedBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly dropdown: {
+        readonly trigger: {
+            readonly icon: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly menu: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly title: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly itemText: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly itemTextSubtle: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly itemHoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly itemDisabledText: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly select: {
+        readonly text: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly placeholder: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly background: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly disabledBackground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly border: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabled: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly error: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly success: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly tooltip: {
+        readonly default: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly popover: {
+        readonly default: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly inverted: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly field: {
+        readonly label: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly required: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly hint: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly error: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+    };
+    readonly label: {
+        readonly text: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly disabledText: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly required: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+    };
+    readonly checkbox: {
+        readonly label: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly description: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabled: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly checkIcon: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabled: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly radio: {
+        readonly label: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly description: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabled: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly control: {
+            readonly dot: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly dotHover: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledDot: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly borderDefault: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly borderFocus: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly borderDisabled: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly toggle: {
+        readonly track: {
+            readonly on: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly off: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverOn: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeOn: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            /** Darken on hover/press (rest is already primaryActive) */
+            readonly hoverOff: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeOff: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledOff: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledOn: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly thumb: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledOff: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledOn: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly switch: {
+        readonly track: {
+            readonly on: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly off: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverOn: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeOn: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverOff: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeOff: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledOff: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledOn: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly thumb: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledOff: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledOn: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly dialog: {
+        readonly overlay: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly content: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly header: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly title: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly description: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly close: {
+            readonly icon: "currentColor";
+        };
+        readonly panel: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly title: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly description: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly drawer: {
+        readonly overlay: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly content: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly header: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly divider: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly title: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly description: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly body: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly divider: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly footer: {
+            readonly divider: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly close: {
+            readonly icon: "currentColor";
+        };
+        readonly panel: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly title: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly description: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly divider: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly body: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly alert: {
+        readonly background: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly border: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly title: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly description: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly info: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly success: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly warning: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly danger: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly custom: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+        };
+        readonly accent: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly info: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly success: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly warning: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly danger: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly custom: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+        };
+    };
+    readonly badge: {
+        readonly default: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly neutral: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly outline: {
+            readonly background: "transparent";
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly success: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly warning: {
+            readonly background: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly foreground: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+        };
+        readonly danger: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly chip: {
+        readonly default: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly outline: {
+            readonly background: "transparent";
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly filled: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly remove: {
+            readonly icon: "currentColor";
+        };
+    };
+    readonly tag: {
+        readonly default: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly outline: {
+            readonly background: "transparent";
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly filled: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly progress: {
+        readonly track: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly indicator: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly success: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly warning: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly danger: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly chart: {
+        readonly plotBackground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly grid: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly gridBaseline: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly axis: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly pointStroke: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly cursor: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly tooltip: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly muted: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly series: {
+            readonly brand: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly info: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly success: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly warning: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly error: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly discovery: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly seriesSubtle: {
+            readonly brand: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly info: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly success: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly warning: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly error: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly discovery: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly spinner: {
+        readonly track: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly indicator: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly label: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+    };
+    readonly skeleton: {
+        readonly background: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+    };
+    readonly carousel: {
+        readonly nav: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBorder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly indicator: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly selected: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly scrollArea: {
+        readonly track: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly thumb: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly toast: {
+        readonly background: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly message: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly accent: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly success: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly error: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly warning: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly toaster: {
+        readonly stackBackground: "transparent";
+    };
+    readonly tabs: {
+        readonly listLine: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly selectedLine: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly itemForeground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly selectedForeground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly hoverForeground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly itemDisabledForeground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+    };
+    readonly segmentedControl: {
+        readonly barBackground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly barBorder: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly itemForeground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly itemDisabledForeground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly selectedBackground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly selectedForeground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly selectedHoverBackground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly selectedDisabledBackground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly hoverForeground: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+    };
+    readonly accordion: {
+        readonly item: {
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly trigger: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly content: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly breadcrumb: {
+        readonly list: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly item: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly link: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly page: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly current: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly separatorToken: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly separator: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly ellipsisTrigger: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly ellipsis: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+    };
+    readonly menu: {
+        readonly panel: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly popover: {
+            readonly background: "transparent";
+        };
+        readonly list: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly section: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly sectionToken: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly divider: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly dividerToken: {
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly item: {
+            readonly text: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly description: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledText: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly pressedBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly command: {
+        readonly panel: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly input: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly placeholder: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly icon: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly group: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly empty: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly separator: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly item: {
+            readonly text: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly disabledText: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly selectedBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly shortcut: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly link: {
+        readonly default: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly hover: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly active: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly visited: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly disabled: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly subtle: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hover: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly active: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly calendar: {
+        readonly background: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly border: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly weekday: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly day: {
+            readonly default: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly otherMonth: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly selectedBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly selectedForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly rangeMiddleBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly rangeMiddleForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly hoverForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeBackground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly activeForeground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+    readonly card: {
+        readonly header: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly headerMain: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly content: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly footer: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly action: {
+            readonly foreground: "currentColor";
+        };
+        readonly titleToken: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly descriptionToken: {
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly elevated: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly outlined: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly title: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly description: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+    };
+    readonly divider: {
+        readonly line: Readonly<{
+            type: "semantic";
+            name: SemanticColorName;
+        }>;
+        readonly label: Readonly<{
+            type: "palette";
+            name: string;
+        }>;
+        readonly icon: Readonly<{
+            type: "palette";
+            name: string;
+        }>;
+    };
+    readonly avatar: {
+        readonly image: {
+            readonly background: "transparent";
+        };
+        readonly fallback: {
+            readonly foreground: "currentColor";
+        };
+        readonly badge: {
+            readonly background: "transparent";
+        };
+        readonly avatarIcon: {
+            readonly foreground: "currentColor";
+        };
+        readonly overflow: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly icon: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        readonly group: {
+            readonly background: "transparent";
+        };
+        readonly groupCount: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+        /** Cell fill only — Global tint per MCP `Color`. Glyph/initials ink: `avatar.icon`. */
+        readonly shell: {
+            readonly background: {
+                readonly neutral: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly blue: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly green: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly lime: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly magenta: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly orange: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly purple: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly red: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly teal: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly yellow: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+            };
+        };
+        readonly icon: {
+            readonly neutral: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly blue: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly green: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly lime: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly magenta: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly orange: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly purple: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly red: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly teal: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly yellow: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+        };
+        readonly status: {
+            readonly online: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly away: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+            readonly unavailable: {
+                readonly background: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+                readonly mark: Readonly<{
+                    type: "palette";
+                    name: string;
+                }>;
+            };
+            readonly offline: Readonly<{
+                type: "palette";
+                name: string;
+            }>;
+        };
+    };
+    readonly avatars: {
+        readonly stack: {
+            readonly background: "transparent";
+        };
+        readonly spread: {
+            readonly background: "transparent";
+        };
+        readonly count: {
+            readonly background: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly border: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+            readonly foreground: Readonly<{
+                type: "semantic";
+                name: SemanticColorName;
+            }>;
+        };
+    };
+};
+
+type ControlSize = "sm" | "md" | "lg";
+declare const componentTypographyTokens: {
+    readonly formControl: {
+        readonly sm: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly md: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly lg: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly label: {
+        readonly sm: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly md: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly lg: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly labelCompanion: {
+        readonly label: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly description: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly fieldFeedback: Readonly<{
+        type: "semantic-text";
+        name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+    }>;
+    /** Trigger = size + medium weight; content = one step smaller / lighter for readable hierarchy */
+    readonly accordion: {
+        readonly trigger: {
+            readonly sm: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly md: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly lg: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+        };
+        readonly content: {
+            readonly sm: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly md: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly lg: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+        };
+    };
+    readonly button: {
+        readonly sm: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly md: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly lg: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly link: Readonly<{
+        type: "semantic-text";
+        name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+    }>;
+    readonly breadcrumb: {
+        readonly row: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    /** Top navigation — trigger denser like segmented control; content links match menu rows. */
+    readonly navigationMenu: {
+        readonly trigger: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly link: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly contentLink: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    /** Site footer — sitemap body; locale trigger uses Button sm typography. */
+    readonly footer: {
+        readonly brandName: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly brandDescription: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly groupLabel: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly link: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly copyright: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    /** App sidebar — group labels match menu sections; links match menu rows. */
+    readonly sidebar: {
+        readonly brand: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly groupLabel: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly link: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly menu: {
+        readonly section: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly item: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly description: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly shortcut: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    /** Command palette — same scale as Menu (list / section / shortcut). */
+    readonly command: {
+        readonly group: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly item: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly empty: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly shortcut: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly input: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly dropdown: {
+        readonly label: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly item: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly shortcut: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly dialog: {
+        readonly title: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly description: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly drawer: {
+        readonly title: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly description: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly body: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly card: {
+        readonly title: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly description: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly alert: {
+        readonly title: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly description: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly bubble: Readonly<{
+        type: "semantic-text";
+        name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+    }>;
+    /** Digits use title scale — applied via `refineui.css` `[data-refineui="input-otp"][data-size]`. */
+    readonly inputOtp: {
+        readonly sm: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly md: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly lg: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly stepper: {
+        readonly indicator: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly title: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly description: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly progressStepper: {
+        readonly marker: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly label: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly toast: {
+        readonly message: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    /** Hierarchical tree — density matches sidebar / menu rows. */
+    readonly tree: {
+        readonly item: {
+            readonly sm: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly md: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly lg: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+        };
+    };
+    readonly pagination: Readonly<{
+        type: "semantic-text";
+        name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+    }>;
+    readonly chip: {
+        readonly sm: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly md: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly lg: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly badge: Readonly<{
+        type: "semantic-text";
+        name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+    }>;
+    readonly segmentedControl: Readonly<{
+        type: "semantic-text";
+        name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+    }>;
+    readonly tabs: Readonly<{
+        type: "semantic-text";
+        name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+    }>;
+    readonly table: {
+        readonly head: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly cell: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly caption: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly tooltip: Readonly<{
+        type: "semantic-text";
+        name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+    }>;
+    readonly textarea: Readonly<{
+        type: "semantic-text";
+        name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+    }>;
+    readonly select: {
+        /** Trigger density matches Navigation Menu (`captionLg` at md). */
+        readonly trigger: {
+            readonly sm: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly md: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly lg: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+        };
+        readonly label: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly item: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly calendar: {
+        readonly day: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly weekday: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly divider: {
+        readonly contentLabel: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly chart: {
+        readonly axisLabel: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly legendLabel: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly tooltipLabel: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly tooltipValue: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly spinner: {
+        readonly xs: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly sm: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly md: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly lg: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly xl: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+        readonly xxl: Readonly<{
+            type: "semantic-text";
+            name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+        }>;
+    };
+    readonly avatar: {
+        readonly initialsNeutral: {
+            readonly xxxsmall: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xxsmall: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xsmall: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly small: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly medium: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly large: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xlarge: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xxlarge: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xxxlarge: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+        };
+        readonly initialsAccent: {
+            readonly xxxlarge: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xxlarge: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xlarge: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly default: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+        };
+        readonly groupCount: {
+            readonly xxxsmall: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xxsmall: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xsmall: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly small: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly medium: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly large: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xlarge: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xxlarge: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+            readonly xxxlarge: Readonly<{
+                type: "semantic-text";
+                name: "displayLg" | "displayMd" | "displaySm" | "headingLg" | "headingMd" | "headingSm" | "titleLg" | "titleMd" | "titleSm" | "subtitleLg" | "subtitleMd" | "bodyLg" | "bodyMd" | "bodySm" | "bodyXs" | "labelLg" | "labelMd" | "labelSm" | "captionLg" | "captionMd" | "captionSm";
+            }>;
+        };
+    };
+};
+
+/** Resolve a semantic text role → `refineui-typo-*` utility class. */
+declare function semanticTextClass(name: SemanticTextName): string;
+/** Resolve a component typography token ref → utility class. */
+declare function componentTextClass(ref: SemanticTextTokenRef<SemanticTextName>): string;
+/** Size-keyed component token map → utility class (`formControl`, `label`, …). */
+declare function sizedComponentTextClass<TSize extends string>(map: Record<TSize, SemanticTextTokenRef<SemanticTextName>>, size: TSize): string;
+
+interface WebIconProps {
+    name: string;
+    size?: number;
+    color?: string;
+    /** RefineUI System Icons style (default: regular) */
+    iconStyle?: "regular" | "filled";
+    className?: string;
+    style?: CSSProperties;
+    /** Shown when the glyph is missing */
+    fallback?: ReactNode;
+    /** Accessibility: omit label → aria-hidden */
+    "aria-label"?: string;
+}
+/** Glyph from @refineui/web-icons — size/color stay inline on the glyph */
+declare function WebIcon({ name, size, color, iconStyle, className, style, fallback, "aria-label": ariaLabel, }: WebIconProps): react.JSX.Element;
+
+/** Web Kit `Button` `79:3304` — Style: Primary · Secondary · Outline · Ghost */
+type ButtonVariant = "primary" | "secondary" | "outline" | "ghost";
+/** Web Kit Size — Small / Medium / Large */
+type ButtonSize = "sm" | "md" | "lg";
+/** Web Kit Layout — Label / Icon-only (MCP `Layout=Icon`). */
+type ButtonLayout = "label" | "icon";
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    layout?: ButtonLayout;
+    fullWidth?: boolean;
+}
+
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size"> {
+    error?: boolean;
+    success?: boolean;
+    fullWidth?: boolean;
+    size?: "sm" | "md" | "lg";
+}
+
+declare function Input({ error, success, fullWidth, size: sizeProp, disabled, className, ...props }: InputProps): react.JSX.Element;
+
+/** Shared sm / md / lg tiers for Input, SpinButton — keep in sync. */
+
+type FormControlSize = ControlSize;
+
+type InputOTPSize = FormControlSize;
+interface InputOTPProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
+    /** Controlled OTP string. */
+    value?: string;
+    /** Uncontrolled initial value. */
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /** Number of slots (must match rendered `InputOTPSlot` indices). */
+    maxLength: number;
+    size?: InputOTPSize;
+    disabled?: boolean;
+    /**
+     * Per-character allowlist. Default: digits only (`/\d/`).
+     * Characters that fail the test are dropped.
+     */
+    pattern?: RegExp;
+    autoFocus?: boolean;
+    name?: string;
+    id?: string;
+    inputMode?: InputHTMLAttributes<HTMLInputElement>["inputMode"];
+    autoComplete?: InputHTMLAttributes<HTMLInputElement>["autoComplete"];
+    /** Accessible name for the control. */
+    "aria-label"?: string;
+}
+interface InputOTPSlotProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "defaultValue" | "maxLength" | "disabled" | "type" | "children"> {
+    /** Zero-based slot index. */
+    index: number;
+}
+
+declare function InputOTP({ value: valueProp, defaultValue, onValueChange, maxLength, size: sizeProp, disabled, pattern, autoFocus, name, id, inputMode, autoComplete, className, children, "aria-label": ariaLabel, ...props }: InputOTPProps): react.JSX.Element;
+declare function InputOTPSlot({ index, className, onChange, onKeyDown, onPaste, onFocus, ...props }: InputOTPSlotProps): react.JSX.Element;
+
+interface SearchFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
+    /** Controlled query */
+    value?: string;
+    /** Uncontrolled initial query */
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    /**
+     * `filled` — standalone control (sunken surface).
+     * `plain` — flush row for composed surfaces like Command.
+     * @default "filled"
+     */
+    appearance?: "filled" | "plain";
+    /** Forwarded to the inner input. */
+    id?: string;
+    /** Accessible name for the search input. */
+    "aria-label"?: string;
+}
+type SearchFieldIconProps = HTMLAttributes<HTMLSpanElement> & {
+    /** Defaults to the search glyph */
+    children?: ReactNode;
+};
+type SearchFieldInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "type" | "value" | "defaultValue" | "disabled">;
+type SearchFieldClearProps = Omit<ButtonHTMLAttributes<HTMLButtonElement>, "type"> & {
+    /** Defaults to the dismiss glyph */
+    children?: ReactNode;
+};
+
+declare function SearchField({ value, defaultValue, onValueChange, disabled, appearance, className, children, id, onPointerDown, "aria-label": ariaLabel, ...props }: SearchFieldProps): react.JSX.Element;
+declare function SearchFieldIcon({ children, className, ...props }: SearchFieldIconProps): react.JSX.Element;
+declare const SearchFieldInput: react.ForwardRefExoticComponent<SearchFieldInputProps & react.RefAttributes<HTMLInputElement>>;
+declare function SearchFieldClear({ className, children, disabled: disabledProp, onClick, "aria-label": ariaLabel, ...props }: SearchFieldClearProps): react.JSX.Element | null;
+
+interface TextProps extends HTMLAttributes<HTMLElement> {
+    /** Semantic text role — maps to Foundation typography via `SEMANTIC_TEXT`. */
+    variant: SemanticTextName;
+    /** Root element. Default `span`. */
+    as?: ElementType;
+}
+/** Semantic typography primitive — Polaris `Text` / M3 typescale consumer. */
+declare function Text({ variant, as: Component, className, ...props }: TextProps): react.JSX.Element;
+
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    error?: boolean;
+    success?: boolean;
+    fullWidth?: boolean;
+}
+
+declare function Textarea({ error, success, fullWidth, disabled, className, ...props }: TextareaProps): react.JSX.Element;
+
+type BadgeVariant = "default" | "neutral" | "outline" | "success" | "warning" | "danger";
+type BadgeLayout = "label" | "number";
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    variant?: BadgeVariant;
+    layout?: BadgeLayout;
+}
+
+declare function Badge({ variant, layout, className, ...props }: BadgeProps): react.JSX.Element;
+
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: "elevated" | "outlined";
+    interactive?: boolean;
+    state?: "default" | "hover" | "pressed" | "disabled";
+}
+declare function Card({ variant, interactive, state, className, ...props }: CardProps): react.JSX.Element;
+
+declare function CardHeaderMain({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+
+declare function CardHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+
+declare function CardTitle({ className, ...props }: HTMLAttributes<HTMLHeadingElement>): react.JSX.Element;
+
+declare function CardDescription({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): react.JSX.Element;
+
+declare function CardAction({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+
+declare function CardContent({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+
+declare function CardFooter({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
+    description?: string;
+    label?: string;
+    variant?: "default" | "circular";
+}
+
+declare function Checkbox({ label, description, variant, id, className, disabled, checked: checkedProp, defaultChecked, onChange, ...props }: CheckboxProps): react.JSX.Element;
+
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
+    label?: string;
+    description?: string;
+    allowUncheck?: boolean;
+}
+interface RadioInputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type"> {
+}
+
+declare function Radio({ label, description, id, className, disabled, allowUncheck, onClick, ...props }: RadioProps): react.JSX.Element;
+
+declare const RadioInput: react.ForwardRefExoticComponent<RadioInputProps & react.RefAttributes<HTMLInputElement>>;
+
+type SelectSize = "sm" | "md" | "lg";
+/**
+ * `filled` — standalone field chrome (border + surface).
+ * `plain` — flush trigger for composed surfaces (Footer locale, Calendar caption).
+ */
+type SelectTriggerAppearance = "filled" | "plain";
+interface SelectProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange" | "defaultValue"> {
+    value?: string;
+    defaultValue?: string;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    size?: SelectSize;
+    fullWidth?: boolean;
+    disabled?: boolean;
+    children?: ReactNode;
+}
+interface SelectTriggerProps extends HTMLAttributes<HTMLButtonElement> {
+    children?: ReactNode;
+    /**
+     * `filled` — default field chrome.
+     * `plain` — no field chrome; compose visuals via `className` / parent recipe.
+     * @default "filled"
+     */
+    appearance?: SelectTriggerAppearance;
+}
+interface SelectValueProps extends HTMLAttributes<HTMLSpanElement> {
+    placeholder?: string;
+}
+interface SelectIconProps extends HTMLAttributes<HTMLSpanElement> {
+    children?: ReactNode;
+}
+interface SelectContentProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+    /** Default `item-aligned`. `popper`: compact panel below/above trigger */
+    position?: "item-aligned" | "popper";
+    /** Portal target when set (else nearest `SelectPortal` or `document.body`) */
+    container?: HTMLElement | null;
+}
+interface SelectViewportProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+interface SelectGroupProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+interface SelectLabelProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+interface SelectSeparatorProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface SelectItemProps extends HTMLAttributes<HTMLDivElement> {
+    value: string;
+    disabled?: boolean;
+    children?: ReactNode;
+    textValue?: string;
+}
+interface SelectItemTextProps extends HTMLAttributes<HTMLSpanElement> {
+    children?: ReactNode;
+}
+interface SelectItemIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+    children?: ReactNode;
+}
+type SelectArrowProps = HTMLAttributes<HTMLSpanElement>;
+type SelectScrollUpButtonProps = HTMLAttributes<HTMLDivElement>;
+type SelectScrollDownButtonProps = HTMLAttributes<HTMLDivElement>;
+type SelectPortalProps = {
+    children?: ReactNode;
+    container?: HTMLElement | null;
+};
+type SelectSectionProps = HTMLAttributes<HTMLDivElement>;
+
+declare function Select({ value: ctrlValue, onValueChange, defaultValue, open: ctrlOpen, onOpenChange, children, placeholder, size: sizeProp, fullWidth, disabled, className, ...props }: SelectProps): react.JSX.Element;
+declare const SelectTrigger: react.ForwardRefExoticComponent<SelectTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare function SelectValue({ placeholder, className, ...props }: SelectValueProps): react.JSX.Element;
+declare function SelectIcon({ children, className, ...props }: SelectIconProps): react.JSX.Element;
+declare function SelectPortal({ children, container }: SelectPortalProps): react.JSX.Element;
+declare const SelectContent: react.ForwardRefExoticComponent<SelectContentProps & react.RefAttributes<HTMLDivElement>>;
+declare const SelectViewport: react.ForwardRefExoticComponent<SelectViewportProps & react.RefAttributes<HTMLDivElement>>;
+declare function SelectGroup({ children, className, ...props }: SelectGroupProps): react.JSX.Element;
+declare function SelectLabel({ children, className, ...props }: SelectLabelProps): react.JSX.Element;
+declare function SelectSection({ children, className, ...props }: SelectSectionProps): react.JSX.Element;
+declare function SelectSeparator({ className, ...props }: SelectSeparatorProps): react.JSX.Element;
+declare function SelectItem({ value: itemValue, children, disabled, textValue, className, onPointerDown, onPointerUp, onPointerLeave, onPointerCancel, onMouseDown, onMouseUp, onMouseLeave, ...props }: SelectItemProps): react.JSX.Element;
+declare function SelectItemText({ children, className, ...props }: SelectItemTextProps): react.JSX.Element;
+declare function SelectItemIndicator({ children, className, ...props }: SelectItemIndicatorProps): react.JSX.Element;
+declare function SelectScrollUpButton({ children, ...props }: SelectScrollUpButtonProps): react.JSX.Element;
+declare function SelectScrollDownButton({ children, ...props }: SelectScrollDownButtonProps): react.JSX.Element;
+declare function SelectArrow({ children, ...props }: SelectArrowProps): react.JSX.Element;
+
+interface ToggleProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    checked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+}
+
+declare function Toggle({ checked, onCheckedChange, onClick, className, disabled, ...props }: ToggleProps): react.JSX.Element;
+
+type ChipVariant = "default" | "outline" | "filled";
+type ChipSize = "sm" | "md" | "lg";
+interface ChipProps extends HTMLAttributes<HTMLSpanElement> {
+    avatar?: ReactNode;
+    disabled?: boolean;
+    onRemove?: () => void;
+    size?: ChipSize;
+    variant?: ChipVariant;
+}
+
+declare function Chip({ variant, size, disabled, avatar, onRemove, children, className, ...props }: ChipProps): react.JSX.Element;
+
+type DialogSize = "lg" | "sm";
+interface DialogProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Web Kit `size`: Large(600px) / Small(300px) */
+    size?: DialogSize;
+    children: ReactNode;
+}
+type DialogTriggerProps = ButtonProps;
+interface DialogContentProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    container?: Element | DocumentFragment | null;
+    style?: CSSProperties;
+    /**
+     * When `false`, children render directly in the panel (no ScrollArea).
+     * Useful for composed surfaces like Command that manage their own scroll.
+     * @default true
+     */
+    scrollable?: boolean;
+}
+interface DialogHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    showClose?: boolean;
+}
+type DialogTitleProps = HTMLAttributes<HTMLHeadingElement>;
+type DialogDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+type DialogCloseProps = ButtonHTMLAttributes<HTMLButtonElement>;
+
+declare function Dialog({ open: openProp, defaultOpen, onOpenChange, size, children }: DialogProps): react.JSX.Element;
+declare const DialogTrigger: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+declare function DialogContent({ className, style, container, scrollable, children, ...props }: DialogContentProps): react.ReactPortal | null;
+declare function DialogHeader({ className, children, showClose, ...props }: DialogHeaderProps): react.JSX.Element;
+declare function DialogTitle({ className, id, children, ...props }: DialogTitleProps): react.JSX.Element;
+declare function DialogDescription({ className, id, children, ...props }: DialogDescriptionProps): react.JSX.Element;
+declare function DialogClose({ className, onClick, type, ...props }: DialogCloseProps): react.JSX.Element;
+
+type CommandFilter = (value: string, search: string, keywords?: string[]) => number;
+interface CommandProps extends HTMLAttributes<HTMLDivElement> {
+    /** Controlled search query */
+    value?: string;
+    /** Uncontrolled initial search query */
+    defaultValue?: string;
+    onValueChange?: (search: string) => void;
+    /** When true (default), filter items by search text */
+    shouldFilter?: boolean;
+    /** Custom score function — return `0` to hide. Default: substring match */
+    filter?: CommandFilter;
+    /** Controlled highlighted item value */
+    selectedValue?: string;
+    /** Uncontrolled initial highlighted item value */
+    defaultSelectedValue?: string;
+    onSelectedValueChange?: (value: string) => void;
+    /** Accessible name for the command root (`aria-label`) */
+    label?: string;
+}
+interface CommandDialogProps extends DialogProps {
+    /** Forwarded to the inner `Command` root */
+    commandProps?: Omit<CommandProps, "children">;
+}
+type CommandInputProps = Omit<InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange"> & {
+    /** Optional leading icon; defaults to search glyph */
+    startIcon?: ReactNode;
+};
+type CommandListProps = HTMLAttributes<HTMLDivElement>;
+type CommandEmptyProps = HTMLAttributes<HTMLDivElement>;
+type CommandGroupProps = HTMLAttributes<HTMLDivElement>;
+type CommandGroupHeadingProps = HTMLAttributes<HTMLDivElement>;
+type CommandSeparatorProps = HTMLAttributes<HTMLDivElement>;
+interface CommandItemProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "value" | "onSelect"> {
+    /** Unique value used for filtering, selection, and `onSelect` */
+    value: string;
+    /** Extra strings included in the default filter */
+    keywords?: string[];
+    /** Called when the item is activated (click / Enter) */
+    onSelect?: (value: string) => void;
+    /** Keep mounted even when filtered out */
+    forceMount?: boolean;
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
+    shortcut?: ReactNode;
+}
+type CommandShortcutProps = HTMLAttributes<HTMLSpanElement>;
+
+declare const defaultCommandFilter: CommandFilter;
+declare function Command({ children, className, value, defaultValue, onValueChange, shouldFilter, filter, selectedValue: selectedValueProp, defaultSelectedValue, onSelectedValueChange, label, onKeyDown, ...props }: CommandProps): react.JSX.Element;
+declare function CommandDialog({ children, commandProps, size, ...dialogProps }: CommandDialogProps): react.JSX.Element;
+declare const CommandInput: react.ForwardRefExoticComponent<Omit<react.InputHTMLAttributes<HTMLInputElement>, "size" | "value" | "onChange"> & {
+    startIcon?: ReactNode;
+} & react.RefAttributes<HTMLInputElement>>;
+declare function CommandList({ className, children, ...props }: CommandListProps): react.JSX.Element;
+declare function CommandEmpty({ className, children, ...props }: CommandEmptyProps): react.JSX.Element | null;
+declare function CommandGroup({ className, children, ...props }: CommandGroupProps): react.JSX.Element;
+declare function CommandGroupHeading({ className, children, ...props }: CommandGroupHeadingProps): react.JSX.Element;
+declare function CommandSeparator({ className, ...props }: CommandSeparatorProps): react.JSX.Element;
+declare function CommandShortcut({ className, children, ...props }: CommandShortcutProps): react.JSX.Element;
+declare const CommandItem: react.ForwardRefExoticComponent<CommandItemProps & react.RefAttributes<HTMLButtonElement>>;
+
+type AvatarSize = "3xs" | "2xs" | "xs" | "sm" | "md" | "lg" | "xl" | "2xl" | "3xl";
+/** MCP / Figma `Avatar` `layout` */
+type AvatarLayout = "image" | "icon" | "initials";
+type AvatarColorImage = "neutral";
+type AvatarColorIcon = "blue" | "green" | "lime" | "magenta" | "neutral" | "orange" | "purple" | "red" | "teal" | "yellow";
+type AvatarColorInitials = AvatarColorIcon;
+type AvatarColor = AvatarColorImage | AvatarColorIcon;
+
+/** Web Kit `Avatar/Status` `65:65` — `Online` | `Away` | `Unavailable` | `Offline` */
+type AvatarPresenceStatus = "online" | "away" | "unavailable" | "offline";
+type AvatarProps = Omit<HTMLAttributes<HTMLDivElement>, "color"> & {
+    src?: string | null;
+    alt?: string;
+    /** When slots are omitted, layout is inferred from children. */
+    layout?: AvatarLayout;
+    size?: AvatarSize;
+    showStatus?: boolean;
+    status?: AvatarPresenceStatus;
+    innerClassName?: string;
+    children?: ReactNode;
+    color?: AvatarColor;
+};
+type AvatarImageProps = ImgHTMLAttributes<HTMLImageElement>;
+type AvatarFallbackProps = HTMLAttributes<HTMLSpanElement>;
+type AvatarBadgeProps = HTMLAttributes<HTMLSpanElement> & {
+    status?: AvatarPresenceStatus;
+};
+type AvatarTextProps = HTMLAttributes<HTMLSpanElement>;
+interface AvatarGroupProps extends HTMLAttributes<HTMLDivElement> {
+    size?: AvatarSize;
+    layout?: "stack" | "spread";
+}
+type AvatarGroupCountProps = HTMLAttributes<HTMLSpanElement>;
+type AvatarIconProps = Omit<WebIconProps, "size"> & {
+    size?: number;
+};
+
+declare function AvatarIcon({ size: sizeProp, ...props }: AvatarIconProps): react.JSX.Element;
+declare function Avatar({ src, alt, size, layout, color, showStatus, status, className, innerClassName, children, style, ...props }: AvatarProps): react.JSX.Element;
+declare function AvatarImage(_props: AvatarImageProps): null;
+declare function AvatarFallback({ className, ...props }: AvatarFallbackProps): react.JSX.Element;
+declare function AvatarText({ className, ...props }: AvatarTextProps): react.JSX.Element;
+declare function AvatarBadge({ className, status, style, ...props }: AvatarBadgeProps): react.JSX.Element;
+declare function AvatarGroup({ size, layout, className, children, style, ...props }: AvatarGroupProps): react.JSX.Element;
+declare function AvatarGroupCount({ className, ...props }: AvatarGroupCountProps): react.JSX.Element;
+
+type AvatarsSize = AvatarSize;
+type AvatarsLayout = "stack" | "spread";
+interface AvatarItem {
+    src?: string | null;
+    alt: string;
+}
+interface AvatarsProps extends HTMLAttributes<HTMLDivElement> {
+    avatars: AvatarItem[];
+    size?: AvatarsSize;
+    max?: number;
+    layout?: AvatarsLayout;
+}
+
+declare function Avatars({ avatars, size, max, layout, className, style, ...props }: AvatarsProps): react.JSX.Element;
+
+type AlertVariant = "default" | "info" | "success" | "warning" | "danger" | "custom";
+interface AlertProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: AlertVariant;
+}
+interface AlertIconProps extends HTMLAttributes<HTMLDivElement> {
+    name?: string;
+    children?: ReactNode;
+}
+type AlertContentProps = HTMLAttributes<HTMLDivElement>;
+type AlertRowProps = HTMLAttributes<HTMLDivElement>;
+type AlertBodyProps = HTMLAttributes<HTMLDivElement>;
+type AlertActionsProps = HTMLAttributes<HTMLDivElement>;
+type AlertActionProps = ButtonHTMLAttributes<HTMLButtonElement>;
+type AlertCloseProps = ButtonHTMLAttributes<HTMLButtonElement>;
+type AlertTitleProps = HTMLAttributes<HTMLHeadingElement>;
+type AlertDescriptionProps = HTMLAttributes<HTMLDivElement>;
+
+declare function AlertIcon({ className, name, children, ...props }: AlertIconProps): react.JSX.Element;
+declare function AlertContent({ className, ...props }: AlertContentProps): react.JSX.Element;
+declare function AlertRow({ className, ...props }: AlertRowProps): react.JSX.Element;
+declare function AlertBody({ className, ...props }: AlertBodyProps): react.JSX.Element;
+declare function AlertActions({ className, ...props }: AlertActionsProps): react.JSX.Element;
+declare function AlertAction({ className, type, ...props }: AlertActionProps): react.JSX.Element;
+declare function AlertClose({ className, type, children, ...props }: AlertCloseProps): react.JSX.Element;
+declare function Alert({ variant, className, children, ...props }: AlertProps): react.JSX.Element;
+
+declare function AlertTitle({ className, ...props }: AlertTitleProps): react.JSX.Element;
+
+declare function AlertDescription({ className, ...props }: AlertDescriptionProps): react.JSX.Element;
+
+interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
+    value: number;
+    max?: number;
+    /** Web Kit `Progress bar` `452:3994` — Small(2px) / Large(4px) */
+    size?: "sm" | "lg";
+}
+
+declare function Progress({ value, max, size, className, ...props }: ProgressProps): react.JSX.Element;
+
+type ProgressStepperState = "complete" | "current" | "upcoming";
+interface ProgressStepperProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** Controlled active step value. */
+    value?: number;
+    /** Uncontrolled initial step. */
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+}
+interface ProgressStepperListProps extends OlHTMLAttributes<HTMLOListElement> {
+}
+interface ProgressStepperItemProps extends LiHTMLAttributes<HTMLLIElement> {
+    /** Step identity used with `ProgressStepper` value. */
+    value: number;
+    disabled?: boolean;
+}
+interface ProgressStepperMarkerProps extends HTMLAttributes<HTMLSpanElement> {
+}
+interface ProgressStepperLabelProps extends HTMLAttributes<HTMLSpanElement> {
+}
+
+declare function ProgressStepper({ children, className, style, value: valueControlled, defaultValue, onValueChange, ...props }: ProgressStepperProps): react.JSX.Element;
+declare namespace ProgressStepper {
+    var displayName: string;
+}
+declare function ProgressStepperList({ className, children, style, ...props }: ProgressStepperListProps): react.JSX.Element;
+declare namespace ProgressStepperList {
+    var displayName: string;
+}
+declare function ProgressStepperItem({ value: itemValue, disabled, className, onClick, onKeyDown, children, ...props }: ProgressStepperItemProps): react.JSX.Element;
+declare namespace ProgressStepperItem {
+    var displayName: string;
+}
+declare function ProgressStepperMarker({ className, children, style, ...props }: ProgressStepperMarkerProps): react.JSX.Element;
+declare namespace ProgressStepperMarker {
+    var displayName: string;
+}
+declare function ProgressStepperLabel({ className, ...props }: ProgressStepperLabelProps): react.JSX.Element;
+declare namespace ProgressStepperLabel {
+    var displayName: string;
+}
+
+/** Web Kit `550:3669` — short tier ids (`xs` … `xxl`) */
+type SpinnerSize = "xs" | "sm" | "md" | "lg" | "xl" | "xxl";
+type SpinnerLabelPosition = "left" | "right" | "top" | "bottom";
+interface SpinnerProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    size?: SpinnerSize;
+    label?: ReactNode;
+    labelPosition?: SpinnerLabelPosition;
+}
+
+declare function Spinner({ size, label, labelPosition, className, ...props }: SpinnerProps): react.JSX.Element;
+
+interface TabsProps extends HTMLAttributes<HTMLDivElement> {
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+interface TabsListProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface TabsTriggerProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "type"> {
+    value: string;
+    children: ReactNode;
+}
+interface TabsContentProps extends HTMLAttributes<HTMLDivElement> {
+    value: string;
+}
+
+declare function Tabs({ children, className, defaultValue, value: valueControlled, onValueChange, ...props }: TabsProps): react.JSX.Element;
+declare function TabsList({ className, children, ...props }: TabsListProps): react.JSX.Element;
+declare const TabsTrigger: react.ForwardRefExoticComponent<TabsTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+declare function TabsContent({ value, className, children, hidden: hiddenProp, ...props }: TabsContentProps): react.JSX.Element;
+
+interface SegmentedControlProps extends HTMLAttributes<HTMLDivElement> {
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+}
+interface SegmentedControlItemProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "type"> {
+    value: string;
+    children: ReactNode;
+}
+
+declare function SegmentedControl({ children, className, defaultValue, value: valueControlled, onValueChange, ...props }: SegmentedControlProps): react.JSX.Element;
+declare const SegmentedControlItem: react.ForwardRefExoticComponent<SegmentedControlItemProps & react.RefAttributes<HTMLButtonElement>>;
+
+type TableProps = TableHTMLAttributes<HTMLTableElement>;
+type TableHeaderProps = HTMLAttributes<HTMLTableSectionElement>;
+type TableBodyProps = HTMLAttributes<HTMLTableSectionElement>;
+type TableFooterProps = HTMLAttributes<HTMLTableSectionElement>;
+type TableRowProps = HTMLAttributes<HTMLTableRowElement>;
+type TableHeadProps = ThHTMLAttributes<HTMLTableCellElement>;
+type TableCellProps = TdHTMLAttributes<HTMLTableCellElement>;
+type TableCaptionProps = HTMLAttributes<HTMLTableCaptionElement>;
+
+/** Dense semantic table — hover / selected via `refineui.css`. Overflow via composed `ScrollArea`. */
+declare const Table: react.ForwardRefExoticComponent<TableProps & react.RefAttributes<HTMLTableElement>>;
+declare function TableHeader({ className, ...props }: TableHeaderProps): react.JSX.Element;
+declare function TableBody({ className, ...props }: TableBodyProps): react.JSX.Element;
+declare function TableFooter({ className, ...props }: TableFooterProps): react.JSX.Element;
+declare function TableRow({ className, ...props }: TableRowProps): react.JSX.Element;
+declare function TableHead({ className, scope, ...props }: TableHeadProps): react.JSX.Element;
+declare function TableCell({ className, ...props }: TableCellProps): react.JSX.Element;
+declare function TableCaption({ className, ...props }: TableCaptionProps): react.JSX.Element;
+
+type AccordionSize = "sm" | "md" | "lg";
+type AccordionType = "single" | "multiple";
+
+interface AccordionProps extends HTMLAttributes<HTMLDivElement> {
+    type?: AccordionType;
+    collapsible?: boolean;
+    defaultValue?: string | string[];
+    value?: string | string[];
+    onValueChange?: (value: string | string[] | undefined) => void;
+    /** Web Kit size tier — scales trigger & content typography via `componentTypographyTokens.accordion`. */
+    size?: AccordionSize;
+}
+declare function Accordion({ type, collapsible, defaultValue, value, onValueChange, size, className, children, ...props }: AccordionProps): react.JSX.Element;
+
+interface AccordionItemSlotProps extends HTMLAttributes<HTMLDivElement> {
+    value: string;
+    icon?: string;
+}
+declare function AccordionItem({ value, icon, className, children, ...props }: AccordionItemSlotProps): react.JSX.Element;
+
+interface AccordionTriggerProps extends HTMLAttributes<HTMLButtonElement> {
+}
+declare function AccordionTrigger({ className, children, ...props }: AccordionTriggerProps): react.JSX.Element;
+
+interface AccordionContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare function AccordionContent({ className, children, ...props }: AccordionContentProps): react.JSX.Element;
+
+type BreadcrumbProps = HTMLAttributes<HTMLElement>;
+type BreadcrumbListProps = OlHTMLAttributes<HTMLOListElement>;
+type BreadcrumbItemProps = LiHTMLAttributes<HTMLLIElement>;
+interface BreadcrumbLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+}
+type BreadcrumbPageProps = HTMLAttributes<HTMLSpanElement>;
+type BreadcrumbSeparatorProps = LiHTMLAttributes<HTMLLIElement>;
+type BreadcrumbEllipsisProps = HTMLAttributes<HTMLSpanElement>;
+type BreadcrumbEllipsisTriggerProps = ButtonHTMLAttributes<HTMLButtonElement>;
+
+declare function Breadcrumb({ className, ...props }: BreadcrumbProps): react.JSX.Element;
+declare function BreadcrumbList({ className, ...props }: BreadcrumbListProps): react.JSX.Element;
+declare function BreadcrumbItem({ className, ...props }: BreadcrumbItemProps): react.JSX.Element;
+declare const breadcrumbLinkClassName: string;
+declare function BreadcrumbLink({ className, children, ...props }: BreadcrumbLinkProps): react.JSX.Element;
+declare function BreadcrumbPage({ className, ...props }: BreadcrumbPageProps): react.JSX.Element;
+declare function BreadcrumbSeparator({ children, className, ...props }: BreadcrumbSeparatorProps): react.JSX.Element;
+declare function BreadcrumbEllipsis({ className, ...props }: BreadcrumbEllipsisProps): react.JSX.Element;
+declare const BreadcrumbEllipsisTrigger: react.ForwardRefExoticComponent<BreadcrumbEllipsisTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+
+type FooterProps = HTMLAttributes<HTMLElement>;
+type FooterExploreProps = HTMLAttributes<HTMLDivElement>;
+type FooterContentProps = FooterExploreProps;
+type FooterBrandProps = HTMLAttributes<HTMLDivElement>;
+type FooterLogoProps = HTMLAttributes<HTMLDivElement>;
+type FooterBrandNameProps = HTMLAttributes<HTMLParagraphElement>;
+type FooterBrandDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+type FooterNavProps = HTMLAttributes<HTMLElement>;
+type FooterGroupProps = HTMLAttributes<HTMLDivElement>;
+type FooterGroupLabelProps = HTMLAttributes<HTMLParagraphElement>;
+interface FooterLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+}
+type FooterMetaProps = HTMLAttributes<HTMLDivElement>;
+type FooterBottomProps = FooterMetaProps;
+type FooterMetaEndProps = HTMLAttributes<HTMLDivElement>;
+type FooterCopyrightProps = HTMLAttributes<HTMLParagraphElement>;
+type FooterLocaleProps = HTMLAttributes<HTMLElement>;
+type FooterSocialProps = HTMLAttributes<HTMLDivElement>;
+
+/** Site footer landmark — token composition (no Web Kit COMPONENT_SET). */
+declare function Footer({ className, ...props }: FooterProps): react.JSX.Element;
+declare function FooterExplore({ className, ...props }: FooterExploreProps): react.JSX.Element;
+/** Alias of `FooterExplore`. */
+declare const FooterContent: typeof FooterExplore;
+declare function FooterBrand({ className, ...props }: FooterBrandProps): react.JSX.Element;
+declare function FooterLogo({ className, ...props }: FooterLogoProps): react.JSX.Element;
+declare function FooterBrandName({ className, ...props }: FooterBrandNameProps): react.JSX.Element;
+declare function FooterBrandDescription({ className, ...props }: FooterBrandDescriptionProps): react.JSX.Element;
+declare function FooterNav({ className, "aria-label": ariaLabel, ...props }: FooterNavProps): react.JSX.Element;
+declare function FooterGroup({ className, ...props }: FooterGroupProps): react.JSX.Element;
+declare function FooterGroupLabel({ className, ...props }: FooterGroupLabelProps): react.JSX.Element;
+declare const footerLinkClassName: string;
+declare const footerSocialLinkClassName: string;
+declare const footerLocaleLinkClassName: string;
+declare const footerLocaleTriggerClassName: string;
+declare function FooterLink({ className, ...props }: FooterLinkProps): react.JSX.Element;
+declare function FooterMeta({ className, ...props }: FooterMetaProps): react.JSX.Element;
+/** Alias of `FooterMeta`. */
+declare const FooterBottom: typeof FooterMeta;
+declare function FooterMetaEnd({ className, ...props }: FooterMetaEndProps): react.JSX.Element;
+declare function FooterCopyright({ className, ...props }: FooterCopyrightProps): react.JSX.Element;
+declare function FooterLocale({ className, ...props }: FooterLocaleProps): react.JSX.Element;
+declare function FooterSocial({ className, ...props }: FooterSocialProps): react.JSX.Element;
+
+type CalendarMode = "single" | "range";
+interface CalendarProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    mode?: CalendarMode;
+    value?: Date;
+    onChange?: (date: Date) => void;
+    rangeStart?: Date;
+    rangeEnd?: Date;
+    onRangeChange?: (start: Date | undefined, end: Date | undefined) => void;
+    weekStartsOn?: 0 | 1;
+    defaultMonth?: Date;
+}
+
+declare function Calendar({ mode, value, onChange, rangeStart, rangeEnd, onRangeChange, weekStartsOn, defaultMonth, className, ...props }: CalendarProps): react.JSX.Element;
+
+type DividerHTML = Omit<HTMLAttributes<HTMLDivElement>, "children">;
+type DividerAlign = "center" | "left" | "right";
+type DividerProps = (DividerHTML & {
+    layout?: "default";
+}) | (DividerHTML & {
+    layout: "content";
+    children: ReactNode;
+    align?: DividerAlign;
+}) | (DividerHTML & {
+    layout: "icon";
+    align?: DividerAlign;
+});
+
+/** Divider — layout default · content · icon; align center · left · right (horizontal). */
+declare function Divider(props: DividerProps): react.JSX.Element;
+
+type LayoutGap = keyof SpacingTokens;
+type LayoutDirection = "row" | "column" | "row-reverse" | "column-reverse";
+type LayoutAlign = "start" | "center" | "end" | "stretch" | "baseline";
+type LayoutJustify = "start" | "center" | "end" | "between" | "around" | "evenly";
+type LayoutWrap = "nowrap" | "wrap" | "wrap-reverse";
+type LayoutAs = ElementType;
+type LayoutRadius = keyof BorderRadiusTokens;
+type LayoutStroke = keyof StrokeWidthTokens;
+type LayoutBackground = Extract<SemanticColorName, `background${string}` | `surface${string}`>;
+type LayoutBorderColor = Extract<SemanticColorName, `border${string}`>;
+type DivProps = HTMLAttributes<HTMLDivElement>;
+type DivPropsNoAlign = Omit<DivProps, "align">;
+interface StackProps extends DivPropsNoAlign {
+    as?: LayoutAs;
+    direction?: LayoutDirection;
+    gap?: LayoutGap;
+    align?: LayoutAlign;
+    justify?: LayoutJustify;
+    wrap?: LayoutWrap | boolean;
+    inline?: boolean;
+}
+interface GridProps extends DivPropsNoAlign {
+    as?: LayoutAs;
+    columns?: number;
+    minItem?: FoundationSizeName;
+    gap?: LayoutGap;
+    columnGap?: LayoutGap;
+    rowGap?: LayoutGap;
+    align?: LayoutAlign;
+    justify?: LayoutJustify;
+}
+interface GridItemProps extends DivProps {
+    as?: LayoutAs;
+    span?: number;
+    rowSpan?: number;
+}
+interface ContainerProps extends DivProps {
+    as?: LayoutAs;
+    padding?: LayoutGap;
+}
+type SpacerProps = DivProps;
+interface BoxProps extends DivProps {
+    as?: LayoutAs;
+    padding?: LayoutGap;
+    paddingX?: LayoutGap;
+    paddingY?: LayoutGap;
+    background?: LayoutBackground;
+    radius?: LayoutRadius;
+    border?: LayoutStroke;
+    borderColor?: LayoutBorderColor;
+}
+
+/** One-axis flex layout with Foundation `gap`. */
+declare function Stack({ as: Component, direction, gap, align, justify, wrap, inline, className, ...props }: StackProps): react.JSX.Element;
+
+/** CSS grid with equal columns or Foundation `minItem` auto-fit. */
+declare function Grid({ as: Component, columns, minItem, gap, columnGap, rowGap, align, justify, className, style, ...props }: GridProps): react.JSX.Element;
+/** Column / row span inside `Grid`. */
+declare function GridItem({ as: Component, span, rowSpan, className, style, ...props }: GridItemProps): react.JSX.Element;
+
+/** Full-width column with Foundation horizontal padding. */
+declare function Container({ as: Component, padding, className, ...props }: ContainerProps): react.JSX.Element;
+
+/** Padding, semantic fill, radius, and border. */
+declare function Box({ as: Component, padding, paddingX, paddingY, background, radius, border, borderColor, className, style, ...props }: BoxProps): react.JSX.Element;
+
+/** Flex-grow filler between Stack children. */
+declare function Spacer({ className, ...props }: SpacerProps): react.JSX.Element;
+
+type DrawerPlacement = "left" | "right";
+type DrawerSize = "sm" | "md" | "lg";
+type DrawerType = "overlay" | "inline";
+type DrawerFooterState = "icons" | "single" | "split";
+interface DrawerProps {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    /** Web Kit Drawer `Type` — Overlay | Inline */
+    type?: DrawerType;
+    /** Web Kit Drawer `showFooter` variant */
+    showFooter?: boolean;
+    placement?: DrawerPlacement;
+    /** Web Kit Overlay `635:1756` — `componentSizes.drawerWidthSm` / `Md` / `Lg` */
+    size?: DrawerSize;
+    children: ReactNode;
+}
+type DrawerTriggerProps = ButtonProps;
+interface DrawerContentProps extends Omit<HTMLAttributes<HTMLDivElement>, "title"> {
+    container?: Element | DocumentFragment | null;
+    style?: CSSProperties;
+    type?: DrawerType;
+    showFooter?: boolean;
+    placement?: DrawerPlacement;
+    size?: DrawerSize;
+}
+interface DrawerHeaderProps extends HTMLAttributes<HTMLDivElement> {
+    showClose?: boolean;
+    actions?: ReactNode;
+}
+type DrawerTitleProps = HTMLAttributes<HTMLHeadingElement>;
+type DrawerDescriptionProps = HTMLAttributes<HTMLParagraphElement>;
+type DrawerBodyProps = HTMLAttributes<HTMLDivElement>;
+interface DrawerFooterProps extends HTMLAttributes<HTMLDivElement> {
+    /** Web Kit Drawer/Footer state */
+    state?: DrawerFooterState;
+}
+interface DrawerCloseProps extends Omit<ButtonProps, "children"> {
+    children?: ReactNode;
+}
+
+declare function Drawer({ open: openProp, defaultOpen, onOpenChange, type, showFooter, placement, size, children, }: DrawerProps): react.JSX.Element;
+declare const DrawerTrigger: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+declare function DrawerContent({ className, style, container, children, type: typeProp, showFooter: showFooterProp, placement: placementProp, size: sizeProp, ...props }: DrawerContentProps): react.JSX.Element | null;
+declare function DrawerHeader({ className, children, showClose, actions, ...props }: DrawerHeaderProps): react.JSX.Element;
+declare function DrawerTitle({ className, id, children, ...props }: DrawerTitleProps): react.JSX.Element;
+declare function DrawerDescription({ className, id, children, ...props }: DrawerDescriptionProps): react.JSX.Element;
+declare function DrawerBody({ className, ...props }: DrawerBodyProps): react.JSX.Element;
+declare function DrawerFooter({ className, ...props }: DrawerFooterProps): react.JSX.Element | null;
+declare function DrawerClose({ children, onClick, className, type, variant, size, layout, ...props }: DrawerCloseProps): react.JSX.Element;
+
+type MenuAlign = "start" | "end" | "center";
+interface DropdownTriggerProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    children: ReactNode;
+}
+interface DropdownContentProps extends HTMLAttributes<HTMLDivElement> {
+    align?: MenuAlign;
+    side?: "auto" | "top" | "bottom";
+    /** Gap between trigger and panel — default `sizeXXSmall` (4px). */
+    sideOffset?: number;
+}
+interface DropdownItemProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    children: ReactNode;
+    selected?: boolean;
+}
+interface DropdownSubTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    children: ReactNode;
+}
+interface DropdownSubContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+
+declare function Dropdown({ className, children, defaultOpen, open: openProp, onOpenChange, ...props }: HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}): react.JSX.Element;
+/** Like `PopoverTrigger` / `MenuTrigger`: merge ref/events onto one mergeable child, else wrap in `button`. */
+declare function DropdownTrigger({ children, className, ...props }: DropdownTriggerProps): react.JSX.Element;
+declare function DropdownContent({ className, align, side, sideOffset, style, children, ...props }: DropdownContentProps): react.ReactPortal | null;
+declare function DropdownGroup({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+declare function DropdownLabel({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+declare function DropdownItem({ className, disabled, selected, children, onClick, style, onPointerDown, onPointerUp, onPointerLeave, onPointerCancel, onMouseDown, onMouseUp, onMouseLeave, ...props }: DropdownItemProps): react.JSX.Element;
+declare function DropdownSeparator({ className, ...props }: HTMLAttributes<HTMLDivElement>): react.JSX.Element;
+declare function DropdownShortcut({ className, ...props }: HTMLAttributes<HTMLSpanElement>): react.JSX.Element;
+/** Legacy: sub-panel already portals to `document.body` internally — renders children only. */
+declare function DropdownPortal({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+declare function DropdownSub({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+declare function DropdownSubTrigger({ className, children, onClick, onPointerEnter, onPointerLeave, disabled, ...props }: DropdownSubTriggerProps): react.JSX.Element;
+declare function DropdownSubContent({ className, children, style, ...props }: DropdownSubContentProps): react.ReactPortal | null;
+
+interface LabelProps extends LabelHTMLAttributes<HTMLLabelElement> {
+    /**
+     * Convenience: appends `LabelRequired`. Prefer composing `<LabelRequired />` (same as Field).
+     */
+    required?: boolean;
+    size?: "sm" | "md" | "lg";
+    disabled?: boolean;
+}
+type LabelRequiredProps = HTMLAttributes<HTMLSpanElement>;
+
+interface FieldProps extends HTMLAttributes<HTMLDivElement> {
+    size?: "sm" | "md" | "lg";
+}
+/** Same surface as `Label`; `size` defaults from nearest `Field`. */
+type FieldLabelProps = LabelProps;
+/** Alias of `LabelRequired` for Field composition. */
+type FieldRequiredProps = LabelRequiredProps;
+interface FieldHintProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+interface FieldErrorProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+declare function Field({ size, className, ...props }: FieldProps): react.JSX.Element;
+/** Field-scoped `Label` — inherits `Field` `size` unless `size` is passed explicitly. */
+declare function FieldLabel({ size: sizeProp, className, ...props }: FieldLabelProps): react.JSX.Element;
+/** Field-scoped required mark — same atom as `LabelRequired`. */
+declare function FieldRequired(props: FieldRequiredProps): react.JSX.Element;
+declare function FieldHint({ className, ...props }: FieldHintProps): react.JSX.Element;
+declare function FieldError({ className, ...props }: FieldErrorProps): react.JSX.Element;
+
+declare function Label({ required, size, disabled, children, className, ...props }: LabelProps): react.JSX.Element;
+
+/** Required asterisk — Web Kit `red700` / alias `foregroundError`. Decorative (`aria-hidden`). */
+declare function LabelRequired({ className, children, ...props }: LabelRequiredProps): react.JSX.Element;
+
+interface LinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    /**
+     * When true, show the external-link icon. When omitted, shown automatically for `target="_blank"`.
+     * Set false to hide the icon even for new windows.
+     */
+    showExternalIcon?: boolean;
+    /** Disabled — sets `aria-disabled` and blocks pointer events (anchors have no native `disabled`). */
+    disabled?: boolean;
+}
+
+/** Web Kit `Link` `226:158` — colors and underline via `refineui.css` `[data-refineui="link"]`. */
+declare function Link({ showExternalIcon, target, disabled, children, className, ...props }: LinkProps): react.JSX.Element;
+
+type MenuPositioning = {
+    autoSize?: boolean;
+};
+interface MenuProps extends HTMLAttributes<HTMLDivElement> {
+    positioning?: MenuPositioning;
+}
+interface MenuPopoverProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface MenuListProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface MenuSectionProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+interface MenuDividerProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface MenuItemProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    children: ReactNode;
+    description?: ReactNode;
+    shortcut?: ReactNode;
+    startIcon?: ReactNode;
+    endIcon?: ReactNode;
+    state?: "default" | "hover" | "pressed" | "active" | "disabled";
+}
+/** Submenu trigger — chevron is built-in (Web Kit endIcon). */
+interface MenuSubTriggerProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    children: ReactNode;
+    description?: ReactNode;
+    startIcon?: ReactNode;
+    state?: "default" | "hover" | "pressed" | "active" | "disabled";
+}
+type MenuSubContentProps = HTMLAttributes<HTMLDivElement>;
+
+declare function Menu({ children, className, positioning, ...props }: MenuProps): react.JSX.Element;
+type MenuTriggerProps = {
+    children: ReactNode;
+};
+declare function MenuTrigger({ children }: MenuTriggerProps): react.JSX.Element;
+declare function MenuPopover({ className, children, style, ...props }: MenuPopoverProps): react.ReactPortal | null;
+declare function MenuList({ className, ...props }: MenuListProps): react.JSX.Element;
+/** Web Kit `Menu / Section` (`633:4258`) */
+declare function MenuSection({ className, children, ...props }: MenuSectionProps): react.JSX.Element;
+/** Web Kit `Menu / Section` Divider (`633:4263`) */
+declare function MenuDivider({ className, ...props }: MenuDividerProps): react.JSX.Element;
+declare function MenuItem({ children, description, shortcut, startIcon, endIcon, className, disabled, state, onClick, onKeyDown, ...props }: MenuItemProps): react.JSX.Element;
+/** Nested menu branch — chevron item opens a sibling panel (Web Kit endIcon / submenu). */
+declare function MenuSub({ children }: {
+    children: ReactNode;
+}): react.JSX.Element;
+declare function MenuSubTrigger({ children, description, startIcon, className, disabled, state, onClick, onPointerEnter, onPointerLeave, ...props }: MenuSubTriggerProps): react.JSX.Element;
+declare function MenuSubContent({ className, children, style, ...props }: MenuSubContentProps): react.ReactPortal | null;
+
+interface NavigationMenuProps extends Omit<HTMLAttributes<HTMLElement>, "defaultValue"> {
+    /** Controlled open item value (`""` = closed). */
+    value?: string;
+    /** Uncontrolled initial open item value. */
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    /**
+     * Delay (ms) before opening a panel on pointer enter.
+     * Defaults to semantic `duration.normal`.
+     */
+    delayDuration?: number;
+    /**
+     * When moving between items while a panel is open, wait this long (ms)
+     * before switching — usually shorter than `delayDuration`.
+     * Defaults to semantic `duration.fast`.
+     */
+    skipDelayDuration?: number;
+    /** Accessible name for the landmark. @default "Main" */
+    "aria-label"?: string;
+}
+interface NavigationMenuListProps extends HTMLAttributes<HTMLUListElement> {
+}
+interface NavigationMenuItemProps extends HTMLAttributes<HTMLLIElement> {
+    /** Stable id for open state. Auto-generated when omitted. */
+    value?: string;
+}
+interface NavigationMenuTriggerProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, "children"> {
+    children: ReactNode;
+}
+interface NavigationMenuContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface NavigationMenuLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Marks the current page (`aria-current="page"`). */
+    active?: boolean;
+}
+interface NavigationMenuIndicatorProps extends HTMLAttributes<HTMLDivElement> {
+}
+
+declare function NavigationMenu({ children, className, value: valueControlled, defaultValue, onValueChange, delayDuration: delayDurationProp, skipDelayDuration: skipDelayDurationProp, "aria-label": ariaLabel, ...props }: NavigationMenuProps): react.JSX.Element;
+declare function NavigationMenuList({ className, onKeyDown, ...props }: NavigationMenuListProps): react.JSX.Element;
+declare function NavigationMenuItem({ children, className, value: valueProp, onPointerEnter, onPointerLeave, ...props }: NavigationMenuItemProps): react.JSX.Element;
+declare function NavigationMenuTrigger({ children, className, disabled, onClick, onKeyDown, ...props }: NavigationMenuTriggerProps): react.JSX.Element;
+declare function NavigationMenuContent({ children, className, onKeyDown, ...props }: NavigationMenuContentProps): react.JSX.Element | null;
+declare function NavigationMenuLink({ children, className, active, onClick, onFocus, "aria-disabled": ariaDisabled, ...props }: NavigationMenuLinkProps): react.JSX.Element;
+declare function NavigationMenuIndicator({ className, style, ...props }: NavigationMenuIndicatorProps): react.JSX.Element | null;
+
+type SidebarProps = HTMLAttributes<HTMLElement>;
+type SidebarHeaderProps = HTMLAttributes<HTMLDivElement>;
+type SidebarBrandProps = HTMLAttributes<HTMLDivElement>;
+type SidebarContentProps = HTMLAttributes<HTMLDivElement>;
+type SidebarNavProps = HTMLAttributes<HTMLElement>;
+type SidebarGroupProps = HTMLAttributes<HTMLDivElement>;
+type SidebarGroupLabelProps = HTMLAttributes<HTMLParagraphElement>;
+type SidebarFooterProps = HTMLAttributes<HTMLDivElement>;
+type SidebarPeekMode = "contained" | "viewport";
+interface SidebarPeekProps extends HTMLAttributes<HTMLDivElement> {
+    /** When false, peek edge/panel/inset offset are inactive. */
+    enabled?: boolean;
+    /** Flyout width as a percentage of the peek root width. */
+    widthPercent: number;
+    mode?: SidebarPeekMode;
+    /** Pin / expand the docked sidebar (flyout toolbar). */
+    onPin?: () => void;
+}
+type SidebarPeekEdgeProps = HTMLAttributes<HTMLDivElement>;
+type SidebarPeekPanelProps = HTMLAttributes<HTMLDivElement>;
+type SidebarPeekPinProps = HTMLAttributes<HTMLDivElement>;
+type SidebarPeekInsetProps = HTMLAttributes<HTMLDivElement>;
+interface SidebarLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    /** Marks the current page (`aria-current="page"`). */
+    active?: boolean;
+}
+
+/** App sidebar landmark — token composition (no Web Kit COMPONENT_SET). */
+declare function Sidebar({ className, ...props }: SidebarProps): react.JSX.Element;
+declare function SidebarHeader({ className, ...props }: SidebarHeaderProps): react.JSX.Element;
+declare function SidebarBrand({ className, ...props }: SidebarBrandProps): react.JSX.Element;
+declare function SidebarContent({ className, ...props }: SidebarContentProps): react.JSX.Element;
+declare function SidebarNav({ className, "aria-label": ariaLabel, ...props }: SidebarNavProps): react.JSX.Element;
+declare function SidebarGroup({ className, ...props }: SidebarGroupProps): react.JSX.Element;
+declare function SidebarGroupLabel({ className, ...props }: SidebarGroupLabelProps): react.JSX.Element;
+declare function SidebarLink({ className, active, "aria-disabled": ariaDisabled, ...props }: SidebarLinkProps): react.JSX.Element;
+declare function SidebarFooter({ className, ...props }: SidebarFooterProps): react.JSX.Element;
+
+type SidebarPeekContextValue = {
+    enabled: boolean;
+    mode: "contained" | "viewport";
+    peekOpen: boolean;
+    flyoutWidthPx: number | undefined;
+    schedulePeekOpen: () => void;
+    schedulePeekClose: (delay?: number) => void;
+    closePeekImmediate: () => void;
+    cancelPeekClose: () => void;
+    cancelPeekOpen: () => void;
+    onPin?: () => void;
+};
+declare function SidebarPeek({ enabled, widthPercent, mode, onPin, className, style, children, ...props }: SidebarPeekProps): react.JSX.Element;
+declare function SidebarPeekEdge({ className, ...props }: SidebarPeekEdgeProps): react.JSX.Element | null;
+declare function SidebarPeekPanel({ className, children, ...props }: SidebarPeekPanelProps): react.JSX.Element | null;
+declare function SidebarPeekPin({ className, children, ...props }: SidebarPeekPinProps): react.JSX.Element;
+declare function SidebarPeekInset({ className, style, children, ...props }: SidebarPeekInsetProps): react.JSX.Element;
+declare function useSidebarPeek(): SidebarPeekContextValue;
+
+type PaginationRootProps = HTMLAttributes<HTMLElement>;
+type PaginationProps = PaginationRootProps;
+type PaginationContentProps = HTMLAttributes<HTMLUListElement>;
+type PaginationItemProps = HTMLAttributes<HTMLLIElement>;
+interface PaginationLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    isActive?: boolean;
+}
+type PaginationPreviousProps = ButtonHTMLAttributes<HTMLButtonElement>;
+type PaginationNextProps = ButtonHTMLAttributes<HTMLButtonElement>;
+type PaginationEllipsisProps = HTMLAttributes<HTMLSpanElement>;
+
+declare function PaginationContent({ className, ...props }: PaginationContentProps): react.JSX.Element;
+declare function PaginationItem({ className, ...props }: PaginationItemProps): react.JSX.Element;
+declare function PaginationLink({ className, isActive, ...props }: PaginationLinkProps): react.JSX.Element;
+declare function PaginationPrevious(props: PaginationPreviousProps): react.JSX.Element;
+declare function PaginationNext(props: PaginationNextProps): react.JSX.Element;
+declare function PaginationEllipsis({ className, ...props }: PaginationEllipsisProps): react.JSX.Element;
+declare function Pagination(props: PaginationProps): react.JSX.Element;
+
+type PopoverPlacement = "top" | "bottom" | "left" | "right";
+type PopoverAlign = "start" | "center" | "end";
+interface PopoverProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    children?: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+interface PopoverTriggerProps extends Omit<HTMLAttributes<HTMLElement>, "children"> {
+    children: ReactNode;
+}
+interface PopoverContentProps extends Omit<HTMLAttributes<HTMLDivElement>, "children"> {
+    children: ReactNode;
+    placement?: PopoverPlacement;
+    align?: PopoverAlign;
+}
+interface PopOverProps extends Omit<HTMLAttributes<HTMLDivElement>, "children" | "content"> {
+    trigger: ReactNode;
+    content: ReactNode;
+    placement?: PopoverPlacement;
+    align?: PopoverAlign;
+}
+type PopOverAlign = PopoverAlign;
+
+declare function Popover({ children, className, open: openProp, defaultOpen, onOpenChange, ...props }: PopoverProps): react.JSX.Element;
+declare function PopoverTrigger({ children, className, ...props }: PopoverTriggerProps): react.JSX.Element;
+declare function PopoverContent({ children, placement, align, className, style: styleProp, ...props }: PopoverContentProps): react.JSX.Element | null;
+declare function PopOver({ trigger, content, placement, align, className, ...props }: PopOverProps): react.JSX.Element;
+
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+    width?: number | string;
+    height?: number | string;
+    /** `rectangle` (default) or `circle` */
+    shape?: "rectangle" | "circle";
+}
+
+declare function Skeleton({ width, height, shape, className, style, ...props }: SkeletonProps): react.JSX.Element;
+
+interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, "type" | "onChange" | "size"> {
+    min?: number;
+    max?: number;
+    step?: number;
+    value?: number;
+    onChange?: (value: number) => void;
+    /** Rail thickness: `sm` (2px) / `md` (4px, default). */
+    size?: "sm" | "md";
+}
+
+declare function Slider({ min, max, step, value, defaultValue, onChange, onInput, size, className, style, ...props }: SliderProps): react.JSX.Element;
+
+interface CarouselProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** Controlled slide index (0-based). */
+    index?: number;
+    /** Uncontrolled initial index. */
+    defaultIndex?: number;
+    onIndexChange?: (index: number) => void;
+    /** Wrap from last → first / first → last. */
+    loop?: boolean;
+}
+interface CarouselContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface CarouselItemProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface CarouselControlsProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface CarouselPreviousProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+}
+interface CarouselNextProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+}
+interface CarouselIndicatorsProps extends HTMLAttributes<HTMLDivElement> {
+}
+
+declare function Carousel({ children, className, index: indexControlled, defaultIndex, onIndexChange, loop, onKeyDown, ...props }: CarouselProps): react.JSX.Element;
+declare function CarouselContent({ className, children, ...props }: CarouselContentProps): react.JSX.Element;
+declare const CarouselItem: react.ForwardRefExoticComponent<CarouselItemProps & react.RefAttributes<HTMLDivElement>>;
+declare function CarouselControls({ className, children, ...props }: CarouselControlsProps): react.JSX.Element;
+declare function CarouselPrevious({ className, disabled, onClick, ...props }: CarouselPreviousProps): react.JSX.Element;
+declare function CarouselNext({ className, disabled, onClick, ...props }: CarouselNextProps): react.JSX.Element;
+declare function CarouselIndicators({ className, ...props }: CarouselIndicatorsProps): react.JSX.Element | null;
+
+type BubbleVariant = "default" | "secondary" | "muted" | "tinted" | "outline" | "ghost" | "destructive";
+type BubbleAlign = "start" | "end";
+type BubbleReactionsSide = "top" | "bottom";
+interface BubbleProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: BubbleVariant;
+    align?: BubbleAlign;
+}
+type BubbleContentProps = HTMLAttributes<HTMLDivElement>;
+interface BubbleReactionsProps extends HTMLAttributes<HTMLDivElement> {
+    side?: BubbleReactionsSide;
+    align?: BubbleAlign;
+}
+type BubbleGroupProps = HTMLAttributes<HTMLDivElement>;
+
+declare function BubbleGroup({ className, ...props }: BubbleGroupProps): react.JSX.Element;
+declare function Bubble({ variant, align, className, style, children, ...props }: BubbleProps): react.JSX.Element;
+declare function BubbleContent({ className, ...props }: BubbleContentProps): react.JSX.Element;
+declare function BubbleReactions({ side, align: alignProp, className, ...props }: BubbleReactionsProps): react.JSX.Element;
+
+type StepperOrientation = "horizontal" | "vertical";
+type StepperState = "complete" | "current" | "upcoming";
+interface StepperProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    /** Controlled active step value. */
+    value?: number;
+    /** Uncontrolled initial step. */
+    defaultValue?: number;
+    onValueChange?: (value: number) => void;
+    orientation?: StepperOrientation;
+}
+interface StepperListProps extends OlHTMLAttributes<HTMLOListElement> {
+}
+interface StepperItemProps extends LiHTMLAttributes<HTMLLIElement> {
+    /** Step identity used with `Stepper` value. */
+    value: number;
+    disabled?: boolean;
+}
+interface StepperIndicatorProps extends HTMLAttributes<HTMLSpanElement> {
+}
+interface StepperContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface StepperTitleProps extends HTMLAttributes<HTMLSpanElement> {
+}
+interface StepperDescriptionProps extends HTMLAttributes<HTMLSpanElement> {
+}
+interface StepperSeparatorProps extends LiHTMLAttributes<HTMLLIElement> {
+}
+
+declare function Stepper({ children, className, style, value: valueControlled, defaultValue, onValueChange, orientation, ...props }: StepperProps): react.JSX.Element;
+declare namespace Stepper {
+    var displayName: string;
+}
+declare function StepperList({ className, children, ...props }: StepperListProps): react.JSX.Element;
+declare namespace StepperList {
+    var displayName: string;
+}
+declare function StepperItem({ value: itemValue, disabled, className, onClick, onKeyDown, children, ...props }: StepperItemProps): react.JSX.Element;
+declare namespace StepperItem {
+    var displayName: string;
+}
+declare function StepperIndicator({ className, children, ...props }: StepperIndicatorProps): react.JSX.Element;
+declare namespace StepperIndicator {
+    var displayName: string;
+}
+declare function StepperContent({ className, ...props }: StepperContentProps): react.JSX.Element;
+declare namespace StepperContent {
+    var displayName: string;
+}
+declare function StepperTitle({ className, ...props }: StepperTitleProps): react.JSX.Element;
+declare namespace StepperTitle {
+    var displayName: string;
+}
+declare function StepperDescription({ className, ...props }: StepperDescriptionProps): react.JSX.Element;
+declare namespace StepperDescription {
+    var displayName: string;
+}
+declare function StepperSeparator({ className, ...props }: StepperSeparatorProps): react.JSX.Element;
+declare namespace StepperSeparator {
+    var displayName: string;
+}
+
+type ResizableOrientation = "horizontal" | "vertical";
+interface ResizablePanelGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, "onResize"> {
+    orientation?: ResizableOrientation;
+    /** Fires after a resize settles with panel sizes in order (percentages summing to ~100). */
+    onLayout?: (sizes: number[]) => void;
+}
+interface ResizablePanelProps extends HTMLAttributes<HTMLDivElement> {
+    /** Initial size as a percentage of the group (default 50). */
+    defaultSize?: number;
+    /** Minimum size percentage (default 10). */
+    minSize?: number;
+    /** Maximum size percentage (default 100). */
+    maxSize?: number;
+    /** Controlled size percentage. */
+    size?: number;
+    onResize?: (size: number) => void;
+}
+interface ResizableHandleProps extends HTMLAttributes<HTMLDivElement> {
+    /** Show a small grip affordance on the separator. */
+    withHandle?: boolean;
+    disabled?: boolean;
+}
+
+declare function ResizablePanelGroup({ children, className, style, orientation, onLayout, ...props }: ResizablePanelGroupProps): react.JSX.Element;
+declare function ResizablePanel({ children, className, style, defaultSize, minSize, maxSize, size: sizeControlled, onResize, ...props }: ResizablePanelProps): react.JSX.Element;
+declare function ResizableHandle({ className, style, withHandle, disabled, onKeyDown, onPointerDown, "aria-label": ariaLabel, "aria-keyshortcuts": ariaKeyshortcuts, ...props }: ResizableHandleProps): react.JSX.Element;
+
+type ScrollAreaOrientation = "vertical" | "horizontal";
+/** When the custom scrollbar is visible. */
+type ScrollAreaType = "hover" | "always";
+interface ScrollAreaProps extends HTMLAttributes<HTMLDivElement> {
+    type?: ScrollAreaType;
+}
+type ScrollAreaViewportProps = HTMLAttributes<HTMLDivElement>;
+interface ScrollAreaScrollbarProps extends HTMLAttributes<HTMLDivElement> {
+    orientation?: ScrollAreaOrientation;
+}
+type ScrollAreaThumbProps = HTMLAttributes<HTMLDivElement>;
+
+declare const ScrollArea: react.ForwardRefExoticComponent<ScrollAreaProps & react.RefAttributes<HTMLDivElement>>;
+declare const ScrollAreaViewport: react.ForwardRefExoticComponent<ScrollAreaViewportProps & react.RefAttributes<HTMLDivElement>>;
+declare function ScrollAreaScrollbar({ orientation, className, children, onPointerDown, ...props }: ScrollAreaScrollbarProps): react.JSX.Element;
+declare function ScrollAreaThumb({ className, style, ...props }: ScrollAreaThumbProps): react.JSX.Element;
+
+interface SpinButtonProps extends Omit<HTMLAttributes<HTMLDivElement>, "onChange"> {
+    value: number;
+    onChange: (value: number) => void;
+    placeholder?: string;
+    min?: number;
+    max?: number;
+    step?: number;
+    /** Field size — shares Input / Select control height tokens (`sm` / `md` / `lg`). */
+    size?: "sm" | "md" | "lg";
+    disabled?: boolean;
+}
+
+declare function SpinButton({ value, onChange, placeholder, min, max, step, size, disabled, className, onKeyDown, ...props }: SpinButtonProps): react.JSX.Element;
+
+type ToastVariant = "default" | "success" | "error" | "warning";
+type ToastSwipeDirection = "top" | "right" | "bottom" | "left";
+type ToastAction = ReactNode | {
+    label: string;
+    onClick?: () => void;
+    variant?: "primary" | "secondary";
+};
+interface ToastProps extends HTMLAttributes<HTMLDivElement> {
+    variant?: ToastVariant;
+    message?: ReactNode;
+    iconName?: string;
+    icon?: ReactNode;
+    action?: ToastAction;
+    stackState?: "entering" | "idle" | "leaving";
+}
+interface ToastOptions {
+    variant?: ToastVariant;
+    iconName?: string;
+    icon?: ReactNode;
+    action?: ToastAction;
+    duration?: number;
+}
+interface ToasterProps {
+    /** Max visible toasts. Default `1` (new toast replaces the previous). */
+    maxToasts?: number;
+    /** Allowed swipe-to-dismiss directions. Default `["top"]` (fixed top-center placement). */
+    swipeDirections?: ToastSwipeDirection[];
+    className?: string;
+}
+interface ToastRecord {
+    id: string;
+    message?: ReactNode;
+    variant: ToastVariant;
+    iconName?: string;
+    icon?: ReactNode;
+    action?: ToastAction;
+    duration: number;
+    phase: "entering" | "idle" | "leaving";
+}
+
+declare function dismissToast(id?: string): void;
+/** Show a toast. Replaces any visible toast (Material snackbar-style). */
+declare function toast(message: ToastRecord["message"], options?: ToastOptions): string;
+declare const Toast: react.ForwardRefExoticComponent<ToastProps & react.RefAttributes<HTMLDivElement>>;
+declare function Toaster({ maxToasts, swipeDirections, className, }: ToasterProps): react.ReactPortal | null;
+
+type TreeSize = "sm" | "md" | "lg";
+
+interface TreeProps extends HTMLAttributes<HTMLUListElement> {
+    size?: TreeSize;
+    defaultExpanded?: string[];
+    expanded?: string[];
+    onExpandedChange?: (value: string[]) => void;
+    defaultSelected?: string;
+    selected?: string | null;
+    onSelectedChange?: (value: string | null) => void;
+}
+declare function Tree({ size, defaultExpanded, expanded: expandedProp, onExpandedChange, defaultSelected, selected: selectedProp, onSelectedChange, className, children, ...props }: TreeProps): react.JSX.Element;
+
+interface TreeItemProps extends Omit<HTMLAttributes<HTMLLIElement>, "value"> {
+    value: string;
+    disabled?: boolean;
+    children?: ReactNode;
+}
+declare function TreeItem({ value, disabled, className, children, ...props }: TreeItemProps): react.JSX.Element;
+
+interface TreeItemTriggerProps extends HTMLAttributes<HTMLDivElement> {
+}
+declare function TreeItemTrigger({ className, children, onClick, onKeyDown, ...props }: TreeItemTriggerProps): react.JSX.Element;
+
+interface TreeItemContentProps extends HTMLAttributes<HTMLUListElement> {
+}
+declare function TreeItemContent({ className, children, ...props }: TreeItemContentProps): react.JSX.Element;
+
+/** Web Kit MCP Tooltip — `position` */
+type TooltipPosition = "Top" | "Left" | "Bottom" | "Right";
+/** Web Kit MCP Tooltip — `align` */
+type TooltipAlign = "Start" | "Center" | "End";
+interface TooltipProps extends Omit<HTMLAttributes<HTMLDivElement>, "title" | "content"> {
+    trigger: ReactNode;
+    content: ReactNode;
+    position?: TooltipPosition;
+    align?: TooltipAlign;
+    delayMs?: number;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+
+declare function Tooltip({ trigger, content, position, align, delayMs, open: ctrlOpen, defaultOpen, onOpenChange, className, ...props }: TooltipProps): react.JSX.Element;
+
+type ChartSeriesColor = keyof typeof componentColorTokens.chart.series;
+/** Interaction state on a bar / point — same vocabulary as Card / Table. */
+type ChartItemState = "default" | "hover" | "selected";
+interface ChartProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface ChartBodyProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface ChartContentProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface ChartPlotProps extends HTMLAttributes<HTMLDivElement> {
+    /** Accessible name for the chart graphic. */
+    "aria-label"?: string;
+}
+interface ChartGridProps extends Omit<SVGAttributes<SVGGElement>, "values"> {
+    /** Horizontal grid line count (includes baseline). Default `5`. */
+    lines?: number;
+    /** Y scale maximum — auto-derived from `values` when omitted. */
+    max?: number;
+    /** Source values used to derive a nice scale when `max` is omitted. */
+    values?: number[];
+}
+interface ChartBarsProps extends Omit<SVGAttributes<SVGGElement>, "color" | "values"> {
+    values: number[];
+    max?: number;
+    seriesColor?: ChartSeriesColor;
+    /** Full-height track behind each bar. Default `false`. */
+    showTrack?: boolean;
+}
+interface ChartLineProps extends Omit<SVGAttributes<SVGGElement>, "color" | "values"> {
+    values: number[];
+    max?: number;
+    seriesColor?: ChartSeriesColor;
+    /** Area fill under the line. Default `false`. */
+    showArea?: boolean;
+    /** Point markers on each value. Default `false` (hover still shows the active point). */
+    showPoints?: boolean;
+}
+interface ChartYAxisLabelsProps extends HTMLAttributes<HTMLDivElement> {
+    lines?: number;
+    max?: number;
+    values?: number[];
+    formatTick?: (value: number) => string;
+}
+interface ChartAxisLabelsProps extends HTMLAttributes<HTMLDivElement> {
+    labels: string[];
+    /** `bar` centers on band slots; `line` centers on point positions. Default `bar`. */
+    align?: "bar" | "line";
+}
+interface ChartTooltipProps extends HTMLAttributes<HTMLDivElement> {
+}
+interface ChartLegendProps extends HTMLAttributes<HTMLUListElement> {
+}
+interface ChartLegendItemProps extends HTMLAttributes<HTMLLIElement> {
+    seriesColor: ChartSeriesColor;
+}
+
+declare function Chart({ className, children, ...props }: ChartProps): react.JSX.Element;
+declare function ChartBody({ className, ...props }: ChartBodyProps): react.JSX.Element;
+declare function ChartContent({ className, ...props }: ChartContentProps): react.JSX.Element;
+declare function ChartPlot({ className, children, "aria-label": ariaLabel, ...props }: ChartPlotProps): react.JSX.Element;
+declare function ChartTooltip({ className, children, style, ...props }: ChartTooltipProps): react.JSX.Element | null;
+declare function ChartYAxisLabels({ lines, max, values, formatTick, className, ...props }: ChartYAxisLabelsProps): react.JSX.Element;
+declare function ChartGrid({ lines, max, values, className, ...props }: ChartGridProps): react.JSX.Element;
+declare function ChartBars({ values, max, seriesColor, showTrack, className, ...props }: ChartBarsProps): react.JSX.Element;
+declare function ChartLine({ values, max, seriesColor, showArea, showPoints, className, ...props }: ChartLineProps): react.JSX.Element;
+declare function ChartAxisLabels({ labels, align, className, ...props }: ChartAxisLabelsProps): react.JSX.Element;
+declare function ChartLegend({ className, ...props }: ChartLegendProps): react.JSX.Element;
+declare function ChartLegendItem({ seriesColor, className, children, style, ...props }: ChartLegendItemProps): react.JSX.Element;
+
+export { Accordion, AccordionContent, type AccordionContentProps, AccordionItem, type AccordionItemSlotProps, type AccordionProps, type AccordionSize, AccordionTrigger, type AccordionTriggerProps, type AccordionType, Alert, AlertAction, type AlertActionProps, AlertActions, type AlertActionsProps, AlertBody, type AlertBodyProps, AlertClose, type AlertCloseProps, AlertContent, type AlertContentProps, AlertDescription, type AlertDescriptionProps, AlertIcon, type AlertIconProps, type AlertProps, AlertRow, type AlertRowProps, AlertTitle, type AlertTitleProps, type AlertVariant, Avatar, AvatarBadge, type AvatarBadgeProps, type AvatarColor, type AvatarColorIcon, type AvatarColorImage, type AvatarColorInitials, AvatarFallback, type AvatarFallbackProps, AvatarGroup, AvatarGroupCount, type AvatarGroupCountProps, type AvatarGroupProps, AvatarIcon, type AvatarIconProps, AvatarImage, type AvatarImageProps, type AvatarItem, type AvatarLayout, type AvatarPresenceStatus, type AvatarProps, type AvatarSize, AvatarText, type AvatarTextProps, Avatars, type AvatarsLayout, type AvatarsProps, type AvatarsSize, Badge, type BadgeLayout, type BadgeProps, type BadgeVariant, Box, type BoxProps, Breadcrumb, BreadcrumbEllipsis, type BreadcrumbEllipsisProps, BreadcrumbEllipsisTrigger, type BreadcrumbEllipsisTriggerProps, BreadcrumbItem, type BreadcrumbItemProps, BreadcrumbLink, type BreadcrumbLinkProps, BreadcrumbList, type BreadcrumbListProps, BreadcrumbPage, type BreadcrumbPageProps, type BreadcrumbProps, BreadcrumbSeparator, type BreadcrumbSeparatorProps, Bubble, type BubbleAlign, BubbleContent, type BubbleContentProps, BubbleGroup, type BubbleGroupProps, type BubbleProps, BubbleReactions, type BubbleReactionsProps, type BubbleReactionsSide, type BubbleVariant, Button, type ButtonLayout, type ButtonProps, type ButtonSize, type ButtonVariant, Calendar, type CalendarMode, type CalendarProps, Card, CardAction, CardContent, CardDescription, CardFooter, CardHeader, CardHeaderMain, type CardProps, CardTitle, Carousel, CarouselContent, type CarouselContentProps, CarouselControls, type CarouselControlsProps, CarouselIndicators, type CarouselIndicatorsProps, CarouselItem, type CarouselItemProps, CarouselNext, type CarouselNextProps, CarouselPrevious, type CarouselPreviousProps, type CarouselProps, Chart, ChartAxisLabels, type ChartAxisLabelsProps, ChartBars, type ChartBarsProps, ChartBody, type ChartBodyProps, ChartContent, type ChartContentProps, ChartGrid, type ChartGridProps, type ChartItemState, ChartLegend, ChartLegendItem, type ChartLegendItemProps, type ChartLegendProps, ChartLine, type ChartLineProps, ChartPlot, type ChartPlotProps, type ChartProps, type ChartSeriesColor, ChartTooltip, type ChartTooltipProps, ChartYAxisLabels, type ChartYAxisLabelsProps, Checkbox, type CheckboxProps, Chip, type ChipProps, type ChipSize, type ChipVariant, Command, CommandDialog, type CommandDialogProps, CommandEmpty, type CommandEmptyProps, type CommandFilter, CommandGroup, CommandGroupHeading, type CommandGroupHeadingProps, type CommandGroupProps, CommandInput, type CommandInputProps, CommandItem, type CommandItemProps, CommandList, type CommandListProps, type CommandProps, CommandSeparator, type CommandSeparatorProps, CommandShortcut, type CommandShortcutProps, Container, type ContainerProps, type ControlSize, Dialog, DialogClose, type DialogCloseProps, DialogContent, type DialogContentProps, DialogDescription, type DialogDescriptionProps, DialogHeader, type DialogHeaderProps, type DialogProps, DialogTitle, type DialogTitleProps, DialogTrigger, type DialogTriggerProps, Divider, type DividerProps, Drawer, DrawerBody, type DrawerBodyProps, DrawerClose, type DrawerCloseProps, DrawerContent, type DrawerContentProps, DrawerDescription, type DrawerDescriptionProps, DrawerFooter, type DrawerFooterProps, DrawerHeader, type DrawerHeaderProps, type DrawerProps, DrawerTitle, type DrawerTitleProps, DrawerTrigger, type DrawerTriggerProps, Dropdown, type MenuAlign as DropdownAlign, DropdownContent, type DropdownContentProps, DropdownGroup, DropdownItem, type DropdownItemProps, DropdownLabel, DropdownPortal, DropdownSeparator, DropdownShortcut, DropdownSub, DropdownSubContent, type DropdownSubContentProps, DropdownSubTrigger, type DropdownSubTriggerProps, DropdownTrigger, type DropdownTriggerProps, Field, FieldError, type FieldErrorProps, FieldHint, type FieldHintProps, FieldLabel, type FieldLabelProps, type FieldProps, FieldRequired, type FieldRequiredProps, Footer, FooterBottom, type FooterBottomProps, FooterBrand, FooterBrandDescription, type FooterBrandDescriptionProps, FooterBrandName, type FooterBrandNameProps, type FooterBrandProps, FooterContent, type FooterContentProps, FooterCopyright, type FooterCopyrightProps, FooterExplore, type FooterExploreProps, FooterGroup, FooterGroupLabel, type FooterGroupLabelProps, type FooterGroupProps, FooterLink, type FooterLinkProps, FooterLocale, type FooterLocaleProps, FooterLogo, type FooterLogoProps, FooterMeta, FooterMetaEnd, type FooterMetaEndProps, type FooterMetaProps, FooterNav, type FooterNavProps, type FooterProps, FooterSocial, type FooterSocialProps, Grid, GridItem, type GridItemProps, type GridProps, Input, InputOTP, type InputOTPProps, type InputOTPSize, InputOTPSlot, type InputOTPSlotProps, type InputProps, Label, type LabelProps, LabelRequired, type LabelRequiredProps, type LayoutAlign, type LayoutAs, type LayoutBackground, type LayoutBorderColor, type LayoutDirection, type LayoutGap, type LayoutJustify, type LayoutRadius, type LayoutStroke, type LayoutWrap, Link, type LinkProps, Menu, MenuDivider, MenuItem, MenuList, MenuPopover, type MenuProps, MenuSection, MenuSub, MenuSubContent, type MenuSubContentProps, MenuSubTrigger, type MenuSubTriggerProps, MenuTrigger, NavigationMenu, NavigationMenuContent, type NavigationMenuContentProps, NavigationMenuIndicator, type NavigationMenuIndicatorProps, NavigationMenuItem, type NavigationMenuItemProps, NavigationMenuLink, type NavigationMenuLinkProps, NavigationMenuList, type NavigationMenuListProps, type NavigationMenuProps, NavigationMenuTrigger, type NavigationMenuTriggerProps, Pagination, PaginationContent, type PaginationContentProps, PaginationEllipsis, type PaginationEllipsisProps, PaginationItem, type PaginationItemProps, PaginationLink, type PaginationLinkProps, PaginationNext, type PaginationNextProps, PaginationPrevious, type PaginationPreviousProps, type PaginationProps, type PaginationRootProps, PopOver, type PopOverAlign, type PopOverProps, Popover, type PopoverAlign, PopoverContent, type PopoverContentProps, type PopoverPlacement, type PopoverProps, PopoverTrigger, type PopoverTriggerProps, Progress, type ProgressProps, ProgressStepper, ProgressStepperItem, type ProgressStepperItemProps, ProgressStepperLabel, type ProgressStepperLabelProps, ProgressStepperList, type ProgressStepperListProps, ProgressStepperMarker, type ProgressStepperMarkerProps, type ProgressStepperProps, type ProgressStepperState, Radio, RadioInput, type RadioInputProps, type RadioProps, ResizableHandle, type ResizableHandleProps, type ResizableOrientation, ResizablePanel, ResizablePanelGroup, type ResizablePanelGroupProps, type ResizablePanelProps, ScrollArea, type ScrollAreaOrientation, type ScrollAreaProps, ScrollAreaScrollbar, type ScrollAreaScrollbarProps, ScrollAreaThumb, type ScrollAreaThumbProps, type ScrollAreaType, ScrollAreaViewport, type ScrollAreaViewportProps, SearchField, SearchFieldClear, type SearchFieldClearProps, SearchFieldIcon, type SearchFieldIconProps, SearchFieldInput, type SearchFieldInputProps, type SearchFieldProps, SegmentedControl, SegmentedControlItem, type SegmentedControlItemProps, type SegmentedControlProps, Select, SelectArrow, type SelectArrowProps, SelectContent, type SelectContentProps, SelectGroup, type SelectGroupProps, SelectIcon, type SelectIconProps, SelectItem, SelectItemIndicator, type SelectItemIndicatorProps, type SelectItemProps, SelectItemText, type SelectItemTextProps, SelectLabel, type SelectLabelProps, SelectPortal, type SelectPortalProps, type SelectProps, SelectScrollDownButton, type SelectScrollDownButtonProps, SelectScrollUpButton, type SelectScrollUpButtonProps, SelectSection, type SelectSectionProps, SelectSeparator, type SelectSeparatorProps, SelectTrigger, type SelectTriggerAppearance, type SelectTriggerProps, SelectValue, type SelectValueProps, SelectViewport, type SelectViewportProps, Sidebar, SidebarBrand, type SidebarBrandProps, SidebarContent, type SidebarContentProps, SidebarFooter, type SidebarFooterProps, SidebarGroup, SidebarGroupLabel, type SidebarGroupLabelProps, type SidebarGroupProps, SidebarHeader, type SidebarHeaderProps, SidebarLink, type SidebarLinkProps, SidebarNav, type SidebarNavProps, SidebarPeek, SidebarPeekEdge, type SidebarPeekEdgeProps, SidebarPeekInset, type SidebarPeekInsetProps, type SidebarPeekMode, SidebarPeekPanel, type SidebarPeekPanelProps, SidebarPeekPin, type SidebarPeekPinProps, type SidebarPeekProps, type SidebarProps, Skeleton, type SkeletonProps, Slider, type SliderProps, Spacer, type SpacerProps, SpinButton, type SpinButtonProps, Spinner, type SpinnerLabelPosition, type SpinnerProps, type SpinnerSize, Stack, type StackProps, Stepper, StepperContent, type StepperContentProps, StepperDescription, type StepperDescriptionProps, StepperIndicator, type StepperIndicatorProps, StepperItem, type StepperItemProps, StepperList, type StepperListProps, type StepperOrientation, type StepperProps, StepperSeparator, type StepperSeparatorProps, type StepperState, StepperTitle, type StepperTitleProps, Toggle as Switch, type ToggleProps as SwitchProps, Table, TableBody, type TableBodyProps, TableCaption, type TableCaptionProps, TableCell, type TableCellProps, TableFooter, type TableFooterProps, TableHead, type TableHeadProps, TableHeader, type TableHeaderProps, type TableProps, TableRow, type TableRowProps, Tabs, TabsContent, type TabsContentProps, TabsList, type TabsListProps, type TabsProps, TabsTrigger, type TabsTriggerProps, Chip as Tag, type ChipProps as TagProps, type ChipSize as TagSize, type ChipVariant as TagVariant, Text, type TextProps, Textarea, type TextareaProps, Toast, type ToastAction, type ToastOptions, type ToastProps, type ToastSwipeDirection, type ToastVariant, Toaster, type ToasterProps, Toggle, type ToggleProps, Tooltip, type TooltipAlign, type TooltipPosition, type TooltipProps, Tree, TreeItem, TreeItemContent, type TreeItemContentProps, type TreeItemProps, TreeItemTrigger, type TreeItemTriggerProps, type TreeProps, type TreeSize, WebIcon, type WebIconProps, breadcrumbLinkClassName, componentColorTokens, componentTextClass, componentTypographyTokens, defaultCommandFilter, dismissToast, footerLinkClassName, footerLocaleLinkClassName, footerLocaleTriggerClassName, footerSocialLinkClassName, semanticTextClass, sizedComponentTextClass, toast, useSidebarPeek };