@stridge/noctis 1.0.0-beta.0

package/dist/components/switch/switch.props.js

@@ -0,0 +1,41 @@
+import { SWITCH_SLOTS } from "./switch.slots.js";
+//#region src/components/switch/switch.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
+};
+/** Track prop bag: slot anchor plus the `data-size`/`data-checked`/`data-disabled`/`data-readonly`/`data-invalid` the CSS keys off. */
+function switchProps({ size = "md", checked, disabled, readonly, invalid, className } = {}) {
+	return withClassName({
+		"data-slot": SWITCH_SLOTS.root,
+		"data-size": size,
+		"data-checked": flag(checked),
+		"data-disabled": flag(disabled),
+		"data-readonly": flag(readonly),
+		"data-invalid": flag(invalid)
+	}, className);
+}
+/** Thumb prop bag: slot anchor plus the `data-checked`/`data-disabled` that drives its travel. */
+function thumbProps({ checked, disabled, className } = {}) {
+	return withClassName({
+		"data-slot": SWITCH_SLOTS.thumb,
+		"data-checked": flag(checked),
+		"data-disabled": flag(disabled)
+	}, className);
+}
+/** Field prop bag: the slot anchor for the row that pairs a switch with its label. */
+function fieldProps({ className } = {}) {
+	return withClassName({ "data-slot": SWITCH_SLOTS.field }, 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": SWITCH_SLOTS.label,
+		"data-disabled": flag(disabled),
+		"data-invalid": flag(invalid)
+	}, className);
+}
+//#endregion
+export { fieldProps, labelProps, switchProps, thumbProps };

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

@@ -0,0 +1,23 @@
+//#region src/components/switch/switch.slots.d.ts
+/**
+ * The `data-*` attributes Base UI's switch stamps, which `switch.css` keys its checked/disabled styling
+ * off. Each member's value is the attribute name; its JSDoc is the description docgen renders.
+ */
+declare enum SwitchDataAttributes {
+  /** The stable styling/testing hook on each rendered part. */
+  slot = "data-slot",
+  /** Present on the track and thumb when the switch is on. */
+  checked = "data-checked",
+  /** Present on the track and thumb when the switch is off. */
+  unchecked = "data-unchecked",
+  /** Present when the switch is disabled. */
+  disabled = "data-disabled",
+  /** Present when the switch is read-only. */
+  readonly = "data-readonly",
+  /** Present when the switch is in an invalid state (also honours `aria-invalid`). */
+  invalid = "data-invalid",
+  /** The size axis, stamped on the track; the thumb diameter re-points off it. */
+  size = "data-size"
+}
+//#endregion
+export { SwitchDataAttributes };

package/dist/components/switch/switch.slots.js

@@ -0,0 +1,35 @@
+//#region src/components/switch/switch.slots.ts
+/**
+* The slot vocabulary every `Switch` 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 SWITCH_SLOTS = {
+	root: "noctis-switch",
+	thumb: "noctis-switch-thumb",
+	field: "noctis-switch-field",
+	label: "noctis-switch-label"
+};
+/**
+* The `data-*` attributes Base UI's switch stamps, which `switch.css` keys its checked/disabled styling
+* off. Each member's value is the attribute name; its JSDoc is the description docgen renders.
+*/
+let SwitchDataAttributes = /* @__PURE__ */ function(SwitchDataAttributes) {
+	/** The stable styling/testing hook on each rendered part. */
+	SwitchDataAttributes["slot"] = "data-slot";
+	/** Present on the track and thumb when the switch is on. */
+	SwitchDataAttributes["checked"] = "data-checked";
+	/** Present on the track and thumb when the switch is off. */
+	SwitchDataAttributes["unchecked"] = "data-unchecked";
+	/** Present when the switch is disabled. */
+	SwitchDataAttributes["disabled"] = "data-disabled";
+	/** Present when the switch is read-only. */
+	SwitchDataAttributes["readonly"] = "data-readonly";
+	/** Present when the switch is in an invalid state (also honours `aria-invalid`). */
+	SwitchDataAttributes["invalid"] = "data-invalid";
+	/** The size axis, stamped on the track; the thumb diameter re-points off it. */
+	SwitchDataAttributes["size"] = "data-size";
+	return SwitchDataAttributes;
+}({});
+//#endregion
+export { SWITCH_SLOTS, SwitchDataAttributes };

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

@@ -0,0 +1 @@
+import { Table } from "./table.js";

