@stridge/noctis 1.0.0-beta.0

package/dist/components/radio/radio.props.d.ts

@@ -0,0 +1,106 @@
+import { Radio } from "./radio.js";
+
+//#region src/components/radio/radio.props.d.ts
+/** A spreadable data-attribute prop bag — the shape every `Radio.*.props()` returns. */
+type RadioPartProps = {
+  /** The slot value the matching `radio.css` rules anchor on. */"data-slot": string; /** Forwarded verbatim — styling is attribute-driven, so this is an optional consumer passthrough. */
+  className?: string; /** A data-attribute present (empty string) or absent (`undefined`); never `false`. */
+  [attr: `data-${string}`]: string | undefined;
+};
+/** Common shape: every part's `.props()` accepts an optional `className` passthrough. */
+interface BasePropsArgs {
+  /** Forwarded verbatim onto the returned prop bag. */
+  className?: string;
+}
+/** Argument to `Radio.Group.props(...)` — the group has no axes of its own; gap flows from the slot. */
+interface RadioGroupPropsArgs extends BasePropsArgs {
+  /** Layout axis — stamped as `data-orientation`; `horizontal` lays the radios in a row. @default "vertical" */
+  orientation?: Radio.Orientation;
+  /** Whether the whole group is disabled (drives the dimmed affordance via `data-disabled`). */
+  disabled?: boolean;
+  /** Whether the group's value is invalid (cascades the danger border via `data-invalid`). */
+  invalid?: boolean;
+}
+/** Argument to `Radio.Root.props(...)` — the box's size axis plus its checked/disabled/read-only/invalid state. */
+interface RadioPropsArgs extends BasePropsArgs {
+  /** Box size — stamped as `data-size`, re-points the box and dot edges. @default "md" */
+  size?: Radio.Size;
+  /** Whether this radio is the selected one (draws the accent border + dot via `data-checked`). */
+  checked?: boolean;
+  /** Whether this radio is disabled (drives the dimmed affordance via `data-disabled`). */
+  disabled?: boolean;
+  /** Whether this radio is read-only (drops the pointer and hover affordance via `data-readonly`). */
+  readonly?: boolean;
+  /** Whether this radio is invalid (paints the danger border via `data-invalid`). */
+  invalid?: boolean;
+}
+/** Argument to `Radio.Indicator.props(...)` — the dot mirrors the box's checked state. */
+interface RadioIndicatorPropsArgs extends BasePropsArgs {
+  /** Whether the parent radio is selected (shows the dot via `data-checked`). */
+  checked?: boolean;
+}
+/** Argument to `Radio.Field.props(...)` — the row pairs a box with its label; its size scales both. */
+interface RadioFieldPropsArgs extends BasePropsArgs {
+  /** Row size — stamped as `data-size`, scales the label text and cascades to the box inside. @default "md" */
+  size?: Radio.Size;
+}
+/** Argument to `Radio.Label.props(...)` — the label mirrors the field's disabled / invalid state. */
+interface RadioLabelPropsArgs extends BasePropsArgs {
+  /** Whether the field is disabled (dims the label and drops its pointer via `data-disabled`). */
+  disabled?: boolean;
+  /** Whether the field is invalid (recolours the label to danger via `data-invalid`). */
+  invalid?: boolean;
+}
+/** Argument to `Radio.Description.props(...)` — the helper text carries no axes of its own. */
+type RadioDescriptionPropsArgs = BasePropsArgs;
+/** Argument to `Radio.Card.props(...)` — the card's control-position axis. */
+interface RadioCardPropsArgs extends BasePropsArgs {
+  /** Where the radio sits relative to the content — stamped as `data-control`. @default "leading" */
+  controlPosition?: Radio.ControlPosition;
+  /** Hide the visible dot (border-only selection) — stamped as `data-control-hidden`. @default false */
+  hideControl?: boolean;
+}
+/** Group prop bag: slot anchor plus the `data-orientation` axis and the `data-disabled`/`data-invalid` state. */
+declare function groupProps({
+  orientation,
+  disabled,
+  invalid,
+  className
+}?: RadioGroupPropsArgs): RadioPartProps;
+/** Radio box prop bag: slot anchor plus the `data-size` and `data-checked`/`data-disabled`/`data-readonly`/`data-invalid` state. */
+declare function radioProps({
+  size,
+  checked,
+  disabled,
+  readonly,
+  invalid,
+  className
+}?: RadioPropsArgs): RadioPartProps;
+/** Indicator dot prop bag: slot anchor plus the mirrored `data-checked` state. */
+declare function indicatorProps({
+  checked,
+  className
+}?: RadioIndicatorPropsArgs): RadioPartProps;
+/** Field prop bag: slot anchor plus the `data-size` axis that scales the label and cascades to the box. */
+declare function fieldProps({
+  size,
+  className
+}?: RadioFieldPropsArgs): RadioPartProps;
+/** Label prop bag: slot anchor plus the `data-disabled`/`data-invalid` that mirror the field state. */
+declare function labelProps({
+  disabled,
+  invalid,
+  className
+}?: RadioLabelPropsArgs): RadioPartProps;
+/** Description prop bag: just the slot anchor (the muted helper text styling flows from the slot). */
+declare function descriptionProps({
+  className
+}?: RadioDescriptionPropsArgs): RadioPartProps;
+/** Card prop bag: slot anchor plus the `data-control` position axis. */
+declare function cardProps({
+  controlPosition,
+  hideControl,
+  className
+}?: RadioCardPropsArgs): RadioPartProps;
+//#endregion
+export { cardProps, descriptionProps, fieldProps, groupProps, indicatorProps, labelProps, radioProps };

