@imfusion/web-ui 0.6.4-dev.1.g4ec1264f → 0.6.4-dev.109.g8d507655

package/dist/code-D2lwxHgd.js

@@ -0,0 +1,134 @@
+import { t as e } from "./chunk-DmhlhrBa.js";
+import { t } from "./meta-j-7HGrWv.js";
+import { Ma as n, Xo as r, r as i } from "./icons-CaGCCwG-.js";
+import { cx as a } from "class-variance-authority";
+import { Fragment as o, jsx as s, jsxs as c } from "react/jsx-runtime";
+import { useCallback as l, useEffect as u, useRef as d, useState as f } from "react";
+import { mergeProps as p } from "@base-ui/react/merge-props";
+import { useRender as m } from "@base-ui/react/use-render";
+//#region src/hooks/use-clipboard.ts
+function h({ timeout: e = 1500 } = {}) {
+	let [t, n] = f(!1), r = d(void 0);
+	return u(() => () => clearTimeout(r.current), []), {
+		copied: t,
+		copy: l((t) => {
+			navigator.clipboard.writeText(t).then(() => {
+				n(!0), clearTimeout(r.current), r.current = setTimeout(() => n(!1), e);
+			});
+		}, [e])
+	};
+}
+var g = {
+	block: "imf-ui-code-module-block",
+	copy: "imf-ui-code-module-copy",
+	inline: "imf-ui-code-module-inline",
+	inlineCopy: "imf-ui-code-module-inlineCopy",
+	inlineLink: "imf-ui-code-module-inlineLink",
+	language: "imf-ui-code-module-language",
+	pre: "imf-ui-code-module-pre",
+	separator: "imf-ui-code-module-separator"
+}, _ = /* @__PURE__ */ e({
+	Block: () => b,
+	Inline: () => v,
+	InlineLink: () => y
+});
+function v({ copyable: e = !1, children: t, render: a, ...l }) {
+	let { copied: u, copy: f } = h(), _ = d(null), v = u ? n : r;
+	return m({
+		defaultTagName: "code",
+		render: a,
+		props: {
+			...p(l, {
+				className: g.inline,
+				children: /* @__PURE__ */ c(o, { children: [
+					/* @__PURE__ */ s("span", {
+						ref: _,
+						children: t
+					}),
+					e && /* @__PURE__ */ s("span", { className: g.separator }),
+					e && /* @__PURE__ */ s("button", {
+						type: "button",
+						className: g.inlineCopy,
+						"data-copied": u || void 0,
+						"aria-label": u ? "Copied" : "Copy",
+						onClick: () => f(_.current?.textContent ?? ""),
+						children: /* @__PURE__ */ s(i, {
+							glyph: v,
+							size: 12,
+							strokeWidth: 2,
+							"aria-hidden": !0
+						})
+					})
+				] })
+			}),
+			"data-imf-ui-component": "Code.Inline"
+		}
+	});
+}
+v.displayName = "Code.Inline";
+function y({ kind: e = "external", ...t }) {
+	let n = e === "external" ? {
+		target: "_blank",
+		rel: "noreferrer"
+	} : {};
+	return m({
+		defaultTagName: "a",
+		render: t.render,
+		props: {
+			...p(n, t, {
+				className: a(g.inline, g.inlineLink, t.className),
+				children: t.children
+			}),
+			"data-imf-ui-component": "Code.InlineLink",
+			"data-kind": e
+		}
+	});
+}
+y.displayName = "Code.InlineLink";
+function b({ className: e, language: t, hideCopy: o = !1, children: l, ...u }) {
+	let { copied: f, copy: p } = h(), m = d(null), _ = f ? n : r;
+	return /* @__PURE__ */ c("div", {
+		"data-imf-ui-component": "Code.Block",
+		className: a(g.block, e),
+		children: [
+			t != null && /* @__PURE__ */ s("span", {
+				className: g.language,
+				children: t
+			}),
+			!o && /* @__PURE__ */ s("button", {
+				type: "button",
+				className: g.copy,
+				"data-copied": f || void 0,
+				"aria-label": f ? "Copied" : "Copy",
+				onClick: () => p(m.current?.textContent ?? ""),
+				children: /* @__PURE__ */ s(i, {
+					glyph: _,
+					size: 12,
+					strokeWidth: 2,
+					"aria-hidden": !0
+				})
+			}),
+			/* @__PURE__ */ s("pre", {
+				...u,
+				className: g.pre,
+				children: /* @__PURE__ */ s("code", {
+					ref: m,
+					children: l
+				})
+			})
+		]
+	});
+}
+b.displayName = "Code.Block";
+//#endregion
+//#region src/components/code/code.meta.ts
+var x = {
+	name: "Code",
+	category: t.display,
+	status: "stable",
+	namespace: !0,
+	description: "Displays source code inline or in a block, with optional language labels and copying. Also called a code snippet or code block.",
+	origin: "native"
+};
+//#endregion
+export { _ as a, y as i, b as n, h as o, v as r, x as t };

