@vikram-hegde/skeletal 0.0.1

package/dist/index-BLFVnve3.d.ts

@@ -0,0 +1,53 @@
+import { HTMLAttributes, ReactNode } from "react";
+//#region src/skeleton/skeleton.d.ts
+/**
+ * A layout-aware skeleton for loading states. Wrap a real component — rendered
+ * with mock content while data loads, or the actual UI once it arrives — and
+ * its text, media, and form controls are replaced by shimmer bars. No manual
+ * rectangle sizing.
+ *
+ * Each text node is wrapped in an inline span whose text is transparent; with
+ * `box-decoration-break: clone` every wrapped line fragment becomes its own
+ * solid shimmer bar, so the bars inherit the exact line box (width per wrapped
+ * line, height from font size × line-height) of the content. Images / video /
+ * svg / buttons become a shimmer block sized to the element, and inputs keep
+ * their box with shimmering value text.
+ *
+ * Pass `loading` to render the real content when it's not loading, or default
+ * (mock) mode by simply wrapping mock content. The two states cross-fade
+ * smoothly (the real content and shimmer overlap in the same box and swap
+ * opacity), so toggling `loading` never jumps — and the real images are
+ * already loaded by the time loading ends.
+ *
+ * The wrapper adds no box (`display: contents`) and is `aria-hidden` while
+ * loading — announce the loading state from a live region around it, e.g.
+ * `<div role="status">Loading…</div>`.
+ *
+ * Customize per instance via CSS custom properties on the wrapper:
+ * `--_skeleton-base`, `--_skeleton-highlight`, `--_skeleton-duration`,
+ * `--_skeleton-radius` (media), and `--_skeleton-text-radius` (text bars).
+ */
+interface SkeletonProps extends HTMLAttributes<HTMLDivElement> {
+  /**
+   * Whether to show the shimmer instead of the real content.
+   *
+   * Defaults to `true` — content wrapped in a Skeleton is treated as mock and
+   * shimmered. Pass `loading={false}`, or a boolean you toggle once data
+   * arrives, to render the children as-is. The layout never jumps: both states
+   * keep the same structure, only the paint changes.
+   *
+   * @default true
+   */
+  loading?: boolean;
+  /**
+   * The content to shimmer. While `loading` is `true`, any text, images, and
+   * form controls inside are replaced with the shimmer effect while keeping
+   * their exact layout; when `false` they render normally.
+   *
+   * @required
+   */
+  children: ReactNode;
+}
+declare function Skeleton({ children, loading, className, style, ...props }: SkeletonProps): import("react").JSX.Element;
+//#endregion
+export { SkeletonProps as n, Skeleton as t };

package/dist/index-BXPUT5u-.d.ts