package/dist/components/table/table.d.ts

@@ -0,0 +1,104 @@
+import { TablePartProps, TablePropsArgs, bodyProps, cellProps, headProps, headerProps, rootProps, rowProps } from "./table.props.js";
+import { ComponentProps, ReactElement } from "react";
+
+//#region src/components/table/table.d.ts
+/**
+ * The root of the table: a bordered, rounded card wrapping the semantic `<table>`. `className` styles
+ * that outer card (use it for call-site margins); native `<table>` attributes pass through to the
+ * `<table>` element. Compose the body from `Table.Header` / `Table.Body` / `Table.Row` / `Table.Head`
+ * / `Table.Cell`.
+ *
+ * The shape is attribute-driven: the parts stamp the single `data-slot` anchor `table.css` keys off,
+ * and `className` is forwarded verbatim (no class merging).
+ */
+declare function TableRoot({
+  className,
+  ...props
+}: Table.Root.Props): ReactElement;
+/** The `<thead>` band — a raised surface above the canvas, reading as a header rather than a well. */
+declare function TableHeader({
+  className,
+  ...props
+}: Table.Header.Props): ReactElement;
+/** The `<tbody>`; flushes its last row's divider into the frame so the bottom border isn't doubled. */
+declare function TableBody({
+  className,
+  ...props
+}: Table.Body.Props): ReactElement;
+/** One `<tr>`, drawing a hairline divider beneath it. */
+declare function TableRow({
+  className,
+  ...props
+}: Table.Row.Props): ReactElement;
+/** A header `<th>` — quiet, medium-weight, start-aligned over the browser's centered default. */
+declare function TableHead({
+  className,
+  ...props
+}: Table.Head.Props): ReactElement;
+/** A body `<td>` — start-aligned, top-aligned so multi-line cells read against single-line ones. */
+declare function TableCell({
+  className,
+  ...props
+}: Table.Cell.Props): ReactElement;
+/**
+ * The Noctis table — one bordered, rounded surface for tabular data, so every table (docs prose, API
+ * references, app screens) reads the same. The header sits on a raised `surface` band above the
+ * canvas; rows divide with hairlines and the last one flushes into the frame; cells are start-aligned
+ * for RTL by construction. It carries no behaviour — sort, select, and paginate are composed by the
+ * caller around these parts.
+ *
+ * Compose it from parts: `Table.Root` is the framed `<table>`, `Table.Header` / `Table.Body` wrap the
+ * `<thead>` / `<tbody>`, and `Table.Row` / `Table.Head` / `Table.Cell` are the `<tr>` / `<th>` / `<td>`.
+ * Each part also carries a `.props()` static (D12) returning a spreadable `{ "data-slot", className }`
+ * bag for styling a foreign element as that part — see `table.props.ts`.
+ */
+declare const Table: {
+  /** The framed `<table>`. `Table.Root.props()` → its spreadable prop bag. */Root: typeof TableRoot & {
+    props: typeof rootProps;
+  }; /** The raised `<thead>` band. `Table.Header.props()` → its spreadable prop bag. */
+  Header: typeof TableHeader & {
+    props: typeof headerProps;
+  }; /** The `<tbody>`. `Table.Body.props()` → its spreadable prop bag. */
+  Body: typeof TableBody & {
+    props: typeof bodyProps;
+  }; /** One `<tr>`. `Table.Row.props()` → its spreadable prop bag. */
+  Row: typeof TableRow & {
+    props: typeof rowProps;
+  }; /** A header `<th>`. `Table.Head.props()` → its spreadable prop bag. */
+  Head: typeof TableHead & {
+    props: typeof headProps;
+  }; /** A body `<td>`. `Table.Cell.props()` → its spreadable prop bag. */
+  Cell: typeof TableCell & {
+    props: typeof cellProps;
+  };
+};
+/**
+ * Per-part prop types. This namespace is types-only — it emits no runtime code and merges with the
+ * `Table` object above, so `Table.Cell` is the component value while `Table.Cell.Props` is its prop type.
+ */
+declare namespace Table {
+  /** The spreadable data-attribute prop bag every `Table.*.props()` returns (D12). */
+  type PartProps = TablePartProps;
+  /** Argument to every `Table.*.props(...)` escape-hatch helper. */
+  type PropsArgs = TablePropsArgs;
+  namespace Root {
+    type Props = ComponentProps<"table">;
+  }
+  namespace Header {
+    type Props = ComponentProps<"thead">;
+  }
+  namespace Body {
+    type Props = ComponentProps<"tbody">;
+  }
+  namespace Row {
+    type Props = ComponentProps<"tr">;
+  }
+  namespace Head {
+    type Props = ComponentProps<"th">;
+  }
+  namespace Cell {
+    type Props = ComponentProps<"td">;
+  }
+}
+//#endregion
+export { Table };

