prime-ui-kit 0.7.13 → 0.9.1

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

@@ -1,57 +1,47 @@
-import * as React from "react";
-import type { ButtonMode, ButtonSize, ButtonVariant } from "@/internal/states";
-export type ButtonRootProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "size"> & {
-    variant?: ButtonVariant;
-    mode?: ButtonMode;
-    size?: ButtonSize;
+import type * as React from "react";
+import type { ControlSize, Tone, Variant } from "@/internal/states";
+/**
+ * `tone="inherit"` takes the host's text color (a close button on a solid Banner): fills are a
+ * `currentColor` wash, so it has no `solid` treatment.
+ */
+type ButtonColorProps = {
+    /** Visual treatment. Default `solid`. */
+    variant?: Variant;
+    /** Semantic color. Default `accent`; `danger` for destructive actions. */
+    tone?: Extract<Tone, "accent" | "neutral" | "danger">;
+} | {
+    variant: Exclude<Variant, "solid">;
+    /** Takes the host's text color; for actions placed on a colored host. */
+    tone: "inherit";
+};
+export type ButtonRootProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "size"> & ButtonColorProps & {
+    /** Tier. Default: the tier of the surrounding control (a form, a panel, a field), else `m`. */
+    size?: ControlSize;
     fullWidth?: boolean;
     loading?: boolean;
     /**
      * Merges Button props onto its single child element instead of rendering `<button>`.
-     * Use when the trigger must be a different element (e.g. `<a>`, React Router `<Link>`).
-     *
-     * - `disabled` / `loading` → `aria-disabled="true"` + `pointer-events: none` (CSS);
-     *   native `disabled` attribute is NOT set (invalid on non-button elements).
-     * - `type` is not forwarded (irrelevant for non-button elements).
-     * - The child must accept `className`, `aria-*`, `data-*`, and event handler props.
+     * `disabled` / `loading` become `aria-disabled` (a link has no native `disabled`), `type` is
+     * dropped, and no spinner is added — the child owns its content.
      */
     asChild?: boolean;
+    ref?: React.Ref<HTMLButtonElement>;
 };
+declare function ButtonRoot({ children, className, variant, tone, size: sizeProp, fullWidth, type, loading, disabled, asChild, onClick, ref, ...rest }: ButtonRootProps): import("react/jsx-runtime").JSX.Element;
+declare namespace ButtonRoot {
+    var displayName: string;
+}
 export type ButtonIconProps = {
     children: React.ReactNode;
     className?: string;
+    ref?: React.Ref<HTMLSpanElement>;
 } & Omit<React.HTMLAttributes<HTMLSpanElement>, "children">;
 declare function ButtonIcon({ children, className, ...rest }: ButtonIconProps): import("react/jsx-runtime").JSX.Element;
 declare namespace ButtonIcon {
     var displayName: string;
 }
-export type ButtonSpinnerProps = {
-    className?: string;
-} & React.HTMLAttributes<HTMLSpanElement>;
-declare function ButtonSpinner({ className, ...rest }: ButtonSpinnerProps): import("react/jsx-runtime").JSX.Element | null;
-declare namespace ButtonSpinner {
-    var displayName: string;
-}
 export declare const Button: {
-    Root: React.ForwardRefExoticComponent<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "size"> & {
-        variant?: ButtonVariant;
-        mode?: ButtonMode;
-        size?: ButtonSize;
-        fullWidth?: boolean;
-        loading?: boolean;
-        /**
-         * Merges Button props onto its single child element instead of rendering `<button>`.
-         * Use when the trigger must be a different element (e.g. `<a>`, React Router `<Link>`).
-         *
-         * - `disabled` / `loading` → `aria-disabled="true"` + `pointer-events: none` (CSS);
-         *   native `disabled` attribute is NOT set (invalid on non-button elements).
-         * - `type` is not forwarded (irrelevant for non-button elements).
-         * - The child must accept `className`, `aria-*`, `data-*`, and event handler props.
-         */
-        asChild?: boolean;
-    } & React.RefAttributes<HTMLButtonElement>>;
+    Root: typeof ButtonRoot;
     Icon: typeof ButtonIcon;
-    Spinner: typeof ButtonSpinner;
 };
 export {};
-//# sourceMappingURL=Button.d.ts.map

package/dist/components/button-group/ButtonGroup.d.ts

@@ -1,34 +1,38 @@
-import * as React from "react";
-import type { ButtonGroupSize } from "@/internal/states";
+import type * as React from "react";
+import type { ControlSize } from "@/internal/states";
 export type ButtonGroupOrientation = "horizontal" | "vertical";
 export type ButtonGroupRootProps = React.HTMLAttributes<HTMLDivElement> & {
     orientation?: ButtonGroupOrientation;
-    size?: ButtonGroupSize;
-    children: React.ReactNode;
+    /** Tier. Default: the tier of the surrounding control (a toolbar, a panel), else `m`. */
+    size?: ControlSize;
+    /** Stretch the group to its container; horizontal segments share the width equally. */
+    fullWidth?: boolean;
+    ref?: React.Ref<HTMLDivElement>;
 };
+declare function ButtonGroupRoot({ orientation, size: sizeProp, fullWidth, children, className, ref, ...rest }: ButtonGroupRootProps): import("react/jsx-runtime").JSX.Element;
+declare namespace ButtonGroupRoot {
+    var displayName: string;
+}
 export type ButtonGroupItemProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
-    /** Включённое состояние сегмента: `data-state="on"` и синхронный `aria-pressed`. */
+    /** Toggle state of the segment: `aria-pressed` and `data-state="active" | "inactive"`. */
     pressed?: boolean;
+    ref?: React.Ref<HTMLButtonElement>;
 };