package/dist/codegen/gen-breakpoints-css.d.ts

@@ -1,6 +1,2 @@
 import { BREAKPOINTS } from '../breakpoints/registry';
-/**
- * Render the `@custom-media --imf-ui-*` declarations from the breakpoint
- * registry. Pure function.
- */
 export declare function renderBreakpointsCss(registry: typeof BREAKPOINTS): string;

package/dist/codegen/gen-token-css.d.ts

@@ -1,6 +1,4 @@
 import { Token } from '../tokens/types';
-/** Render `token-controls.gen.css` — every non-font token's `:root` declarations, in registry order. */
 export declare function renderColorTokensCss(registry?: readonly Token[]): string;
-/** Render `font-families.gen.css` — the `--imf-ui-font-family-*` tokens, base stacks and aliases. */
 export declare function renderFontTokensCss(registry?: readonly Token[]): string;
 export declare function writeTokenCss(): void;

package/dist/components/app-shell/app-shell.d.ts

@@ -1,4 +1,3 @@
-type RootProps = React.HTMLAttributes<HTMLDivElement>;
 /**
  * AppShell — application layout shell.
  *
@@ -20,12 +19,11 @@ type RootProps = React.HTMLAttributes<HTMLDivElement>;
  *
  * @see https://mantine.dev/llms/core-app-shell.md
  */
-declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+declare function Root(props: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
 declare namespace Root {
     var displayName: string;
 }
-type HeaderProps = React.HTMLAttributes<HTMLElement>;
-declare function Header({ className, ...props }: HeaderProps): import("react/jsx-runtime").JSX.Element;
+declare function Header(props: React.HTMLAttributes<HTMLElement>): import("react/jsx-runtime").JSX.Element;
 declare namespace Header {
     var displayName: string;
 }
@@ -33,7 +31,7 @@ type NavbarProps = React.HTMLAttributes<HTMLElement> & {
     /** Whether the mobile overlay is open. Ignored above the `md` breakpoint, where the navbar is always visible. */
     open?: boolean;
 };
-declare function Navbar({ className, open, ...props }: NavbarProps): import("react/jsx-runtime").JSX.Element;
+declare function Navbar({ open, ...props }: NavbarProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Navbar {
     var displayName: string;
 }
@@ -41,17 +39,15 @@ type AsideProps = React.HTMLAttributes<HTMLElement> & {
     /** Whether the mobile overlay is open. Ignored above the `lg` breakpoint, where the aside is always visible. */
     open?: boolean;
 };
-declare function Aside({ className, open, ...props }: AsideProps): import("react/jsx-runtime").JSX.Element;
+declare function Aside({ open, ...props }: AsideProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Aside {
     var displayName: string;
 }
-type FooterProps = React.HTMLAttributes<HTMLElement>;
-declare function Footer({ className, ...props }: FooterProps): import("react/jsx-runtime").JSX.Element;
+declare function Footer(props: React.HTMLAttributes<HTMLElement>): import("react/jsx-runtime").JSX.Element;
 declare namespace Footer {
     var displayName: string;
 }
-type MainProps = React.HTMLAttributes<HTMLElement>;
-declare function Main({ className, ...props }: MainProps): import("react/jsx-runtime").JSX.Element;
+declare function Main(props: React.HTMLAttributes<HTMLElement>): import("react/jsx-runtime").JSX.Element;
 declare namespace Main {
     var displayName: string;
 }
@@ -59,7 +55,7 @@ type SectionProps = React.HTMLAttributes<HTMLDivElement> & {
     /** If set, the section expands to fill the remaining space in its sidebar. */
     grow?: boolean;
 };
-declare function Section({ className, grow, ...props }: SectionProps): import("react/jsx-runtime").JSX.Element;
+declare function Section({ grow, ...props }: SectionProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Section {
     var displayName: string;
 }

package/dist/components/button/button.d.ts

@@ -5,26 +5,21 @@ declare const button: (props?: ({
     size?: "sm" | "md" | "lg" | "hero" | null | undefined;
     chamfer?: boolean | null | undefined;
     radius?: "sm" | "md" | "lg" | "none" | "round" | null | undefined;
+    context?: "default" | "oncolor" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-type UpstreamButton = React.ComponentProps<typeof ButtonPrimitive>;
-type Props = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "style"> & VariantProps<typeof button> & {
-    /** @default false */
-    focusableWhenDisabled?: boolean;
-    /** @default true */
-    nativeButton?: boolean;
+interface Props extends React.ComponentProps<typeof ButtonPrimitive>, VariantProps<typeof button> {
     /** Leading slot — typically a label. When present, the label aligns right and the icon pins left. */
     startIcon?: React.ReactNode;
     /** Trailing slot — typically an icon. When present, the label aligns left and the icon pins right. */
     endIcon?: React.ReactNode;
-    className?: UpstreamButton["className"];
-    style?: UpstreamButton["style"];
-    render?: UpstreamButton["render"];
-};
+}
 /**
- * Button component
+ * Button
  *
  * @doc https://base-ui.com/react/components/button
  * @llm https://base-ui.com/react/components/button.md
  */
-export declare function Button({ variant, size, chamfer, radius, className, startIcon, endIcon, children, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Button({ variant, size, 
+/** Explicit saturated-surface context; this is never inferred from an ancestor. */
+context, chamfer, radius, startIcon, endIcon, children, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/callout/callout.d.ts

@@ -3,39 +3,32 @@ declare const root: (props?: ({
     variant?: "positive" | "negative" | "warning" | "info" | "accent-1" | "accent-2" | "accent-3" | null | undefined;
     maxWidth?: "sm" | "md" | "lg" | "full" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-type RootProps = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof root>;
 /**
- * Callout.Root — the banner container. Sets the `variant` (which tints the
- * surface and colours the icon and text) and lays out a leading `Callout.Icon`
- * beside a text region of `Callout.Title` / `Callout.Description`. `maxWidth`
- * caps the banner so it reads as a block region rather than stretching full
- * container width. A persistent element in the content flow — not a transient
- * Toast, not a modal Alert Dialog.
+ * Callout.Root — the banner container. Sets `variant` (tints surface, icon, and text) and lays
+ * out a leading `Callout.Icon` beside `Callout.Title` / `Callout.Description`. `maxWidth` caps
+ * the banner so it reads as a block region, not full container width. A persistent content-flow
+ * element — not a transient Toast, not a modal Alert Dialog.
  */
-declare function Root({ variant, maxWidth, className, children, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+declare function Root({ variant, maxWidth, children, ...props }: React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof root>): import("react/jsx-runtime").JSX.Element;
 declare namespace Root {
     var displayName: string;
 }
-type IconProps = React.HTMLAttributes<HTMLSpanElement>;
 /**
- * Callout.Icon — the leading status glyph. With no children it renders the
- * variant's default local icon; pass a custom icon as children to override.
- * `aria-hidden` (the variant is conveyed by copy, not the glyph) and inherits
- * the status colour via `currentColor`.
+ * Callout.Icon — the leading status glyph. Renders the variant's default icon when no children
+ * are passed; pass a custom icon as children to override. `aria-hidden` (variant is conveyed by
+ * copy) and inherits colour via `currentColor`.
  */
-declare function Icon({ className, children, ...props }: IconProps): import("react/jsx-runtime").JSX.Element;
+declare function Icon({ children, ...props }: React.HTMLAttributes<HTMLSpanElement>): import("react/jsx-runtime").JSX.Element;
 declare namespace Icon {
     var displayName: string;
 }
-type TitleProps = React.HTMLAttributes<HTMLDivElement>;
 /** Callout.Title — an optional short heading, set in the semi-mono UPPERCASE technical voice. */
-declare function Title({ className, ...props }: TitleProps): import("react/jsx-runtime").JSX.Element;
+declare function Title(props: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
 declare namespace Title {
     var displayName: string;
 }
-type DescriptionProps = React.HTMLAttributes<HTMLDivElement>;
 /** Callout.Description — the message body, set in the editorial (grotesk) body voice. */
-declare function Description({ className, ...props }: DescriptionProps): import("react/jsx-runtime").JSX.Element;
+declare function Description(props: React.HTMLAttributes<HTMLDivElement>): import("react/jsx-runtime").JSX.Element;
 declare namespace Description {
     var displayName: string;
 }

package/dist/components/card/card.d.ts

@@ -23,32 +23,33 @@ type RootProps = React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof root
  * The image is always the first entry in the stack, so `orientation` just
  * switches the stack between a column and a row without reordering slots.
  *
- * The ImFusion brand ships flat (`shadow="none"`), but the shadow scale is a
- * first-class opt-in axis for third-party consumers. `shadow` picks the elevation
- * level only — how hard or spread that shadow reads is a global lighting decision,
- * owned by the `--imf-ui-shadow-hardness` / `--imf-ui-shadow-spread` tokens.
+ * `shadow` defaults to `lg`; `shadow="none"` gives the flat surface. It picks the elevation level only: how hard or
+ * spread the shadow reads is global, set by `--imf-ui-shadow-hardness` and `--imf-ui-shadow-spread`.
  */
-declare function Root({ density, variant, shadow, radius, orientation, withBorder, className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+declare function Root({ density, variant, shadow, radius, orientation, withBorder, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Root {
     var displayName: string;
 }
-type ImageProps = React.ImgHTMLAttributes<HTMLImageElement>;
+type ImageProps = React.ImgHTMLAttributes<HTMLImageElement> & {
+    /** Width divided by height, or "auto" to use the image's intrinsic ratio. */
+    aspectRatio?: number | "auto";
+};
 /**
  * Card.Image — an edge-to-edge media slot. Has no padding, so the image bleeds
  * to the card edges. Always place it first among the slots.
  */
-declare function Image({ className, alt, ...props }: ImageProps): import("react/jsx-runtime").JSX.Element;
+declare function Image({ alt, aspectRatio, style, ...props }: ImageProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Image {
     var displayName: string;
 }
 type SlotProps = React.HTMLAttributes<HTMLDivElement>;
 /** Card.Header — the padded title region at the top of the card body. */
-declare function Header({ className, ...props }: SlotProps): import("react/jsx-runtime").JSX.Element;
+declare function Header(props: SlotProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Header {
     var displayName: string;
 }
 /** Card.Content — the padded main body of the card. */
-declare function Content({ className, ...props }: SlotProps): import("react/jsx-runtime").JSX.Element;
+declare function Content(props: SlotProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Content {
     var displayName: string;
 }
@@ -57,7 +58,7 @@ declare namespace Content {
  * the card fill by default; override `background` in `style` for a distinct
  * action bar.
  */
-declare function Footer({ className, ...props }: SlotProps): import("react/jsx-runtime").JSX.Element;
+declare function Footer(props: SlotProps): import("react/jsx-runtime").JSX.Element;
 declare namespace Footer {
     var displayName: string;
 }

package/dist/components/checkbox/checkbox.d.ts

@@ -1,56 +1,20 @@
 import { Checkbox as CheckboxPrimitive } from '@base-ui/react/checkbox';
-type UpstreamRoot = React.ComponentProps<typeof CheckboxPrimitive.Root>;
-type UpstreamIndicator = React.ComponentProps<typeof CheckboxPrimitive.Indicator>;
-type RootProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    /** @default false */
-    defaultChecked?: boolean;
-    checked?: boolean;
-    onCheckedChange?: UpstreamRoot["onCheckedChange"];
-    /** @default false */
-    indeterminate?: boolean;
-    /** @default false */
-    disabled?: boolean;
-    /** @default false */
-    readOnly?: boolean;
-    /** @default false */
-    required?: boolean;
-    /** @default false */
-    nativeButton?: boolean;
-    /** @default false */
-    parent?: boolean;
-    name?: string;
-    value?: string;
-    uncheckedValue?: string;
-    form?: string;
-    inputRef?: React.Ref<HTMLInputElement>;
-    className?: UpstreamRoot["className"];
-    style?: UpstreamRoot["style"];
-    render?: UpstreamRoot["render"];
-};
 /**
  * Checkbox.Root — binary form control; renders a `<span>` plus a hidden `<input>`.
  *
  * @doc https://base-ui.com/react/components/checkbox
  * @llm https://base-ui.com/react/components/checkbox.md
  */
-export declare function Root({ className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root(props: React.ComponentProps<typeof CheckboxPrimitive.Root>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-type IndicatorProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "className" | "style"> & {
-    /** @default false */
-    keepMounted?: boolean;
-    className?: UpstreamIndicator["className"];
-    style?: UpstreamIndicator["style"];
-    render?: UpstreamIndicator["render"];
-};
 /**
  * Checkbox.Indicator — shows the checked / indeterminate mark. Ships brand
  * icons by default (check, and a minus while `indeterminate`); pass children
  * to replace them.
  */
-export declare function Indicator({ className, children, ...props }: IndicatorProps): import("react/jsx-runtime").JSX.Element;
+export declare function Indicator({ children, ...props }: React.ComponentProps<typeof CheckboxPrimitive.Indicator>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Indicator {
     var displayName: string;
 }
-export {};

package/dist/components/chip/chip.cva.d.ts

@@ -1,9 +1,7 @@
 /**
  * Shared variants for `Chip` and any sibling primitive that renders the same
- * Chip visual on a different element (`ChipLink` renders `<a>`; a future
- * `ChipButton` would render `<button>`). Keeping them in their own module
- * means variant axes stay aligned without cross-component imports of a
- * component file.
+ * visual on a different element (`ChipLink` renders `<a>`). Keeping them here
+ * avoids cross-component imports between Chip and its siblings.
  */
 export declare const chip: (props?: ({
     variant?: "primary" | "positive" | "negative" | "main" | "support" | "minor" | "brand" | "warning" | "info" | "accent-1" | "accent-2" | "accent-3" | null | undefined;

package/dist/components/chip/chip.d.ts

@@ -7,5 +7,5 @@ type Props = React.HTMLAttributes<HTMLSpanElement> & VariantProps<typeof chip> &
  * Chip — compact inline label for status or category.
  * Not based on any upstream component.
  */
-export declare function Chip({ variant, appearance, inline, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function Chip({ variant, appearance, inline, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/components/code/code.d.ts

@@ -10,25 +10,23 @@ type InlineProps = Omit<useRender.ComponentProps<"code">, "children"> & {
  * text. `Typo.InlineCode` renders this under the hood so inline-code chrome is
  * defined in one place. The copy button copies the rendered text.
  */
-export declare function Inline({ className, copyable, children, render, ...props }: InlineProps): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function Inline({ copyable, children, render, ...props }: InlineProps): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
 export declare namespace Inline {
     var displayName: string;
 }
 export type CodeInlineLinkKind = "external" | "internal";
-type InlineLinkProps = Omit<useRender.ComponentProps<"a">, "children"> & {
-    /** The link text, as a raw string, rendered as a code fragment. */
-    children: string;
-    /** Link target scope. `"external"` (default) opens in a new tab with a diagonal `ArrowUpRight` icon; `"internal"` stays in the current tab with a horizontal `ArrowRight` icon. */
+type InlineLinkProps = useRender.ComponentProps<"a"> & {
+    /** Link target scope. `"external"` (default) opens in a new tab; `"internal"` stays in the current tab. */
     kind?: CodeInlineLinkKind;
 };
 /**
  * Code.InlineLink — the inline-code chip rendered as a link: the same hairline
- * box, with a directional arrow behind the separator instead of a copy button.
- * Sibling of `Code.Inline`, sharing its chip visual (`.inline`) — never both a
+ * box, with an optional directional arrow behind the separator instead of a copy button.
+ * Sibling of `Code.Inline`, sharing its chip visual (`.inline`). Never both a
  * copy button and a link on the same chip. Mirrors `ChipLink`'s shape (anchor
  * is the chip root, trailing icon nudges on hover, `data-kind` picks the icon).
  */
-export declare function InlineLink({ className, kind, children, render, ...props }: InlineLinkProps): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
+export declare function InlineLink({ kind, ...props }: InlineLinkProps): import('react').ReactElement<unknown, string | import('react').JSXElementConstructor<any>>;
 export declare namespace InlineLink {
     var displayName: string;
 }

package/dist/components/collapsible/collapsible.d.ts

@@ -1,56 +1,25 @@
 import { Collapsible as CollapsiblePrimitive } from '@base-ui/react/collapsible';
 import { VariantProps } from 'class-variance-authority';
-type UpstreamRoot = React.ComponentProps<typeof CollapsiblePrimitive.Root>;
-type UpstreamTrigger = React.ComponentProps<typeof CollapsiblePrimitive.Trigger>;
-type UpstreamPanel = React.ComponentProps<typeof CollapsiblePrimitive.Panel>;
 declare const collapsibleRoot: (props?: ({
-    variant?: "solid" | "default" | null | undefined;
+    variant?: "default" | "solid" | null | undefined;
 } & import('class-variance-authority/types').ClassProp) | undefined) => string;
-type RootProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & VariantProps<typeof collapsibleRoot> & {
-    /** Visual treatment applied to the trigger. `solid` gives the trigger a contained surface background; `default` is transparent at rest and drenched-blue when open. */
-    /** @default false */
-    defaultOpen?: UpstreamRoot["defaultOpen"];
-    open?: UpstreamRoot["open"];
-    onOpenChange?: UpstreamRoot["onOpenChange"];
-    /** @default false */
-    disabled?: UpstreamRoot["disabled"];
-    className?: UpstreamRoot["className"];
-    style?: UpstreamRoot["style"];
-    render?: UpstreamRoot["render"];
-};
 /**
  * Collapsible.Root — container that manages open/closed state for a trigger–panel pair.
  *
  * @see https://base-ui.com/react/components/collapsible
  * @llm https://base-ui.com/react/components/collapsible.md
  */
-export declare function Root({ variant, className, ...props }: RootProps): import("react/jsx-runtime").JSX.Element;
+export declare function Root({ variant, ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Root> & VariantProps<typeof collapsibleRoot>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Root {
     var displayName: string;
 }
-type TriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "className" | "style"> & {
-    /** @default true */
-    nativeButton?: UpstreamTrigger["nativeButton"];
-    className?: UpstreamTrigger["className"];
-    style?: UpstreamTrigger["style"];
-    render?: UpstreamTrigger["render"];
-};
 /** Collapsible.Trigger — button that toggles the panel open and closed. */
-export declare function Trigger({ className, children, ...props }: TriggerProps): import("react/jsx-runtime").JSX.Element;
+export declare function Trigger({ children, ...props }: React.ComponentProps<typeof CollapsiblePrimitive.Trigger>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Trigger {
     var displayName: string;
 }
-type PanelProps = Omit<React.HTMLAttributes<HTMLDivElement>, "className" | "style"> & {
-    /** @default false */
-    hiddenUntilFound?: UpstreamPanel["hiddenUntilFound"];
-    /** @default false */
-    keepMounted?: UpstreamPanel["keepMounted"];
-    className?: UpstreamPanel["className"];
-    style?: UpstreamPanel["style"];
-    render?: UpstreamPanel["render"];
-};
 /** Collapsible.Panel — region that expands and collapses when the trigger is activated. */
-export declare function Panel({ className, ...props }: PanelProps): import("react/jsx-runtime").JSX.Element;
+export declare function Panel(props: React.ComponentProps<typeof CollapsiblePrimitive.Panel>): import("react/jsx-runtime").JSX.Element;
 export declare namespace Panel {
     var displayName: string;
 }

package/dist/components/copy-button/copy-button.d.ts

@@ -14,7 +14,7 @@ type Props = Omit<React.ComponentProps<typeof Button>, "children" | "onClick"> &
  * transient confirmation (Copy → Check). Composes Button rather than rendering
  * its own element, so all Button variants and native attributes pass through.
  */
-export declare function CopyButton({ value, label, copiedLabel, variant, size, className, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+export declare function CopyButton({ value, label, copiedLabel, variant, size, ...props }: Props): import("react/jsx-runtime").JSX.Element;
 export declare namespace CopyButton {
     var displayName: string;
 }