package/dist/components/radio/radio.props.js

@@ -0,0 +1,65 @@
+import { RADIO_SLOTS } from "./radio.slots.js";
+//#region src/components/radio/radio.props.ts
+/** Stamp a boolean state as a bare data-attribute: present (`""`) when on, absent (`undefined`) when off. */
+const flag = (on) => on ? "" : void 0;
+const withClassName = (bag, className) => className === void 0 ? bag : {
+	...bag,
+	className
+};
+/** Group prop bag: slot anchor plus the `data-orientation` axis and the `data-disabled`/`data-invalid` state. */
+function groupProps({ orientation = "vertical", disabled, invalid, className } = {}) {
+	return withClassName({
+		"data-slot": RADIO_SLOTS.group,
+		"data-orientation": orientation,
+		"data-disabled": flag(disabled),
+		"data-invalid": flag(invalid)
+	}, className);
+}
+/** Radio box prop bag: slot anchor plus the `data-size` and `data-checked`/`data-disabled`/`data-readonly`/`data-invalid` state. */
+function radioProps({ size = "md", checked, disabled, readonly, invalid, className } = {}) {
+	return withClassName({
+		"data-slot": RADIO_SLOTS.radio,
+		"data-size": size,
+		"data-checked": flag(checked),
+		"data-unchecked": flag(!checked),
+		"data-disabled": flag(disabled),
+		"data-readonly": flag(readonly),
+		"data-invalid": flag(invalid)
+	}, className);
+}
+/** Indicator dot prop bag: slot anchor plus the mirrored `data-checked` state. */
+function indicatorProps({ checked, className } = {}) {
+	return withClassName({
+		"data-slot": RADIO_SLOTS.indicator,
+		"data-checked": flag(checked)
+	}, className);
+}
+/** Field prop bag: slot anchor plus the `data-size` axis that scales the label and cascades to the box. */
+function fieldProps({ size = "md", className } = {}) {
+	return withClassName({
+		"data-slot": RADIO_SLOTS.field,
+		"data-size": size
+	}, className);
+}
+/** Label prop bag: slot anchor plus the `data-disabled`/`data-invalid` that mirror the field state. */
+function labelProps({ disabled, invalid, className } = {}) {
+	return withClassName({
+		"data-slot": RADIO_SLOTS.label,
+		"data-disabled": flag(disabled),
+		"data-invalid": flag(invalid)
+	}, className);
+}
+/** Description prop bag: just the slot anchor (the muted helper text styling flows from the slot). */
+function descriptionProps({ className } = {}) {
+	return withClassName({ "data-slot": RADIO_SLOTS.description }, className);
+}
+/** Card prop bag: slot anchor plus the `data-control` position axis. */
+function cardProps({ controlPosition = "leading", hideControl, className } = {}) {
+	return withClassName({
+		"data-slot": RADIO_SLOTS.card,
+		"data-control": controlPosition,
+		"data-control-hidden": flag(hideControl)
+	}, className);
+}
+//#endregion
+export { cardProps, descriptionProps, fieldProps, groupProps, indicatorProps, labelProps, radioProps };