package/dist/components/table/table.js

@@ -0,0 +1,92 @@
+import { TABLE_SLOTS } from "./table.slots.js";
+import { bodyProps, cellProps, headProps, headerProps, rootProps, rowProps } from "./table.props.js";
+import { clsx } from "clsx";
+import { jsx } from "react/jsx-runtime";
+//#region src/components/table/table.tsx
+/**
+* The root of the table: a bordered, rounded card wrapping the semantic `<table>`. `className` styles
+* that outer card (use it for call-site margins); native `<table>` attributes pass through to the
+* `<table>` element. Compose the body from `Table.Header` / `Table.Body` / `Table.Row` / `Table.Head`
+* / `Table.Cell`.
+*
+* The shape is attribute-driven: the parts stamp the single `data-slot` anchor `table.css` keys off,
+* and `className` is forwarded verbatim (no class merging).
+*/
+function TableRoot({ className, ...props }) {
+	return /* @__PURE__ */ jsx("div", {
+		"data-slot": TABLE_SLOTS.root,
+		className: clsx(className) || void 0,
+		children: /* @__PURE__ */ jsx("table", {
+			"data-slot": TABLE_SLOTS.grid,
+			...props
+		})
+	});
+}
+/** The `<thead>` band — a raised surface above the canvas, reading as a header rather than a well. */
+function TableHeader({ className, ...props }) {
+	return /* @__PURE__ */ jsx("thead", {
+		"data-slot": TABLE_SLOTS.header,
+		className: clsx(className) || void 0,
+		...props
+	});
+}
+/** The `<tbody>`; flushes its last row's divider into the frame so the bottom border isn't doubled. */
+function TableBody({ className, ...props }) {
+	return /* @__PURE__ */ jsx("tbody", {
+		"data-slot": TABLE_SLOTS.body,
+		className: clsx(className) || void 0,
+		...props
+	});
+}
+/** One `<tr>`, drawing a hairline divider beneath it. */
+function TableRow({ className, ...props }) {
+	return /* @__PURE__ */ jsx("tr", {
+		"data-slot": TABLE_SLOTS.row,
+		className: clsx(className) || void 0,
+		...props
+	});
+}
+/** A header `<th>` — quiet, medium-weight, start-aligned over the browser's centered default. */
+function TableHead({ className, ...props }) {
+	return /* @__PURE__ */ jsx("th", {
+		"data-slot": TABLE_SLOTS.head,
+		className: clsx(className) || void 0,
+		...props
+	});
+}
+/** A body `<td>` — start-aligned, top-aligned so multi-line cells read against single-line ones. */
+function TableCell({ className, ...props }) {
+	return /* @__PURE__ */ jsx("td", {
+		"data-slot": TABLE_SLOTS.cell,
+		className: clsx(className) || void 0,
+		...props
+	});
+}
+/**
+* The Noctis table — one bordered, rounded surface for tabular data, so every table (docs prose, API
+* references, app screens) reads the same. The header sits on a raised `surface` band above the
+* canvas; rows divide with hairlines and the last one flushes into the frame; cells are start-aligned
+* for RTL by construction. It carries no behaviour — sort, select, and paginate are composed by the
+* caller around these parts.
+*
+* Compose it from parts: `Table.Root` is the framed `<table>`, `Table.Header` / `Table.Body` wrap the
+* `<thead>` / `<tbody>`, and `Table.Row` / `Table.Head` / `Table.Cell` are the `<tr>` / `<th>` / `<td>`.
+* Each part also carries a `.props()` static (D12) returning a spreadable `{ "data-slot", className }`
+* bag for styling a foreign element as that part — see `table.props.ts`.
+*/
+const Table = {
+	/** The framed `<table>`. `Table.Root.props()` → its spreadable prop bag. */
+	Root: Object.assign(TableRoot, { props: rootProps }),
+	/** The raised `<thead>` band. `Table.Header.props()` → its spreadable prop bag. */
+	Header: Object.assign(TableHeader, { props: headerProps }),
+	/** The `<tbody>`. `Table.Body.props()` → its spreadable prop bag. */
+	Body: Object.assign(TableBody, { props: bodyProps }),
+	/** One `<tr>`. `Table.Row.props()` → its spreadable prop bag. */
+	Row: Object.assign(TableRow, { props: rowProps }),
+	/** A header `<th>`. `Table.Head.props()` → its spreadable prop bag. */
+	Head: Object.assign(TableHead, { props: headProps }),
+	/** A body `<td>`. `Table.Cell.props()` → its spreadable prop bag. */
+	Cell: Object.assign(TableCell, { props: cellProps })
+};
+//#endregion
+export { Table };

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

