@vikram-hegde/skeletal 0.0.1

package/dist/index-CznsZ_1M.d.ts

@@ -0,0 +1,85 @@
+import { r as DialogBackdrop, t as DialogViewport } from "./dialog-viewport-CaMWJrCJ.js";
+import { n as ButtonProps } from "./button-Dvd4n2U4.js";
+import { a as DialogClose, r as DialogDescription, t as DialogTitle } from "./dialog-title-jyf86Q8C.js";
+import { r as DialogContent, t as DialogFooter } from "./dialog-footer-bNVIVPbu.js";
+import { t as DialogPortal } from "./dialog-portal-BF89FBeX.js";
+import { DialogRootProps, DialogTriggerProps } from "@base-ui/react/dialog";
+//#region src/dialog/dialog-root.d.ts
+/**
+ * The root of the dialog, grouping all parts together. Renders no DOM element.
+ *
+ * All Base UI root props are supported: `open`, `defaultOpen`, `modal`,
+ * `onOpenChange`, `onOpenChangeComplete`, `disablePointerDismissal`,
+ * `actionsRef`, `handle`, and `triggerId`.
+ *
+ * Use `open` + `onOpenChange` to control the dialog; otherwise it is
+ * uncontrolled. `modal` accepts `true`, `'trap-focus'`, or `false`.
+ *
+ * @default modal = true
+ */
+interface DialogProps<Payload = unknown> extends DialogRootProps<Payload> {}
+declare function DialogRoot<Payload>(props: DialogProps<Payload>): import("react").JSX.Element;
+//#endregion
+//#region src/dialog/dialog-trigger.d.ts
+/**
+ * A button that opens the dialog. Renders a `<button>` element.
+ *
+ * Composed from the `Button` component via Base UI's `render` prop, so it
+ * accepts all `Button` props (`variant`, `size`, `fullWidth`, `disabled`,
+ * `onClick`, ...) plus the dialog-trigger props from Base UI (`payload`,
+ * `handle`, `id`). Defaults to the `primary` variant.
+ *
+ * The `payload` prop lets you pass data from the trigger to the dialog's
+ * render-prop content.
+ */
+interface DialogTriggerProps$1<Payload = unknown> extends ButtonProps, Omit<DialogTriggerProps<Payload>, "className" | "style" | "render" | "nativeButton"> {}
+declare function DialogTrigger<Payload>({ className, variant, size, fullWidth, ...props }: DialogTriggerProps$1<Payload>): import("react").JSX.Element;
+//#endregion
+//#region src/dialog/index.d.ts
+/**
+ * Compound component for dialogs.
+ *
+ * Assemble the parts as properties of the object:
+ *
+ * ```tsx
+ * import { Dialog } from '@vikram-hegde/skeletal'
+ *
+ * <Dialog.Root>
+ *   <Dialog.Trigger>Open</Dialog.Trigger>
+ *   <Dialog.Portal>
+ *     <Dialog.Backdrop />
+ *     <Dialog.Viewport>
+ *       <Dialog.Content>
+ *         <Dialog.Title>Title</Dialog.Title>
+ *         <Dialog.Description>Description</Dialog.Description>
+ *         <Dialog.Footer>
+ *           <Dialog.Close>Cancel</Dialog.Close>
+ *           <Dialog.Close variant="primary">Confirm</Dialog.Close>
+ *         </Dialog.Footer>
+ *       </Dialog.Content>
+ *     </Dialog.Viewport>
+ *   </Dialog.Portal>
+ * </Dialog.Root>
+ * ```
+ *
+ * Composition follows the Base UI anatomy — `Dialog.Viewport` is the
+ * full-screen positioning/scroll container that centers `Dialog.Content`.
+ *
+ * All parts are thin styled wrappers over Base UI's `Dialog`, so every Base UI
+ * prop, `render` override, and ref behaves the same. Part prop types are
+ * exported separately (`DialogContentProps`, etc.).
+ */
+declare const Dialog$1: {
+  Root: typeof DialogRoot;
+  Trigger: typeof DialogTrigger;
+  Portal: typeof DialogPortal;
+  Backdrop: typeof DialogBackdrop;
+  Content: typeof DialogContent;
+  Title: typeof DialogTitle;
+  Description: typeof DialogDescription;
+  Footer: typeof DialogFooter;
+  Close: typeof DialogClose;
+  Viewport: typeof DialogViewport;
+};
+//#endregion
+export { DialogTriggerProps$1 as n, DialogProps as r, Dialog$1 as t };