package/dist/components/radio/radio.slots.d.ts

@@ -0,0 +1,29 @@
+//#region src/components/radio/radio.slots.d.ts
+/**
+ * The `data-*` attributes a `Radio` exposes. Base UI stamps the live state attributes the CSS keys
+ * off; each member's JSDoc is the description docgen renders into the attributes table.
+ */
+declare enum RadioDataAttributes {
+  /** The styling/testing hook: the part's stable slot name. */
+  slot = "data-slot",
+  /** Size axis on the radio box — `sm` | `md` | `lg`; re-points the box and dot edges. */
+  size = "data-size",
+  /** Layout axis on the group — `vertical` | `horizontal`; switches the row/column flow. */
+  orientation = "data-orientation",
+  /** Present on the selected radio box (and its indicator). */
+  checked = "data-checked",
+  /** Present on an unselected radio box. */
+  unchecked = "data-unchecked",
+  /** Present on a disabled radio or group. */
+  disabled = "data-disabled",
+  /** Present on a read-only radio — valid and announced, but not editable. */
+  readonly = "data-readonly",
+  /** Present on an invalid radio (and on a group flagged `invalid`); also honours `aria-invalid`. */
+  invalid = "data-invalid",
+  /** On a `Radio.Card`, where the control sits — `leading` | `trailing`. */
+  control = "data-control",
+  /** On a `Radio.Card` with `hideControl`, marks the dot hidden so the accent edge is the only signal. */
+  controlHidden = "data-control-hidden"
+}
+//#endregion
+export { RadioDataAttributes };

package/dist/components/radio/radio.slots.js

@@ -0,0 +1,44 @@
+//#region src/components/radio/radio.slots.ts
+/**
+* The slot vocabulary every `Radio` part stamps as its `data-slot`. The authored source the
+* orchestration files read from, kebab-cased `{component}-{part}`; SLOTS.md still generates from the
+* token-graph declarations.
+*/
+const RADIO_SLOTS = {
+	group: "noctis-radio-group",
+	radio: "noctis-radio",
+	indicator: "noctis-radio-indicator",
+	field: "noctis-radio-field",
+	label: "noctis-radio-label",
+	description: "noctis-radio-description",
+	card: "noctis-radio-card"
+};
+/**
+* The `data-*` attributes a `Radio` exposes. Base UI stamps the live state attributes the CSS keys
+* off; each member's JSDoc is the description docgen renders into the attributes table.
+*/
+let RadioDataAttributes = /* @__PURE__ */ function(RadioDataAttributes) {
+	/** The styling/testing hook: the part's stable slot name. */
+	RadioDataAttributes["slot"] = "data-slot";
+	/** Size axis on the radio box — `sm` | `md` | `lg`; re-points the box and dot edges. */
+	RadioDataAttributes["size"] = "data-size";
+	/** Layout axis on the group — `vertical` | `horizontal`; switches the row/column flow. */
+	RadioDataAttributes["orientation"] = "data-orientation";
+	/** Present on the selected radio box (and its indicator). */
+	RadioDataAttributes["checked"] = "data-checked";
+	/** Present on an unselected radio box. */
+	RadioDataAttributes["unchecked"] = "data-unchecked";
+	/** Present on a disabled radio or group. */
+	RadioDataAttributes["disabled"] = "data-disabled";
+	/** Present on a read-only radio — valid and announced, but not editable. */
+	RadioDataAttributes["readonly"] = "data-readonly";
+	/** Present on an invalid radio (and on a group flagged `invalid`); also honours `aria-invalid`. */
+	RadioDataAttributes["invalid"] = "data-invalid";
+	/** On a `Radio.Card`, where the control sits — `leading` | `trailing`. */
+	RadioDataAttributes["control"] = "data-control";
+	/** On a `Radio.Card` with `hideControl`, marks the dot hidden so the accent edge is the only signal. */
+	RadioDataAttributes["controlHidden"] = "data-control-hidden";
+	return RadioDataAttributes;
+}({});
+//#endregion
+export { RADIO_SLOTS, RadioDataAttributes };

package/dist/components/rail/index.d.ts

@@ -0,0 +1,3 @@
+import { RailSide, RailSize, RailVariant } from "./rail.context.js";
+import { Rail } from "./rail.js";
+import { RailDataAttributes } from "./rail.slots.js";

package/dist/components/rail/rail.context.d.ts