-export type ButtonGroupIconProps = {
+declare function ButtonGroupItem({ className, pressed, type, children, ref, ...rest }: ButtonGroupItemProps): import("react/jsx-runtime").JSX.Element;
+declare namespace ButtonGroupItem {
+    var displayName: string;
+}
+export type ButtonGroupIconProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> & {
     children: React.ReactNode;
-    className?: string;
-} & Omit<React.HTMLAttributes<HTMLSpanElement>, "children">;
+    ref?: React.Ref<HTMLSpanElement>;
+};
 declare function ButtonGroupIcon({ children, className, ...rest }: ButtonGroupIconProps): import("react/jsx-runtime").JSX.Element;
 declare namespace ButtonGroupIcon {
     var displayName: string;
 }
-export type { ButtonGroupSize };
 export declare const ButtonGroup: {
-    Root: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
-        orientation?: ButtonGroupOrientation;
-        size?: ButtonGroupSize;
-        children: React.ReactNode;
-    } & React.RefAttributes<HTMLDivElement>>;
-    Item: React.ForwardRefExoticComponent<React.ButtonHTMLAttributes<HTMLButtonElement> & {
-        /** Включённое состояние сегмента: `data-state="on"` и синхронный `aria-pressed`. */
-        pressed?: boolean;
-    } & React.RefAttributes<HTMLButtonElement>>;
+    Root: typeof ButtonGroupRoot;
+    Item: typeof ButtonGroupItem;
     Icon: typeof ButtonGroupIcon;
 };
-//# sourceMappingURL=ButtonGroup.d.ts.map
+export {};

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

