glasswind 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,735 @@
+import * as react from 'react';
+import { HTMLAttributes, ReactNode, ButtonHTMLAttributes, InputHTMLAttributes, SelectHTMLAttributes, TextareaHTMLAttributes, RefObject, useEffect } from 'react';
+
+/** Whether one item can be open at a time (`single`) or many (`multiple`). */
+type AccordionType = 'single' | 'multiple';
+/** Open-item value(s): a single item value, or a list of them for `multiple`. */
+type AccordionValue = string | string[];
+interface AccordionProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    /** Whether only one item may be open (`single`) or several (`multiple`). @default 'single' */
+    type?: AccordionType;
+    /** Controlled open value(s). A string for `single`, an array for `multiple`. */
+    value?: AccordionValue;
+    /** Initial open value(s) when uncontrolled. */
+    defaultValue?: AccordionValue;
+    /** Fires with the next open value(s) whenever the open set changes. */
+    onChange?: (value: AccordionValue) => void;
+    /** In `single` mode, allow closing the open item by clicking it again. @default true */
+    collapsible?: boolean;
+    /** One or more `<AccordionItem>` children. */
+    children?: ReactNode;
+}
+/**
+ * Accordion — a stack of collapsible frosted-glass panels.
+ *
+ * Manages the open item(s) through context and `useControllableState`, so it
+ * works controlled (`value` + `onChange`) or uncontrolled (`defaultValue`).
+ * Panels expand with a pure-CSS `grid-template-rows` animation — no height
+ * measuring — and headers support Arrow/Home/End roving focus.
+ */
+declare const Accordion: react.ForwardRefExoticComponent<AccordionProps & react.RefAttributes<HTMLDivElement>>;
+interface AccordionItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Unique value identifying this item within its accordion. */
+    value: string;
+    /** Header content rendered inside the trigger button. */
+    title: ReactNode;
+    /** Disable the header so the item cannot be toggled. @default false */
+    disabled?: boolean;
+    /** Panel content revealed when the item is expanded. */
+    children?: ReactNode;
+}
+/**
+ * AccordionItem — a single header + collapsible panel pair.
+ *
+ * Reads its open state from the parent `<Accordion>` context. The header is a
+ * `<button>` with `aria-expanded`/`aria-controls`; the panel is a region
+ * labelled by that header and animated via `grid-template-rows`.
+ */
+declare const AccordionItem: react.ForwardRefExoticComponent<AccordionItemProps & react.RefAttributes<HTMLDivElement>>;
+
+type AvatarSize = 'sm' | 'md' | 'lg' | 'xl';
+type AvatarShape = 'circle' | 'square';
+type AvatarStatus = 'online' | 'offline' | 'busy' | 'away';
+interface AvatarProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Image URL. When it fails to load, the component falls back to initials. */
+    src?: string;
+    /** Alternative text for the image / accessible label for the fallback. */
+    alt?: string;
+    /** Full name used to derive initials when no image is available. */
+    name?: string;
+    /** Diameter preset. @default 'md' */
+    size?: AvatarSize;
+    /** Outline shape. @default 'circle' */
+    shape?: AvatarShape;
+    /** Presence indicator rendered as a dot at the bottom-right. */
+    status?: AvatarStatus;
+}
+/**
+ * Avatar — a frosted-glass user thumbnail.
+ * Shows a photo when `src` loads, gracefully falls back to initials (from
+ * `name`) or a generic glyph, and can display a colored presence dot.
+ */
+declare const Avatar: react.ForwardRefExoticComponent<AvatarProps & react.RefAttributes<HTMLSpanElement>>;
+
+type BadgeVariant = 'glass' | 'primary' | 'success' | 'danger' | 'warning' | 'info';
+type BadgeSize = 'sm' | 'md';
+interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Visual style. @default 'glass' */
+    variant?: BadgeVariant;
+    /** Text/padding scale. @default 'md' */
+    size?: BadgeSize;
+    /** Render a small leading colored dot before the label. @default false */
+    dot?: boolean;
+    /** Fully-rounded (radius-full) shape. @default true */
+    pill?: boolean;
+}
+/**
+ * Badge — a compact inline label for status, counts, or metadata.
+ * Colored variants use the soft token backgrounds with the solid accent as
+ * text; the default `glass` variant uses the frosted-glass surface.
+ */
+declare const Badge: react.ForwardRefExoticComponent<BadgeProps & react.RefAttributes<HTMLSpanElement>>;
+
+type ButtonVariant = 'glass' | 'primary' | 'secondary' | 'ghost' | 'danger';
+type ButtonSize = 'sm' | 'md' | 'lg';
+interface ButtonProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Visual style. @default 'glass' */
+    variant?: ButtonVariant;
+    /** Control height/padding. @default 'md' */
+    size?: ButtonSize;
+    /** Show a spinner and disable interaction. */
+    loading?: boolean;
+    /** Icon rendered before the label. */
+    leftIcon?: ReactNode;
+    /** Icon rendered after the label. */
+    rightIcon?: ReactNode;
+    /** Stretch to fill the container width. */
+    fullWidth?: boolean;
+}
+/**
+ * Button — the primary action element.
+ * Frosted-glass surface with a GPU-accelerated hover lift and press feedback.
+ */
+declare const Button: react.ForwardRefExoticComponent<ButtonProps & react.RefAttributes<HTMLButtonElement>>;
+
+type CardVariant = 'glass' | 'solid';
+type CardPadding = 'none' | 'sm' | 'md' | 'lg';
+interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    /** Surface style: frosted `glass` or an opaque `solid` panel. @default 'glass' */
+    variant?: CardVariant;
+    /** Inner spacing applied to the card and its sections. @default 'md' */
+    padding?: CardPadding;
+    /** Lift the card on hover with a translateY + stronger shadow. @default false */
+    hoverable?: boolean;
+}
+/**
+ * Card — a frosted-glass surface container.
+ * Compose with `CardHeader`, `CardBody`, and `CardFooter` for structured
+ * content. Features a radius-lg glass surface and a top-edge sheen.
+ */
+declare const Card: react.ForwardRefExoticComponent<CardProps & react.RefAttributes<HTMLDivElement>>;
+/** Props shared by the Card section wrappers (`CardHeader`/`CardBody`/`CardFooter`). */
+type CardSectionProps = HTMLAttributes<HTMLDivElement>;
+/**
+ * CardHeader — top section of a `Card`, separated by a subtle bottom border.
+ */
+declare const CardHeader: react.ForwardRefExoticComponent<CardSectionProps & react.RefAttributes<HTMLDivElement>>;
+/**
+ * CardBody — main content region of a `Card`.
+ */
+declare const CardBody: react.ForwardRefExoticComponent<CardSectionProps & react.RefAttributes<HTMLDivElement>>;
+/**
+ * CardFooter — bottom section of a `Card`, separated by a subtle top border.
+ */
+declare const CardFooter: react.ForwardRefExoticComponent<CardSectionProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Box dimension preset for the checkbox control. */
+type CheckboxSize = 'sm' | 'md' | 'lg';
+interface CheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    /** Text/label rendered next to the box. Omit for a standalone control (pass `aria-label`). */
+    label?: ReactNode;
+    /** Show the tri-state "mixed" dash. Drives the native `indeterminate` DOM property. */
+    indeterminate?: boolean;
+    /** Paint the control in the danger color to signal a validation error. */
+    error?: boolean;
+    /** Size of the check box. @default 'md' */
+    boxSize?: CheckboxSize;
+}
+/**
+ * Checkbox — a custom-styled, fully accessible checkbox.
+ * Wraps a visually hidden native `input[type=checkbox]` so keyboard,
+ * form submission, and screen-reader semantics are preserved while a
+ * frosted-glass box renders the check/indeterminate state.
+ */
+declare const Checkbox: react.ForwardRefExoticComponent<CheckboxProps & react.RefAttributes<HTMLInputElement>>;
+
+/** Edge the drawer panel is pinned to. */
+type DrawerSide = 'left' | 'right' | 'top' | 'bottom';
+interface DrawerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Whether the drawer is currently open (visible). */
+    isOpen: boolean;
+    /** Called when a close is requested — Esc key, backdrop click, or close button. */
+    onClose: () => void;
+    /** Panel content. Compose with `DrawerHeader` / `DrawerBody` / `DrawerFooter`. */
+    children: ReactNode;
+    /** Screen edge the panel slides in from. @default 'right' */
+    side?: DrawerSide;
+    /** Panel width (left/right) or height (top/bottom). Numbers are treated as px. @default '340px' */
+    size?: string | number;
+    /** Optional heading rendered in a built-in header row alongside the close button. */
+    title?: ReactNode;
+    /** Close the drawer when the backdrop is clicked. @default true */
+    closeOnBackdrop?: boolean;
+    /** Close the drawer when the Escape key is pressed. @default true */
+    closeOnEsc?: boolean;
+    /** Render the built-in close button in the header. @default true */
+    showClose?: boolean;
+}
+/**
+ * Drawer — a frosted-glass edge sheet.
+ * Renders through a `Portal`, pins a glass panel to the chosen screen edge,
+ * and slides it in with the matching GPU keyframe. Locks body scroll, closes
+ * on Esc / backdrop click, traps initial focus on the panel, and exposes
+ * `role="dialog"` with `aria-modal`. The forwarded ref points at the panel.
+ */
+declare const Drawer: react.ForwardRefExoticComponent<DrawerProps & react.RefAttributes<HTMLDivElement>>;
+/** Props shared by the Drawer section wrappers (`DrawerHeader`/`DrawerBody`/`DrawerFooter`). */
+type DrawerSectionProps = HTMLAttributes<HTMLDivElement>;
+/**
+ * DrawerHeader — pinned top section of a `Drawer`, separated by a bottom border.
+ * Use instead of the built-in `title` header when you need custom header markup.
+ */
+declare const DrawerHeader: react.ForwardRefExoticComponent<DrawerSectionProps & react.RefAttributes<HTMLDivElement>>;
+/**
+ * DrawerBody — the scrollable main content region of a `Drawer`.
+ * Grows to fill remaining space and scrolls its own overflow.
+ */
+declare const DrawerBody: react.ForwardRefExoticComponent<DrawerSectionProps & react.RefAttributes<HTMLDivElement>>;
+/**
+ * DrawerFooter — pinned bottom section of a `Drawer`, separated by a top border.
+ */
+declare const DrawerFooter: react.ForwardRefExoticComponent<DrawerSectionProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Corner of the trigger the menu anchors to. */
+type DropdownPlacement = 'bottom-start' | 'bottom-end' | 'top-start' | 'top-end';
+interface DropdownProps {
+    /** Controlled open state. Provide together with `onOpenChange`. */
+    open?: boolean;
+    /** Initial open state when uncontrolled. @default false */
+    defaultOpen?: boolean;
+    /** Called whenever the open state should change. */
+    onOpenChange?: (open: boolean) => void;
+    /** Corner of the trigger the menu anchors to. @default 'bottom-start' */
+    placement?: DropdownPlacement;
+    /** Trigger and menu parts (`DropdownTrigger`, `DropdownMenu`, …). */
+    children: ReactNode;
+}
+/**
+ * Dropdown — a compound menu-button.
+ * Provides open state, placement, and focus management via context to its
+ * `DropdownTrigger` and `DropdownMenu` parts. Closes on outside click and Esc,
+ * with roving arrow-key navigation across items.
+ */
+declare function Dropdown({ open: openProp, defaultOpen, onOpenChange, placement, children, }: DropdownProps): react.JSX.Element;
+interface DropdownTriggerProps extends ButtonHTMLAttributes<HTMLButtonElement> {
+    /** Trigger content (text and/or icons). */
+    children?: ReactNode;
+}
+/**
+ * DropdownTrigger — the button that toggles the menu.
+ * Wires up `aria-haspopup`, `aria-expanded`, and `aria-controls`, and opens the
+ * menu on ArrowUp/ArrowDown.
+ */
+declare const DropdownTrigger: react.ForwardRefExoticComponent<DropdownTriggerProps & react.RefAttributes<HTMLButtonElement>>;
+interface DropdownMenuProps extends HTMLAttributes<HTMLDivElement> {
+    /** Menu contents (`DropdownItem`, `DropdownSeparator`, `DropdownLabel`). */
+    children?: ReactNode;
+}
+/**
+ * DropdownMenu — the popover surface holding the items.
+ * Renders only while open, positioned per `placement`, with arrow/Home/End
+ * roving focus. Auto-focuses the first item when it opens.
+ */
+declare const DropdownMenu: react.ForwardRefExoticComponent<DropdownMenuProps & react.RefAttributes<HTMLDivElement>>;
+interface DropdownItemProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onSelect'> {
+    /** Called when the item is chosen (click or Enter/Space). */
+    onSelect?: () => void;
+    /** Disable interaction and skip the item during keyboard navigation. */
+    disabled?: boolean;
+    /** Icon rendered before the item label. */
+    leftIcon?: ReactNode;
+    /** Item label / content. */
+    children?: ReactNode;
+}
+/**
+ * DropdownItem — a selectable menu row.
+ * Activates on click or Enter/Space (native button), then closes the menu and
+ * returns focus to the trigger.
+ */
+declare const DropdownItem: react.ForwardRefExoticComponent<DropdownItemProps & react.RefAttributes<HTMLButtonElement>>;
+/** Props for the menu separator (a horizontal divider). */
+type DropdownSeparatorProps = HTMLAttributes<HTMLDivElement>;
+/**
+ * DropdownSeparator — a non-interactive horizontal divider between groups.
+ */
+declare const DropdownSeparator: react.ForwardRefExoticComponent<DropdownSeparatorProps & react.RefAttributes<HTMLDivElement>>;
+/** Props for a non-interactive group label inside the menu. */
+type DropdownLabelProps = HTMLAttributes<HTMLDivElement>;
+/**
+ * DropdownLabel — a small, muted heading that titles a group of items.
+ */
+declare const DropdownLabel: react.ForwardRefExoticComponent<DropdownLabelProps & react.RefAttributes<HTMLDivElement>>;
+
+type InputVariant = 'glass' | 'subtle';
+type InputSize = 'sm' | 'md' | 'lg';
+interface InputProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size'> {
+    /** Visual surface treatment. @default 'subtle' */
+    variant?: InputVariant;
+    /** Control height/padding preset. @default 'md' */
+    inputSize?: InputSize;
+    /** Render the invalid state (danger border + `aria-invalid`). */
+    error?: boolean;
+    /** Adornment rendered before the field (e.g. a search icon). */
+    leftIcon?: ReactNode;
+    /** Adornment rendered after the field (e.g. a clear button). */
+    rightIcon?: ReactNode;
+    /** Stretch the field to fill the container width. */
+    fullWidth?: boolean;
+}
+/**
+ * Input — a single-line text field on a frosted-glass surface.
+ * The wrapper lifts its focus ring via `:focus-within` so clicking either the
+ * field or its icons keeps the whole control highlighted.
+ */
+declare const Input: react.ForwardRefExoticComponent<InputProps & react.RefAttributes<HTMLInputElement>>;
+
+/** Preset widths for the modal panel. */
+type ModalSize = 'sm' | 'md' | 'lg' | 'full';
+interface ModalProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    /** Whether the modal is currently visible. */
+    isOpen: boolean;
+    /** Called when the modal requests to close (Esc, backdrop, close button). */
+    onClose: () => void;
+    /** Panel contents — typically ModalBody / ModalFooter sections. */
+    children: ReactNode;
+    /** Optional heading rendered in the panel header; also labels the dialog. */
+    title?: ReactNode;
+    /** Preset panel width. @default 'md' */
+    size?: ModalSize;
+    /** Close when the backdrop (area outside the panel) is clicked. @default true */
+    closeOnBackdrop?: boolean;
+    /** Close when the Escape key is pressed. @default true */
+    closeOnEsc?: boolean;
+    /** Render the header close button. @default true */
+    showClose?: boolean;
+}
+/**
+ * Modal — an accessible, glassmorphic dialog rendered in a Portal.
+ *
+ * Traps the page behind a frosted backdrop, locks body scroll while open,
+ * closes on Escape / backdrop click, and moves focus to the panel on open
+ * (restoring it to the previously-focused element on close).
+ */
+declare const Modal: react.ForwardRefExoticComponent<ModalProps & react.RefAttributes<HTMLDivElement>>;
+/** Props for {@link ModalHeader}. Accepts all native `<div>` attributes. */
+type ModalHeaderProps = HTMLAttributes<HTMLDivElement>;
+/** Optional custom header section for use inside a Modal panel. */
+declare const ModalHeader: react.ForwardRefExoticComponent<ModalHeaderProps & react.RefAttributes<HTMLDivElement>>;
+/** Props for {@link ModalBody}. Accepts all native `<div>` attributes. */
+type ModalBodyProps = HTMLAttributes<HTMLDivElement>;
+/** Scrollable main content section for use inside a Modal panel. */
+declare const ModalBody: react.ForwardRefExoticComponent<ModalBodyProps & react.RefAttributes<HTMLDivElement>>;
+/** Props for {@link ModalFooter}. Accepts all native `<div>` attributes. */
+type ModalFooterProps = HTMLAttributes<HTMLDivElement>;
+/** Footer section (typically actions) for use inside a Modal panel. */
+declare const ModalFooter: react.ForwardRefExoticComponent<ModalFooterProps & react.RefAttributes<HTMLDivElement>>;
+
+interface PortalProps {
+    children: ReactNode;
+    /** Where to mount. Defaults to document.body. */
+    container?: HTMLElement | null;
+}
+/**
+ * Renders children into document.body (or a custom container) via a React
+ * portal. SSR-safe: renders nothing until mounted on the client, so it never
+ * touches `document` during server rendering (Next.js friendly).
+ */
+declare function Portal({ children, container }: PortalProps): react.ReactPortal | null;
+
+type ProgressSize = 'sm' | 'md' | 'lg';
+type ProgressColor = 'primary' | 'success' | 'danger' | 'warning' | 'info';
+interface ProgressProps extends HTMLAttributes<HTMLDivElement> {
+    /** Current progress, clamped to the range 0..max. Ignored when `indeterminate`. @default 0 */
+    value?: number;
+    /** Upper bound of the progress range. @default 100 */
+    max?: number;
+    /** Loop an animated partial bar for work of unknown duration. @default false */
+    indeterminate?: boolean;
+    /** Thickness of the track/fill. @default 'md' */
+    barSize?: ProgressSize;
+    /** Fill accent color. @default 'primary' */
+    color?: ProgressColor;
+    /** Render a live percentage label beside the track (determinate only). @default false */
+    showLabel?: boolean;
+}
+/**
+ * Progress — a linear glass progress bar.
+ *
+ * Determinate mode reveals the fill with a GPU-friendly `scaleX` transform driven
+ * by an inline `--gl-progress-value` custom property (value / max), so updates
+ * animate smoothly without touching layout. Indeterminate mode loops a partial bar
+ * for work of unknown length. Exposes the `progressbar` role with matching
+ * `aria-value*` attributes (`aria-valuenow` is omitted while indeterminate).
+ */
+declare const Progress: react.ForwardRefExoticComponent<ProgressProps & react.RefAttributes<HTMLDivElement>>;
+
+/** Layout direction for the radios inside a {@link RadioGroup}. */
+type RadioGroupOrientation = 'vertical' | 'horizontal';
+/** Value shared through {@link RadioGroupContext} to every descendant {@link Radio}. */
+interface RadioGroupContextValue {
+    /** The `name` applied to every radio input so the browser treats them as one group. */
+    name: string;
+    /** The currently selected value, or an empty string when nothing is selected yet. */
+    value: string | undefined;
+    /** Select the radio identified by `value`. */
+    setValue: (value: string) => void;
+}
+/**
+ * Context published by {@link RadioGroup}. Consumed internally by {@link Radio};
+ * exported for advanced compositions that need to read or drive the selection.
+ */
+declare const RadioGroupContext: react.Context<RadioGroupContextValue | null>;
+interface RadioGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    /** Controlled selected value. Provide together with `onChange`. */
+    value?: string;
+    /** Initial selected value when the group is uncontrolled. */
+    defaultValue?: string;
+    /** Fired with the newly selected value whenever the selection changes. */
+    onChange?: (value: string) => void;
+    /** Shared `name` for every radio input; auto-generated when omitted. */
+    name?: string;
+    /** Direction the radios are laid out. @default 'vertical' */
+    orientation?: RadioGroupOrientation;
+    /** The `<Radio>` children that make up the group. */
+    children?: ReactNode;
+}
+/**
+ * RadioGroup — owns the selected value and shares it with its {@link Radio}
+ * children through context. Works controlled (`value` + `onChange`) or
+ * uncontrolled (`defaultValue`). Native radio semantics give arrow-key
+ * navigation between options for free.
+ */
+declare const RadioGroup: react.ForwardRefExoticComponent<RadioGroupProps & react.RefAttributes<HTMLDivElement>>;
+interface RadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'value' | 'type' | 'onChange' | 'checked' | 'defaultChecked' | 'name'> {
+    /** The value this radio contributes; selected when it equals the group value. */
+    value: string;
+    /** Content rendered beside the control as the visible, clickable label. */
+    label?: ReactNode;
+    /** Prevent selection and mute the control. @default false */
+    disabled?: boolean;
+}
+/**
+ * Radio — a single frosted-glass option within a {@link RadioGroup}. Reads the
+ * shared selection from context and renders a visually hidden native
+ * `input[type="radio"]` (keeping full keyboard + form semantics) alongside a
+ * glass dot whose inner primary mark scales in when selected.
+ */
+declare const Radio: react.ForwardRefExoticComponent<RadioProps & react.RefAttributes<HTMLInputElement>>;
+
+/** A single choice rendered as an `<option>` inside the Select. */
+interface SelectOption {
+    /** Human-readable text shown for this option. */
+    label: string;
+    /** Value reported/submitted when this option is chosen. */
+    value: string | number;
+    /** Prevent this option from being selectable. @default false */
+    disabled?: boolean;
+}
+/** Control height, padding and font scale of the Select. */
+type SelectSize = 'sm' | 'md' | 'lg';
+interface SelectProps extends Omit<SelectHTMLAttributes<HTMLSelectElement>, 'size'> {
+    /** Options to render as `<option>`s. Omit to supply your own `children` instead. */
+    options?: SelectOption[];
+    /** Non-selectable prompt shown before a value is chosen. */
+    placeholder?: string;
+    /** Control height/padding/font scale. @default 'md' */
+    selectSize?: SelectSize;
+    /** Render the invalid/danger styling and set `aria-invalid`. @default false */
+    error?: boolean;
+    /** Stretch the control to fill its container width. @default false */
+    fullWidth?: boolean;
+    /** Custom `<option>` markup. Ignored when `options` is provided. */
+    children?: ReactNode;
+}
+/**
+ * Select — a styled, fully accessible wrapper around the native `<select>`.
+ *
+ * Keeps the reliability and built-in keyboard/screen-reader support of the
+ * platform control while hiding the native arrow and presenting a frosted-glass
+ * surface with a custom chevron, focus-within ring and error state.
+ */
+declare const Select: react.ForwardRefExoticComponent<SelectProps & react.RefAttributes<HTMLSelectElement>>;
+
+interface SliderProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'value' | 'defaultValue' | 'onChange'> {
+    /** Lowest selectable value. @default 0 */
+    min?: number;
+    /** Highest selectable value. @default 100 */
+    max?: number;
+    /** Granularity the value snaps to. @default 1 */
+    step?: number;
+    /** Controlled value. Provide together with `onChange`. */
+    value?: number;
+    /** Initial value when uncontrolled. Falls back to `min`. */
+    defaultValue?: number;
+    /** Fires with the new numeric value whenever the user drags or keys. */
+    onChange?: (value: number) => void;
+    /** Render a floating glass bubble with the live value above the thumb. @default false */
+    showValue?: boolean;
+}
+/**
+ * Slider — a styled range input on a frosted-glass track.
+ * The filled portion is driven by the `--gl-slider-fill` custom property so the
+ * gradient track and optional value bubble stay in sync with the thumb.
+ * Works controlled (`value` + `onChange`) or uncontrolled (`defaultValue`).
+ */
+declare const Slider: react.ForwardRefExoticComponent<SliderProps & react.RefAttributes<HTMLInputElement>>;
+
+type SpinnerSize = 'sm' | 'md' | 'lg' | 'xl';
+interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
+    /** Diameter preset controlling width/height. @default 'md' */
+    size?: SpinnerSize;
+    /** Accessible, visually-hidden status text announced to screen readers. @default 'Loading' */
+    label?: string;
+    /** Ring border width in pixels. Falls back to a size-derived default when omitted. */
+    thickness?: number;
+}
+/**
+ * Spinner — a compact loading indicator.
+ * Renders a frosted-friendly circular ring that rotates via the shared
+ * `gl-spin` keyframe. Color follows `currentColor`, so it inherits the
+ * surrounding text color. Exposes `role="status"` with a visually-hidden
+ * label so assistive tech announces the loading state.
+ */
+declare const Spinner: react.ForwardRefExoticComponent<SpinnerProps & react.RefAttributes<HTMLSpanElement>>;
+
+type SwitchSize = 'sm' | 'md' | 'lg';
+interface SwitchProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'size' | 'onChange' | 'checked' | 'defaultChecked'> {
+    /** Controlled checked state. Provide together with `onChange`; omit for uncontrolled usage. */
+    checked?: boolean;
+    /** Initial checked state when the switch is uncontrolled. @default false */
+    defaultChecked?: boolean;
+    /** Called with the next checked value each time the switch toggles. */
+    onChange?: (checked: boolean) => void;
+    /** Visible text rendered beside the track and used as the accessible name. */
+    label?: ReactNode;
+    /** Control the track and thumb dimensions. @default 'md' */
+    switchSize?: SwitchSize;
+    /** Disable interaction and dim the control. @default false */
+    disabled?: boolean;
+}
+/**
+ * Switch — an accessible on/off toggle with a frosted-glass track and a
+ * spring-animated thumb. Renders a visually-hidden native checkbox (exposing
+ * `role="switch"`) so keyboard, form, and screen-reader behaviour come for
+ * free. Works in both controlled and uncontrolled modes.
+ */
+declare const Switch: react.ForwardRefExoticComponent<SwitchProps & react.RefAttributes<HTMLInputElement>>;
+
+interface TabsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    /** Controlled active tab value. Provide together with `onChange`. */
+    value?: string;
+    /** Initial active tab value when uncontrolled. */
+    defaultValue?: string;
+    /** Fired with the newly selected tab value whenever the selection changes. */
+    onChange?: (value: string) => void;
+    /** `TabList` and `TabPanel` descendants. */
+    children?: ReactNode;
+}
+/**
+ * Tabs — accessible, compound tab set built on React context.
+ * Wrap a `TabList` (with `Tab` children) and matching `TabPanel`s.
+ * Works controlled (`value` + `onChange`) or uncontrolled (`defaultValue`).
+ */
+declare const Tabs: react.ForwardRefExoticComponent<TabsProps & react.RefAttributes<HTMLDivElement>>;
+interface TabListProps extends HTMLAttributes<HTMLDivElement> {
+    /** `Tab` children rendered inside the glass pill. */
+    children?: ReactNode;
+}
+/**
+ * TabList — the `role="tablist"` container.
+ * Renders a frosted glass pill and provides Arrow Left/Right (plus Home/End)
+ * roving focus between the enabled tabs, activating each as focus lands on it.
+ */
+declare const TabList: react.ForwardRefExoticComponent<TabListProps & react.RefAttributes<HTMLDivElement>>;
+interface TabProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value'> {
+    /** Unique value that links this tab to its `TabPanel`. */
+    value: string;
+    /** Disable selection and remove the tab from keyboard navigation. */
+    disabled?: boolean;
+    /** Label content for the tab. */
+    children?: ReactNode;
+}
+/**
+ * Tab — a single selectable `role="tab"` control.
+ * Reflects selection via `aria-selected`, owns roving `tabIndex`, and points
+ * at its panel through `aria-controls`. Renders as a native button so
+ * Enter/Space activation and disabled handling come for free.
+ */
+declare const Tab: react.ForwardRefExoticComponent<TabProps & react.RefAttributes<HTMLButtonElement>>;
+interface TabPanelProps extends HTMLAttributes<HTMLDivElement> {
+    /** Value that links this panel to its `Tab`. */
+    value: string;
+    /** Panel content, shown only while this tab is active. */
+    children?: ReactNode;
+}
+/**
+ * TabPanel — the `role="tabpanel"` region for a tab's content.
+ * Labelled by its tab, hidden unless active, and animated in on reveal.
+ */
+declare const TabPanel: react.ForwardRefExoticComponent<TabPanelProps & react.RefAttributes<HTMLDivElement>>;
+
+type TextareaVariant = 'glass' | 'subtle';
+interface TextareaProps extends TextareaHTMLAttributes<HTMLTextAreaElement> {
+    /** Visual surface style. @default 'subtle' */
+    variant?: TextareaVariant;
+    /** Render the invalid state (danger border + `aria-invalid`). */
+    error?: boolean;
+    /** Stretch the field to fill the container width. */
+    fullWidth?: boolean;
+    /** Grow the field height to fit its content as the value changes (SSR-safe). */
+    autoResize?: boolean;
+}
+/**
+ * Textarea — a multi-line text field on a frosted-glass surface.
+ * The focus ring follows `:focus-within` on the wrapper, an error state is
+ * supported, and the field can optionally auto-grow to fit its content. The
+ * forwarded ref is merged with an internal ref so auto-resize works even when
+ * the consumer also needs a handle on the underlying element.
+ */
+declare const Textarea: react.ForwardRefExoticComponent<TextareaProps & react.RefAttributes<HTMLTextAreaElement>>;
+
+/** Accent style of a toast. */
+type ToastVariant = 'glass' | 'success' | 'danger' | 'warning' | 'info';
+/** Corner the toast stack anchors to. */
+type ToastPosition = 'top-right' | 'top-left' | 'bottom-right' | 'bottom-left';
+/** Configuration passed to `toast(options)`. */
+interface ToastOptions {
+    /** Bold headline line. */
+    title?: ReactNode;
+    /** Secondary muted line under the title. */
+    description?: ReactNode;
+    /** Accent color. @default 'glass' */
+    variant?: ToastVariant;
+    /** Auto-dismiss delay in ms; pass `0` (or `Infinity`) to keep it sticky. @default 4000 */
+    duration?: number;
+}
+/** Options accepted by the `success` / `error` / `info` / `warning` shortcuts (title + variant are fixed by the shortcut). */
+type ToastShortcutOptions = Omit<ToastOptions, 'title' | 'variant'>;
+/** Value returned by {@link useToast}. */
+interface ToastContextValue {
+    /** Push a toast and get back its id for manual dismissal. */
+    toast: (options: ToastOptions) => string;
+    /** Remove a toast by id. */
+    dismiss: (id: string) => void;
+    /** Shortcut for a success (green) toast. */
+    success: (title: ReactNode, options?: ToastShortcutOptions) => string;
+    /** Shortcut for an error (danger/red) toast. */
+    error: (title: ReactNode, options?: ToastShortcutOptions) => string;
+    /** Shortcut for an info (blue) toast. */
+    info: (title: ReactNode, options?: ToastShortcutOptions) => string;
+    /** Shortcut for a warning (amber) toast. */
+    warning: (title: ReactNode, options?: ToastShortcutOptions) => string;
+}
+/** Props for {@link ToastProvider}. */
+interface ToastProviderProps {
+    /** App subtree that can trigger toasts via {@link useToast}. */
+    children: ReactNode;
+    /** Corner the toast stack anchors to. @default 'bottom-right' */
+    position?: ToastPosition;
+}
+/**
+ * ToastProvider — holds the live toast queue and renders the fixed viewport.
+ * Wrap your app (or any subtree) in it, then call {@link useToast} to push
+ * notifications. The viewport is portalled to `document.body` so toasts float
+ * above every other layer regardless of where the trigger lives.
+ */
+declare function ToastProvider({ children, position, }: ToastProviderProps): react.JSX.Element;
+/**
+ * useToast — access the toast API from anywhere inside a {@link ToastProvider}.
+ * Throws a descriptive error when called outside a provider.
+ */
+declare function useToast(): ToastContextValue;
+
+type TooltipPlacement = 'top' | 'bottom' | 'left' | 'right';
+interface TooltipProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'content'> {
+    /** Floating content shown when the trigger is hovered or focused. */
+    content: ReactNode;
+    /** The trigger element the tooltip describes. */
+    children: ReactNode;
+    /** Side of the trigger the tooltip is anchored to. @default 'top' */
+    placement?: TooltipPlacement;
+    /** Delay in milliseconds before the tooltip appears. @default 200 */
+    delay?: number;
+    /** When true the tooltip never opens. @default false */
+    disabled?: boolean;
+}
+/**
+ * Tooltip — a small frosted-glass label that reveals descriptive text when the
+ * trigger is hovered or keyboard-focused. It opens after a configurable delay,
+ * closes instantly on leave/blur, and is fully SSR-safe (timeouts run only in
+ * event handlers and effects).
+ */
+declare const Tooltip: react.ForwardRefExoticComponent<TooltipProps & react.RefAttributes<HTMLSpanElement>>;
+
+interface UseDisclosureReturn {
+    isOpen: boolean;
+    open: () => void;
+    close: () => void;
+    toggle: () => void;
+    setOpen: (value: boolean) => void;
+}
+/**
+ * Controlled/uncontrolled open state for overlays (Modal, Drawer, Dropdown…).
+ */
+declare function useDisclosure(defaultOpen?: boolean): UseDisclosureReturn;
+
+/**
+ * Fires `handler` when a pointerdown/touch happens outside the referenced
+ * element. Used by Dropdown, Popover, Tooltip, etc.
+ */
+declare function useClickOutside<T extends HTMLElement = HTMLElement>(ref: RefObject<T | null>, handler: (event: MouseEvent | TouchEvent) => void, enabled?: boolean): void;
+
+/**
+ * Locks <body> scroll while an overlay is open (Modal, Drawer), preserving
+ * the scrollbar gutter so the page doesn't shift.
+ */
+declare function useScrollLock(locked: boolean): void;
+
+/**
+ * Supports both controlled and uncontrolled usage of a value.
+ * If `value` is provided, the component is controlled; otherwise it manages
+ * its own state seeded by `defaultValue`. Used by Tabs, Accordion, Switch…
+ */
+declare function useControllableState<T>(params: {
+    value?: T;
+    defaultValue: T;
+    onChange?: (value: T) => void;
+}): [T, (next: T) => void];
+
+/**
+ * useLayoutEffect that silently degrades to useEffect on the server,
+ * avoiding React's "useLayoutEffect does nothing on the server" warning.
+ * Essential for SSR frameworks like Next.js.
+ */
+declare const useIsomorphicLayoutEffect: typeof useEffect;
+
+/**
+ * cn — tiny classnames joiner.
+ * Filters out falsey values and flattens arrays so components can write:
+ *   cn('gl-btn', `gl-btn--${variant}`, disabled && 'gl-btn--disabled', className)
+ * No external dependency (keeps the bundle small).
+ */
+type ClassValue = string | number | null | boolean | undefined | ClassValue[];
+declare function cn(...inputs: ClassValue[]): string;
+
+export { Accordion, AccordionItem, type AccordionItemProps, type AccordionProps, type AccordionType, type AccordionValue, Avatar, type AvatarProps, type AvatarShape, type AvatarSize, type AvatarStatus, Badge, type BadgeProps, type BadgeSize, type BadgeVariant, Button, type ButtonProps, type ButtonSize, type ButtonVariant, Card, CardBody, CardFooter, CardHeader, type CardPadding, type CardProps, type CardSectionProps, type CardVariant, Checkbox, type CheckboxProps, type CheckboxSize, type ClassValue, Drawer, DrawerBody, DrawerFooter, DrawerHeader, type DrawerProps, type DrawerSectionProps, type DrawerSide, Dropdown, DropdownItem, type DropdownItemProps, DropdownLabel, type DropdownLabelProps, DropdownMenu, type DropdownMenuProps, type DropdownPlacement, type DropdownProps, DropdownSeparator, type DropdownSeparatorProps, DropdownTrigger, type DropdownTriggerProps, Input, type InputProps, type InputSize, type InputVariant, Modal, ModalBody, type ModalBodyProps, ModalFooter, type ModalFooterProps, ModalHeader, type ModalHeaderProps, type ModalProps, type ModalSize, Portal, type PortalProps, Progress, type ProgressColor, type ProgressProps, type ProgressSize, Radio, RadioGroup, RadioGroupContext, type RadioGroupContextValue, type RadioGroupOrientation, type RadioGroupProps, type RadioProps, Select, type SelectOption, type SelectProps, type SelectSize, Slider, type SliderProps, Spinner, type SpinnerProps, type SpinnerSize, Switch, type SwitchProps, type SwitchSize, Tab, TabList, type TabListProps, TabPanel, type TabPanelProps, type TabProps, Tabs, type TabsProps, Textarea, type TextareaProps, type TextareaVariant, type ToastContextValue, type ToastOptions, type ToastPosition, ToastProvider, type ToastProviderProps, type ToastShortcutOptions, type ToastVariant, Tooltip, type TooltipPlacement, type TooltipProps, type UseDisclosureReturn, cn, useClickOutside, useControllableState, useDisclosure, useIsomorphicLayoutEffect, useScrollLock, useToast };