@@ -0,0 +1,17 @@
+//#region src/components/rail/rail.context.d.ts
+/**
+ * Which edge the rail docks to, and the side its divider faces the content (logical, so it mirrors
+ * under RTL). Re-homed here from the now-deleted `rail.styles.ts` so the component, props, and context
+ * share one import site without a cycle through `rail.tsx`.
+ */
+type RailSide = "start" | "end";
+/** The rail's width — re-points the size-keyed `--_rail-panel-width` token on the panel. */
+type RailSize = "xs" | "sm" | "md" | "lg";
+/**
+ * How an open rail affects the content beside it (see `Rail.Layout`):
+ * - `squeeze` — the content's width shrinks; it re-lays-out into the narrower space.
+ * - `push` — the content keeps its width and slides over; nothing reflows, the overflow is clipped.
+ */
+type RailVariant = "squeeze" | "push";
+//#endregion
+export { RailSide, RailSize, RailVariant };

package/dist/components/rail/rail.context.js

@@ -0,0 +1,23 @@
+"use client";
+import { createContext, use } from "react";
+//#region src/components/rail/rail.context.ts
+const RailLayoutContext = createContext(null);
+/** Provided by `Rail.Layout`; carries the reflow `variant`, docking `side`, and `size` to the parts. */
+const RailLayoutProvider = RailLayoutContext.Provider;
+/**
+* Read the surrounding `Rail.Layout`, or `null` when a part renders standalone (a lone `Rail.Panel`
+* docks to the viewport edge, a bare `Rail.Content` lays out on its own) — there is a sensible default,
+* so this never throws.
+*/
+function useRailLayout() {
+	return use(RailLayoutContext);
+}
+const RailTitleContext = createContext(null);
+/** Provided by `Rail.Panel`; carries the generated title id so a `Rail.Title` names the panel. */
+const RailTitleProvider = RailTitleContext.Provider;
+/** Read the panel's generated title id, or `null` for a `Rail.Title` rendered outside a `Rail.Panel`. */
+function useRailTitleId() {
+	return use(RailTitleContext);
+}
+//#endregion
+export { RailLayoutProvider, RailTitleProvider, useRailLayout, useRailTitleId };

package/dist/components/rail/rail.d.ts