@@ -0,0 +1,38 @@
+//#region src/components/table/table.props.d.ts
+/** A spreadable data-attribute prop bag — the shape every `Table.*.props()` returns. */
+type TablePartProps = {
+  /** The slot value the matching `table.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 TablePropsArgs {
+  /** Forwarded verbatim onto the returned prop bag. */
+  className?: string;
+}
+/** Root prop bag: the framed card's slot anchor. */
+declare function rootProps({
+  className
+}?: TablePropsArgs): TablePartProps;
+/** Header prop bag: the raised `<thead>` band slot anchor. */
+declare function headerProps({
+  className
+}?: TablePropsArgs): TablePartProps;
+/** Body prop bag: the `<tbody>` slot anchor. */
+declare function bodyProps({
+  className
+}?: TablePropsArgs): TablePartProps;
+/** Row prop bag: the `<tr>` slot anchor. */
+declare function rowProps({
+  className
+}?: TablePropsArgs): TablePartProps;
+/** Head prop bag: the `<th>` slot anchor. */
+declare function headProps({
+  className
+}?: TablePropsArgs): TablePartProps;
+/** Cell prop bag: the `<td>` slot anchor. */
+declare function cellProps({
+  className
+}?: TablePropsArgs): TablePartProps;
+//#endregion
+export { TablePartProps, TablePropsArgs, bodyProps, cellProps, headProps, headerProps, rootProps, rowProps };

package/dist/components/table/table.props.js

@@ -0,0 +1,49 @@
+import { TABLE_SLOTS } from "./table.slots.js";
+//#region src/components/table/table.props.ts
+/**
+* The D12 unified variant contract for Table — the data-attribute-native escape hatch mirroring the
+* other migrated components.
+*
+* Each compound part exposes a `props(...)` builder returning a **spreadable props object** of the form
+* `{ "data-slot": "noctis-table-<part>", ...dataAttrs }`. Under the single-`data-slot` anchor model
+* (D4 final) the `data-slot` is the only styling hook — `table.css` keys every rule off it — so
+* spreading a part's `props()` onto a *foreign* element styles it as that part:
+*
+*     <td {...Table.Cell.props()}>cell</td>
+*     // → <td data-slot="noctis-table-cell">
+*
+* Table parts carry no variants or state of their own (the look is structural), so each builder takes
+* only an optional `className` passthrough, forwarded verbatim. The same slot vocabulary is emitted as
+* data from the token graph (`generated/declarations.json`) so non-React / agent consumers can
+* hand-write the markup from the docs.
+*/
+const withClassName = (bag, className) => className === void 0 ? bag : {
+	...bag,
+	className
+};
+/** Root prop bag: the framed card's slot anchor. */
+function rootProps({ className } = {}) {
+	return withClassName({ "data-slot": TABLE_SLOTS.root }, className);
+}
+/** Header prop bag: the raised `<thead>` band slot anchor. */
+function headerProps({ className } = {}) {
+	return withClassName({ "data-slot": TABLE_SLOTS.header }, className);
+}
+/** Body prop bag: the `<tbody>` slot anchor. */
+function bodyProps({ className } = {}) {
+	return withClassName({ "data-slot": TABLE_SLOTS.body }, className);
+}
+/** Row prop bag: the `<tr>` slot anchor. */
+function rowProps({ className } = {}) {
+	return withClassName({ "data-slot": TABLE_SLOTS.row }, className);
+}
+/** Head prop bag: the `<th>` slot anchor. */
+function headProps({ className } = {}) {
+	return withClassName({ "data-slot": TABLE_SLOTS.head }, className);
+}
+/** Cell prop bag: the `<td>` slot anchor. */
+function cellProps({ className } = {}) {
+	return withClassName({ "data-slot": TABLE_SLOTS.cell }, className);
+}
+//#endregion
+export { bodyProps, cellProps, headProps, headerProps, rootProps, rowProps };