package/dist/index-D-6gOciw.d.ts

@@ -0,0 +1,350 @@
+import { n as ButtonProps } from "./button-Dvd4n2U4.js";
+import { MenuArrowProps, MenuBackdropProps, MenuCheckboxItemIndicatorProps, MenuCheckboxItemProps, MenuGroupLabelProps, MenuGroupProps, MenuItemProps, MenuLinkItemProps, MenuPopupProps, MenuPortalProps, MenuPositionerProps, MenuRadioGroupProps, MenuRadioItemIndicatorProps, MenuRadioItemProps, MenuRootProps, MenuSubmenuRootProps, MenuSubmenuTriggerProps, MenuTriggerProps, MenuViewportProps } from "@base-ui/react/menu";
+import { SeparatorProps } from "@base-ui/react/separator";
+//#region src/menu/menu-arrow.d.ts
+/**
+ * A small arrow pointing from the popup to the trigger. Renders a `<div>`
+ * element.
+ *
+ * Place it inside `<Menu.Popup>` (before the items). It orients itself based
+ * on the popup's `data-side` attribute, so it works for any placement. Pair
+ * with a larger `sideOffset` on the `Menu.Positioner` so the arrow has room.
+ */
+interface MenuArrowProps$1 extends MenuArrowProps {}
+declare function MenuArrow({ className, ...props }: MenuArrowProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-backdrop.d.ts
+/**
+ * An overlay rendered beneath the menu popup, used when the menu is modal.
+ * Renders a `<div>` element.
+ *
+ * Only needed when `Menu.Root` is modal (the default). Clicking the backdrop
+ * dismisses the menu. The overlay is translucent; set a fully opaque color
+ * (or remove it) if you prefer a "dimmed page" look vs. a light scrim.
+ */
+interface MenuBackdropProps$1 extends MenuBackdropProps {}
+declare function MenuBackdrop({ className, ...props }: MenuBackdropProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-checkbox-item.d.ts
+/**
+ * A menu item that toggles a setting on or off. Renders a `<div>` element.
+ *
+ * Accepts all Base UI checkbox-item props: `checked`, `defaultChecked`, and
+ * `onCheckedChange` for controlled/uncontrolled state, plus `disabled`,
+ * `label`, and `closeOnClick` (defaults to `false`).
+ *
+ * The first column is reserved for a `Menu.CheckboxItemIndicator`, so labels
+ * stay aligned whether or not an item is checked.
+ */
+interface MenuCheckboxItemProps$1 extends MenuCheckboxItemProps {}
+declare function MenuCheckboxItem({ className, ...props }: MenuCheckboxItemProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-checkbox-item-indicator.d.ts
+/**
+ * Marks a `Menu.CheckboxItem` as checked. Renders a `<span>` element.
+ *
+ * Place it as the first child of the checkbox item and render your checked
+ * glyph inside (e.g. an `<Icon name={Check} />`). `keepMounted` keeps the
+ * indicator in the DOM when the item is not checked (useful for exit
+ * animations).
+ *
+ * @default keepMounted = false
+ */
+interface MenuCheckboxItemIndicatorProps$1 extends MenuCheckboxItemIndicatorProps {}
+declare function MenuCheckboxItemIndicator({ className, ...props }: MenuCheckboxItemIndicatorProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-group.d.ts
+/**
+ * Groups related menu items under an accessible label. Renders a `<div>`
+ * element.
+ *
+ * Pair with `<Menu.GroupLabel>` inside the group; Base UI wires the
+ * `aria-labelledby` association automatically.
+ *
+ * Rendered with `display: contents` so its items participate directly in the
+ * popup grid, letting checkbox items share the tick-mark column via subgrid.
+ */
+interface MenuGroupProps$1 extends MenuGroupProps {}
+declare function MenuGroup({ className, ...props }: MenuGroupProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-group-label.d.ts
+/**
+ * A label for a `<Menu.Group>`, automatically associated with it for screen
+ * readers. Renders a `<div>` element.
+ *
+ * Styled small and muted; add a `Menu.Separator` before the group to visually
+ * divide it from the items above.
+ */
+interface MenuGroupLabelProps$1 extends MenuGroupLabelProps {}
+declare function MenuGroupLabel({ className, ...props }: MenuGroupLabelProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-item.d.ts
+/**
+ * An individual interactive item in the menu. Renders a `<div>` element.
+ *
+ * Accepts all Base UI item props: `onClick`, `disabled`, `closeOnClick`
+ * (defaults to `true`), and `label` for keyboard text navigation.
+ *
+ * Set `danger` for destructive actions (e.g. delete, remove) — the item takes
+ * on the destructive color, and stays destructive when highlighted.
+ *
+ * @default closeOnClick = true
+ * @default danger = false
+ */
+interface MenuItemProps$1 extends MenuItemProps {
+  /**
+   * Whether the item is a destructive action. @default false
+   */
+  danger?: boolean;
+}
+declare function MenuItem({ className, danger, ...props }: MenuItemProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-link-item.d.ts
+/**
+ * A link inside the menu for navigating to another page or section. Renders an
+ * `<a>` element.
+ *
+ * Accepts all Base UI link-item props plus anchor attributes (`href`, `target`,
+ * `rel`, ...). Keyboard navigation, type-ahead, and highlight behave the same
+ * as `Menu.Item`.
+ *
+ * @default closeOnClick = false
+ */
+interface MenuLinkItemProps$1 extends MenuLinkItemProps {}
+declare function MenuLinkItem({ className, ...props }: MenuLinkItemProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-popup.d.ts
+/**
+ * The menu panel that holds the items. Renders a `<div>` element.
+ *
+ * Accepts all Base UI popup props, including `finalFocus` for controlling
+ * focus when the menu closes. Content animates in/out via the
+ * `data-starting-style` / `data-ending-style` transitions.
+ *
+ * By default the popup sizes to its content with a `min-width` of 10rem; pass
+ * `style={{ width: ... }}` or a `className` to constrain it.
+ *
+ * @default finalFocus = true
+ */
+interface MenuPopupProps$1 extends MenuPopupProps {}
+declare function MenuPopup({ className, ...props }: MenuPopupProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-portal.d.ts
+/**
+ * Moves the menu popup to a different part of the DOM, appended to `<body>`
+ * by default. Renders a `<div>` element.
+ *
+ * `keepMounted` keeps the portal in the DOM while the menu is closed (useful
+ * for exit animations). `container` overrides the portal target.
+ *
+ * @default keepMounted = false
+ */
+interface MenuPortalProps$1 extends MenuPortalProps {}
+declare function MenuPortal({ className, ...props }: MenuPortalProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-positioner.d.ts
+/**
+ * Positions the menu popup against the trigger. Renders a `<div>` element.
+ *
+ * Accepts all Base UI positioner props: `side`, `align`, `sideOffset`,
+ * `alignOffset`, `collisionAvoidance`, `collisionBoundary`, `collisionPadding`,
+ * `sticky`, `positionMethod`, `arrowPadding`, and `anchor`.
+ *
+ * `side` may flip automatically to avoid collisions (default `'bottom'`).
+ * `align` controls horizontal placement against the trigger — use `'start'`
+ * to align the popup's leading edge with the trigger.
+ *
+ * @default side = 'bottom'
+ * @default sideOffset = 8
+ */
+interface MenuPositionerProps$1 extends MenuPositionerProps {}
+declare function MenuPositioner({ className, sideOffset, ...props }: MenuPositionerProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-radio-group.d.ts
+/**
+ * Groups `Menu.RadioItem`s so selecting one deselects the others. Renders a
+ * `<div>` element.
+ *
+ * Accepts all Base UI radio-group props: `value`, `defaultValue`, and
+ * `onValueChange` for controlled/uncontrolled selection, plus `disabled`.
+ *
+ * Rendered with `display: contents` so its items participate directly in the
+ * popup grid, letting radio items share the tick-mark column via subgrid.
+ */
+interface MenuRadioGroupProps$1 extends MenuRadioGroupProps {}
+declare function MenuRadioGroup({ className, ...props }: MenuRadioGroupProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-radio-item.d.ts
+/**
+ * A menu item that behaves like a radio button within its `Menu.RadioGroup`.
+ * Renders a `<div>` element.
+ *
+ * `value` (required) is what `Menu.RadioGroup.onValueChange` reports on
+ * selection. Also accepts `disabled`, `label`, and `closeOnClick` (defaults to
+ * `false` — selecting usually keeps the menu open).
+ *
+ * The first column is reserved for a `Menu.RadioItemIndicator`, so labels
+ * stay aligned whether or not an item is checked.
+ */
+interface MenuRadioItemProps$1 extends MenuRadioItemProps {}
+declare function MenuRadioItem({ className, ...props }: MenuRadioItemProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-radio-item-indicator.d.ts
+/**
+ * Marks a `Menu.RadioItem` as selected. Renders a `<span>` element.
+ *
+ * Place it as the first child of the radio item and render your selected-state
+ * glyph inside (e.g. an `<Icon name={Check} />`). `keepMounted` keeps the
+ * indicator in the DOM when the item is not selected (useful for exit
+ * animations).
+ *
+ * @default keepMounted = false
+ */
+interface MenuRadioItemIndicatorProps$1 extends MenuRadioItemIndicatorProps {}
+declare function MenuRadioItemIndicator({ className, ...props }: MenuRadioItemIndicatorProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-root.d.ts
+/**
+ * The root of the menu, grouping all parts together. Renders no DOM element.
+ *
+ * All Base UI root props are supported: `open`, `defaultOpen`, `modal`,
+ * `onOpenChange`, `onOpenChangeComplete`, `orientation`, `loopFocus`,
+ * `highlightItemOnHover`, `actionsRef`, `handle`, `triggerId`, and `disabled`.
+ *
+ * Use `open` + `onOpenChange` to control the menu; otherwise it is
+ * uncontrolled. `modal` is `true` by default (pointer outside is blocked and
+ * page scroll is locked while open); set `modal={false}` for a non-blocking
+ * dropdown that dismisses when you click elsewhere.
+ *
+ * @default modal = true
+ */
+interface MenuProps<Payload = unknown> extends MenuRootProps<Payload> {}
+declare function MenuRoot<Payload>(props: MenuProps<Payload>): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-separator.d.ts
+/**
+ * A horizontal divider between groups of menu items. Renders a `<div>` element.
+ *
+ * Accepts the Base UI separator `orientation` prop (`'horizontal'` default,
+ * `'vertical'` for menubar-style layouts). It is announced to screen readers
+ * via `role="separator"`.
+ *
+ * @default orientation = 'horizontal'
+ */
+interface MenuSeparatorProps extends SeparatorProps {}
+declare function MenuSeparator({ className, ...props }: MenuSeparatorProps): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-submenu-root.d.ts
+/**
+ * The root of a nested submenu, grouping all its parts together. Renders no
+ * DOM element.
+ *
+ * Place it inside a `<Menu.Popup>` as a sibling of the `Menu.SubmenuTrigger`
+ * that opens it. All Base UI submenu-root props are supported: `open`,
+ * `defaultOpen`, `onOpenChange`, `onOpenChangeComplete`, `loopFocus`,
+ * `highlightItemOnHover`, `closeParentOnEsc`, `orientation`, and `disabled`.
+ *
+ * Submenus open on hover by default and never use a modal state.
+ */
+interface MenuSubmenuRootProps$1 extends MenuSubmenuRootProps {}
+declare function MenuSubmenuRoot(props: MenuSubmenuRootProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-submenu-trigger.d.ts
+/**
+ * A menu item that opens a submenu. Renders a `<div>` element.
+ *
+ * Accepts all Base UI submenu-trigger props: `disabled`, `label`, `openOnHover`,
+ * `delay`, and `closeDelay`. A right-pointing caret is added automatically and
+ * rotates as the submenu opens.
+ *
+ * Per the Base UI anatomy, the submenu's `Menu.Portal`/`Positioner`/`Popup`
+ * live inside a `Menu.SubmenuRoot` that wraps this trigger.
+ */
+interface MenuSubmenuTriggerProps$1 extends MenuSubmenuTriggerProps {}
+declare function MenuSubmenuTrigger({ className, ...props }: MenuSubmenuTriggerProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-trigger.d.ts
+/**
+ * A button that opens the menu. Renders a `<button>` element.
+ *
+ * Composed from the `Button` component via Base UI's `render` prop, so it
+ * accepts all `Button` props (`variant`, `size`, `fullWidth`, `disabled`,
+ * `onClick`, ...) plus the menu-trigger props from Base UI (`payload`,
+ * `handle`, `openOnHover`, `delay`, `closeDelay`, `id`). Defaults to the
+ * `outline` variant; for a plain text trigger pass `variant="ghost"`.
+ *
+ * Set `openOnHover` to open the menu when the pointer hovers the trigger
+ * (useful for nav-menus); tune it with `delay` and `closeDelay`.
+ */
+interface MenuTriggerProps$1<Payload = unknown> extends ButtonProps, Omit<MenuTriggerProps<Payload>, "className" | "style" | "render" | "nativeButton"> {}
+declare function MenuTrigger<Payload>({ className, variant, size, fullWidth, ...props }: MenuTriggerProps$1<Payload>): import("react").JSX.Element;
+//#endregion
+//#region src/menu/menu-viewport.d.ts
+/**
+ * A transition container for menu content. Renders a `<div>` element.
+ *
+ * This part is only required when one popup is opened by multiple triggers,
+ * its content changes based on the trigger, and switching between them is
+ * animated (e.g. a shared menu for several `Menu.Trigger`s via `handle`).
+ *
+ * When used, the popup should be sized with the `--popup-width` /
+ * `--popup-height` variables so content changes don't thrash the layout.
+ */
+interface MenuViewportProps$1 extends MenuViewportProps {}
+declare function MenuViewport({ className, ...props }: MenuViewportProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/menu/index.d.ts
+/**
+ * Compound component for dropdown menus.
+ *
+ * Assemble the parts as properties of the object:
+ *
+ * ```tsx
+ * import { Menu } from '@vikram-hegde/skeletal'
+ *
+ * <Menu.Root>
+ *   <Menu.Trigger>Options</Menu.Trigger>
+ *   <Menu.Portal>
+ *     <Menu.Positioner sideOffset={8} align="start">
+ *       <Menu.Popup>
+ *         <Menu.Item onClick={…}>Edit</Menu.Item>
+ *         <Menu.Separator />
+ *         <Menu.Item danger>Delete</Menu.Item>
+ *       </Menu.Popup>
+ *     </Menu.Positioner>
+ *   </Menu.Portal>
+ * </Menu.Root>
+ * ```
+ *
+ * Composition follows the Base UI anatomy — `Menu.Positioner` floats the
+ * popup against the trigger and handles collision avoidance; `Menu.Portal`
+ * moves it to `<body>`.
+ *
+ * All parts are thin styled wrappers over Base UI's `Menu`, so every Base UI
+ * prop, `render` override, and ref behaves the same. Part prop types are
+ * exported separately (`MenuItemProps`, `MenuPopupProps`, etc.).
+ */
+declare const Menu$1: {
+  Root: typeof MenuRoot;
+  Trigger: typeof MenuTrigger;
+  Portal: typeof MenuPortal;
+  Backdrop: typeof MenuBackdrop;
+  Positioner: typeof MenuPositioner;
+  Popup: typeof MenuPopup;
+  Item: typeof MenuItem;
+  LinkItem: typeof MenuLinkItem;
+  Separator: typeof MenuSeparator;
+  Group: typeof MenuGroup;
+  GroupLabel: typeof MenuGroupLabel;
+  SubmenuRoot: typeof MenuSubmenuRoot;
+  SubmenuTrigger: typeof MenuSubmenuTrigger;
+  RadioGroup: typeof MenuRadioGroup;
+  RadioItem: typeof MenuRadioItem;
+  RadioItemIndicator: typeof MenuRadioItemIndicator;
+  CheckboxItem: typeof MenuCheckboxItem;
+  CheckboxItemIndicator: typeof MenuCheckboxItemIndicator;
+  Arrow: typeof MenuArrow;
+  Viewport: typeof MenuViewport;
+};
+//#endregion
+export { MenuGroupProps$1 as _, MenuSubmenuRootProps$1 as a, MenuBackdropProps$1 as b, MenuRadioItemIndicatorProps$1 as c, MenuPositionerProps$1 as d, MenuPortalProps$1 as f, MenuGroupLabelProps$1 as g, MenuItemProps$1 as h, MenuSubmenuTriggerProps$1 as i, MenuRadioItemProps$1 as l, MenuLinkItemProps$1 as m, MenuViewportProps$1 as n, MenuSeparatorProps as o, MenuPopupProps$1 as p, MenuTriggerProps$1 as r, MenuProps as s, Menu$1 as t, MenuRadioGroupProps$1 as u, MenuCheckboxItemIndicatorProps$1 as v, MenuArrowProps$1 as x, MenuCheckboxItemProps$1 as y };

package/dist/index-DdqDyczP.d.ts

@@ -0,0 +1,209 @@
+import { n as ButtonProps$1 } from "./button-Dvd4n2U4.js";
+import { ButtonState } from "@base-ui/react/button";
+import { CSSProperties } from "react";
+import { Tooltip, TooltipArrowProps, TooltipPopupProps, TooltipPortalProps, TooltipPositionerProps, TooltipProviderProps, TooltipRootProps, TooltipTriggerProps, TooltipViewportProps } from "@base-ui/react/tooltip";
+//#region src/tooltip/tooltip-arrow.d.ts
+/**
+ * A small arrow pointing from the popup to the trigger. Renders a `<div>`
+ * element.
+ *
+ * Place it inside `<Tooltip.Popup>` (before the content). It orients itself
+ * based on the popup's `data-side` attribute, so it works for any placement.
+ */
+interface TooltipArrowProps$1 extends TooltipArrowProps {}
+declare function TooltipArrow({ className, ...props }: TooltipArrowProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/tooltip/tooltip-popup.d.ts
+/**
+ * The tooltip panel that holds the content. Renders a `<div>` element.
+ *
+ * Accepts all Base UI popup props. Content animates in/out via the
+ * `data-starting-style` / `data-ending-style` transitions, and `data-instant`
+ * skips the animation when the tooltip opens instantly (e.g. inside a
+ * `Tooltip.Provider` group).
+ *
+ * Keep tooltip content short and label-like. For rich or essential content use
+ * a `Popover` or inline text so touch and screen-reader users can access it.
+ */
+interface TooltipPopupProps$1 extends TooltipPopupProps {}
+declare function TooltipPopup({ className, ...props }: TooltipPopupProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/tooltip/tooltip-portal.d.ts
+/**
+ * Moves the tooltip popup to a different part of the DOM, appended to `<body>`
+ * by default. Renders a `<div>` element.
+ *
+ * `keepMounted` keeps the portal in the DOM while the tooltip is closed (useful
+ * for exit animations). `container` overrides the portal target.
+ *
+ * @default keepMounted = false
+ */
+interface TooltipPortalProps$1 extends TooltipPortalProps {}
+declare function TooltipPortal({ className, ...props }: TooltipPortalProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/tooltip/tooltip-positioner.d.ts
+/**
+ * Positions the tooltip popup against the trigger. Renders a `<div>` element.
+ *
+ * Accepts all Base UI positioner props: `side`, `align`, `sideOffset`,
+ * `alignOffset`, `collisionAvoidance`, `collisionBoundary`, `collisionPadding`,
+ * `sticky`, `positionMethod`, `arrowPadding`, and `anchor`.
+ *
+ * `side` may flip automatically to avoid collisions (default `'top'`). Pair
+ * the `sideOffset` with the `Tooltip.Arrow` so the arrow has room to point at
+ * the trigger.
+ *
+ * When one popup is shared across several triggers (via `handle` +
+ * `Tooltip.Viewport`), size it with the `--positioner-width` /
+ * `--positioner-height` / `--available-width` CSS variables so content changes
+ * don't thrash the layout.
+ *
+ * @default side = 'top'
+ * @default align = 'center'
+ * @default sideOffset = 8
+ */
+interface TooltipPositionerProps$1 extends TooltipPositionerProps {}
+declare function TooltipPositioner({ className, sideOffset, ...props }: TooltipPositionerProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/tooltip/tooltip-provider.d.ts
+/**
+ * Provides a shared delay for a group of tooltips. Renders no DOM element.
+ *
+ * Wrap several `Tooltip.Root`s in one `Tooltip.Provider` so that, once a
+ * tooltip in the group has opened, the next one opens instantly when the
+ * pointer moves to it (within `timeout` ms) instead of re-waiting the full
+ * hover `delay`.
+ *
+ * @default delay = 600 (on each trigger)
+ * @default closeDelay = 0 (on each trigger)
+ * @default timeout = 300
+ */
+interface TooltipProviderProps$1 extends TooltipProviderProps {}
+declare function TooltipProvider({ timeout, ...props }: TooltipProviderProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/tooltip/tooltip-root.d.ts
+/**
+ * The root of the tooltip, grouping all parts together. Renders no DOM element.
+ *
+ * All Base UI root props are supported: `open`, `defaultOpen`, `onOpenChange`,
+ * `onOpenChangeComplete`, `disableHoverablePopup`, `trackCursorAxis`,
+ * `actionsRef`, `disabled`, `handle`, `triggerId`, and `defaultTriggerId`.
+ *
+ * Tooltips open on hover and focus, and close on blur, Escape, or outside
+ * press. They are disabled on touch devices (Base UI behavior) — tooltips are
+ * a visual label for sighted mouse/keyboard users, not a replacement for an
+ * accessible trigger name (`aria-label`).
+ *
+ * `disableHoverablePopup` (`@default false`) keeps the tooltip from staying
+ * open when the pointer moves onto the popup itself — enable it for an
+ * interactive popup.
+ *
+ * `trackCursorAxis` (`@default 'none'`) makes the popup follow the cursor
+ * along the given axis ('x' | 'y' | 'both') instead of anchoring to the
+ * trigger.
+ */
+interface TooltipProps<Payload = unknown> extends TooltipRootProps<Payload> {}
+declare function TooltipRoot<Payload>(props: TooltipProps<Payload>): import("react").JSX.Element;
+//#endregion
+//#region src/tooltip/tooltip-trigger.d.ts
+/**
+ * The element that opens the tooltip when hovered or focused. Renders a
+ * `<button>` element.
+ *
+ * Composed from the `Button` component via Base UI's `render` prop, so it
+ * accepts all `Button` props (`variant`, `size`, `fullWidth`, `disabled`, ...)
+ * plus the tooltip-trigger props from Base UI (`handle`, `payload`, `delay`,
+ * `closeDelay`, `closeOnClick`, `disabled`, `id`). Defaults to the `ghost`
+ * variant — use `variant="outline"` for a bordered icon button.
+ *
+ * The trigger must carry an `aria-label` matching the tooltip content so
+ * screen-reader users get an accessible name; the tooltip itself is
+ * visual-only.
+ *
+ * @default variant = 'ghost'
+ * @default size = 'sm'
+ * @default delay = 600
+ * @default closeDelay = 0
+ * @default closeOnClick = true
+ */
+interface TooltipTriggerProps$1<Payload = unknown> extends Omit<ButtonProps$1, "className" | "style" | "render">, Omit<TooltipTriggerProps<Payload>, "className" | "style" | "render"> {
+  /** Class applied to the trigger button, or a function of the button state. */
+  className?: string | ((state: ButtonState) => string | undefined);
+  /** Style applied to the trigger button, or a function of the button state. */
+  style?: CSSProperties | ((state: ButtonState) => CSSProperties | undefined);
+}
+declare function TooltipTrigger<Payload>({ className, style, variant, size, fullWidth, ...props }: TooltipTriggerProps$1<Payload>): import("react").JSX.Element;
+//#endregion
+//#region src/tooltip/tooltip-viewport.d.ts
+/**
+ * A transition container for tooltip content. Renders a `<div>` element.
+ *
+ * Only required when one popup is opened by multiple triggers, its content
+ * changes based on the trigger, and switching between them is animated (e.g. a
+ * shared tooltip for several `Tooltip.Trigger`s via `handle`).
+ *
+ * When used, size the positioner with the `--positioner-width` /
+ * `--positioner-height` CSS variables so content changes don't thrash the
+ * layout.
+ */
+interface TooltipViewportProps$1 extends TooltipViewportProps {}
+declare function TooltipViewport({ className, ...props }: TooltipViewportProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/tooltip/index.d.ts
+/**
+ * Compound component for tooltips.
+ *
+ * Assemble the parts as properties of the object:
+ *
+ * ```tsx
+ * import { Tooltip } from '@vikram-hegde/skeletal'
+ *
+ * <Tooltip.Provider>
+ *   <Tooltip.Root>
+ *     <Tooltip.Trigger aria-label="Bold">
+ *       <BoldIcon aria-hidden="true" />
+ *     </Tooltip.Trigger>
+ *     <Tooltip.Portal>
+ *       <Tooltip.Positioner sideOffset={8}>
+ *         <Tooltip.Popup>
+ *           <Tooltip.Arrow />
+ *           Bold
+ *         </Tooltip.Popup>
+ *       </Tooltip.Positioner>
+ *     </Tooltip.Portal>
+ *   </Tooltip.Root>
+ * </Tooltip.Provider>
+ * ```
+ *
+ * Tooltips appear on hover/focus and are visual-only: the trigger must carry
+ * an `aria-label` matching the tooltip content. They are disabled on touch
+ * devices. Use `Popover` for essential or interactive content.
+ *
+ * `Tooltip.createHandle()` links a `Root` with triggers rendered outside of it
+ * (detached triggers), including multiple triggers sharing one popup:
+ *
+ * ```tsx
+ * const tip = Tooltip.createHandle();
+ * <Tooltip.Trigger handle={tip} aria-label="Delete">…</Tooltip.Trigger>
+ * <Tooltip.Root handle={tip}>…</Tooltip.Root>
+ * ```
+ *
+ * All parts are thin styled wrappers over Base UI's `Tooltip`, so every Base UI
+ * prop, `render` override, and ref behaves the same. Part prop types are
+ * exported separately (`TooltipProps`, `TooltipTriggerProps`, ...).
+ */
+declare const Tooltip$1: {
+  Provider: typeof TooltipProvider;
+  Root: typeof TooltipRoot;
+  Trigger: typeof TooltipTrigger;
+  Portal: typeof TooltipPortal;
+  Positioner: typeof TooltipPositioner;
+  Popup: typeof TooltipPopup;
+  Arrow: typeof TooltipArrow;
+  Viewport: typeof TooltipViewport;
+  createHandle: typeof Tooltip.createHandle;
+};
+/** The handle created by `Tooltip.createHandle()`, for typing detached triggers. */
+type TooltipHandle<Payload> = Tooltip.Handle<Payload>;
+//#endregion
+export { TooltipProps as a, TooltipPortalProps$1 as c, TooltipTriggerProps$1 as i, TooltipPopupProps$1 as l, TooltipHandle as n, TooltipProviderProps$1 as o, TooltipViewportProps$1 as r, TooltipPositionerProps$1 as s, Tooltip$1 as t, TooltipArrowProps$1 as u };