@@ -0,0 +1,72 @@
+import { InputProps } from "@base-ui/react/input";
+import { FieldDescriptionProps, FieldErrorProps, FieldLabelProps, FieldRootProps } from "@base-ui/react/field";
+//#region src/input/input.d.ts
+/**
+ * The height and text size of the input:
+ * - `sm`: 2rem tall — dense forms, inline filters, table toolbars.
+ * - `md`: 2.5rem tall — default; most form fields.
+ * - `lg`: 3rem tall — prominent search bars, hero CTAs.
+ *
+ * @default size = 'md'
+ */
+type InputSize = "sm" | "md" | "lg";
+/**
+ * A styled text input. Renders a native `<input>` element.
+ *
+ * Wraps Base UI's `Input`, so every Base UI prop works: `render` to swap the
+ * element, `value`/`defaultValue`/`onValueChange` for controlled usage,
+ * `className`, `disabled`, etc.
+ *
+ * It is designed to live inside Base UI's `Field` (`Field.Root`,
+ * `Field.Label`, `Field.Description`, `Field.Error`, `Field.Control`). When it
+ * is, it automatically reflects validation state via `data-valid`,
+ * `data-invalid`, `data-filled`, `data-touched`, `data-dirty`, and `data-focused`
+ * attributes set by Base UI — so the border and ring restyle themselves with no
+ * extra wiring. The same styling works standalone (unwrapped) too.
+ *
+ * All props are optional.
+ */
+interface InputProps$1 extends Omit<InputProps, "size"> {
+  /** Height and text size of the input. @default 'md' */
+  size?: InputSize;
+  /** Whether the input stretches to fill its parent width. @default false */
+  fullWidth?: boolean;
+}
+declare function Input$1({ className, size, fullWidth, ...props }: InputProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/input/field.d.ts
+/**
+ * Groups a label, control, description, and error into a single accessible
+ * field. Wraps Base UI's `Field.Root`, so every Base UI prop works
+ * (`disabled`, `name`, `validate`, `validationMode`, etc.). All parts placed
+ * inside it (including Skeletal's `Input`) automatically share validation
+ * state.
+ *
+ * All props are optional.
+ */
+interface FieldRootProps$1 extends FieldRootProps {}
+/**
+ * An accessible label automatically associated with the field's control.
+ * Wraps Base UI's `Field.Label`. All props are optional.
+ */
+interface FieldLabelProps$1 extends FieldLabelProps {}
+/**
+ * Helper text shown beneath the label, before the control. Use it to clarify
+ * the expected format or purpose. Wraps Base UI's `Field.Description`. All
+ * props are optional.
+ */
+interface FieldDescriptionProps$1 extends FieldDescriptionProps {}
+/**
+ * An error message revealed when the field fails validation (driven by the
+ * field's `ValidityState`). Wraps Base UI's `Field.Error`, so its `match` prop
+ * controls visibility. All props are optional.
+ */
+interface FieldErrorProps$1 extends FieldErrorProps {}
+declare const Field$1: {
+  Root: ({ className, ...props }: FieldRootProps$1) => import("react").JSX.Element;
+  Label: ({ className, ...props }: FieldLabelProps$1) => import("react").JSX.Element;
+  Description: ({ className, ...props }: FieldDescriptionProps$1) => import("react").JSX.Element;
+  Error: ({ className, ...props }: FieldErrorProps$1) => import("react").JSX.Element;
+};
+//#endregion
+export { FieldRootProps$1 as a, InputSize as c, FieldLabelProps$1 as i, FieldDescriptionProps$1 as n, Input$1 as o, FieldErrorProps$1 as r, InputProps$1 as s, Field$1 as t };

package/dist/index-BngvATZx.d.ts

@@ -0,0 +1,35 @@
+import { HTMLAttributes } from "react";
+//#region src/spinner/spinner.d.ts
+/**
+ * A rotating arc indicator for pending states. Renders a `<span>`.
+ *
+ * Pure CSS (conic-gradient arc + mask ring) — no state, no library. Inherits
+ * the surrounding text color via `currentColor`, so it works on any
+ * foreground, including inside a `Button` or on a `--primary` fill.
+ *
+ * By default it is decorative (`aria-hidden`). Pass `label` to announce the
+ * pending state to screen readers (`role="status"`); for a `Button` with
+ * `loading` the label is redundant, so omit it there.
+ *
+ * The rotation is essential feedback and is kept under
+ * `prefers-reduced-motion`.
+ */
+interface SpinnerProps extends HTMLAttributes<HTMLSpanElement> {
+  /**
+   * The spinner diameter, in any CSS length.
+   *
+   * @default '1em'
+   */
+  size?: string;
+  /**
+   * Accessible status text read by screen readers while pending.
+   *
+   * Omit for decorative use (e.g. inside a `Button` with `loading`).
+   *
+   * @default undefined
+   */
+  label?: string;
+}
+declare function Spinner({ size, label, className, style, ...props }: SpinnerProps): import("react").JSX.Element;
+//#endregion
+export { SpinnerProps as n, Spinner as t };

package/dist/index-Br2NrBW_.d.ts

@@ -0,0 +1,444 @@
+import { n as ButtonProps } from "./button-Dvd4n2U4.js";
+import { ComboboxArrowProps, ComboboxBackdropProps, ComboboxChipProps, ComboboxChipRemoveProps, ComboboxChipsProps, ComboboxClearProps, ComboboxCollectionProps, ComboboxEmptyProps, ComboboxGroupLabelProps, ComboboxGroupProps, ComboboxInputGroupProps, ComboboxInputProps, ComboboxItemIndicatorProps, ComboboxItemProps, ComboboxLabelProps, ComboboxListProps, ComboboxPopupProps, ComboboxPortalProps, ComboboxPositionerProps, ComboboxRootProps, ComboboxRowProps, ComboboxSeparatorProps, ComboboxStatusProps, ComboboxTriggerProps, ComboboxValueProps } from "@base-ui/react/combobox";
+//#region src/combobox/combobox-arrow.d.ts
+/**
+ * A small arrow pointing from the popup to the anchor. Renders a `<div>`
+ * element.
+ *
+ * Place it inside `Combobox.Popup` (before the list). It orients itself based
+ * on the popup's `data-side` attribute, so it works for any placement. Pair
+ * with a larger `sideOffset` on the `Combobox.Positioner` so the arrow has room.
+ */
+interface ComboboxArrowProps$1 extends ComboboxArrowProps {}
+declare function ComboboxArrow({ className, ...props }: ComboboxArrowProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-backdrop.d.ts
+/**
+ * An overlay rendered beneath the combobox popup. Renders a `<div>` element.
+ *
+ * Only rendered when the combobox is modal. Clicking the backdrop dismisses the
+ * popup. The overlay is translucent; set a fully opaque color (or remove it) if
+ * you prefer a "dimmed page" look vs. a light scrim.
+ */
+interface ComboboxBackdropProps$1 extends ComboboxBackdropProps {}
+declare function ComboboxBackdrop({ className, ...props }: ComboboxBackdropProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-chip.d.ts
+/**
+ * An individual chip representing one selected value in a multi-select
+ * combobox. Renders a `<div>` element.
+ *
+ * Give it the value's label as children and a `Combobox.ChipRemove` for the
+ * remove affordance. Provide an `aria-label` describing the value.
+ */
+interface ComboboxChipProps$1 extends ComboboxChipProps {}
+declare function ComboboxChip({ className, ...props }: ComboboxChipProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-chip-remove.d.ts
+/**
+ * A button that removes its parent `Combobox.Chip`. Renders a `<button>`
+ * element.
+ *
+ * Place it as the last child of a chip with an `x` icon. Give it an
+ * `aria-label` like `Remove <value>`.
+ */
+interface ComboboxChipRemoveProps$1 extends ComboboxChipRemoveProps {}
+declare function ComboboxChipRemove({ className, ...props }: ComboboxChipRemoveProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-chips.d.ts
+/**
+ * A container for the chips in a multi-select combobox. Renders a `<div>`
+ * element.
+ *
+ * Wrap the `<Combobox.Value>` (which renders one `Combobox.Chip` per selected
+ * value, followed by the `<Combobox.Input>`) inside it. Chips wrap onto multiple
+ * lines as the selection grows.
+ */
+interface ComboboxChipsProps$1 extends ComboboxChipsProps {}
+declare function ComboboxChips({ className, ...props }: ComboboxChipsProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-clear.d.ts
+/**
+ * A button that clears the current selection (and input text). Renders a
+ * `<button>` element.
+ *
+ * Composed from the `Button` component via Base UI's `render` prop, so it
+ * accepts all `Button` props plus the combobox-clear props from Base UI
+ * (`keepMounted`, `disabled`). Defaults to the `ghost` `sm` variant, compacted
+ * into an icon-sized square when inside a `Combobox.InputGroup`.
+ *
+ * It is only visible when there is a value to clear (single/multi select) or
+ * non-empty input text; pass `keepMounted` to keep it in the DOM and drive its
+ * show/hide styling yourself. Give it an `aria-label` and an `x` icon child.
+ *
+ * @default keepMounted = false
+ */
+interface ComboboxClearProps$1 extends ButtonProps, Omit<ComboboxClearProps, "className" | "style" | "render" | "nativeButton"> {}
+declare function ComboboxClear({ className, variant, size, fullWidth, ...props }: ComboboxClearProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-collection.d.ts
+/**
+ * Renders filtered list items as a group. Renders no DOM element.
+ *
+ * Provide a render function receiving each item (and index) to map filtered
+ * items to `Combobox.Item`s. This is the building block for custom layouts
+ * (e.g. grouped/grid lists); for a flat list, pass the same function directly
+ * to `Combobox.List`, which implicitly wraps it.
+ */
+interface ComboboxCollectionProps$1 extends ComboboxCollectionProps {}
+declare function ComboboxCollection(props: ComboboxCollectionProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-empty.d.ts
+/**
+ * Renders its children only when the filtered list is empty. Renders a `<div>`
+ * element.
+ *
+ * Requires the `items` prop on `Combobox.Root`. Keep the element mounted in the
+ * DOM (don't `display: none` or conditionally unmount it) — render or update its
+ * children instead — so the "no results" announcement is consistent across
+ * screen readers.
+ */
+interface ComboboxEmptyProps$1 extends ComboboxEmptyProps {}
+declare function ComboboxEmpty({ className, ...props }: ComboboxEmptyProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-group.d.ts
+/**
+ * Groups related items under an accessible label. Renders a `<div>` element.
+ *
+ * Pair with `<Combobox.GroupLabel>` inside the group; Base UI wires the
+ * `aria-labelledby` association automatically.
+ *
+ * Rendered with `display: contents` so its items participate directly in the
+ * popup layout.
+ */
+interface ComboboxGroupProps$1 extends ComboboxGroupProps {}
+declare function ComboboxGroup({ className, ...props }: ComboboxGroupProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-group-label.d.ts
+/**
+ * A label for a `<Combobox.Group>`, automatically associated with it for screen
+ * readers. Renders a `<div>` element.
+ *
+ * Styled small and muted; add a `Combobox.Separator` before the group to
+ * visually divide it from the items above.
+ */
+interface ComboboxGroupLabelProps$1 extends ComboboxGroupLabelProps {}
+declare function ComboboxGroupLabel({ className, ...props }: ComboboxGroupLabelProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-input.d.ts
+/**
+ * The text input used to filter the items. Renders an `<input>` element.
+ *
+ * Inside a `Combobox.InputGroup` the input grows to fill it, and trailing
+ * controls push against its right edge; the group provides the border, focus
+ * ring, and leading gutter. Rendered directly inside `Combobox.Popup` (the
+ * searchable-select pattern) it spans the popup end-to-end with a bottom
+ * divider, and its inline gutter matches the list's so text lines up with
+ * items. Placeholder text is muted.
+ *
+ * This is the combobox's form control, so label it with a native `<label>` (or
+ * `aria-label`) for an accessible name.
+ */
+interface ComboboxInputProps$1 extends ComboboxInputProps {}
+declare function ComboboxInput({ className, ...props }: ComboboxInputProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-input-group.d.ts
+/**
+ * A bordered container that wraps the input and its trailing controls (clear
+ * and trigger buttons, or chips). Renders a `<div>` element.
+ *
+ * The group reads as the field's focus target: it shows a focus ring whenever
+ * the inner input is focused, and dims when `disabled`. Place the
+ * `<Combobox.Input>` first, then `<Combobox.Clear>` / `<Combobox.Trigger>` (or
+ * `<Combobox.Chips>` for multi-select) so they line up against the trailing
+ * edge.
+ */
+interface ComboboxInputGroupProps$1 extends ComboboxInputGroupProps {}
+declare function ComboboxInputGroup({ className, ...props }: ComboboxInputGroupProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-item.d.ts
+/**
+ * An individual option in the combobox list. Renders a `<div>` element.
+ *
+ * Accepts all Base UI item props: `value` (any primitive or object),
+ * `disabled`, `label` for keyboard text navigation, and `onClick`. Give each
+ * item a unique `value`; when `Combobox.Value` renders the label, pass the same
+ * `items` to `Combobox.Root`.
+ *
+ * A selected item shows its `Combobox.ItemIndicator` (e.g. a check icon) in the
+ * leading column; the highlighted item (keyboard/pointer) gets the accent
+ * background.
+ *
+ * The leading column is always reserved: every item mirrors the list's
+ * two-column grid template, so labels line up on the same baseline whether or
+ * not an indicator is mounted.
+ *
+ * @default value = null
+ * @default disabled = false
+ */
+interface ComboboxItemProps$1 extends ComboboxItemProps {}
+declare function ComboboxItem({ className, ...props }: ComboboxItemProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-item-indicator.d.ts
+/**
+ * A checkmark slot shown on the selected item. Renders a `<span>` element.
+ *
+ * Place it as the first child of a `Combobox.Item`; it sits in the leading grid
+ * column. The indicator (and its children) unmount when the item is not
+ * selected unless `keepMounted` is set. It animates in/out via
+ * `data-starting-style` / `data-ending-style`.
+ *
+ * @default keepMounted = false
+ */
+interface ComboboxItemIndicatorProps$1 extends ComboboxItemIndicatorProps {}
+declare function ComboboxItemIndicator({ className, ...props }: ComboboxItemIndicatorProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-label.d.ts
+/**
+ * An accessible label for the combobox. Renders a `<div>` element.
+ *
+ * In the trigger pattern this labels the trigger; in the input pattern, label
+ * the `<Combobox.Input>` with a native `<label>` (or pass `aria-label`) instead.
+ * Place it as a sibling of the input/trigger inside `Combobox.Root`; Base UI
+ * wires the `aria-labelledby` association automatically.
+ *
+ * Styled medium-weight with comfortable spacing below it (0.5rem), so the label
+ * reads as a field caption rather than crowding the control. It dims to the
+ * muted color when the combobox is `disabled`.
+ */
+interface ComboboxLabelProps$1 extends ComboboxLabelProps {}
+declare function ComboboxLabel({ className, ...props }: ComboboxLabelProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-list.d.ts
+/**
+ * A scrollable container for the filtered items. Renders a `<div>` element.
+ *
+ * Constrained by `--available-height` so long lists scroll. Children may be a
+ * render function that receives each item (and index), which is the idiomatic
+ * way to map filtered items to `Combobox.Item`s.
+ */
+interface ComboboxListProps$1 extends ComboboxListProps {}
+declare function ComboboxList({ className, ...props }: ComboboxListProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-popup.d.ts
+/**
+ * The popup panel that holds the list (and optionally the input). Renders a
+ * `<div>` element.
+ *
+ * Accepts all Base UI popup props, including `initialFocus` / `finalFocus` for
+ * controlling focus when the popup opens/closes. Content animates in/out via
+ * the `data-starting-style` / `data-ending-style` transitions.
+ *
+ * By default the popup is at least as wide as its anchor (`min-width:
+ * var(--anchor-width)`), so the list aligns with the input group. Pass
+ * `style={{ width: ... }}` or a `className` to constrain it.
+ */
+interface ComboboxPopupProps$1 extends ComboboxPopupProps {}
+declare function ComboboxPopup({ className, ...props }: ComboboxPopupProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-portal.d.ts
+/**
+ * Moves the combobox popup to a different part of the DOM, appended to `<body>`
+ * by default. Renders a `<div>` element.
+ *
+ * `container` overrides the portal target. `keepMounted` keeps the portal in
+ * the DOM while closed.
+ *
+ * @default keepMounted = false
+ */
+interface ComboboxPortalProps$1 extends ComboboxPortalProps {}
+declare function ComboboxPortal({ className, ...props }: ComboboxPortalProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-positioner.d.ts
+/**
+ * Positions the combobox popup against the anchor. Renders a `<div>` element.
+ *
+ * Accepts all Base UI positioner props: `side`, `align`, `sideOffset`,
+ * `alignOffset`, `collisionAvoidance`, `collisionBoundary`, `collisionPadding`,
+ * `sticky`, `positionMethod`, `arrowPadding`, and `anchor`.
+ *
+ * By default the popup anchors to the `Combobox.InputGroup` (so it matches the
+ * field's width), or to the trigger when the input lives inside the popup.
+ *
+ * @default sideOffset = 4
+ */
+interface ComboboxPositionerProps$1 extends ComboboxPositionerProps {}
+declare function ComboboxPositioner({ className, sideOffset, ...props }: ComboboxPositionerProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-root.d.ts
+/**
+ * The root of the combobox, grouping all parts together. Renders no DOM element.
+ *
+ * All Base UI root props are supported: `value` / `defaultValue`,
+ * `onValueChange`, `multiple`, `items`, `itemToStringLabel`,
+ * `itemToStringValue`, `isItemEqualToValue`, `open` / `defaultOpen`,
+ * `onOpenChange`, `onInputValueChange`, `autoHighlight`, `highlightItemOnHover`,
+ * `disabled`, `readOnly`, `required`, `name`, `form`, `autoComplete`, and the
+ * `filter` function.
+ *
+ * Pass `items` (an array of `{ value, label }` or a record of label lookups)
+ * so filtering and value formatting work. The `Value` type is inferred from
+ * `value` / `defaultValue`. Add `multiple` to allow multi-selection with chips.
+ *
+ * @default multiple = false
+ */
+interface ComboboxProps<Value, Multiple extends boolean | undefined = false> extends ComboboxRootProps<Value, Multiple> {}
+declare function ComboboxRoot<Value, Multiple extends boolean | undefined = false>(props: ComboboxProps<Value, Multiple>): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-row.d.ts
+/**
+ * Displays a single row of items in a grid list. Renders a `<div>` element.
+ *
+ * Enable `grid` on `Combobox.Root` to turn the listbox into a grid, then wrap
+ * each row's items in a `Combobox.Row`. Rendered with `display: contents` so
+ * rows don't disrupt the flat list layout when `grid` is off.
+ */
+interface ComboboxRowProps$1 extends ComboboxRowProps {}
+declare function ComboboxRow({ className, ...props }: ComboboxRowProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-separator.d.ts
+/**
+ * A horizontal divider between groups of items. Renders a `<div>` element.
+ *
+ * It is announced to screen readers via `role="separator"`.
+ *
+ * @default orientation = 'horizontal'
+ */
+interface ComboboxSeparatorProps$1 extends ComboboxSeparatorProps {}
+declare function ComboboxSeparator({ className, ...props }: ComboboxSeparatorProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-status.d.ts
+/**
+ * Displays a status message (e.g. "Loading…") whose changes are announced
+ * politely to screen readers. Renders a `<div>` element.
+ *
+ * Useful for conveying the state of an asynchronously loaded list. Keep the
+ * element mounted in the DOM — update or conditionally render its children
+ * instead — so announcements are consistent.
+ */
+interface ComboboxStatusProps$1 extends ComboboxStatusProps {}
+declare function ComboboxStatus({ className, ...props }: ComboboxStatusProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-trigger.d.ts
+/**
+ * A button that opens the combobox popup. 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 combobox-trigger props from Base UI. Defaults to the `ghost` `sm`
+ * variant, which — when placed inside a `Combobox.InputGroup` — compacts into
+ * an icon-sized square button. For the "input inside popup" (select-like)
+ * pattern, pass `variant="outline"` / `size="md"` and wrap a
+ * `<Combobox.Value>` inside.
+ *
+ * The disclosure `CaretDown` chevron is always rendered by the trigger itself
+ * (via `BaseCombobox.Icon`, rotating 180° when open) — no `Combobox.Icon`
+ * prop is needed.
+ */
+interface ComboboxTriggerProps$1 extends ButtonProps, Omit<ComboboxTriggerProps, "className" | "style" | "render" | "nativeButton"> {}
+declare function ComboboxTrigger({ className, variant, size, fullWidth, children, ...props }: ComboboxTriggerProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/combobox-value.d.ts
+/**
+ * The current selected value, for formatting. Renders no DOM element.
+ *
+ * By default renders the selected value's label (when `items` is passed to
+ * `Combobox.Root`) or the raw value. Pass `placeholder` to show hint text when
+ * no value is selected, or a function as `children` to format the value:
+ *
+ * ```tsx
+ * <Combobox.Value placeholder="Choose a fruit">
+ *   {(value) => value ? value.label.toUpperCase() : ''}
+ * </Combobox.Value>
+ * ```
+ *
+ * In multi-select mode the child function receives the array of selected values
+ * (the place to render `Combobox.Chip`s).
+ */
+interface ComboboxValueProps$1 extends ComboboxValueProps {}
+declare function ComboboxValue(props: ComboboxValueProps$1): import("react").JSX.Element;
+//#endregion
+//#region src/combobox/index.d.ts
+/**
+ * Compound component for a filterable select — an input combined with a list of
+ * predefined items.
+ *
+ * Assemble the parts as properties of the object:
+ *
+ * ```tsx
+ * import { Combobox } from '@vikram-hegde/skeletal'
+ *
+ * const fruits = [
+ *   { value: 'apple', label: 'Apple' },
+ *   { value: 'banana', label: 'Banana' },
+ *   { value: 'orange', label: 'Orange' },
+ * ]
+ *
+ * <Combobox.Root items={fruits}>
+ *   <Combobox.Label>Choose a fruit</Combobox.Label>
+ *   <Combobox.InputGroup>
+ *     <Combobox.Input placeholder="e.g. Apple" />
+ *     <Combobox.Clear aria-label="Clear selection">
+ *       <Icon name={X} size={14} />
+ *     </Combobox.Clear>
+ *     <Combobox.Trigger aria-label="Open popup" />
+ *   </Combobox.InputGroup>
+ *   <Combobox.Portal>
+ *     <Combobox.Positioner>
+ *       <Combobox.Popup>
+ *         <Combobox.Empty>No fruits found.</Combobox.Empty>
+ *         <Combobox.List>
+ *           {(fruit) => (
+ *             <Combobox.Item key={fruit.value} value={fruit}>
+ *               <Combobox.ItemIndicator>
+ *                 <Icon name={Check} size={14} />
+ *               </Combobox.ItemIndicator>
+ *               {fruit.label}
+ *             </Combobox.Item>
+ *           )}
+ *         </Combobox.List>
+ *       </Combobox.Popup>
+ *     </Combobox.Positioner>
+ *   </Combobox.Portal>
+ * </Combobox.Root>
+ * ```
+ *
+ * Composition follows the Base UI anatomy — the popup anchors to the
+ * `Combobox.InputGroup` (so it matches the field's width) and handles collision
+ * avoidance; `Combobox.Portal` moves it to `<body>`. Add `multiple` to
+ * `Combobox.Root` and render `Combobox.Chip`s inside `Combobox.Value` for
+ * multi-select. The trigger owns its `CaretDown` chevron — no `Combobox.Icon` is needed.
+ *
+ * All parts are thin styled wrappers over Base UI's `Combobox`, so every Base UI
+ * prop, `render` override, and ref behaves the same. Part prop types are
+ * exported separately (`ComboboxProps`, `ComboboxItemProps`, etc.).
+ */
+declare const Combobox$1: {
+  Root: typeof ComboboxRoot;
+  Label: typeof ComboboxLabel;
+  InputGroup: typeof ComboboxInputGroup;
+  Input: typeof ComboboxInput;
+  Trigger: typeof ComboboxTrigger;
+  Clear: typeof ComboboxClear;
+  Value: typeof ComboboxValue;
+  Chips: typeof ComboboxChips;
+  Chip: typeof ComboboxChip;
+  ChipRemove: typeof ComboboxChipRemove;
+  Portal: typeof ComboboxPortal;
+  Backdrop: typeof ComboboxBackdrop;
+  Positioner: typeof ComboboxPositioner;
+  Popup: typeof ComboboxPopup;
+  Arrow: typeof ComboboxArrow;
+  Status: typeof ComboboxStatus;
+  Empty: typeof ComboboxEmpty;
+  List: typeof ComboboxList;
+  Row: typeof ComboboxRow;
+  Item: typeof ComboboxItem;
+  ItemIndicator: typeof ComboboxItemIndicator;
+  Separator: typeof ComboboxSeparator;
+  Group: typeof ComboboxGroup;
+  GroupLabel: typeof ComboboxGroupLabel;
+  Collection: typeof ComboboxCollection;
+};
+//#endregion
+export { ComboboxChipRemoveProps$1 as C, ComboboxArrowProps$1 as E, ComboboxChipsProps$1 as S, ComboboxBackdropProps$1 as T, ComboboxGroupLabelProps$1 as _, ComboboxSeparatorProps$1 as a, ComboboxCollectionProps$1 as b, ComboboxPositionerProps$1 as c, ComboboxListProps$1 as d, ComboboxLabelProps$1 as f, ComboboxInputProps$1 as g, ComboboxInputGroupProps$1 as h, ComboboxStatusProps$1 as i, ComboboxPortalProps$1 as l, ComboboxItemProps$1 as m, ComboboxValueProps$1 as n, ComboboxRowProps$1 as o, ComboboxItemIndicatorProps$1 as p, ComboboxTriggerProps$1 as r, ComboboxProps as s, Combobox$1 as t, ComboboxPopupProps$1 as u, ComboboxGroupProps$1 as v, ComboboxChipProps$1 as w, ComboboxClearProps$1 as x, ComboboxEmptyProps$1 as y };