package/dist/components/table/table.slots.js

@@ -0,0 +1,17 @@
+//#region src/components/table/table.slots.ts
+/**
+* The slot vocabulary every `Table` part stamps as its `data-slot`. The authored source the
+* orchestration file reads from, kebab-cased `{component}-{part}`; SLOTS.md still generates from the
+* token-graph declarations.
+*/
+const TABLE_SLOTS = {
+	root: "noctis-table",
+	grid: "noctis-table-grid",
+	header: "noctis-table-header",
+	body: "noctis-table-body",
+	row: "noctis-table-row",
+	head: "noctis-table-head",
+	cell: "noctis-table-cell"
+};
+//#endregion
+export { TABLE_SLOTS };

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

@@ -0,0 +1,2 @@
+import { Tabs } from "./tabs.js";
+import { TabsDataAttributes } from "./tabs.slots.js";

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

@@ -0,0 +1,9 @@
+//#region src/components/tabs/tabs.context.d.ts
+/** Strip look — `line`, `pill`, or `segmented`. */
+type TabsVariant = "line" | "pill" | "segmented";
+/** Control height and type — `sm` or `md`. */
+type TabsSize = "sm" | "md";
+/** The `segmented` active chip's fill — `primary` (default) or the `accent`. */
+type TabsColor = "primary" | "accent";
+//#endregion
+export { TabsColor, TabsSize, TabsVariant };

package/dist/components/tabs/tabs.context.js

@@ -0,0 +1,13 @@
+"use client";
+import { createContext, use } from "react";
+//#region src/components/tabs/tabs.context.ts
+const TabsContext = createContext(null);
+const TabsProvider = TabsContext.Provider;
+/** Read the strip context, throwing a named error when a part renders outside `Tabs.Root`. */
+function useTabsContext(part) {
+	const context = use(TabsContext);
+	if (context === null) throw new Error(`Tabs.${part} must be rendered inside <Tabs.Root>.`);
+	return context;
+}
+//#endregion
+export { TabsProvider, useTabsContext };

package/dist/components/tabs/tabs.d.ts