@@ -1,234 +1,113 @@
-import * as React from "react";
-/** Карточки дашборда: KPI, списки, CTA, split, cover и секции с графиками. */
-export type CardVariant = "mini" | "mini-media" | "metric" | "panel" | "stat-trend" | "cta" | "list" | "split" | "cover";
-export type CardRootProps = {
-    variant: CardVariant;
-    /**
-     * Без лёгкой тени (плоская плитка на фоне страницы).
-     * По умолчанию — тень поверхности для отделения от фона.
-     */
+import type * as React from "react";
+import type { Tone } from "@/internal/states";
+type DivProps = React.HTMLAttributes<HTMLDivElement> & {
+    ref?: React.Ref<HTMLDivElement>;
+};
+type SpanProps = React.HTMLAttributes<HTMLSpanElement> & {
+    ref?: React.Ref<HTMLSpanElement>;
+};
+export type CardVariant = "panel" | "mini" | "stat-trend" | "split" | "cta" | "list" | "cover";
+export type CardRootProps = DivProps & {
+    /** Structural template: KPI tiles, lists, CTA, split, cover and titled panels. Default `panel`. */
+    variant?: CardVariant;
+    /** No raised shadow: a flat tile on the page (dense grids where shadows add noise). */
     flat?: boolean;
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-export type CardIconBoxProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardIconBox({ className, children, ...rest }: CardIconBoxProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardIconBox {
-    var displayName: string;
-}
-export type CardLeadProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardLead({ className, children, ...rest }: CardLeadProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardLead {
-    var displayName: string;
-}
-export type CardHeaderRowProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardHeaderRow({ className, children, ...rest }: CardHeaderRowProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardHeaderRow {
-    var displayName: string;
-}
-export type CardStackProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardStack({ className, children, ...rest }: CardStackProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardStack {
-    var displayName: string;
-}
-export type CardLabelProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLSpanElement>;
-declare function CardLabel({ className, children, ...rest }: CardLabelProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardLabel {
-    var displayName: string;
-}
-export type CardValueProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLSpanElement>;
-declare function CardValue({ className, children, ...rest }: CardValueProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardValue {
-    var displayName: string;
-}
-export type CardDescriptionProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLParagraphElement>;
-declare function CardDescription({ className, children, ...rest }: CardDescriptionProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardDescription {
+};
+declare function CardRoot({ variant, flat, className, ...rest }: CardRootProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardRoot {
     var displayName: string;
 }
-export type CardMediaProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardMedia({ className, children, ...rest }: CardMediaProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardMedia {
+export type CardHeaderProps = DivProps;
+/** The top row: the title first, anything after it (a control, a quiet caption) at the end. */
+declare function CardHeader({ className, ...rest }: CardHeaderProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardHeader {
     var displayName: string;
 }
-export type CardTitleProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLHeadingElement>;
-declare function CardTitle({ className, children, ...rest }: CardTitleProps): import("react/jsx-runtime").JSX.Element;
+export type CardHeadingLevel = "h2" | "h3" | "h4";
+export type CardTitleProps = React.HTMLAttributes<HTMLHeadingElement> & {
+    /** Heading level that fits the page outline (the look does not change). */
+    as?: CardHeadingLevel;
+    ref?: React.Ref<HTMLHeadingElement>;
+};
+declare function CardTitle({ as: Tag, className, ...rest }: CardTitleProps): import("react/jsx-runtime").JSX.Element;
 declare namespace CardTitle {
     var displayName: string;
 }
-export type CardDeltaProps = {
-    /** Подкраска тренда: рост / падение / нейтрально. */
-    trend?: "up" | "down" | "neutral";
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLSpanElement>;
-declare function CardDelta({ className, trend, children, ...rest }: CardDeltaProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardDelta {
-    var displayName: string;
-}
-export type CardActionsProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardActions({ className, children, ...rest }: CardActionsProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardActions {
-    var displayName: string;
-}
-export type CardCtaBodyProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardCtaBody({ className, children, ...rest }: CardCtaBodyProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardCtaBody {
+export type CardDescriptionProps = React.HTMLAttributes<HTMLParagraphElement> & {
+    ref?: React.Ref<HTMLParagraphElement>;
+};
+declare function CardDescription({ className, ...rest }: CardDescriptionProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardDescription {
     var displayName: string;
 }
-export type CardCoverProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardCover({ className, children, ...rest }: CardCoverProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardCover {
+export type CardBodyProps = DivProps;
+declare function CardBody({ className, ...rest }: CardBodyProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardBody {
     var displayName: string;
 }
-export type CardSplitProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardSplit({ className, children, ...rest }: CardSplitProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardSplit {
+export type CardMediaProps = DivProps;
+/** A chart, an image or a gauge: edge to edge in `panel`, the top cover in `cover`, the bottom slot in `mini`. */
+declare function CardMedia({ className, ...rest }: CardMediaProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardMedia {
     var displayName: string;
 }
-export type CardSplitCellProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardSplitCell({ className, children, ...rest }: CardSplitCellProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardSplitCell {
+export type CardFooterProps = DivProps;
+/** The bottom row of buttons. */
+declare function CardFooter({ className, ...rest }: CardFooterProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardFooter {
     var displayName: string;
 }
-export type CardListHeaderProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardListHeader({ className, children, ...rest }: CardListHeaderProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardListHeader {
+export type CardIconProps = DivProps;
+/** The 40px accent tile of a KPI; holds one icon. */
+declare function CardIcon({ className, ...rest }: CardIconProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardIcon {
     var displayName: string;
 }
-export type CardListProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLUListElement>;
-export type CardListItemProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLLIElement>;
-export type CardSectionHeaderProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardSectionHeader({ className, children, ...rest }: CardSectionHeaderProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardSectionHeader {
+export type CardLabelProps = SpanProps;
+declare function CardLabel({ className, ...rest }: CardLabelProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardLabel {
     var displayName: string;
 }
-export type CardSectionTitleProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLHeadingElement>;
-declare function CardSectionTitle({ className, children, ...rest }: CardSectionTitleProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardSectionTitle {
+export type CardValueProps = SpanProps;
+declare function CardValue({ className, ...rest }: CardValueProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardValue {
     var displayName: string;
 }
-export type CardSectionTrailingProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardSectionTrailing({ className, children, ...rest }: CardSectionTrailingProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardSectionTrailing {
+export type CardDeltaProps = SpanProps & {
+    /** Color of the change: `success` — good, `danger` — bad, `neutral` (default). Independent of the sign. */
+    tone?: Extract<Tone, "neutral" | "success" | "warning" | "danger">;
+};
+declare function CardDelta({ className, tone, ...rest }: CardDeltaProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardDelta {
     var displayName: string;
 }
-export type CardBodyProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardBody({ className, children, ...rest }: CardBodyProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardBody {
+export type CardListProps = React.HTMLAttributes<HTMLUListElement> & {
+    ref?: React.Ref<HTMLUListElement>;
+};
+declare function CardList({ className, ...rest }: CardListProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardList {
     var displayName: string;
 }
-export type CardChartProps = {
-    className?: string;
-    children?: React.ReactNode;
-} & React.HTMLAttributes<HTMLDivElement>;
-declare function CardChart({ className, children, ...rest }: CardChartProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CardChart {
+export type CardListItemProps = React.HTMLAttributes<HTMLLIElement> & {
+    ref?: React.Ref<HTMLLIElement>;
+};
+declare function CardListItem({ className, ...rest }: CardListItemProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CardListItem {
     var displayName: string;
 }
 export declare const Card: {
-    Root: React.ForwardRefExoticComponent<{
-        variant: CardVariant;
-        /**
-         * Без лёгкой тени (плоская плитка на фоне страницы).
-         * По умолчанию — тень поверхности для отделения от фона.
-         */
-        flat?: boolean;
-        className?: string;
-        children?: React.ReactNode;
-    } & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
-    IconBox: typeof CardIconBox;
-    Lead: typeof CardLead;
-    HeaderRow: typeof CardHeaderRow;
-    Stack: typeof CardStack;
-    Label: typeof CardLabel;
-    Value: typeof CardValue;
+    Root: typeof CardRoot;
+    Header: typeof CardHeader;
+    Title: typeof CardTitle;
     Description: typeof CardDescription;
+    Body: typeof CardBody;
     Media: typeof CardMedia;
-    Title: typeof CardTitle;
+    Footer: typeof CardFooter;
+    Icon: typeof CardIcon;
+    Label: typeof CardLabel;
+    Value: typeof CardValue;
     Delta: typeof CardDelta;
-    Actions: typeof CardActions;
-    CtaBody: typeof CardCtaBody;
-    Cover: typeof CardCover;
-    Split: typeof CardSplit;
-    SplitCell: typeof CardSplitCell;
-    ListHeader: typeof CardListHeader;
-    List: React.ForwardRefExoticComponent<{
-        className?: string;
-        children?: React.ReactNode;
-    } & React.HTMLAttributes<HTMLUListElement> & React.RefAttributes<HTMLUListElement>>;
-    ListItem: React.ForwardRefExoticComponent<{
-        className?: string;
-        children?: React.ReactNode;
-    } & React.HTMLAttributes<HTMLLIElement> & React.RefAttributes<HTMLLIElement>>;
-    SectionHeader: typeof CardSectionHeader;
-    SectionTitle: typeof CardSectionTitle;
-    SectionTrailing: typeof CardSectionTrailing;
-    Body: typeof CardBody;
-    Chart: typeof CardChart;
+    List: typeof CardList;
+    ListItem: typeof CardListItem;
 };
 export {};
-//# sourceMappingURL=Card.d.ts.map

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

@@ -1,42 +1,55 @@
 import * as React from "react";
-import type { CheckboxSize, CheckboxVariant } from "@/internal/states";
-export type CheckboxRootProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> & {
-    variant?: CheckboxVariant;
-    size?: CheckboxSize;
+import { type ChoiceLabelProps } from "@/internal/ChoiceField";
+import type { ControlSize } from "@/internal/states";
+export type CheckboxRootProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size" | "checked" | "defaultChecked" | "onChange"> & {
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    /** Mixed state (e.g. «select all» with a partial selection); wins over `checked` visually. */
     indeterminate?: boolean;
-};
-export type CheckboxLabelProps = {
+    /** Invalid state; a non-empty `error` implies it. */
+    invalid?: boolean;
+    /** Help text under the label text. Hidden while `error` is shown. */
+    hint?: React.ReactNode;
+    /** Error message in the hint slot; implies `invalid`. */
+    error?: React.ReactNode;
+    /** Tier. Default: the tier of the surrounding control (a form, a panel, a table), else `m`. */
+    size?: ControlSize;
+    /** `Checkbox.Label`; without it the bare box renders (give it an `aria-label`). */
     children?: React.ReactNode;
-    className?: string;
-} & Omit<React.HTMLAttributes<HTMLLabelElement>, "htmlFor" | "size">;
-export type CheckboxHintProps = {
-    children: React.ReactNode;
-    className?: string;
-} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
-declare function CheckboxHint({ children, className, ...rest }: CheckboxHintProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CheckboxHint {
+    /** The native checkbox input. */
+    ref?: React.Ref<HTMLInputElement>;
+};
+declare function CheckboxRoot({ id, checked: checkedProp, defaultChecked, onCheckedChange, indeterminate, invalid, hint, error, size: sizeProp, disabled, readOnly, className, "aria-describedby": ariaDescribedBy, children, ref, ...inputRest }: CheckboxRootProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CheckboxRoot {
+    var displayName: string;
+}
+export type CheckboxLabelProps = ChoiceLabelProps;
+declare function CheckboxLabel(props: CheckboxLabelProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CheckboxLabel {
     var displayName: string;
 }
-export type CheckboxErrorProps = {
-    children: React.ReactNode;
-    className?: string;
-} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
-declare function CheckboxError({ children, className, ...rest }: CheckboxErrorProps): import("react/jsx-runtime").JSX.Element;
-declare namespace CheckboxError {
+export type CheckboxIndicatorProps = Omit<React.HTMLAttributes<HTMLSpanElement>, "children"> & {
+    checked?: boolean;
+    /** Mixed state; wins over `checked` visually. */
+    indeterminate?: boolean;
+    disabled?: boolean;
+    /** Box tier; without it the nearest control size (e.g. the Select or menu it sits in), else `m`. */
+    size?: ControlSize;
+    ref?: React.Ref<HTMLSpanElement>;
+};
+/**
+ * The checkbox box alone, without an input: a decorative mark for rows whose own element carries
+ * the state (`role="option"` with `aria-selected`, `role="menuitemcheckbox"` with `aria-checked`).
+ * Used outside `Checkbox.Root`; it is `aria-hidden` and takes no focus or clicks.
+ */
+declare function CheckboxIndicator({ checked, indeterminate, disabled, size: sizeProp, className, ...rest }: CheckboxIndicatorProps): import("react/jsx-runtime").JSX.Element;
+declare namespace CheckboxIndicator {
     var displayName: string;
 }
 export declare const Checkbox: {
-    Root: React.ForwardRefExoticComponent<Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "type"> & {
-        variant?: CheckboxVariant;
-        size?: CheckboxSize;
-        indeterminate?: boolean;
-    } & React.RefAttributes<HTMLInputElement>>;
-    Label: React.ForwardRefExoticComponent<{
-        children?: React.ReactNode;
-        className?: string;
-    } & Omit<React.HTMLAttributes<HTMLLabelElement>, "size" | "htmlFor"> & React.RefAttributes<HTMLLabelElement>>;
-    Hint: typeof CheckboxHint;
-    Error: typeof CheckboxError;
+    Root: typeof CheckboxRoot;
+    Label: typeof CheckboxLabel;
+    Indicator: typeof CheckboxIndicator;
 };
 export {};
-//# sourceMappingURL=Checkbox.d.ts.map

package/dist/components/code-block/CodeBlock.d.ts

@@ -1,17 +1,16 @@
 import * as React from "react";
+import type { Variant } from "@/internal/states";
 export type CodeBlockColorScheme = "light" | "dark";
-export type CodeBlockRootProps = {
-    /** Исходник TS/TSX; подсветка через `highlightTsxHtml`. */
+/** `soft` — sunken panel with padding and the `code` text role; `ghost` — bare `pre` that inherits type and background from its host. */
+export type CodeBlockVariant = Extract<Variant, "soft" | "ghost">;
+export type CodeBlockProps = Omit<React.HTMLAttributes<HTMLPreElement>, "children" | "dangerouslySetInnerHTML"> & {
+    /** TS/TSX source; highlighted with `highlightTsxHtml`. */
     code: string;
+    /** Forces a theme for the block. Omit to follow the surrounding theme. */
     colorScheme?: CodeBlockColorScheme;
-    className?: string;
-} & Omit<React.HTMLAttributes<HTMLPreElement>, "children" | "dangerouslySetInnerHTML">;
-export declare const CodeBlock: {
-    Root: React.ForwardRefExoticComponent<{
-        /** Исходник TS/TSX; подсветка через `highlightTsxHtml`. */
-        code: string;
-        colorScheme?: CodeBlockColorScheme;
-        className?: string;
-    } & Omit<React.HTMLAttributes<HTMLPreElement>, "children" | "dangerouslySetInnerHTML"> & React.RefAttributes<HTMLPreElement>>;
+    /** Default `soft`. */
+    variant?: CodeBlockVariant;
+    ref?: React.Ref<HTMLPreElement>;
 };
-//# sourceMappingURL=CodeBlock.d.ts.map
+/** A static, highlighted TS/TSX snippet in `<pre><code>`. */
+export declare function CodeBlock({ code, colorScheme, variant, className, tabIndex, ...rest }: CodeBlockProps): import("react/jsx-runtime").JSX.Element;