@@ -0,0 +1,232 @@
+import { collapsible_d_exports } from "../../primitives/collapsible.js";
+import { RailSide, RailSize, RailVariant } from "./rail.context.js";
+import { RailPartProps, bodyProps, closeProps, contentProps, headerProps, layoutProps, panelProps, rootProps, surfaceProps, titleProps, triggerProps } from "./rail.props.js";
+import { ComponentProps, ReactElement } from "react";
+
+//#region src/components/rail/rail.d.ts
+/**
+ * Groups the parts and owns open state — controlled via `open`/`onOpenChange`, or uncontrolled via
+ * `defaultOpen` — on Base UI's Collapsible. Unlike a modal sheet, the rail is non-modal: no backdrop,
+ * no focus trap, no `Escape`-to-close. It renders transparently (`display: contents`) so the `Layout`
+ * (or a lone `Panel`) becomes the surrounding layout's child directly.
+ *
+ * Slot: `noctis-rail`.
+ * @see {@link Rail.Root.Props}
+ */
+declare function RailRoot({
+  className,
+  ...props
+}: Rail.Root.Props): ReactElement;
+/**
+ * A button that toggles the rail. Base UI wires `aria-expanded` and `aria-controls` to the panel.
+ *
+ * Slot: `noctis-rail-trigger`.
+ * @see {@link Rail.Trigger.Props}
+ */
+declare function RailTrigger({
+  className,
+  ...props
+}: Rail.Trigger.Props): ReactElement;
+/**
+ * The docking row: lays the content and the rail side by side and sets the reflow `variant` so an
+ * open rail reshapes the content beside it. Place a `Rail.Content` and a `Rail.Panel` inside. Use this
+ * to dock a rail inside a region; drop a `Rail.Panel` on its own (no `Layout`) to dock it to the
+ * viewport edge instead.
+ *
+ * Slot: `noctis-rail-layout`.
+ * @see {@link Rail.Layout.Props}
+ */
+declare function RailLayout({
+  variant,
+  side,
+  size,
+  className,
+  style,
+  ...props
+}: Rail.Layout.Props): ReactElement;
+/**
+ * The content beside the rail inside a `Rail.Layout`. Reshapes per the layout's `variant` when open.
+ *
+ * Slot: `noctis-rail-content`.
+ * @see {@link Rail.Content.Props}
+ */
+declare function RailContent({
+  className,
+  ...props
+}: Rail.Content.Props): ReactElement;
+/**
+ * The docked rail itself: a `Collapsible.Panel` rendered as an `aside` (a complementary landmark).
+ * Kept mounted while closed and hidden via Base UI, so it leaves the layout and the a11y tree without
+ * losing its content. Drop `Rail.Header`/`Rail.Body` inside; a `Rail.Title` names it automatically via
+ * `aria-labelledby`. Inside a `Rail.Layout` it docks in that layout's cell; on its own it docks to the
+ * viewport edge. `side`/`size` default to the surrounding `Rail.Layout`'s.
+ *
+ * Slots: `noctis-rail-panel` (the collapsible), `noctis-rail-surface` (the inner surface).
+ * @see {@link Rail.Panel.Props}
+ */
+declare function RailPanel({
+  side,
+  size,
+  keepMounted,
+  className,
+  children,
+  "aria-label": ariaLabel,
+  "aria-labelledby": ariaLabelledby,
+  ...props
+}: Rail.Panel.Props): ReactElement;
+/**
+ * A ghost icon button that closes the rail. Defaults its glyph to a lucide `X` and its name to the
+ * translated "Close"; pass `children` to swap the glyph or `aria-label` to override the name.
+ *
+ * Slot: `noctis-rail-close`.
+ * @see {@link Rail.Close.Props}
+ */
+declare function RailClose({
+  className,
+  children,
+  "aria-label": ariaLabel,
+  ...props
+}: Rail.Close.Props): ReactElement;
+/**
+ * The rail's top region — title and corner actions. Separated by a divider.
+ *
+ * Slot: `noctis-rail-header`.
+ * @see {@link Rail.Header.Props}
+ */
+declare function RailHeader({
+  className,
+  ...props
+}: Rail.Header.Props): ReactElement;
+/**
+ * The scrollable middle region. Grows to fill and scrolls its overflow so the header stays put.
+ *
+ * Slot: `noctis-rail-body`.
+ * @see {@link Rail.Body.Props}
+ */
+declare function RailBody({
+  className,
+  ...props
+}: Rail.Body.Props): ReactElement;
+/**
+ * The accessible name of the rail, linked to the panel via `aria-labelledby`. Renders an `<h2>`.
+ *
+ * Slot: `noctis-rail-title`.
+ * @see {@link Rail.Title.Props}
+ */
+declare function RailTitle({
+  className,
+  children,
+  ...props
+}: Rail.Title.Props): ReactElement;
+/**
+ * A docked, collapsible side rail — a non-modal panel that lives in the layout rather than over it.
+ *
+ * **Rail vs. Sheet.** Reach for a `Sheet` when the panel is a *modal task*: it overlays the page on a
+ * dimmed backdrop, traps focus, and closes on `Escape`/outside-click — the page behind is inert until
+ * it's dismissed. Reach for a `Rail` when the panel is a *persistent companion* to the page (an
+ * inspector, a filter rail, a settings panel): it docks beside the content and **reshapes** it instead
+ * of covering it, so the page stays fully usable with the rail open. No backdrop, no focus trap, no
+ * `Escape`-to-close.
+ *
+ * **Two reflow variants** (set on {@link Rail.Layout}): `squeeze` shrinks the content's width so it
+ * re-lays-out into the narrower space; `push` keeps the content's width and slides it over, clipping
+ * the overflow. Both keep the content interactive — that's the line between a rail and a sheet.
+ *
+ * **Docking.** Wrap a `Rail.Content` and a `Rail.Panel` in a `Rail.Layout` to dock the rail inside a
+ * region. Or drop a `Rail.Panel` straight into the page (no `Layout`) to dock it full-height to the
+ * viewport edge — reflowing on large screens, overlaying the edge on small ones.
+ *
+ * Compose it from parts: `Rail.Root` owns state, `Rail.Trigger` toggles it, `Rail.Layout` +
+ * `Rail.Content` set up the reflow, and `Rail.Panel` holds `Header`/`Body`, `Title`, and `Close`.
+ *
+ * Built on Base UI's Collapsible for the open/close behavior, measured-size animation, and a11y; the
+ * runtime compound is a plain object (kept tree-shakeable), with per-part prop types exposed through
+ * the matching `Rail` namespace below — e.g. `Rail.Panel.Props`.
+ */
+declare const Rail: {
+  /** Groups the parts and owns open state. `Rail.Root.props()` → its spreadable prop bag. */Root: typeof RailRoot & {
+    props: typeof rootProps;
+  }; /** Toggles the rail. `Rail.Trigger.props()` → its spreadable prop bag. */
+  Trigger: typeof RailTrigger & {
+    props: typeof triggerProps;
+  }; /** The docking row. `Rail.Layout.props({ variant })` → its spreadable prop bag. */
+  Layout: typeof RailLayout & {
+    props: typeof layoutProps;
+  }; /** The content beside the rail. `Rail.Content.props({ variant, side })` → its spreadable prop bag. */
+  Content: typeof RailContent & {
+    props: typeof contentProps;
+  }; /** The docked rail. `Rail.Panel.props({ docking, variant, side, size })` → its spreadable prop bag. */
+  Panel: typeof RailPanel & {
+    props: typeof panelProps;
+  }; /** The ghost-icon close button. `Rail.Close.props()` → its spreadable prop bag. */
+  Close: typeof RailClose & {
+    props: typeof closeProps;
+  }; /** The header region. `Rail.Header.props()` → its spreadable prop bag. */
+  Header: typeof RailHeader & {
+    props: typeof headerProps;
+  }; /** The scrollable body. `Rail.Body.props()` → its spreadable prop bag. */
+  Body: typeof RailBody & {
+    props: typeof bodyProps;
+  }; /** The accessible name. `Rail.Title.props()` → its spreadable prop bag. */
+  Title: typeof RailTitle & {
+    props: typeof titleProps;
+  }; /** The inner surface escape-hatch. `Rail.Surface.props({ side })` → its spreadable prop bag. */
+  Surface: {
+    props: typeof surfaceProps;
+  };
+};
+/**
+ * Per-part prop and state types, mirroring Base UI's `Component.Part.Props` convention. This namespace
+ * is types-only — it emits no runtime code and merges with the `Rail` object above, so `Rail.Panel` is
+ * the component value while `Rail.Panel.Props` is its prop type.
+ */
+declare namespace Rail {
+  /** How an open rail reshapes the surrounding content. */
+  type Variant = RailVariant;
+  /** Which edge the rail docks to. */
+  type Side = RailSide;
+  /** The rail's open extent — width when docked left/right, height when docked top/bottom. */
+  type Size = RailSize;
+  /** The spreadable data-attribute prop bag every `Rail.*.props()` returns (D12). */
+  type PartProps = RailPartProps;
+  namespace Root {
+    type Props = collapsible_d_exports.Collapsible.Root.Props;
+    type State = collapsible_d_exports.Collapsible.Root.State;
+  }
+  namespace Trigger {
+    type Props = collapsible_d_exports.Collapsible.Trigger.Props;
+    type State = collapsible_d_exports.Collapsible.Trigger.State;
+  }
+  namespace Layout {
+    type Props = ComponentProps<"div"> & {
+      /** How an open rail reshapes the content. Defaults to `squeeze`. */variant?: RailVariant; /** Which edge the rail docks to. Defaults to `end`. Inherited by `Content`/`Panel`. */
+      side?: RailSide; /** The rail's width — also the `push` slide distance. Defaults to `md`. Inherited by `Panel`. */
+      size?: RailSize;
+    };
+  }
+  namespace Content {
+    type Props = ComponentProps<"div">;
+  }
+  namespace Panel {
+    type Props = collapsible_d_exports.Collapsible.Panel.Props & {
+      /** Which edge to dock to. Defaults to the `Rail.Layout`'s, then `end`. */side?: RailSide; /** The rail's width. Defaults to the `Rail.Layout`'s, then `md`. */
+      size?: RailSize;
+    };
+    type State = collapsible_d_exports.Collapsible.Panel.State;
+  }
+  namespace Close {
+    type Props = collapsible_d_exports.Collapsible.Trigger.Props;
+    type State = collapsible_d_exports.Collapsible.Trigger.State;
+  }
+  namespace Header {
+    type Props = ComponentProps<"div">;
+  }
+  namespace Body {
+    type Props = ComponentProps<"div">;
+  }
+  namespace Title {
+    type Props = ComponentProps<"h2">;
+  }
+}
+//#endregion
+export { Rail };