@@ -0,0 +1,139 @@
+import { IconGlyph } from "../../icons/glyphs.js";
+import { tabs_d_exports } from "../../primitives/tabs.js";
+import { TabsColor, TabsSize, TabsVariant } from "./tabs.context.js";
+import { TabsPartProps, TabsRootPropsArgs, TabsTabPropsArgs, indicatorProps, listProps, panelProps, rootProps, tabProps } from "./tabs.props.js";
+import { ReactElement, ReactNode } from "react";
+
+//#region src/components/tabs/tabs.d.ts
+/**
+ * Owns the active value and shares the `variant`/`size` with the strip. Works controlled (`value` +
+ * `onValueChange`) or uncontrolled (`defaultValue`). Compose `Tabs.List` (holding `Tabs.Tab`s and a
+ * `Tabs.Indicator`) with one `Tabs.Panel` per value.
+ */
+declare function TabsRoot({
+  variant,
+  size,
+  color,
+  className,
+  children,
+  ...props
+}: Tabs.Root.Props): ReactElement;
+/**
+ * The row of tabs. Holds the `Tab`s and a single `Indicator`, and carries the strip's `variant` look.
+ * Arrow keys move between tabs and switch immediately (`activateOnFocus`); set it `false` for manual
+ * activation (move with arrows, commit with Enter/Space) when showing a panel is expensive.
+ */
+declare function TabsList({
+  activateOnFocus,
+  className,
+  ...props
+}: Tabs.List.Props): ReactElement;
+/** One tab. Names its panel; pass `value` to match a `Panel`. Optional leading `icon`. */
+declare function TabsTab({
+  icon,
+  className,
+  children,
+  ...props
+}: Tabs.Tab.Props): ReactElement;
+/** The sliding active highlight. Render it once inside `Tabs.List`; it follows the active tab. */
+declare function TabsIndicator({
+  className,
+  style,
+  ...props
+}: Tabs.Indicator.Props): ReactElement;
+/** The content for one tab. Match its `value` to a `Tab`. Only the active panel is shown. */
+declare function TabsPanel({
+  className,
+  ...props
+}: Tabs.Panel.Props): ReactElement;
+/**
+ * A tabbed control: a strip of tabs over swappable panels, with a single highlight that slides between
+ * the active tab. Three looks — `line` (underline), `pill` (floating pill), and `segmented` (raised
+ * pill in a sunken track) — in two sizes. Built on Base UI's Tabs, so the strip is fully
+ * keyboard-operable (arrows, Home/End), RTL-aware, and the indicator animation respects
+ * `prefers-reduced-motion`.
+ *
+ * Compose from parts: `Tabs.Root` owns the value and the shared `variant`/`size`, `Tabs.List` holds
+ * the `Tabs.Tab`s and one `Tabs.Indicator`, and a `Tabs.Panel` renders each value's content.
+ *
+ * The runtime compound is a plain object (kept tree-shakeable); per-part prop and state types are
+ * exposed through the matching `Tabs` namespace — e.g. `Tabs.Tab.Props`.
+ */
+declare const Tabs: {
+  /** Owns the value and the shared look/size. `Tabs.Root.props({ variant, size })` → its spreadable prop bag. */Root: typeof TabsRoot & {
+    props: typeof rootProps;
+  }; /** The tab strip. `Tabs.List.props()` → its spreadable prop bag. */
+  List: typeof TabsList & {
+    props: typeof listProps;
+  }; /** One tab. `Tabs.Tab.props({ selected, disabled })` → its spreadable prop bag for a foreign element. */
+  Tab: typeof TabsTab & {
+    props: typeof tabProps;
+  }; /** The sliding highlight. `Tabs.Indicator.props()` → its spreadable prop bag. */
+  Indicator: typeof TabsIndicator & {
+    props: typeof indicatorProps;
+  }; /** One panel. `Tabs.Panel.props()` → its spreadable prop bag. */
+  Panel: typeof TabsPanel & {
+    props: typeof panelProps;
+  };
+};
+/**
+ * Per-part prop and state types, mirroring Base UI's `Component.Part.Props` convention. Types-only —
+ * it emits no runtime code and merges with the `Tabs` object above, so `Tabs.Tab` is the component
+ * value while `Tabs.Tab.Props` is its prop type.
+ */
+declare namespace Tabs {
+  /** Strip look — `line`, `pill`, or `segmented`. */
+  type Variant = TabsVariant;
+  /** Control height and type — `sm` or `md`. */
+  type Size = TabsSize;
+  /** The `segmented` active chip's fill — `primary` (default) or the `accent`. */
+  type Color = TabsColor;
+  /** The spreadable data-attribute prop bag every `Tabs.*.props()` returns (D12). */
+  type PartProps = TabsPartProps;
+  namespace Root {
+    type Props = Omit<tabs_d_exports.Tabs.Root.Props, "className" | "children"> & {
+      /**
+       * Strip look — `line`, `pill`, or `segmented`.
+       * @default "line"
+       */
+      variant?: TabsVariant;
+      /**
+       * Control height and type.
+       * @default "md"
+       */
+      size?: TabsSize;
+      /**
+       * The `segmented` active chip's fill — `primary` (the default, the bold neutral key) or the
+       * indigo `accent`. No effect on the `line` / `pill` variants, which keep their neutral indicator.
+       * @default "primary"
+       */
+      color?: TabsColor; /** `Tabs.List` and the `Tabs.Panel`s. */
+      children?: ReactNode; /** Classes merged onto the root. */
+      className?: string;
+    };
+    /** Argument to the `Tabs.Root.props(...)` escape-hatch helper. */
+    type PropsArgs = TabsRootPropsArgs;
+  }
+  namespace List {
+    type Props = tabs_d_exports.Tabs.List.Props;
+    type State = tabs_d_exports.Tabs.List.State;
+  }
+  namespace Tab {
+    type Props = tabs_d_exports.Tabs.Tab.Props & {
+      /** Optional leading glyph. */icon?: IconGlyph;
+    };
+    type State = tabs_d_exports.Tabs.Tab.State;
+    /** Argument to the `Tabs.Tab.props(...)` escape-hatch helper. */
+    type PropsArgs = TabsTabPropsArgs;
+  }
+  namespace Indicator {
+    type Props = tabs_d_exports.Tabs.Indicator.Props;
+    type State = tabs_d_exports.Tabs.Indicator.State;
+  }
+  namespace Panel {
+    type Props = tabs_d_exports.Tabs.Panel.Props;
+    type State = tabs_d_exports.Tabs.Panel.State;
+  }
+}
+//#endregion
+export { Tabs };