prime-ui-kit 0.2.0

package/dist/components/index.d.ts

@@ -0,0 +1,2679 @@
+import { ColorPickerProps, ColorField, ColorAreaProps, ColorThumbProps, ColorSliderProps, SliderTrackProps, SliderOutputProps, ColorSwatchPickerProps, ColorSwatchPickerItemProps, ColorSwatchProps } from 'react-aria-components';
+export { Color as ColorPickerColorValue, ColorPickerRenderProps, parseColor } from 'react-aria-components';
+import { DayPickerProps, DateRange } from 'react-day-picker';
+export { DateRange } from 'react-day-picker';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import * as React from 'react';
+import * as react_router from 'react-router';
+import { NavLink } from 'react-router-dom';
+import { LucideProps } from 'lucide-react';
+
+declare const interactionStates: readonly ["default", "hover", "active", "focus", "focus-visible", "disabled"];
+declare const selectionStates: readonly ["selected", "checked", "indeterminate"];
+declare const validationStates: readonly ["valid", "invalid", "readonly", "required"];
+declare const asyncStates: readonly ["idle", "loading", "success", "error"];
+declare const disclosureStates: readonly ["open", "closed"];
+declare const componentVariants: {
+    readonly button: readonly ["primary", "neutral", "error"];
+    readonly input: readonly ["default", "error"];
+    readonly textarea: readonly ["default", "error"];
+    readonly checkbox: readonly ["default", "error"];
+    readonly radio: readonly ["default", "error"];
+    readonly switch: readonly ["default", "error"];
+    readonly select: readonly ["default", "error"];
+    readonly modal: readonly ["default"];
+};
+declare const componentSizes: {
+    readonly buttonGroup: readonly ["s", "m", "l", "xl"];
+    readonly button: readonly ["s", "m", "l", "xl"];
+    readonly input: readonly ["s", "m", "l", "xl"];
+    readonly textarea: readonly ["s", "m", "l", "xl"];
+    readonly checkbox: readonly ["s", "m", "l", "xl"];
+    readonly radio: readonly ["s", "m", "l", "xl"];
+    readonly switch: readonly ["s", "m", "l", "xl"];
+    readonly select: readonly ["s", "m", "l", "xl"];
+    readonly fileUpload: readonly ["s", "m", "l", "xl"];
+    readonly linkButton: readonly ["s", "m", "l", "xl"];
+    readonly breadcrumb: readonly ["s", "m", "l", "xl"];
+    readonly divider: readonly ["s", "m", "l", "xl"];
+    readonly label: readonly ["s", "m", "l", "xl"];
+    readonly modal: readonly ["s", "m", "l", "xl"];
+    readonly hint: readonly ["s", "m", "l", "xl"];
+    readonly alert: readonly ["s", "m", "l", "xl"];
+    readonly banner: readonly ["s", "m", "l", "xl"];
+    readonly digitInput: readonly ["s", "m", "l", "xl"];
+    readonly kbd: readonly ["s", "m", "l", "xl"];
+    readonly slider: readonly ["s", "m", "l", "xl"];
+    readonly tabs: readonly ["s", "m", "l", "xl"];
+    readonly pagination: readonly ["s", "m", "l", "xl"];
+    readonly stepper: readonly ["s", "m", "l", "xl"];
+    readonly accordion: readonly ["s", "m", "l", "xl"];
+    readonly dropdown: readonly ["s", "m", "l", "xl"];
+    readonly progressBar: readonly ["s", "m", "l", "xl"];
+    readonly sidebar: readonly ["s", "m", "l", "xl"];
+    readonly drawer: readonly ["s", "m", "l", "xl"];
+    readonly dataTable: readonly ["s", "m", "l", "xl"];
+};
+declare const buttonModes: readonly ["filled", "stroke", "lighter", "ghost", "fancy"];
+type InteractionState = (typeof interactionStates)[number];
+type SelectionState = (typeof selectionStates)[number];
+type ValidationState = (typeof validationStates)[number];
+type AsyncState = (typeof asyncStates)[number];
+type DisclosureState = (typeof disclosureStates)[number];
+type ButtonVariant = (typeof componentVariants.button)[number];
+type InputVariant = (typeof componentVariants.input)[number];
+type TextareaVariant = (typeof componentVariants.textarea)[number];
+type CheckboxVariant = (typeof componentVariants.checkbox)[number];
+type RadioVariant = (typeof componentVariants.radio)[number];
+type SwitchVariant = (typeof componentVariants.switch)[number];
+type SelectVariant = (typeof componentVariants.select)[number];
+type ModalVariant = (typeof componentVariants.modal)[number];
+type ButtonGroupSize = (typeof componentSizes.buttonGroup)[number];
+type ButtonSize = (typeof componentSizes.button)[number];
+type InputSize = (typeof componentSizes.input)[number];
+type TextareaSize = (typeof componentSizes.textarea)[number];
+type CheckboxSize = (typeof componentSizes.checkbox)[number];
+type RadioSize = (typeof componentSizes.radio)[number];
+type SwitchSize = (typeof componentSizes.switch)[number];
+type SelectSize = (typeof componentSizes.select)[number];
+type FileUploadSize = (typeof componentSizes.fileUpload)[number];
+type LinkButtonSize = (typeof componentSizes.linkButton)[number];
+type BreadcrumbSize = (typeof componentSizes.breadcrumb)[number];
+type DividerSize = (typeof componentSizes.divider)[number];
+type LabelSize = (typeof componentSizes.label)[number];
+type ModalSize = (typeof componentSizes.modal)[number];
+type HintSize = (typeof componentSizes.hint)[number];
+type AlertSize = (typeof componentSizes.alert)[number];
+type BannerSize = (typeof componentSizes.banner)[number];
+type DigitInputSize = (typeof componentSizes.digitInput)[number];
+type KbdSize = (typeof componentSizes.kbd)[number];
+type SliderSize = (typeof componentSizes.slider)[number];
+type TabsSize = (typeof componentSizes.tabs)[number];
+type PaginationSize = (typeof componentSizes.pagination)[number];
+type StepperSize = (typeof componentSizes.stepper)[number];
+type AccordionSize = (typeof componentSizes.accordion)[number];
+type DropdownSize = (typeof componentSizes.dropdown)[number];
+type ProgressBarSize = (typeof componentSizes.progressBar)[number];
+type SidebarSize = (typeof componentSizes.sidebar)[number];
+type DrawerSize = (typeof componentSizes.drawer)[number];
+type DataTableSize = (typeof componentSizes.dataTable)[number];
+type ButtonMode = (typeof buttonModes)[number];
+
+/** Размер «контрольной поверхности» (поля, кнопки, селект и т.д.) для каскада в дочерние `Icon`. */
+type ControlSurfaceSize = "xs" | InputSize;
+type ControlSizeProviderProps = {
+    value: ControlSurfaceSize;
+    children: React.ReactNode;
+};
+declare function ControlSizeProvider({ value, children }: ControlSizeProviderProps): react_jsx_runtime.JSX.Element;
+declare namespace ControlSizeProvider {
+    var displayName: string;
+}
+/** Для `Icon`: если `size` не передан явно, берётся из ближайшего контрола. */
+declare function useOptionalControlSize(): ControlSurfaceSize | undefined;
+
+type AccordionType = "single" | "multiple";
+
+type AccordionRootProps = React.HTMLAttributes<HTMLDivElement> & {
+    type?: AccordionType;
+    value?: string | string[];
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    /** Только для `type="single"`. Если `false`, в одиночном режиме нельзя закрыть открытый пункт. По умолчанию `true`. */
+    collapsible?: boolean;
+    /** Размер триггера, иконок и отступов контента. По умолчанию `m`. */
+    size?: AccordionSize;
+    /** Групповой список без зазоров (`grouped`) или отдельные карточки (`separate`). */
+    layout?: "grouped" | "separate";
+};
+type AccordionItemProps = React.HTMLAttributes<HTMLDivElement> & {
+    value: string;
+    disabled?: boolean;
+};
+type AccordionHeaderProps = React.HTMLAttributes<HTMLHeadingElement>;
+type AccordionTriggerProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+type AccordionContentProps = React.HTMLAttributes<HTMLDivElement>;
+type AccordionIconProps<T extends React.ElementType = "div"> = {
+    as?: T;
+    className?: string;
+    children?: React.ReactNode;
+} & Omit<React.ComponentPropsWithoutRef<T>, "as" | "className">;
+type AccordionArrowProps = React.HTMLAttributes<HTMLSpanElement> & {
+    openIcon?: React.ElementType<{
+        className?: string;
+        strokeWidth?: number | string;
+    }>;
+    closeIcon?: React.ElementType<{
+        className?: string;
+        strokeWidth?: number | string;
+    }>;
+};
+declare function AccordionIcon<T extends React.ElementType = "div">({ as, className, children, ...rest }: AccordionIconProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace AccordionIcon {
+    var displayName: string;
+}
+declare function AccordionArrow({ className, openIcon: OpenIcon, closeIcon: CloseIcon, ...rest }: AccordionArrowProps): react_jsx_runtime.JSX.Element;
+declare namespace AccordionArrow {
+    var displayName: string;
+}
+declare const Accordion: {
+    Root: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+        type?: AccordionType;
+        value?: string | string[];
+        defaultValue?: string | string[];
+        onValueChange?: (value: string | string[]) => void;
+        /** Только для `type="single"`. Если `false`, в одиночном режиме нельзя закрыть открытый пункт. По умолчанию `true`. */
+        collapsible?: boolean;
+        /** Размер триггера, иконок и отступов контента. По умолчанию `m`. */
+        size?: AccordionSize;
+        /** Групповой список без зазоров (`grouped`) или отдельные карточки (`separate`). */
+        layout?: "grouped" | "separate";
+    } & React.RefAttributes<HTMLDivElement>>;
+    Header: React.ForwardRefExoticComponent<AccordionHeaderProps & React.RefAttributes<HTMLHeadingElement>>;
+    Item: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLDivElement> & {
+        value: string;
+        disabled?: boolean;
+    } & React.RefAttributes<HTMLDivElement>>;
+    Trigger: React.ForwardRefExoticComponent<AccordionTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Icon: typeof AccordionIcon;
+    Arrow: typeof AccordionArrow;
+    Content: React.ForwardRefExoticComponent<AccordionContentProps & React.RefAttributes<HTMLDivElement>>;
+};
+
+type AvatarSize = "s" | "m" | "l" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl";
+type AvatarImageStatus = "idle" | "loading" | "loaded" | "error";
+type AvatarRootProps = {
+    size?: AvatarSize;
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+type AvatarImageProps = {
+    src: string;
+    alt?: string;
+    className?: string;
+} & Omit<React.ImgHTMLAttributes<HTMLImageElement>, "src" | "alt">;
+type AvatarFallbackProps = {
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLSpanElement>;
+declare function AvatarFallback({ children, className, ...rest }: AvatarFallbackProps): react_jsx_runtime.JSX.Element;
+declare namespace AvatarFallback {
+    var displayName: string;
+}
+type AvatarGroupOverflowProps = {
+    size?: AvatarSize;
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+type AvatarGroupRootProps = {
+    size?: AvatarSize;
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare const Avatar: {
+    Root: React.ForwardRefExoticComponent<{
+        size?: AvatarSize;
+        className?: string;
+        children?: React.ReactNode;
+    } & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+    Image: React.ForwardRefExoticComponent<{
+        src: string;
+        alt?: string;
+        className?: string;
+    } & Omit<React.ImgHTMLAttributes<HTMLImageElement>, "alt" | "src"> & React.RefAttributes<HTMLImageElement>>;
+    Fallback: typeof AvatarFallback;
+    Group: {
+        Root: React.ForwardRefExoticComponent<{
+            size?: AvatarSize;
+            className?: string;
+            children?: React.ReactNode;
+        } & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+        Overflow: React.ForwardRefExoticComponent<{
+            size?: AvatarSize;
+            className?: string;
+            children?: React.ReactNode;
+        } & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+    };
+};
+
+type BadgeColor = "gray" | "red" | "blue" | "green" | "orange" | "yellow" | "purple" | "sky" | "pink" | "teal";
+/** Состояние индикатора при `variant="status"`. */
+type BadgeStatus = "online" | "offline" | "away" | "busy";
+type BadgeVariant = "filled" | "light" | "lighter" | "stroke" | "status";
+type BadgeSize = "s" | "m" | "l" | "xl";
+type BadgeRootProps = {
+    color?: BadgeColor;
+    variant?: BadgeVariant;
+    size?: BadgeSize;
+    disabled?: boolean;
+    /** При `variant="status"` — цвет точки (online / offline / away / busy). */
+    status?: BadgeStatus;
+    /** При `variant="status"` — `aria-label` на корне (`role="status"`). */
+    label?: string;
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+type BadgeIconProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLDivElement>, "children">;
+type BadgeDotProps = {
+    className?: string;
+} & React.HTMLAttributes<HTMLSpanElement>;
+declare function BadgeIcon({ children, className, ...rest }: BadgeIconProps): react_jsx_runtime.JSX.Element;
+declare namespace BadgeIcon {
+    var displayName: string;
+}
+declare function BadgeDot({ className, ...rest }: BadgeDotProps): react_jsx_runtime.JSX.Element;
+declare namespace BadgeDot {
+    var displayName: string;
+}
+declare const Badge: {
+    Root: React.ForwardRefExoticComponent<{
+        color?: BadgeColor;
+        variant?: BadgeVariant;
+        size?: BadgeSize;
+        disabled?: boolean;
+        /** При `variant="status"` — цвет точки (online / offline / away / busy). */
+        status?: BadgeStatus;
+        /** При `variant="status"` — `aria-label` на корне (`role="status"`). */
+        label?: string;
+        children?: React.ReactNode;
+        className?: string;
+    } & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+    Icon: typeof BadgeIcon;
+    Dot: typeof BadgeDot;
+};
+
+type BannerVariant = "filled" | "light" | "lighter" | "stroke";
+type BannerStatus = "information" | "warning" | "error" | "success" | "feature";
+
+type BannerRootProps = {
+    variant?: BannerVariant;
+    status?: BannerStatus;
+    size?: BannerSize;
+    onDismiss?: () => void;
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+type BannerContentProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare function BannerContent({ className, children, ...rest }: BannerContentProps): react_jsx_runtime.JSX.Element;
+declare namespace BannerContent {
+    var displayName: string;
+}
+type BannerIconProps<T extends React.ElementType = "div"> = {
+    as?: T;
+    className?: string;
+    children?: React.ReactNode;
+} & Omit<React.ComponentPropsWithoutRef<T>, "as" | "className">;
+declare function BannerIcon<T extends React.ElementType = "div">({ as, className, children, ...rest }: BannerIconProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace BannerIcon {
+    var displayName: string;
+}
+type BannerTitleProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLSpanElement>;
+declare function BannerTitle({ className, children, ...rest }: BannerTitleProps): react_jsx_runtime.JSX.Element;
+declare namespace BannerTitle {
+    var displayName: string;
+}
+type BannerDescriptionProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLSpanElement>;
+declare function BannerDescription({ className, children, ...rest }: BannerDescriptionProps): react_jsx_runtime.JSX.Element;
+declare namespace BannerDescription {
+    var displayName: string;
+}
+type BannerActionsProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare function BannerActions({ className, children, ...rest }: BannerActionsProps): react_jsx_runtime.JSX.Element;
+declare namespace BannerActions {
+    var displayName: string;
+}
+type BannerCloseButtonProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "size">;
+declare const Banner: {
+    Root: React.ForwardRefExoticComponent<{
+        variant?: BannerVariant;
+        status?: BannerStatus;
+        size?: BannerSize;
+        onDismiss?: () => void;
+        className?: string;
+        children?: React.ReactNode;
+    } & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+    Content: typeof BannerContent;
+    Icon: typeof BannerIcon;
+    Title: typeof BannerTitle;
+    Description: typeof BannerDescription;
+    Actions: typeof BannerActions;
+    CloseButton: React.ForwardRefExoticComponent<{
+        className?: string;
+        children?: React.ReactNode;
+    } & Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "size"> & React.RefAttributes<HTMLButtonElement>>;
+};
+
+type BreadcrumbRootProps = {
+    children: React.ReactNode;
+    className?: string;
+    /** Кегль ссылок (LinkButton), текущей страницы, многоточия; иконка-разделитель и иконка «дом» — тот же ярус. */
+    size?: BreadcrumbSize;
+} & React.HTMLAttributes<HTMLElement>;
+declare function BreadcrumbRoot({ children, className, size, ...rest }: BreadcrumbRootProps): react_jsx_runtime.JSX.Element;
+declare namespace BreadcrumbRoot {
+    var displayName: string;
+}
+type BreadcrumbItemProps = {
+    href?: string;
+    current?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+    /** Для ссылки без видимого текста (например, только иконка «дом»). */
+    "aria-label"?: string;
+};
+declare function BreadcrumbItem({ href, current, children, className, "aria-label": ariaLabel, }: BreadcrumbItemProps): react_jsx_runtime.JSX.Element;
+declare namespace BreadcrumbItem {
+    var displayName: string;
+}
+type BreadcrumbSeparatorProps = {
+    children?: React.ReactNode;
+    className?: string;
+};
+declare function BreadcrumbSeparator({ children, className }: BreadcrumbSeparatorProps): react_jsx_runtime.JSX.Element;
+declare namespace BreadcrumbSeparator {
+    var displayName: string;
+}
+type BreadcrumbEllipsisProps = {
+    className?: string;
+};
+declare function BreadcrumbEllipsis({ className }: BreadcrumbEllipsisProps): react_jsx_runtime.JSX.Element;
+declare namespace BreadcrumbEllipsis {
+    var displayName: string;
+}
+declare const Breadcrumb: {
+    Root: typeof BreadcrumbRoot;
+    Item: typeof BreadcrumbItem;
+    Separator: typeof BreadcrumbSeparator;
+    Ellipsis: typeof BreadcrumbEllipsis;
+};
+
+type ButtonRootProps = 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;
+};
+type ButtonIconProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLSpanElement>, "children">;
+declare function ButtonIcon({ children, className, ...rest }: ButtonIconProps): react_jsx_runtime.JSX.Element;
+declare namespace ButtonIcon {
+    var displayName: string;
+}
+type ButtonSpinnerProps = {
+    className?: string;
+} & React.HTMLAttributes<HTMLSpanElement>;
+declare function ButtonSpinner({ className, ...rest }: ButtonSpinnerProps): react_jsx_runtime.JSX.Element | null;
+declare namespace ButtonSpinner {
+    var displayName: string;
+}
+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>>;
+    Icon: typeof ButtonIcon;
+    Spinner: typeof ButtonSpinner;
+};
+
+type ButtonGroupOrientation = "horizontal" | "vertical";
+type ButtonGroupRootProps = React.HTMLAttributes<HTMLDivElement> & {
+    orientation?: ButtonGroupOrientation;
+    size?: ButtonGroupSize;
+    children: React.ReactNode;
+};
+type ButtonGroupItemProps = React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    /** Включённое состояние сегмента: `data-state="on"` и синхронный `aria-pressed`. */
+    pressed?: boolean;
+};
+type ButtonGroupIconProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLSpanElement>, "children">;
+declare function ButtonGroupIcon({ children, className, ...rest }: ButtonGroupIconProps): react_jsx_runtime.JSX.Element;
+declare namespace ButtonGroupIcon {
+    var displayName: string;
+}
+
+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>>;
+    Icon: typeof ButtonGroupIcon;
+};
+
+type CheckboxRootProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> & {
+    variant?: CheckboxVariant;
+    size?: CheckboxSize;
+    indeterminate?: boolean;
+};
+type CheckboxLabelProps = {
+    children?: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLLabelElement>, "htmlFor" | "size">;
+type CheckboxHintProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
+declare function CheckboxHint({ children, className, ...rest }: CheckboxHintProps): react_jsx_runtime.JSX.Element;
+declare namespace CheckboxHint {
+    var displayName: string;
+}
+type CheckboxErrorProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
+declare function CheckboxError({ children, className, ...rest }: CheckboxErrorProps): react_jsx_runtime.JSX.Element;
+declare namespace CheckboxError {
+    var displayName: string;
+}
+declare const Checkbox: {
+    Root: React.ForwardRefExoticComponent<Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> & {
+        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;
+};
+
+type CodeBlockColorScheme = "light" | "dark";
+type CodeBlockRootProps = {
+    /** Исходник TS/TSX; подсветка через `highlightTsxHtml`. */
+    code: string;
+    colorScheme?: CodeBlockColorScheme;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLPreElement>, "children" | "dangerouslySetInnerHTML">;
+declare const CodeBlock: {
+    Root: React.ForwardRefExoticComponent<{
+        /** Исходник TS/TSX; подсветка через `highlightTsxHtml`. */
+        code: string;
+        colorScheme?: CodeBlockColorScheme;
+        className?: string;
+    } & Omit<React.HTMLAttributes<HTMLPreElement>, "children" | "dangerouslySetInnerHTML"> & React.RefAttributes<HTMLPreElement>>;
+};
+
+type ColorPickerRootProps = ColorPickerProps;
+type ColorValueFormat = "hsl" | "rgb" | "hex";
+type ColorPickerHexInputProps = {
+    size?: InputSize;
+    label?: React.ReactNode;
+    className?: string;
+};
+type ColorPickerFormatProviderProps = {
+    children: React.ReactNode;
+    defaultFormat?: ColorValueFormat;
+};
+
+declare function FormatProvider({ children, defaultFormat }: ColorPickerFormatProviderProps): react_jsx_runtime.JSX.Element;
+declare function FormatSelect({ className }: {
+    className?: string;
+}): react_jsx_runtime.JSX.Element | null;
+/** Полоса каналов: слева пипетка из {@link EyeDropperButton}, справа — ячейки; иконку пипетки передайте `pipetteIcon`. */
+declare function ChannelStripWithIcon({ className, pipetteIcon, }: {
+    className?: string;
+    pipetteIcon: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function ColorPickerRoot(props: ColorPickerProps): react_jsx_runtime.JSX.Element;
+declare function Field({ className, ...props }: React.ComponentProps<typeof ColorField>): react_jsx_runtime.JSX.Element;
+declare function Slider$1({ className, ...props }: ColorSliderProps): react_jsx_runtime.JSX.Element;
+declare function Area({ className, ...props }: ColorAreaProps): react_jsx_runtime.JSX.Element;
+declare function SliderTrack({ className, style, ...props }: SliderTrackProps): react_jsx_runtime.JSX.Element;
+declare function Thumb({ className, ...props }: ColorThumbProps): react_jsx_runtime.JSX.Element;
+declare function AreaThumb({ className, ...props }: ColorThumbProps): react_jsx_runtime.JSX.Element;
+declare function SwatchPicker({ className, ...props }: ColorSwatchPickerProps): react_jsx_runtime.JSX.Element;
+declare function SwatchPickerItem({ className, ...props }: ColorSwatchPickerItemProps): react_jsx_runtime.JSX.Element;
+declare function Swatch({ className, style, ...props }: ColorSwatchProps): react_jsx_runtime.JSX.Element;
+declare function Output(props: SliderOutputProps): react_jsx_runtime.JSX.Element;
+declare function SliderMeta({ label }: {
+    label: React.ReactNode;
+}): react_jsx_runtime.JSX.Element;
+declare function HexInput({ size, label, className }: ColorPickerHexInputProps): react_jsx_runtime.JSX.Element | null;
+type ColorPickerTriggerSwatchProps = {
+    className?: string;
+};
+/** Квадратик текущего цвета из {@link ColorPickerStateContext}; для кнопки-триггера поповера и т.п. */
+declare function TriggerSwatch({ className }: ColorPickerTriggerSwatchProps): react_jsx_runtime.JSX.Element;
+declare namespace TriggerSwatch {
+    var displayName: string;
+}
+declare const ColorPicker: {
+    Root: typeof ColorPickerRoot;
+    TriggerSwatch: typeof TriggerSwatch;
+    FormatProvider: typeof FormatProvider;
+    FormatSelect: typeof FormatSelect;
+    ChannelStrip: typeof ChannelStripWithIcon;
+    Field: typeof Field;
+    HexInput: typeof HexInput;
+    Area: typeof Area;
+    AreaThumb: typeof AreaThumb;
+    Slider: typeof Slider$1;
+    SliderMeta: typeof SliderMeta;
+    SliderTrack: typeof SliderTrack;
+    Thumb: typeof Thumb;
+    Output: typeof Output;
+    SwatchPicker: typeof SwatchPicker;
+    SwatchPickerItem: typeof SwatchPickerItem;
+    Swatch: typeof Swatch;
+    EyeDropperButton: React.ForwardRefExoticComponent<Omit<Omit<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "size"> & {
+        variant?: ButtonVariant;
+        mode?: ButtonMode;
+        size?: ButtonSize;
+        fullWidth?: boolean;
+        loading?: boolean;
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLButtonElement>, "ref">, "size" | "mode" | "variant"> & React.RefAttributes<HTMLButtonElement>>;
+};
+
+type ModalRootProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    closeOnEscape?: boolean;
+    closeOnOverlayClick?: boolean;
+    /** Масштаб оболочки (панель, отступы, типографика шапки) и ярус для каскада `ControlSizeProvider`. По умолчанию `m`. */
+    size?: ModalSize;
+    children?: React.ReactNode;
+};
+declare function ModalRoot({ open, defaultOpen, onOpenChange, closeOnEscape, closeOnOverlayClick, size, children, }: ModalRootProps): react_jsx_runtime.JSX.Element;
+type ModalTriggerProps = {
+    children: React.ReactElement<{
+        onClick?: React.MouseEventHandler;
+    }>;
+};
+declare function ModalTrigger({ children }: ModalTriggerProps): React.ReactElement<{
+    onClick?: React.MouseEventHandler;
+}, string | React.JSXElementConstructor<any>>;
+type ModalCloseProps = {
+    children: React.ReactElement<{
+        onClick?: React.MouseEventHandler;
+        className?: string;
+        size?: ButtonSize;
+    }>;
+};
+declare function ModalClose({ children }: ModalCloseProps): React.ReactElement<{
+    onClick?: React.MouseEventHandler;
+    className?: string;
+    size?: ButtonSize;
+}, string | React.JSXElementConstructor<any>>;
+type ModalPortalProps = {
+    children: React.ReactNode;
+    container?: HTMLElement | null;
+};
+declare function ModalPortal({ children, container }: ModalPortalProps): react_jsx_runtime.JSX.Element | null;
+type ModalOverlayProps = React.HTMLAttributes<HTMLDivElement>;
+declare function ModalOverlay({ className, onClick, ...rest }: ModalOverlayProps): react_jsx_runtime.JSX.Element;
+type ModalContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+};
+declare function ModalContent({ children, className, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, "aria-describedby": ariaDescribedBy, ...rest }: ModalContentProps): react_jsx_runtime.JSX.Element;
+type ModalHeaderProps = React.HTMLAttributes<HTMLElement> & {
+    icon?: React.ReactNode;
+};
+declare function ModalHeader({ children, className, icon, ...rest }: ModalHeaderProps): react_jsx_runtime.JSX.Element;
+type ModalTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+declare function ModalTitle({ children, className, ...rest }: ModalTitleProps): react_jsx_runtime.JSX.Element;
+type ModalDescriptionProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare function ModalDescription({ children, className, ...rest }: ModalDescriptionProps): react_jsx_runtime.JSX.Element;
+type ModalBodyProps = React.HTMLAttributes<HTMLDivElement>;
+declare function ModalBody({ children, className, ...rest }: ModalBodyProps): react_jsx_runtime.JSX.Element;
+type ModalFooterProps = React.HTMLAttributes<HTMLElement>;
+declare function ModalFooter({ children, className, ...rest }: ModalFooterProps): react_jsx_runtime.JSX.Element;
+declare const Modal: {
+    Root: typeof ModalRoot;
+    Trigger: typeof ModalTrigger;
+    Close: typeof ModalClose;
+    Portal: typeof ModalPortal;
+    Overlay: typeof ModalOverlay;
+    Content: typeof ModalContent;
+    Header: typeof ModalHeader;
+    Title: typeof ModalTitle;
+    Description: typeof ModalDescription;
+    Body: typeof ModalBody;
+    Footer: typeof ModalFooter;
+};
+
+type CommandMenuDialogProps = Omit<ModalRootProps, "children"> & {
+    children?: React.ReactNode;
+    overlayClassName?: string;
+    /** Дополнительный класс для панели контента (совмещается с внутренними стилями диалога). */
+    className?: string;
+    contentClassName?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+};
+declare function CommandMenuDialog({ children, overlayClassName, className, contentClassName, size, open, defaultOpen, onOpenChange, closeOnEscape, closeOnOverlayClick, "aria-labelledby": ariaLabelledBy, "aria-describedby": ariaDescribedBy, }: CommandMenuDialogProps): react_jsx_runtime.JSX.Element;
+type CommandMenuInputRowProps = React.HTMLAttributes<HTMLDivElement> & {
+    leading?: React.ReactNode;
+    trailing?: React.ReactNode;
+    /** `compact` — ниже строка поиска, `comfortable` — выше. */
+    density?: "compact" | "comfortable";
+};
+declare function CommandMenuInputRow({ leading, trailing, children, className, density, ...rest }: CommandMenuInputRowProps): react_jsx_runtime.JSX.Element;
+type CommandMenuInputProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "size" | "type">;
+type CommandMenuListProps = React.HTMLAttributes<HTMLDivElement>;
+type CommandMenuGroupProps = React.HTMLAttributes<HTMLDivElement> & {
+    heading?: React.ReactNode;
+};
+declare function CommandMenuGroup({ heading, className, children, ...rest }: CommandMenuGroupProps): react_jsx_runtime.JSX.Element;
+type CommandMenuItemSize = "s" | "m";
+type CommandMenuItemProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type" | "onSelect"> & {
+    /** Текст для фильтрации; пустая строка — пункт всегда виден при любом запросе. */
+    value: string;
+    keywords?: string;
+    size?: CommandMenuItemSize;
+    onSelect?: () => void;
+};
+type CommandMenuItemIconProps<T extends React.ElementType = "span"> = {
+    as?: T;
+    className?: string;
+} & Omit<React.ComponentPropsWithoutRef<T>, "as" | "className">;
+declare function CommandMenuItemIcon<T extends React.ElementType = "span">({ as, className, ...rest }: CommandMenuItemIconProps<T>): react_jsx_runtime.JSX.Element;
+type CommandMenuTagSectionProps = React.HTMLAttributes<HTMLDivElement>;
+declare function CommandMenuTagSection({ className, ...rest }: CommandMenuTagSectionProps): react_jsx_runtime.JSX.Element;
+type CommandMenuTagSectionLabelProps = React.HTMLAttributes<HTMLDivElement>;
+declare function CommandMenuTagSectionLabel({ className, ...rest }: CommandMenuTagSectionLabelProps): react_jsx_runtime.JSX.Element;
+type CommandMenuTagRowProps = React.HTMLAttributes<HTMLDivElement>;
+declare function CommandMenuTagRow({ className, ...rest }: CommandMenuTagRowProps): react_jsx_runtime.JSX.Element;
+type CommandMenuFooterProps = React.HTMLAttributes<HTMLDivElement>;
+declare function CommandMenuFooter({ className, ...rest }: CommandMenuFooterProps): react_jsx_runtime.JSX.Element;
+type CommandMenuFooterKeyBoxProps = Omit<React.HTMLAttributes<HTMLDivElement>, "color"> & {
+    /** На футере с `footerMuted` — бейдж `lighter`, иначе `stroke` (контур). */
+    tone?: "default" | "muted";
+};
+declare const CommandMenu: {
+    Dialog: typeof CommandMenuDialog;
+    DialogTitle: ({ children, className, ...rest }: ModalTitleProps) => react_jsx_runtime.JSX.Element;
+    DialogDescription: ({ children, className, ...rest }: ModalDescriptionProps) => react_jsx_runtime.JSX.Element;
+    InputRow: typeof CommandMenuInputRow;
+    Input: React.ForwardRefExoticComponent<CommandMenuInputProps & React.RefAttributes<HTMLInputElement>>;
+    List: React.ForwardRefExoticComponent<CommandMenuListProps & React.RefAttributes<HTMLDivElement>>;
+    Group: typeof CommandMenuGroup;
+    Item: React.ForwardRefExoticComponent<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "onSelect" | "type"> & {
+        /** Текст для фильтрации; пустая строка — пункт всегда виден при любом запросе. */
+        value: string;
+        keywords?: string;
+        size?: CommandMenuItemSize;
+        onSelect?: () => void;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    ItemIcon: typeof CommandMenuItemIcon;
+    TagSection: typeof CommandMenuTagSection;
+    TagSectionLabel: typeof CommandMenuTagSectionLabel;
+    TagRow: typeof CommandMenuTagRow;
+    Footer: typeof CommandMenuFooter;
+    FooterKeyBox: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLDivElement>, "color"> & {
+        /** На футере с `footerMuted` — бейдж `lighter`, иначе `stroke` (контур). */
+        tone?: "default" | "muted";
+    } & React.RefAttributes<HTMLDivElement>>;
+};
+
+type DataTableOrder = "asc" | "desc";
+type DataTableSortState = {
+    columnId: string;
+    order: DataTableOrder;
+} | null;
+type DataTableCellAlign = "start" | "center" | "end";
+type DataTableDividerStyle = "standard" | "dashed" | "dotted" | "none";
+type DataTableColumn<Row> = {
+    id: string;
+    header: React.ReactNode;
+    accessor?: keyof Row | ((row: Row) => unknown);
+    cell?: (row: Row) => React.ReactNode;
+    sortable?: boolean;
+    sortAccessor?: (row: Row) => unknown;
+    sortComparator?: (a: Row, b: Row, order: DataTableOrder) => number;
+    align?: DataTableCellAlign;
+    width?: string;
+    minWidth?: string;
+    onHeaderClick?: (event: React.MouseEvent<HTMLTableCellElement>) => void;
+    onCellClick?: (row: Row, event: React.MouseEvent<HTMLTableCellElement> | React.KeyboardEvent<HTMLTableCellElement>) => void;
+};
+type DataTableRootProps<Row> = {
+    columns: DataTableColumn<Row>[];
+    rows: Row[];
+    size?: DataTableSize;
+    className?: string;
+    showHeader?: boolean;
+    stickyHeader?: boolean;
+    stickyFirstColumn?: boolean;
+    getRowKey?: (row: Row, index: number) => React.Key;
+    onRowClick?: (row: Row, index: number, event: React.MouseEvent<HTMLTableRowElement>) => void;
+    loading?: boolean;
+    loadingText?: React.ReactNode;
+    emptyText?: React.ReactNode;
+    dividerStyle?: DataTableDividerStyle;
+    sort?: DataTableSortState;
+    defaultSort?: DataTableSortState;
+    onSortChange?: (sort: DataTableSortState) => void;
+    page?: number;
+    defaultPage?: number;
+    onPageChange?: (page: number) => void;
+    pageSize?: number;
+    showPagination?: boolean;
+    siblingCount?: number;
+    paginationSize?: DataTableSize;
+    infiniteScroll?: boolean;
+    initialVisibleRows?: number;
+    infiniteBatchSize?: number;
+    hasMore?: boolean;
+    loadingMore?: boolean;
+    onLoadMore?: () => void | Promise<void>;
+    scrollHeight?: number | string;
+    /** Подсветка строки при наведении (полупрозрачная смесь с фоном строки). */
+    highlightRowOnHover?: boolean;
+    /** Подсветка колонки под курсором (шапка + ячейки). */
+    highlightColumnOnHover?: boolean;
+    /** Чередование фона строк (зебра). */
+    striped?: boolean;
+};
+declare function DataTableRoot<Row>({ columns, rows, size, className, showHeader, stickyHeader, stickyFirstColumn, getRowKey, onRowClick, loading, loadingText, emptyText, dividerStyle, sort, defaultSort, onSortChange, page, defaultPage, onPageChange, pageSize, showPagination, siblingCount, paginationSize, infiniteScroll, initialVisibleRows, infiniteBatchSize, hasMore, loadingMore, onLoadMore, scrollHeight, highlightRowOnHover, highlightColumnOnHover, striped, }: DataTableRootProps<Row>): react_jsx_runtime.JSX.Element;
+declare namespace DataTableRoot {
+    var displayName: string;
+}
+declare const DataTable: {
+    Root: typeof DataTableRoot;
+};
+
+type TypographySize = "2xs" | "xs" | "s" | "m" | "l" | "xl" | "2xl" | "3xl" | "4xl" | "5xl" | "6xl";
+type TypographyWeight = "regular" | "medium" | "semibold";
+type TypographyTracking = "normal" | "tight" | "tighter" | "wide";
+type TypographyTone = "default" | "muted";
+type TypographyAs = "p" | "span" | "div";
+type TypographyRootProps = {
+    as?: TypographyAs;
+    size: TypographySize;
+    weight?: TypographyWeight;
+    tracking?: TypographyTracking;
+    italic?: boolean;
+    tone?: TypographyTone;
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLElement>;
+declare const Typography: {
+    Root: React.ForwardRefExoticComponent<{
+        as?: TypographyAs;
+        size: TypographySize;
+        weight?: TypographyWeight;
+        tracking?: TypographyTracking;
+        italic?: boolean;
+        tone?: TypographyTone;
+        children?: React.ReactNode;
+        className?: string;
+    } & React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
+};
+
+type ResponsiveMonthsBreakpoints = {
+    /** Минимальная ширина для двух колонок месяцев */
+    twoColumns: number;
+};
+
+type DatepickerSize = InputSize;
+/** Значение для `<input type="time" />` в локальном времени */
+declare function formatTimeInputValue(date: Date | undefined): string;
+/** Подставляет часы и минуты из строки `HH:mm` в дату */
+declare function mergeTimeIntoDate(date: Date, timeHHmm: string): Date;
+type DatepickerCalendarProps = DayPickerProps & {
+    /**
+     * Подстраивать `numberOfMonths` под ширину контейнера (1 / 2 колонки).
+     * Если `true`, проп `numberOfMonths` игнорируется.
+     */
+    responsiveMonths?: boolean;
+    /** Порог ширины для 2 колонок */
+    responsiveBreakpoints?: ResponsiveMonthsBreakpoints;
+    /** Размер календаря: влияет на кегль, ячейки и кнопки навигации */
+    size?: DatepickerSize;
+};
+declare function Calendar({ responsiveMonths, responsiveBreakpoints, numberOfMonths: numberOfMonthsProp, classNames: userClassNames, components: userComponents, style, weekStartsOn, navLayout, month: monthProp, onMonthChange, size: sizeProp, ...rest }: DatepickerCalendarProps): react_jsx_runtime.JSX.Element;
+declare namespace Calendar {
+    var displayName: string;
+}
+type DatepickerShellProps = {
+    children: React.ReactNode;
+    className?: string;
+    presets?: React.ReactNode;
+    /** Размер всей оболочки датпикера */
+    size?: DatepickerSize;
+};
+declare function Shell({ children, className, presets, size }: DatepickerShellProps): react_jsx_runtime.JSX.Element;
+declare namespace Shell {
+    var displayName: string;
+}
+type DatepickerPresetSingle = {
+    label: string;
+    date: Date | undefined;
+};
+type DatepickerPresetRange = {
+    label: string;
+    range: DateRange | undefined;
+};
+type DatepickerPresetsProps = {
+    className?: string;
+    title?: string;
+    size?: DatepickerSize;
+} & ({
+    mode: "single";
+    presets: DatepickerPresetSingle[];
+    onSelect: (date: Date | undefined) => void;
+} | {
+    mode: "range";
+    presets: DatepickerPresetRange[];
+    onSelect: (range: DateRange | undefined) => void;
+});
+declare function Presets(props: DatepickerPresetsProps): react_jsx_runtime.JSX.Element;
+declare namespace Presets {
+    var displayName: string;
+}
+type DatepickerTimeSingleProps = {
+    mode?: "single";
+    size?: DatepickerSize;
+    value: Date | undefined;
+    onChange: (next: Date) => void;
+    labels?: {
+        time?: string;
+    };
+};
+type DatepickerTimeRangeProps = {
+    mode: "range";
+    size?: DatepickerSize;
+    from: Date | undefined;
+    to: Date | undefined;
+    onFromChange: (next: Date) => void;
+    onToChange: (next: Date) => void;
+    labels?: {
+        from?: string;
+        to?: string;
+    };
+};
+type DatepickerTimeProps = DatepickerTimeSingleProps | DatepickerTimeRangeProps;
+declare function Time(props: DatepickerTimeProps): react_jsx_runtime.JSX.Element;
+declare namespace Time {
+    var displayName: string;
+}
+type DatepickerValueProps = Omit<TypographyRootProps, "size"> & {
+    size?: DatepickerSize;
+};
+declare function Value({ className, size: sizeProp, tone, ...rest }: DatepickerValueProps): react_jsx_runtime.JSX.Element;
+declare namespace Value {
+    var displayName: string;
+}
+declare const Datepicker: {
+    Calendar: typeof Calendar;
+    Shell: typeof Shell;
+    Presets: typeof Presets;
+    Time: typeof Time;
+    Value: typeof Value;
+};
+
+type DigitInputRootProps = {
+    length?: number;
+    size?: DigitInputSize;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    hasError?: boolean;
+    onComplete?: (value: string) => void;
+    className?: string;
+};
+declare function DigitInputRoot({ length: lengthProp, size, value: valueProp, defaultValue, onChange, disabled, hasError, onComplete, className, }: DigitInputRootProps): react_jsx_runtime.JSX.Element;
+declare namespace DigitInputRoot {
+    var displayName: string;
+}
+declare const DigitInput: {
+    Root: typeof DigitInputRoot;
+};
+
+type DividerOrientation = "horizontal" | "vertical";
+type DividerAlign = "start" | "center" | "end";
+/** `line-spacing` — маркер для линии между секциями (ритм соседей — через `gap` у flex-родителя); `text` — подпись секции. */
+type DividerVariant = "default" | "line-spacing" | "text";
+type DividerRootProps = {
+    orientation?: DividerOrientation;
+    align?: DividerAlign;
+    variant?: DividerVariant;
+    size?: DividerSize;
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare const Divider: {
+    Root: React.ForwardRefExoticComponent<{
+        orientation?: DividerOrientation;
+        align?: DividerAlign;
+        variant?: DividerVariant;
+        size?: DividerSize;
+        children?: React.ReactNode;
+        className?: string;
+    } & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+};
+
+type DrawerSide = "left" | "right" | "bottom" | "top";
+type DrawerRootProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    closeOnEscape?: boolean;
+    closeOnOverlayClick?: boolean;
+    children: React.ReactNode;
+};
+declare function DrawerRoot({ open, defaultOpen, onOpenChange, closeOnEscape, closeOnOverlayClick, children, }: DrawerRootProps): react_jsx_runtime.JSX.Element;
+type DrawerTriggerProps = {
+    children: React.ReactElement<{
+        onClick?: React.MouseEventHandler;
+    }>;
+};
+declare function DrawerTrigger({ children }: DrawerTriggerProps): React.ReactElement<{
+    onClick?: React.MouseEventHandler;
+}, string | React.JSXElementConstructor<any>>;
+type DrawerCloseProps = {
+    children: React.ReactElement<{
+        onClick?: React.MouseEventHandler;
+        className?: string;
+    }>;
+};
+declare function DrawerClose({ children }: DrawerCloseProps): React.ReactElement<{
+    onClick?: React.MouseEventHandler;
+    className?: string;
+}, string | React.JSXElementConstructor<any>>;
+type DrawerPortalProps = {
+    children: React.ReactNode;
+    container?: HTMLElement | null;
+};
+declare function DrawerPortal({ children, container }: DrawerPortalProps): react_jsx_runtime.JSX.Element | null;
+type DrawerOverlayProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DrawerOverlay({ className, onClick, ...rest }: DrawerOverlayProps): react_jsx_runtime.JSX.Element;
+type DrawerContentProps = React.HTMLAttributes<HTMLDivElement> & {
+    side?: DrawerSide;
+    size?: DrawerSize;
+    "aria-label"?: string;
+    "aria-labelledby"?: string;
+    "aria-describedby"?: string;
+};
+declare function DrawerContent({ children, className, side, size, "aria-label": ariaLabel, "aria-labelledby": ariaLabelledBy, "aria-describedby": ariaDescribedBy, ...rest }: DrawerContentProps): react_jsx_runtime.JSX.Element;
+type DrawerHeaderProps = React.HTMLAttributes<HTMLElement> & {
+    showCloseButton?: boolean;
+};
+declare function DrawerHeader({ children, className, showCloseButton, ...rest }: DrawerHeaderProps): react_jsx_runtime.JSX.Element;
+type DrawerTitleProps = React.HTMLAttributes<HTMLHeadingElement>;
+declare function DrawerTitle({ children, className, ...rest }: DrawerTitleProps): react_jsx_runtime.JSX.Element;
+type DrawerBodyProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DrawerBody({ children, className, ...rest }: DrawerBodyProps): react_jsx_runtime.JSX.Element;
+type DrawerFooterProps = React.HTMLAttributes<HTMLElement>;
+declare function DrawerFooter({ children, className, ...rest }: DrawerFooterProps): react_jsx_runtime.JSX.Element;
+declare const Drawer: {
+    Root: typeof DrawerRoot;
+    Trigger: typeof DrawerTrigger;
+    Close: typeof DrawerClose;
+    Portal: typeof DrawerPortal;
+    Overlay: typeof DrawerOverlay;
+    Content: typeof DrawerContent;
+    Header: typeof DrawerHeader;
+    Title: typeof DrawerTitle;
+    Body: typeof DrawerBody;
+    Footer: typeof DrawerFooter;
+};
+
+type PositionSide = "bottom" | "top";
+type PositionAlign = "start" | "center" | "end";
+
+type DropdownRootProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+};
+declare function DropdownRoot({ open, defaultOpen, onOpenChange, children }: DropdownRootProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownRoot {
+    var displayName: string;
+}
+type DropdownTriggerProps = {
+    children: React.ReactElement;
+    asChild?: boolean;
+};
+declare function DropdownTrigger({ children, asChild: _asChild }: DropdownTriggerProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare namespace DropdownTrigger {
+    var displayName: string;
+}
+type DropdownContentProps = {
+    align?: PositionAlign;
+    side?: PositionSide;
+    sameMinWidthAsTrigger?: boolean;
+    size?: DropdownSize;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function DropdownContent({ align, side, sameMinWidthAsTrigger, size, children, className, }: DropdownContentProps): react_jsx_runtime.JSX.Element | null;
+declare namespace DropdownContent {
+    var displayName: string;
+}
+type DropdownItemProps = {
+    onSelect?: () => void;
+    disabled?: boolean;
+    destructive?: boolean;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function DropdownItem({ onSelect, disabled, destructive, children, className }: DropdownItemProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownItem {
+    var displayName: string;
+}
+type DropdownItemIconProps = {
+    as?: React.ElementType;
+    className?: string;
+    children?: React.ReactNode;
+} & Record<string, unknown>;
+type DropdownGroupProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DropdownGroup({ className, ...rest }: DropdownGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownGroup {
+    var displayName: string;
+}
+type DropdownGroupLabelProps = {
+    children: React.ReactNode;
+    className?: string;
+};
+declare function DropdownGroupLabel({ children, className }: DropdownGroupLabelProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownGroupLabel {
+    var displayName: string;
+}
+type DropdownSeparatorProps = {
+    className?: string;
+};
+declare function DropdownSeparator({ className }: DropdownSeparatorProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownSeparator {
+    var displayName: string;
+}
+type DropdownBlockProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DropdownBlock({ className, ...rest }: DropdownBlockProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownBlock {
+    var displayName: string;
+}
+type DropdownHeaderProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DropdownHeader({ className, ...rest }: DropdownHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownHeader {
+    var displayName: string;
+}
+type DropdownHeaderRowProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DropdownHeaderRow({ className, ...rest }: DropdownHeaderRowProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownHeaderRow {
+    var displayName: string;
+}
+type DropdownHeaderLeadingProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DropdownHeaderLeading({ className, ...rest }: DropdownHeaderLeadingProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownHeaderLeading {
+    var displayName: string;
+}
+type DropdownHeaderMainProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DropdownHeaderMain({ className, ...rest }: DropdownHeaderMainProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownHeaderMain {
+    var displayName: string;
+}
+type DropdownHeaderTitleProps = React.HTMLAttributes<HTMLDivElement>;
+declare function DropdownHeaderTitle({ className, ...rest }: DropdownHeaderTitleProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownHeaderTitle {
+    var displayName: string;
+}
+type DropdownHeaderDescriptionProps = React.HTMLAttributes<HTMLDivElement> & {
+    truncate?: boolean;
+};
+declare function DropdownHeaderDescription({ className, truncate, ...rest }: DropdownHeaderDescriptionProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownHeaderDescription {
+    var displayName: string;
+}
+type DropdownHeaderTrailingProps = React.HTMLAttributes<HTMLDivElement> & {
+    alignSelf?: "start" | "center";
+};
+declare function DropdownHeaderTrailing({ className, alignSelf, ...rest }: DropdownHeaderTrailingProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownHeaderTrailing {
+    var displayName: string;
+}
+type DropdownInsetPadding = "none" | "x1" | "x2" | "x3";
+type DropdownInsetGap = "none" | "x2" | "x3" | "x4";
+type DropdownInsetProps = React.HTMLAttributes<HTMLDivElement> & {
+    children: React.ReactNode;
+    /** Доп. отступы от внутреннего края `Dropdown.Content`. По умолчанию `x2`. */
+    padding?: DropdownInsetPadding;
+    /** Вертикальный зазор между прямыми дочерними блоками. По умолчанию `x3`. */
+    gap?: DropdownInsetGap;
+};
+declare function DropdownInset({ children, className, padding, gap, ...rest }: DropdownInsetProps): react_jsx_runtime.JSX.Element;
+declare namespace DropdownInset {
+    var displayName: string;
+}
+declare const Dropdown: {
+    Root: typeof DropdownRoot;
+    Trigger: typeof DropdownTrigger;
+    Content: typeof DropdownContent;
+    Inset: typeof DropdownInset;
+    Block: typeof DropdownBlock;
+    Header: typeof DropdownHeader;
+    HeaderRow: typeof DropdownHeaderRow;
+    HeaderLeading: typeof DropdownHeaderLeading;
+    HeaderMain: typeof DropdownHeaderMain;
+    HeaderTitle: typeof DropdownHeaderTitle;
+    HeaderDescription: typeof DropdownHeaderDescription;
+    HeaderTrailing: typeof DropdownHeaderTrailing;
+    Item: typeof DropdownItem;
+    ItemIcon: React.ForwardRefExoticComponent<Omit<DropdownItemIconProps, "ref"> & React.RefAttributes<HTMLElement>>;
+    Group: typeof DropdownGroup;
+    GroupLabel: typeof DropdownGroupLabel;
+    Separator: typeof DropdownSeparator;
+};
+
+type ExampleFrameViewport = "desktop" | "tablet" | "mobile";
+type ColorScheme = "light" | "dark";
+/** Раскладка содержимого превью — чтобы в сниппетах не оборачивать компоненты в div.stack/row. */
+type ExampleFramePreviewLayout = "default" | "stack" | "stack-center" | "stack-narrow" | "dense-stack" | "row" | "row-start" | "row-wrap";
+type ExampleFrameRootProps = {
+    /** Исходный текст для вкладки «Код» и для копирования (независимо от активной вкладки). */
+    code: string;
+    /** Зарезервировано под будущую мультиязычность; сейчас подсветка всегда TS/TSX (`CodeBlock`). */
+    language?: string;
+    children?: React.ReactNode;
+    className?: string;
+    /** Управляемая цветовая схема превью (light/dark). */
+    colorScheme?: ColorScheme;
+    defaultColorScheme?: ColorScheme;
+    onColorSchemeChange?: (scheme: ColorScheme) => void;
+    /** Управляемая ширина превью (desktop / tablet / mobile). */
+    viewport?: ExampleFrameViewport;
+    defaultViewport?: ExampleFrameViewport;
+    onViewportChange?: (v: ExampleFrameViewport) => void;
+    /** Показывать ли кнопку переключения light/dark в тулбаре. */
+    showThemeToggle?: boolean;
+    /** Вызывается после успешного копирования `code` в буфер. */
+    onCopy?: () => void;
+    /**
+     * Как выстроить детей внутри превью. По умолчанию — по центру (один блок).
+     * Для списков из нескольких компонентов используйте `stack` / `stack-center` / `row`.
+     */
+    previewLayout?: ExampleFramePreviewLayout;
+    /**
+     * Синхронизация с глобальным бренд-пресетом (например playground: `data-theme-preset` на `html`).
+     * Если задан только `data-theme` без пресета, на узле действует «голый» dark/light из theme-*.css —
+     * без оверлеев `[data-theme][data-theme-preset]` из playground, цвета превью расходятся с оболочкой.
+     */
+    themePreset?: string;
+};
+declare function ExampleFrameRoot({ code, language, children, className, colorScheme: colorSchemeProp, defaultColorScheme, onColorSchemeChange, viewport: viewportProp, defaultViewport, onViewportChange, showThemeToggle, onCopy, previewLayout, themePreset, }: ExampleFrameRootProps): react_jsx_runtime.JSX.Element;
+declare namespace ExampleFrameRoot {
+    var displayName: string;
+}
+type ExampleFrameStageProps = {
+    children: React.ReactNode;
+};
+declare function ExampleFrameStage({ children }: ExampleFrameStageProps): react_jsx_runtime.JSX.Element;
+declare namespace ExampleFrameStage {
+    var displayName: string;
+}
+declare const ExampleFrame: {
+    Root: typeof ExampleFrameRoot;
+    Stage: typeof ExampleFrameStage;
+};
+
+type FileUploadFormatBadgeColor = "gray" | "red" | "blue" | "green" | "orange" | "purple" | "sky" | "yellow";
+type FileUploadItemVariant = "default" | "error";
+/** `dashed` — дефолтная зона; `solid` — как в модалках Align (сплошная обводка, фон canvas → elevated при hover). */
+type FileUploadAppearance = "dashed" | "solid";
+type FileUploadIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function FileUploadIcon({ className, children, ...rest }: FileUploadIconProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadIcon {
+    var displayName: string;
+}
+type FileUploadTitleProps = React.HTMLAttributes<HTMLParagraphElement> & {
+    /** `muted` — как `text-sub-600` в Align (строка подсказки в модалке). */
+    tone?: "default" | "muted";
+};
+declare function FileUploadTitle({ className, children, tone, ...rest }: FileUploadTitleProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadTitle {
+    var displayName: string;
+}
+type FileUploadHintProps = React.HTMLAttributes<HTMLParagraphElement>;
+declare function FileUploadHint({ className, children, ...rest }: FileUploadHintProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadHint {
+    var displayName: string;
+}
+type FileUploadBrowseLabelProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function FileUploadBrowseLabel({ className, children, ...rest }: FileUploadBrowseLabelProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadBrowseLabel {
+    var displayName: string;
+}
+/** Кнопка «browse» внутри заголовка модалки (primary + underline, не открывает picker по клику сама по себе — навесьте `onClick`). */
+type FileUploadBrowseLinkProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+/** Обёртка для модалок: `pointer-events: none` + колонка; вложенные кнопки/ссылки с `pointer-events: auto`. */
+type FileUploadDropBodyProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadDropBody({ className, children, ...rest }: FileUploadDropBodyProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadDropBody {
+    var displayName: string;
+}
+/** Ряд чипов «My Device / Dropbox» — `pointer-events: auto`. */
+type FileUploadActionsRowProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadActionsRow({ className, children, ...rest }: FileUploadActionsRowProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadActionsRow {
+    var displayName: string;
+}
+/** Кнопка-источник внутри `Root` — останавливает всплытие к `label`, не открывает файловый диалог. */
+type FileUploadChipProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+type FileUploadChipLabelProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function FileUploadChipLabel({ className, children, ...rest }: FileUploadChipLabelProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadChipLabel {
+    var displayName: string;
+}
+type FileUploadFormatBadgeProps = {
+    format: string;
+    color?: FileUploadFormatBadgeColor;
+    className?: string;
+};
+declare function FileUploadFormatBadge({ format, color, className }: FileUploadFormatBadgeProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadFormatBadge {
+    var displayName: string;
+}
+type FileUploadItemProps = React.HTMLAttributes<HTMLDivElement> & {
+    variant?: FileUploadItemVariant;
+    /** Типографика, отступы, бейдж формата, прогресс и иконки статуса — из того же яруса, что контролы. */
+    size?: FileUploadSize;
+};
+declare function FileUploadItem({ className, variant, size, ...rest }: FileUploadItemProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItem {
+    var displayName: string;
+}
+type FileUploadItemRowProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadItemRow({ className, children, ...rest }: FileUploadItemRowProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemRow {
+    var displayName: string;
+}
+type FileUploadItemMainProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadItemMain({ className, children, ...rest }: FileUploadItemMainProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemMain {
+    var displayName: string;
+}
+/** Вертикальный стек внутри `ItemMain` (колонка ошибки: текст + «Try again»). */
+type FileUploadItemStackProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadItemStack({ className, children, ...rest }: FileUploadItemStackProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemStack {
+    var displayName: string;
+}
+/** Группа имени файла + мета-строки (`space-y-1`). */
+type FileUploadItemTextGroupProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadItemTextGroup({ className, children, ...rest }: FileUploadItemTextGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemTextGroup {
+    var displayName: string;
+}
+type FileUploadItemTryAgainProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+type FileUploadItemNameProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadItemName({ className, children, ...rest }: FileUploadItemNameProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemName {
+    var displayName: string;
+}
+type FileUploadItemMetaProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadItemMeta({ className, children, ...rest }: FileUploadItemMetaProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemMeta {
+    var displayName: string;
+}
+type FileUploadItemMetaSepProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function FileUploadItemMetaSep({ className, ...rest }: FileUploadItemMetaSepProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemMetaSep {
+    var displayName: string;
+}
+type FileUploadItemActionsProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadItemActions({ className, children, ...rest }: FileUploadItemActionsProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemActions {
+    var displayName: string;
+}
+type FileUploadItemFooterProps = React.HTMLAttributes<HTMLDivElement>;
+declare function FileUploadItemFooter({ className, children, ...rest }: FileUploadItemFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemFooter {
+    var displayName: string;
+}
+type FileUploadItemProgressProps = {
+    value?: number;
+    max?: number;
+    className?: string;
+    children?: React.ReactNode;
+};
+declare function FileUploadItemProgress({ value, max, className, children }: FileUploadItemProgressProps): react_jsx_runtime.JSX.Element;
+declare namespace FileUploadItemProgress {
+    var displayName: string;
+}
+type FileUploadRootProps = Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "children"> & {
+    size?: FileUploadSize;
+    appearance?: FileUploadAppearance;
+    /** Доступ к скрытому input (программный клик из модалки и т.п.). */
+    inputRef?: React.Ref<HTMLInputElement>;
+    accept?: string;
+    multiple?: boolean;
+    /** Блокирует выбор файлов и drag-and-drop. */
+    disabled?: boolean;
+    onFilesChange?: (files: File[]) => void;
+    children?: React.ReactNode;
+};
+declare const FileUpload: {
+    Root: React.ForwardRefExoticComponent<Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "children"> & {
+        size?: FileUploadSize;
+        appearance?: FileUploadAppearance;
+        /** Доступ к скрытому input (программный клик из модалки и т.п.). */
+        inputRef?: React.Ref<HTMLInputElement>;
+        accept?: string;
+        multiple?: boolean;
+        /** Блокирует выбор файлов и drag-and-drop. */
+        disabled?: boolean;
+        onFilesChange?: (files: File[]) => void;
+        children?: React.ReactNode;
+    } & React.RefAttributes<HTMLLabelElement>>;
+    Icon: typeof FileUploadIcon;
+    Title: typeof FileUploadTitle;
+    Hint: typeof FileUploadHint;
+    BrowseLabel: typeof FileUploadBrowseLabel;
+    BrowseLink: React.ForwardRefExoticComponent<FileUploadBrowseLinkProps & React.RefAttributes<HTMLButtonElement>>;
+    DropBody: typeof FileUploadDropBody;
+    ActionsRow: typeof FileUploadActionsRow;
+    Chip: React.ForwardRefExoticComponent<FileUploadChipProps & React.RefAttributes<HTMLButtonElement>>;
+    ChipLabel: typeof FileUploadChipLabel;
+    FormatBadge: typeof FileUploadFormatBadge;
+    Item: typeof FileUploadItem;
+    ItemRow: typeof FileUploadItemRow;
+    ItemMain: typeof FileUploadItemMain;
+    ItemStack: typeof FileUploadItemStack;
+    ItemTextGroup: typeof FileUploadItemTextGroup;
+    ItemTryAgain: React.ForwardRefExoticComponent<FileUploadItemTryAgainProps & React.RefAttributes<HTMLButtonElement>>;
+    ItemName: typeof FileUploadItemName;
+    ItemMeta: typeof FileUploadItemMeta;
+    ItemMetaSep: typeof FileUploadItemMetaSep;
+    ItemActions: typeof FileUploadItemActions;
+    ItemFooter: typeof FileUploadItemFooter;
+    ItemProgress: typeof FileUploadItemProgress;
+};
+
+type HintVariant = "default" | "error" | "disabled";
+
+type HintRootProps = {
+    size?: HintSize;
+    variant?: HintVariant;
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLParagraphElement>;
+declare function HintRoot({ className, size, variant, children, ...rest }: HintRootProps): react_jsx_runtime.JSX.Element;
+declare namespace HintRoot {
+    var displayName: string;
+}
+type HintIconProps = {
+    children: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLSpanElement>;
+declare function HintIcon({ className, children, ...rest }: HintIconProps): react_jsx_runtime.JSX.Element;
+declare namespace HintIcon {
+    var displayName: string;
+}
+declare const Hint: {
+    Root: typeof HintRoot;
+    Icon: typeof HintIcon;
+};
+
+type InputRootProps = {
+    size?: InputSize;
+    /** Mark the field as invalid visually and propagate aria-invalid to the input. */
+    hasError?: boolean;
+    label?: React.ReactNode;
+    optionalLabel?: React.ReactNode;
+    hint?: React.ReactNode;
+    /** Error message rendered below the field; also sets hasError=true. */
+    error?: React.ReactNode;
+    /** Explicit id for the underlying <input>; auto-generated if omitted. */
+    id?: string;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function InputRoot({ size, hasError: hasErrorProp, label, optionalLabel, hint, error, id, children, className, }: InputRootProps): react_jsx_runtime.JSX.Element;
+declare namespace InputRoot {
+    var displayName: string;
+}
+type InputWrapperProps = {
+    children: React.ReactNode;
+    className?: string;
+};
+declare function InputWrapper({ children, className }: InputWrapperProps): react_jsx_runtime.JSX.Element;
+declare namespace InputWrapper {
+    var displayName: string;
+}
+type InputFieldProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "size">;
+type InputIconProps = {
+    side: "start" | "end";
+    children: React.ReactNode;
+    className?: string;
+};
+declare function InputIcon({ side, children, className }: InputIconProps): react_jsx_runtime.JSX.Element;
+declare namespace InputIcon {
+    var displayName: string;
+}
+type InputAffixProps = {
+    side: "start" | "end";
+    children: React.ReactNode;
+    className?: string;
+};
+declare function InputAffix({ side, children, className }: InputAffixProps): react_jsx_runtime.JSX.Element;
+declare namespace InputAffix {
+    var displayName: string;
+}
+type InputInlineAffixProps = {
+    side: "start" | "end";
+    children: React.ReactNode;
+    className?: string;
+};
+declare function InputInlineAffix({ side, children, className }: InputInlineAffixProps): react_jsx_runtime.JSX.Element;
+declare namespace InputInlineAffix {
+    var displayName: string;
+}
+declare const Input: {
+    Root: typeof InputRoot;
+    Wrapper: typeof InputWrapper;
+    Field: React.ForwardRefExoticComponent<InputFieldProps & React.RefAttributes<HTMLInputElement>>;
+    Icon: typeof InputIcon;
+    Affix: typeof InputAffix;
+    InlineAffix: typeof InputInlineAffix;
+};
+
+declare const Kbd: {
+    Root: React.ForwardRefExoticComponent<Omit<React.HTMLAttributes<HTMLElement>, "size"> & {
+        children: React.ReactNode;
+        className?: string;
+        size?: KbdSize;
+    } & React.RefAttributes<HTMLElement>>;
+};
+
+type LabelRootProps = Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "size"> & {
+    disabled?: boolean;
+    size?: LabelSize;
+};
+declare function LabelIcon({ className, children, ...rest }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+declare namespace LabelIcon {
+    var displayName: string;
+}
+declare function LabelAsterisk({ className, children, ...rest }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+declare namespace LabelAsterisk {
+    var displayName: string;
+}
+declare function LabelSub({ className, children, ...rest }: React.HTMLAttributes<HTMLSpanElement>): react_jsx_runtime.JSX.Element;
+declare namespace LabelSub {
+    var displayName: string;
+}
+declare const Label: {
+    Root: React.ForwardRefExoticComponent<Omit<React.LabelHTMLAttributes<HTMLLabelElement>, "size"> & {
+        disabled?: boolean;
+        size?: LabelSize;
+    } & React.RefAttributes<HTMLLabelElement>>;
+    Icon: typeof LabelIcon;
+    Asterisk: typeof LabelAsterisk;
+    Sub: typeof LabelSub;
+};
+
+type LinkButtonRootProps = {
+    size?: LinkButtonSize;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+} & React.AnchorHTMLAttributes<HTMLAnchorElement>;
+declare const LinkButton: {
+    Root: React.ForwardRefExoticComponent<{
+        size?: LinkButtonSize;
+        disabled?: boolean;
+        children?: React.ReactNode;
+        className?: string;
+    } & React.AnchorHTMLAttributes<HTMLAnchorElement> & React.RefAttributes<HTMLAnchorElement>>;
+};
+
+type NotificationType = "success" | "error" | "warning" | "info";
+type NotificationSize = "s" | "m" | "l";
+type NotificationPosition = "top-left" | "top-center" | "top-right" | "bottom-left" | "bottom-center" | "bottom-right";
+type NotificationAction = {
+    label: string;
+    onClick: () => void;
+};
+type NotificationOptions = {
+    type: NotificationType;
+    title: string;
+    description?: string;
+    size?: NotificationSize;
+    position?: NotificationPosition;
+    duration?: number;
+    persistent?: boolean;
+    icon?: React.ReactNode;
+    badge?: string | number;
+    closable?: boolean;
+    action?: NotificationAction;
+};
+type NotificationRecord = NotificationOptions & {
+    id: string;
+    position: NotificationPosition;
+    size: NotificationSize;
+    duration: number;
+    persistent: boolean;
+    closable: boolean;
+    createdAt: number;
+};
+type NotificationCardProps = {
+    item: NotificationRecord;
+    className?: string;
+    paused: boolean;
+    onDismiss: (id: string) => void;
+    stackDepth?: number;
+    stackExpanded?: boolean;
+};
+declare function NotificationCard({ item, className, paused, onDismiss, stackDepth, stackExpanded, }: NotificationCardProps): react_jsx_runtime.JSX.Element;
+
+type NotificationProviderProps = {
+    children: React.ReactNode;
+    position?: NotificationPosition;
+    max?: number;
+};
+type StoreValue = {
+    items: NotificationRecord[];
+    notify: (options: NotificationOptions) => string;
+    dismiss: (id: string) => void;
+    dismissAll: () => void;
+};
+declare function NotificationProvider({ children, position, max, }: NotificationProviderProps): react_jsx_runtime.JSX.Element;
+declare function useNotifications(): Pick<StoreValue, "notify" | "dismiss" | "dismissAll">;
+declare function useNotificationStore(): StoreValue;
+
+/** Ограничение ширины текстового блока внутри колонки `main`. */
+type PageContentMaxWidth = "full" | "readable" | "wide";
+type PageContentRootProps = {
+    maxWidth?: PageContentMaxWidth;
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+type PageContentHeaderProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare function PageContentHeader({ className, children, ...rest }: PageContentHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace PageContentHeader {
+    var displayName: string;
+}
+type PageContentTitleProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLHeadingElement>;
+type PageContentDescriptionProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLParagraphElement>;
+type PageContentBodyProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+declare function PageContentBody({ className, children, ...rest }: PageContentBodyProps): react_jsx_runtime.JSX.Element;
+declare namespace PageContentBody {
+    var displayName: string;
+}
+declare const PageContent: {
+    Root: React.ForwardRefExoticComponent<{
+        maxWidth?: PageContentMaxWidth;
+        className?: string;
+        children?: React.ReactNode;
+    } & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+    Header: typeof PageContentHeader;
+    Title: React.ForwardRefExoticComponent<{
+        className?: string;
+        children?: React.ReactNode;
+    } & React.HTMLAttributes<HTMLHeadingElement> & React.RefAttributes<HTMLHeadingElement>>;
+    Description: React.ForwardRefExoticComponent<{
+        className?: string;
+        children?: React.ReactNode;
+    } & React.HTMLAttributes<HTMLParagraphElement> & React.RefAttributes<HTMLParagraphElement>>;
+    Body: typeof PageContentBody;
+};
+
+type PageShellRootProps = {
+    fillViewport?: boolean;
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLDivElement>;
+type PageShellNavAreaProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLElement>;
+declare function PageShellNavArea({ className, children, ...rest }: PageShellNavAreaProps): react_jsx_runtime.JSX.Element;
+declare namespace PageShellNavArea {
+    var displayName: string;
+}
+type PageShellContentAreaProps = {
+    className?: string;
+    children?: React.ReactNode;
+} & React.HTMLAttributes<HTMLElement>;
+declare const PageShell: {
+    Root: React.ForwardRefExoticComponent<{
+        fillViewport?: boolean;
+        className?: string;
+        children?: React.ReactNode;
+    } & React.HTMLAttributes<HTMLDivElement> & React.RefAttributes<HTMLDivElement>>;
+    NavArea: typeof PageShellNavArea;
+    ContentArea: React.ForwardRefExoticComponent<{
+        className?: string;
+        children?: React.ReactNode;
+    } & React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>>;
+};
+
+type PaginationRootProps = {
+    page: number;
+    totalPages: number;
+    onPageChange: (page: number) => void;
+    siblingCount?: number;
+    /** Размер кнопок страниц и стрелок; многоточие — тот же ярус `--prime-sys-size-control-*`. */
+    size?: PaginationSize;
+    className?: string;
+};
+declare function PaginationRoot({ page, totalPages, onPageChange, siblingCount, size, className, }: PaginationRootProps): react_jsx_runtime.JSX.Element | null;
+declare namespace PaginationRoot {
+    var displayName: string;
+}
+declare const Pagination: {
+    Root: typeof PaginationRoot;
+};
+
+type PopoverSize = DropdownSize;
+type PopoverRootProps = {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    children: React.ReactNode;
+};
+declare function PopoverRoot({ open, defaultOpen, onOpenChange, children }: PopoverRootProps): react_jsx_runtime.JSX.Element;
+declare namespace PopoverRoot {
+    var displayName: string;
+}
+type PopoverTriggerProps = {
+    children: React.ReactElement;
+    asChild?: boolean;
+};
+declare function PopoverTrigger({ children, asChild: _asChild }: PopoverTriggerProps): React.ReactElement<any, string | React.JSXElementConstructor<any>>;
+declare namespace PopoverTrigger {
+    var displayName: string;
+}
+type PopoverContentProps = {
+    align?: PositionAlign;
+    side?: PositionSide;
+    sameMinWidthAsTrigger?: boolean;
+    size?: PopoverSize;
+    trapFocus?: boolean;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function PopoverContent({ align, side, sameMinWidthAsTrigger, size, trapFocus, children, className, }: PopoverContentProps): react_jsx_runtime.JSX.Element | null;
+declare namespace PopoverContent {
+    var displayName: string;
+}
+type PopoverInsetPadding = "none" | "x1" | "x2" | "x3";
+type PopoverInsetGap = "none" | "x2" | "x3" | "x4";
+type PopoverInsetProps = React.HTMLAttributes<HTMLDivElement> & {
+    children: React.ReactNode;
+    /** Доп. отступы от внутреннего края `Popover.Content`. По умолчанию `x2`. */
+    padding?: PopoverInsetPadding;
+    /** Вертикальный зазор между прямыми дочерними блоками. По умолчанию `x3`. */
+    gap?: PopoverInsetGap;
+};
+declare function PopoverInset({ children, className, padding, gap, ...rest }: PopoverInsetProps): react_jsx_runtime.JSX.Element;
+declare namespace PopoverInset {
+    var displayName: string;
+}
+declare const Popover: {
+    Root: typeof PopoverRoot;
+    Trigger: typeof PopoverTrigger;
+    Content: typeof PopoverContent;
+    Inset: typeof PopoverInset;
+};
+
+type ProgressBarRootProps = {
+    value: number;
+    max?: number;
+    label?: string;
+    size?: ProgressBarSize;
+    className?: string;
+};
+declare const ProgressBar: {
+    Root: React.ForwardRefExoticComponent<ProgressBarRootProps & React.RefAttributes<HTMLProgressElement>>;
+};
+
+declare const pc: {
+    readonly s: {
+        readonly diameter: "2.5625rem";
+        readonly strokeWidth: "3";
+    };
+    readonly m: {
+        readonly diameter: "3.375rem";
+        readonly strokeWidth: "4";
+    };
+    readonly l: {
+        readonly diameter: "4.25rem";
+        readonly strokeWidth: "5";
+    };
+    readonly xl: {
+        readonly diameter: "5.125rem";
+        readonly strokeWidth: "6";
+    };
+};
+type ProgressCircleSize = keyof typeof pc;
+type ProgressCircleRootProps = {
+    value: number;
+    max?: number;
+    size?: ProgressCircleSize;
+    label?: string;
+    children?: React.ReactNode;
+    className?: string;
+};
+declare const ProgressCircle: {
+    Root: React.ForwardRefExoticComponent<ProgressCircleRootProps & React.RefAttributes<HTMLDivElement>>;
+};
+
+type RadioRootProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> & {
+    variant?: RadioVariant;
+    size?: RadioSize;
+};
+type RadioLabelProps = {
+    children?: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLLabelElement>, "htmlFor" | "size">;
+type RadioHintProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
+declare function RadioHint({ children, className, ...rest }: RadioHintProps): react_jsx_runtime.JSX.Element;
+declare namespace RadioHint {
+    var displayName: string;
+}
+type RadioErrorProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
+declare function RadioError({ children, className, ...rest }: RadioErrorProps): react_jsx_runtime.JSX.Element;
+declare namespace RadioError {
+    var displayName: string;
+}
+declare const Radio: {
+    Root: React.ForwardRefExoticComponent<Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size"> & {
+        variant?: RadioVariant;
+        size?: RadioSize;
+    } & React.RefAttributes<HTMLInputElement>>;
+    Label: React.ForwardRefExoticComponent<{
+        children?: React.ReactNode;
+        className?: string;
+    } & Omit<React.HTMLAttributes<HTMLLabelElement>, "size" | "htmlFor"> & React.RefAttributes<HTMLLabelElement>>;
+    Hint: typeof RadioHint;
+    Error: typeof RadioError;
+};
+
+type SegmentedControlRootProps = {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    disabled?: boolean;
+    size?: InputSize;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function SegmentedControlRoot({ value, defaultValue, onValueChange, disabled, size, children, className, }: SegmentedControlRootProps): react_jsx_runtime.JSX.Element;
+declare namespace SegmentedControlRoot {
+    var displayName: string;
+}
+type SegmentedControlItemProps = {
+    value: string;
+    disabled?: boolean;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function SegmentedControlItem({ value, disabled, children, className, }: SegmentedControlItemProps): react_jsx_runtime.JSX.Element;
+declare namespace SegmentedControlItem {
+    var displayName: string;
+}
+type SegmentedControlIconProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLSpanElement>, "children">;
+declare function SegmentedControlIcon({ children, className, ...rest }: SegmentedControlIconProps): react_jsx_runtime.JSX.Element;
+declare namespace SegmentedControlIcon {
+    var displayName: string;
+}
+declare const SegmentedControl: {
+    Root: typeof SegmentedControlRoot;
+    Item: typeof SegmentedControlItem;
+    Icon: typeof SegmentedControlIcon;
+};
+
+type SelectRootProps = {
+    size?: SelectSize;
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    disabled?: boolean;
+    placeholder?: string;
+    hasError?: boolean;
+    children: React.ReactNode;
+};
+declare function SelectRoot({ size, value, defaultValue, onChange, disabled, placeholder, hasError, children, }: SelectRootProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectRoot {
+    var displayName: string;
+}
+type SelectTriggerProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "id" | "type" | "role">;
+type SelectValueProps = {
+    className?: string;
+};
+declare function SelectValue({ className }: SelectValueProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectValue {
+    var displayName: string;
+}
+type SelectTriggerIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function SelectTriggerIcon({ className, children, ...rest }: SelectTriggerIconProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectTriggerIcon {
+    var displayName: string;
+}
+type SelectContentProps = {
+    className?: string;
+    children: React.ReactNode;
+};
+declare function SelectContent({ className, children }: SelectContentProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectContent {
+    var displayName: string;
+}
+type SelectItemIconProps = React.HTMLAttributes<HTMLSpanElement>;
+declare function SelectItemIcon({ className, children, ...rest }: SelectItemIconProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectItemIcon {
+    var displayName: string;
+}
+type SelectItemProps = {
+    value: string;
+    /** Explicit label for display in trigger; falls back to string children, then value */
+    label?: string;
+    disabled?: boolean;
+    className?: string;
+    children: React.ReactNode;
+};
+type SelectGroupProps = React.HTMLAttributes<HTMLDivElement>;
+declare function SelectGroup({ className, ...rest }: SelectGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectGroup {
+    var displayName: string;
+}
+type SelectGroupLabelProps = React.HTMLAttributes<HTMLDivElement>;
+declare function SelectGroupLabel({ className, ...rest }: SelectGroupLabelProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectGroupLabel {
+    var displayName: string;
+}
+type SelectSeparatorProps = React.HTMLAttributes<HTMLHRElement>;
+declare function SelectSeparator({ className, ...rest }: SelectSeparatorProps): react_jsx_runtime.JSX.Element;
+declare namespace SelectSeparator {
+    var displayName: string;
+}
+declare const Select: {
+    Root: typeof SelectRoot;
+    Trigger: React.ForwardRefExoticComponent<SelectTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+    Value: typeof SelectValue;
+    TriggerIcon: typeof SelectTriggerIcon;
+    Content: typeof SelectContent;
+    Item: React.ForwardRefExoticComponent<SelectItemProps & React.RefAttributes<HTMLDivElement>>;
+    ItemIcon: typeof SelectItemIcon;
+    Group: typeof SelectGroup;
+    GroupLabel: typeof SelectGroupLabel;
+    Separator: typeof SelectSeparator;
+};
+
+type SidebarVariant = "simple" | "double";
+type SidebarResponsive = boolean;
+type SidebarContextItem = {
+    id: string;
+    label: string;
+    icon: React.ReactNode;
+    tooltip?: React.ReactNode;
+    ariaLabel?: string;
+    disabled?: boolean;
+};
+type SidebarContextValue = {
+    size: SidebarSize;
+    variant: SidebarVariant;
+    setVariant: (next: SidebarVariant) => void;
+    activeSection: string | null;
+    setActiveSection: (id: string) => void;
+    open: boolean;
+    setOpen: (next: boolean) => void;
+    toggleOpen: () => void;
+};
+declare const useSidebarContext: () => SidebarContextValue;
+
+/**
+ * Собирает `to` для пунктов **панели** при `Sidebar.Root variant="double"`: префикс =
+ * `activeSection` из контекста (выбранный пункт `ContextBar`). Внутри `PanelSwitch` для
+ * каждого раздела рендерите свой `Menu` с `MenuRouterLink`, передавая либо полный `to`,
+ * либо короткий путь сюда — например `useSidebarNavTo("deals")` → `/crm/deals` при активном CRM.
+ *
+ * При `variant="simple"` или пока раздел не выбран — путь от корня: `/${pathWithinSection}`.
+ */
+declare function useSidebarNavTo(pathWithinSection: string): string;
+type SidebarRootProps = Omit<React.ComponentPropsWithoutRef<"aside">, "children"> & {
+    children: React.ReactNode;
+    size?: SidebarSize;
+    variant?: SidebarVariant;
+    defaultVariant?: SidebarVariant;
+    onVariantChange?: (variant: SidebarVariant) => void;
+    activeSection?: string;
+    defaultActiveSection?: string;
+    onActiveSectionChange?: (section: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    responsive?: SidebarResponsive;
+    /** Узкая ширина панели навигации (`--sb-panel-width`). */
+    panelWidth?: "compact";
+    /** Размещение в колонке навигации рядом с контентом (flex-слот). */
+    sidebarSlot?: "page-nav";
+};
+declare function SidebarRoot({ children, className, size, variant: variantProp, defaultVariant, onVariantChange, activeSection: activeSectionProp, defaultActiveSection, onActiveSectionChange, open: openProp, defaultOpen, onOpenChange, responsive, panelWidth, sidebarSlot, "aria-label": ariaLabel, ...rest }: SidebarRootProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarRoot {
+    var displayName: string;
+}
+type SidebarContextBarProps = React.ComponentPropsWithoutRef<"nav"> & {
+    items?: SidebarContextItem[];
+    activeSection?: string | null;
+    onSelectSection?: (sectionId: string) => void;
+    logo?: React.ReactNode;
+    footer?: React.ReactNode;
+};
+declare function SidebarContextBar({ className, items, activeSection: activeSectionProp, onSelectSection, logo, footer, children, ...rest }: SidebarContextBarProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarContextBar {
+    var displayName: string;
+}
+type SidebarContextBarHeaderProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarContextBarHeader({ className, ...rest }: SidebarContextBarHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarContextBarHeader {
+    var displayName: string;
+}
+type SidebarContextBarBodyProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarContextBarBody({ className, ...rest }: SidebarContextBarBodyProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarContextBarBody {
+    var displayName: string;
+}
+type SidebarContextBarFooterProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarContextBarFooter({ className, ...rest }: SidebarContextBarFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarContextBarFooter {
+    var displayName: string;
+}
+type SidebarContextItemButtonProps = React.ComponentPropsWithoutRef<"button"> & {
+    active?: boolean;
+    asChild?: boolean;
+};
+type SidebarNavPanelProps = React.ComponentPropsWithoutRef<"nav">;
+declare function SidebarNavPanel({ className, ...rest }: SidebarNavPanelProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarNavPanel {
+    var displayName: string;
+}
+type SidebarNavPanelBodyProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarNavPanelBody({ className, ...rest }: SidebarNavPanelBodyProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarNavPanelBody {
+    var displayName: string;
+}
+type SidebarNavDocTreeProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarNavDocTree({ className, ...rest }: SidebarNavDocTreeProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarNavDocTree {
+    var displayName: string;
+}
+type SidebarNavPanelHeadingProps = React.ComponentPropsWithoutRef<"h2">;
+declare function SidebarNavPanelHeading({ className, ...rest }: SidebarNavPanelHeadingProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarNavPanelHeading {
+    var displayName: string;
+}
+type SidebarNavCategoryProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarNavCategory({ className, ...rest }: SidebarNavCategoryProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarNavCategory {
+    var displayName: string;
+}
+type SidebarNavCategoryTriggerProps = React.ComponentPropsWithoutRef<"button">;
+type SidebarNavCategoryLabelProps = React.ComponentPropsWithoutRef<"span">;
+declare function SidebarNavCategoryLabel({ className, ...rest }: SidebarNavCategoryLabelProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarNavCategoryLabel {
+    var displayName: string;
+}
+type SidebarNavCategoryCountProps = React.ComponentPropsWithoutRef<"span">;
+declare function SidebarNavCategoryCount({ className, ...rest }: SidebarNavCategoryCountProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarNavCategoryCount {
+    var displayName: string;
+}
+type SidebarNavCategoryPanelProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarNavCategoryPanel({ className, ...rest }: SidebarNavCategoryPanelProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarNavCategoryPanel {
+    var displayName: string;
+}
+type SidebarPanelSwitchProps = React.ComponentPropsWithoutRef<"div"> & {
+    sections?: Record<string, React.ReactNode>;
+    renderSection?: (activeSection: string | null) => React.ReactNode;
+    fallback?: React.ReactNode;
+};
+declare function SidebarPanelSwitch({ className, sections, renderSection, fallback, ...rest }: SidebarPanelSwitchProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarPanelSwitch {
+    var displayName: string;
+}
+type SidebarHeaderProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarHeader({ className, ...rest }: SidebarHeaderProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarHeader {
+    var displayName: string;
+}
+type SidebarHeaderRowProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarHeaderRow({ className, ...rest }: SidebarHeaderRowProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarHeaderRow {
+    var displayName: string;
+}
+type SidebarHeaderMainProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarHeaderMain({ className, ...rest }: SidebarHeaderMainProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarHeaderMain {
+    var displayName: string;
+}
+type SidebarContentProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarContent({ className, ...rest }: SidebarContentProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarContent {
+    var displayName: string;
+}
+type SidebarFooterProps = React.ComponentPropsWithoutRef<"div"> & {
+    variant?: "plain" | "inset";
+};
+declare function SidebarFooter({ className, variant, ...rest }: SidebarFooterProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarFooter {
+    var displayName: string;
+}
+type SidebarIdentityButtonProps = Omit<React.ComponentPropsWithoutRef<"button">, "children"> & {
+    leading?: React.ReactNode;
+    title: React.ReactNode;
+    subtitle?: React.ReactNode;
+    trailing?: React.ReactNode;
+};
+type SidebarToggleButtonProps = React.ComponentPropsWithoutRef<"button"> & {
+    openLabel?: string;
+    closedLabel?: string;
+};
+type SidebarGroupProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarGroup({ className, ...rest }: SidebarGroupProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarGroup {
+    var displayName: string;
+}
+type SidebarGroupLabelProps = React.ComponentPropsWithoutRef<"div">;
+declare function SidebarGroupLabel({ className, ...rest }: SidebarGroupLabelProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarGroupLabel {
+    var displayName: string;
+}
+type SidebarMenuProps = React.ComponentPropsWithoutRef<"ul">;
+declare function SidebarMenu({ className, ...rest }: SidebarMenuProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarMenu {
+    var displayName: string;
+}
+type SidebarMenuItemProps = React.ComponentPropsWithoutRef<"li">;
+declare function SidebarMenuItem({ className, ...rest }: SidebarMenuItemProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarMenuItem {
+    var displayName: string;
+}
+type SidebarMenuButtonProps = React.ComponentPropsWithoutRef<"button"> & {
+    active?: boolean;
+    asChild?: boolean;
+};
+type SidebarMenuLinkProps = React.ComponentPropsWithoutRef<"a"> & {
+    active?: boolean;
+};
+type SidebarMenuRouterLinkProps = React.ComponentPropsWithoutRef<typeof NavLink>;
+type SidebarMenuActionProps = React.ComponentPropsWithoutRef<"button">;
+type SidebarMenuIconProps = React.ComponentPropsWithoutRef<"span">;
+declare function SidebarMenuIcon({ className, ...rest }: SidebarMenuIconProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarMenuIcon {
+    var displayName: string;
+}
+type SidebarMenuLabelProps = React.ComponentPropsWithoutRef<"span">;
+declare function SidebarMenuLabel({ className, ...rest }: SidebarMenuLabelProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarMenuLabel {
+    var displayName: string;
+}
+type SidebarMenuTrailingProps = React.ComponentPropsWithoutRef<"span">;
+declare function SidebarMenuTrailing({ className, ...rest }: SidebarMenuTrailingProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarMenuTrailing {
+    var displayName: string;
+}
+type SidebarTextProps = React.ComponentPropsWithoutRef<"span">;
+declare function SidebarText({ className, ...rest }: SidebarTextProps): react_jsx_runtime.JSX.Element;
+declare namespace SidebarText {
+    var displayName: string;
+}
+declare const Sidebar: {
+    Root: typeof SidebarRoot;
+    ContextBar: typeof SidebarContextBar;
+    ContextBarHeader: typeof SidebarContextBarHeader;
+    ContextBarBody: typeof SidebarContextBarBody;
+    ContextBarFooter: typeof SidebarContextBarFooter;
+    ContextItemButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+        active?: boolean;
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    NavPanel: typeof SidebarNavPanel;
+    NavPanelBody: typeof SidebarNavPanelBody;
+    NavDocTree: typeof SidebarNavDocTree;
+    NavPanelHeading: typeof SidebarNavPanelHeading;
+    NavCategory: typeof SidebarNavCategory;
+    NavCategoryTrigger: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    NavCategoryLabel: typeof SidebarNavCategoryLabel;
+    NavCategoryCount: typeof SidebarNavCategoryCount;
+    NavCategoryPanel: typeof SidebarNavCategoryPanel;
+    PanelSwitch: typeof SidebarPanelSwitch;
+    Header: typeof SidebarHeader;
+    HeaderRow: typeof SidebarHeaderRow;
+    HeaderMain: typeof SidebarHeaderMain;
+    Content: typeof SidebarContent;
+    Footer: typeof SidebarFooter;
+    IdentityButton: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref">, "children"> & {
+        leading?: React.ReactNode;
+        title: React.ReactNode;
+        subtitle?: React.ReactNode;
+        trailing?: React.ReactNode;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    ToggleButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+        openLabel?: string;
+        closedLabel?: string;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    Group: typeof SidebarGroup;
+    GroupLabel: typeof SidebarGroupLabel;
+    Menu: typeof SidebarMenu;
+    MenuItem: typeof SidebarMenuItem;
+    MenuButton: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & {
+        active?: boolean;
+        asChild?: boolean;
+    } & React.RefAttributes<HTMLButtonElement>>;
+    MenuLink: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.AnchorHTMLAttributes<HTMLAnchorElement>, HTMLAnchorElement>, "ref"> & {
+        active?: boolean;
+    } & React.RefAttributes<HTMLAnchorElement>>;
+    MenuRouterLink: React.ForwardRefExoticComponent<Omit<react_router.NavLinkProps & React.RefAttributes<HTMLAnchorElement>, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+    MenuAction: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+    MenuIcon: typeof SidebarMenuIcon;
+    MenuLabel: typeof SidebarMenuLabel;
+    MenuTrailing: typeof SidebarMenuTrailing;
+    Text: typeof SidebarText;
+};
+
+type SliderRootProps = {
+    value?: number;
+    defaultValue?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    disabled?: boolean;
+    onChange?: (value: number) => void;
+    label?: string;
+    size?: SliderSize;
+    className?: string;
+    "aria-label"?: string;
+};
+declare function SliderRoot({ value: valueProp, defaultValue, min: minProp, max: maxProp, step: stepProp, disabled, onChange, label, size, className, "aria-label": ariaLabel, }: SliderRootProps): react_jsx_runtime.JSX.Element;
+declare namespace SliderRoot {
+    var displayName: string;
+}
+declare const Slider: {
+    Root: typeof SliderRoot;
+};
+
+type IconTone = "default" | "subtle" | "accent" | "danger";
+type IconSize = "s" | "m" | "l" | "xl";
+type BaseIconProps = Omit<LucideProps, "size" | "color"> & {
+    size?: IconSize;
+    tone?: IconTone;
+};
+
+declare const IconCheck: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconChevronRight: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconCircleDot: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconNavItemDot: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconClose: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconCloudUpload: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconCopy: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconDownload: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconMail: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconEye: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconEyeOff: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconHouse: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconLayoutGrid: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconLock: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconMoon: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const IconSun: React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+declare const iconRegistry: {
+    readonly "nav.chevronRight": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "nav.home": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "nav.itemDot": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "nav.layoutGrid": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "action.close": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "action.copy": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "action.upload": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "field.email": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "field.password.show": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "field.password.hide": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "status.locked": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "theme.dark": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+    readonly "theme.light": React.ForwardRefExoticComponent<Omit<BaseIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+};
+type IconName = keyof typeof iconRegistry;
+type NamedIconProps = BaseIconProps & {
+    name: IconName;
+};
+declare const Icon: React.ForwardRefExoticComponent<Omit<NamedIconProps, "ref"> & React.RefAttributes<SVGSVGElement>>;
+
+/** Состояние шага в примитивных степперах: `default` соответствует ожиданию до активации (аналог «pending» у высокоуровневого Stepper). */
+type StepperAlignItemState = "completed" | "active" | "default";
+
+type HorizontalStepperRootProps = React.HTMLAttributes<HTMLDivElement> & {
+    size?: StepperSize;
+};
+declare function HorizontalStepperRoot({ className, size, children, ...rest }: HorizontalStepperRootProps): react_jsx_runtime.JSX.Element;
+declare namespace HorizontalStepperRoot {
+    var displayName: string;
+}
+type HorizontalStepperSeparatorIconProps<T extends React.ElementType = typeof IconChevronRight> = {
+    as?: T;
+    className?: string;
+} & Omit<React.ComponentPropsWithoutRef<T>, "as" | "className">;
+declare function HorizontalStepperSeparatorIcon<T extends React.ElementType = typeof IconChevronRight>({ as, className, ...rest }: HorizontalStepperSeparatorIconProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace HorizontalStepperSeparatorIcon {
+    var displayName: string;
+}
+type HorizontalStepperItemProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type"> & {
+    state?: StepperAlignItemState;
+    type?: "button" | "submit" | "reset";
+};
+type HorizontalStepperItemIndicatorProps = React.HTMLAttributes<HTMLDivElement> & {
+    state?: StepperAlignItemState;
+};
+declare function HorizontalStepperItemIndicator({ state: stateProp, className, children, ...rest }: HorizontalStepperItemIndicatorProps): react_jsx_runtime.JSX.Element;
+declare namespace HorizontalStepperItemIndicator {
+    var displayName: string;
+}
+declare const HorizontalStepper: {
+    Root: typeof HorizontalStepperRoot;
+    SeparatorIcon: typeof HorizontalStepperSeparatorIcon;
+    Item: React.ForwardRefExoticComponent<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type"> & {
+        state?: StepperAlignItemState;
+        type?: "button" | "submit" | "reset";
+    } & React.RefAttributes<HTMLButtonElement>>;
+    ItemIndicator: typeof HorizontalStepperItemIndicator;
+};
+
+type VerticalStepperRootProps = React.HTMLAttributes<HTMLDivElement> & {
+    size?: StepperSize;
+};
+declare function VerticalStepperRoot({ className, size, children, ...rest }: VerticalStepperRootProps): react_jsx_runtime.JSX.Element;
+declare namespace VerticalStepperRoot {
+    var displayName: string;
+}
+type VerticalStepperArrowProps<T extends React.ElementType = typeof IconChevronRight> = {
+    as?: T;
+    className?: string;
+} & Omit<React.ComponentPropsWithoutRef<T>, "as" | "className">;
+declare function VerticalStepperArrow<T extends React.ElementType = typeof IconChevronRight>({ as, className, ...rest }: VerticalStepperArrowProps<T>): react_jsx_runtime.JSX.Element;
+declare namespace VerticalStepperArrow {
+    var displayName: string;
+}
+type VerticalStepperItemProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type"> & {
+    state?: StepperAlignItemState;
+    type?: "button" | "submit" | "reset";
+};
+type VerticalStepperItemIndicatorProps = React.HTMLAttributes<HTMLDivElement> & {
+    state?: StepperAlignItemState;
+};
+declare function VerticalStepperItemIndicator({ state: stateProp, className, children, ...rest }: VerticalStepperItemIndicatorProps): react_jsx_runtime.JSX.Element;
+declare namespace VerticalStepperItemIndicator {
+    var displayName: string;
+}
+declare const VerticalStepper: {
+    Root: typeof VerticalStepperRoot;
+    Arrow: typeof VerticalStepperArrow;
+    Item: React.ForwardRefExoticComponent<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type"> & {
+        state?: StepperAlignItemState;
+        type?: "button" | "submit" | "reset";
+    } & React.RefAttributes<HTMLButtonElement>>;
+    ItemIndicator: typeof VerticalStepperItemIndicator;
+};
+
+type StepperOrientation = "horizontal" | "vertical";
+type StepStatus = "pending" | "active" | "completed" | "error";
+type StepperRootProps = {
+    orientation?: StepperOrientation;
+    currentStep?: number;
+    size?: StepperSize;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function StepperRoot({ orientation, currentStep, size, children, className, }: StepperRootProps): react_jsx_runtime.JSX.Element;
+declare namespace StepperRoot {
+    var displayName: string;
+}
+type StepperSeparatorIconProps = {
+    className?: string;
+};
+declare function StepperSeparatorIcon({ className }: StepperSeparatorIconProps): react_jsx_runtime.JSX.Element;
+declare namespace StepperSeparatorIcon {
+    var displayName: string;
+}
+type StepperArrowProps = {
+    className?: string;
+} & Omit<React.ComponentPropsWithoutRef<typeof VerticalStepper.Arrow>, "className">;
+declare function StepperArrow({ className, ...rest }: StepperArrowProps): react_jsx_runtime.JSX.Element;
+declare namespace StepperArrow {
+    var displayName: string;
+}
+type StepperIndicatorProps = {
+    children?: React.ReactNode;
+    className?: string;
+};
+declare function StepperIndicator({ children, className }: StepperIndicatorProps): react_jsx_runtime.JSX.Element;
+declare namespace StepperIndicator {
+    var displayName: string;
+}
+type StepperContentProps = {
+    title: string;
+    description?: string;
+    className?: string;
+};
+declare function StepperContent({ title, description, className }: StepperContentProps): react_jsx_runtime.JSX.Element;
+declare namespace StepperContent {
+    var displayName: string;
+}
+type StepperStepProps = Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type"> & {
+    index?: number;
+    status?: StepStatus;
+    children: React.ReactNode;
+    type?: "button" | "submit" | "reset";
+};
+declare const Stepper: {
+    Root: typeof StepperRoot;
+    Step: React.ForwardRefExoticComponent<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type"> & {
+        index?: number;
+        status?: StepStatus;
+        children: React.ReactNode;
+        type?: "button" | "submit" | "reset";
+    } & React.RefAttributes<HTMLButtonElement>>;
+    Item: React.ForwardRefExoticComponent<Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, "type"> & {
+        index?: number;
+        status?: StepStatus;
+        children: React.ReactNode;
+        type?: "button" | "submit" | "reset";
+    } & React.RefAttributes<HTMLButtonElement>>;
+    Indicator: typeof StepperIndicator;
+    ItemIndicator: typeof StepperIndicator;
+    Content: typeof StepperContent;
+    SeparatorIcon: typeof StepperSeparatorIcon;
+    Arrow: typeof StepperArrow;
+};
+
+type SwitchRootProps = Omit<React.InputHTMLAttributes<HTMLInputElement>, "type" | "size" | "checked" | "defaultChecked" | "onChange"> & {
+    label?: React.ReactNode;
+    checked?: boolean;
+    defaultChecked?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    variant?: SwitchVariant;
+    size?: SwitchSize;
+};
+type SwitchLabelProps = {
+    children?: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLLabelElement>, "htmlFor" | "size">;
+type SwitchHintProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
+declare function SwitchHint({ children, className, ...rest }: SwitchHintProps): react_jsx_runtime.JSX.Element;
+declare namespace SwitchHint {
+    var displayName: string;
+}
+type SwitchErrorProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
+declare function SwitchError({ children, className, ...rest }: SwitchErrorProps): react_jsx_runtime.JSX.Element;
+declare namespace SwitchError {
+    var displayName: string;
+}
+declare const Switch: {
+    Root: React.ForwardRefExoticComponent<Omit<React.InputHTMLAttributes<HTMLInputElement>, "checked" | "defaultChecked" | "onChange" | "type" | "size"> & {
+        label?: React.ReactNode;
+        checked?: boolean;
+        defaultChecked?: boolean;
+        onCheckedChange?: (checked: boolean) => void;
+        variant?: SwitchVariant;
+        size?: SwitchSize;
+    } & React.RefAttributes<HTMLInputElement>>;
+    Label: React.ForwardRefExoticComponent<{
+        children?: React.ReactNode;
+        className?: string;
+    } & Omit<React.HTMLAttributes<HTMLLabelElement>, "size" | "htmlFor"> & React.RefAttributes<HTMLLabelElement>>;
+    Hint: typeof SwitchHint;
+    Error: typeof SwitchError;
+};
+
+type TabsOrientation = "horizontal" | "vertical";
+
+type TabsRootProps = {
+    value?: string;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    orientation?: TabsOrientation;
+    size?: TabsSize;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function TabsRoot({ value, defaultValue, onValueChange, orientation, size, children, className, }: TabsRootProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsRoot {
+    var displayName: string;
+}
+type TabsListProps = {
+    children: React.ReactNode;
+    className?: string;
+};
+declare function TabsList({ children, className }: TabsListProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsList {
+    var displayName: string;
+}
+type TabsTabProps = {
+    value: string;
+    disabled?: boolean;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function TabsTab({ value, disabled, children, className }: TabsTabProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsTab {
+    var displayName: string;
+}
+type TabsIconProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLSpanElement>, "children">;
+declare function TabsIcon({ children, className, ...rest }: TabsIconProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsIcon {
+    var displayName: string;
+}
+type TabsLabelProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLSpanElement>, "children">;
+declare function TabsLabel({ children, className, ...rest }: TabsLabelProps): react_jsx_runtime.JSX.Element;
+declare namespace TabsLabel {
+    var displayName: string;
+}
+type TabsPanelProps = {
+    value: string;
+    children: React.ReactNode;
+    className?: string;
+};
+declare function TabsPanel({ value, children, className }: TabsPanelProps): react_jsx_runtime.JSX.Element | null;
+declare namespace TabsPanel {
+    var displayName: string;
+}
+declare const Tabs: {
+    Root: typeof TabsRoot;
+    List: typeof TabsList;
+    Tab: typeof TabsTab;
+    Icon: typeof TabsIcon;
+    Label: typeof TabsLabel;
+    Panel: typeof TabsPanel;
+};
+
+type TagSize = "s" | "m" | "l" | "xl";
+type TagRootProps = {
+    size?: TagSize;
+    onRemove?: () => void;
+    disabled?: boolean;
+    children?: React.ReactNode;
+    className?: string;
+} & React.HTMLAttributes<HTMLSpanElement>;
+type TagIconProps = {
+    children: React.ReactNode;
+    className?: string;
+};
+declare function TagIcon({ children, className }: TagIconProps): react_jsx_runtime.JSX.Element;
+declare namespace TagIcon {
+    var displayName: string;
+}
+declare const Tag: {
+    Root: React.ForwardRefExoticComponent<{
+        size?: TagSize;
+        onRemove?: () => void;
+        disabled?: boolean;
+        children?: React.ReactNode;
+        className?: string;
+    } & React.HTMLAttributes<HTMLSpanElement> & React.RefAttributes<HTMLSpanElement>>;
+    Icon: typeof TagIcon;
+};
+
+type TextareaCharCounterProps = {
+    current: number;
+    max: number;
+};
+declare function TextareaCharCounter({ current, max }: TextareaCharCounterProps): react_jsx_runtime.JSX.Element;
+declare namespace TextareaCharCounter {
+    var displayName: string;
+}
+type TextareaRootProps = Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> & {
+    variant?: TextareaVariant;
+    size?: TextareaSize;
+    autoResize?: boolean;
+};
+type TextareaHintProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
+declare function TextareaHint({ children, className, ...rest }: TextareaHintProps): react_jsx_runtime.JSX.Element;
+declare namespace TextareaHint {
+    var displayName: string;
+}
+type TextareaErrorProps = {
+    children: React.ReactNode;
+    className?: string;
+} & Omit<React.HTMLAttributes<HTMLParagraphElement>, "id">;
+declare function TextareaError({ children, className, ...rest }: TextareaErrorProps): react_jsx_runtime.JSX.Element;
+declare namespace TextareaError {
+    var displayName: string;
+}
+declare const Textarea: {
+    Root: React.ForwardRefExoticComponent<Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, "size"> & {
+        variant?: TextareaVariant;
+        size?: TextareaSize;
+        autoResize?: boolean;
+    } & React.RefAttributes<HTMLTextAreaElement>>;
+    CharCounter: typeof TextareaCharCounter;
+    Hint: typeof TextareaHint;
+    Error: typeof TextareaError;
+};
+
+type TooltipSize = "s" | "m" | "l" | "xl";
+type TooltipSide = "top" | "bottom" | "left" | "right";
+type TooltipProviderProps = {
+    delayDuration?: number;
+    children: React.ReactNode;
+};
+declare function TooltipProvider({ delayDuration, children }: TooltipProviderProps): react_jsx_runtime.JSX.Element;
+declare namespace TooltipProvider {
+    var displayName: string;
+}
+type TooltipRootProps = {
+    children: React.ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+};
+declare function TooltipRoot({ children, open, defaultOpen, onOpenChange }: TooltipRootProps): react_jsx_runtime.JSX.Element;
+declare namespace TooltipRoot {
+    var displayName: string;
+}
+type TooltipTriggerProps = {
+    children: React.ReactElement;
+    className?: string;
+};
+declare function TooltipTrigger({ children, className }: TooltipTriggerProps): React.ReactElement<React.HTMLAttributes<HTMLElement> & React.RefAttributes<HTMLElement>, string | React.JSXElementConstructor<any>>;
+declare namespace TooltipTrigger {
+    var displayName: string;
+}
+type TooltipContentProps = {
+    children: React.ReactNode;
+    size?: TooltipSize;
+    side?: TooltipSide;
+    className?: string;
+};
+declare function TooltipContent({ children, size, side, className }: TooltipContentProps): react_jsx_runtime.JSX.Element | null;
+declare namespace TooltipContent {
+    var displayName: string;
+}
+declare const Tooltip: {
+    Provider: typeof TooltipProvider;
+    Root: typeof TooltipRoot;
+    Trigger: typeof TooltipTrigger;
+    Content: typeof TooltipContent;
+};
+
+export { validationStates as $, type AlertSize as A, Accordion, type AccordionArrowProps, type AccordionContentProps, type AccordionHeaderProps, type AccordionIconProps, type AccordionItemProps, type AccordionRootProps, type AccordionSize, type AccordionTriggerProps, type AccordionType, Avatar, type AvatarFallbackProps, type AvatarGroupOverflowProps, type AvatarGroupRootProps, type AvatarImageProps, type AvatarImageStatus, type AvatarRootProps, type AvatarSize, type BaseIconProps as B, Badge, type BadgeColor, type BadgeDotProps, type BadgeIconProps, type BadgeRootProps, type BadgeSize, type BadgeStatus, type BadgeVariant, Banner, type BannerActionsProps, type BannerCloseButtonProps, type BannerContentProps, type BannerDescriptionProps, type BannerIconProps, type BannerRootProps, type BannerSize, type BannerStatus, type BannerTitleProps, type BannerVariant, Breadcrumb, type BreadcrumbEllipsisProps, type BreadcrumbItemProps, type BreadcrumbRootProps, type BreadcrumbSeparatorProps, type BreadcrumbSize, Button, ButtonGroup, type ButtonGroupIconProps, type ButtonGroupItemProps, type ButtonGroupOrientation, type ButtonGroupRootProps, type ButtonGroupSize, type ButtonIconProps, type ButtonRootProps, type ButtonSpinnerProps, type CheckboxSize as C, Checkbox, type CheckboxErrorProps, type CheckboxHintProps, type CheckboxLabelProps, type CheckboxRootProps, CodeBlock, type CodeBlockColorScheme, type CodeBlockRootProps, ColorPicker, type ColorPickerFormatProviderProps, type ColorPickerHexInputProps, type ColorPickerRootProps, type ColorPickerTriggerSwatchProps, type ColorValueFormat, CommandMenu, type CommandMenuDialogProps, type ModalSize as CommandMenuDialogSize, type CommandMenuFooterKeyBoxProps, type CommandMenuFooterProps, type CommandMenuGroupProps, type CommandMenuInputProps, type CommandMenuInputRowProps, type CommandMenuItemIconProps, type CommandMenuItemProps, type CommandMenuItemSize, type CommandMenuListProps, type CommandMenuTagRowProps, type CommandMenuTagSectionLabelProps, type CommandMenuTagSectionProps, ControlSizeProvider, type ControlSizeProviderProps, type ControlSurfaceSize, type DisclosureState as D, DataTable, type DataTableCellAlign, type DataTableColumn, type DataTableDividerStyle, type DataTableOrder, type DataTableRootProps, type DataTableSize, type DataTableSortState, Datepicker, type DatepickerCalendarProps, type DatepickerPresetRange, type DatepickerPresetSingle, type DatepickerPresetsProps, type DatepickerShellProps, type DatepickerSize, type DatepickerTimeProps, type DatepickerTimeRangeProps, type DatepickerTimeSingleProps, type DatepickerValueProps, DigitInput, type DigitInputRootProps, type DigitInputSize, Divider, type DividerRootProps, type DividerSize, type DividerVariant, Drawer, type DrawerBodyProps, type DrawerCloseProps, type DrawerContentProps, type DrawerFooterProps, type DrawerHeaderProps, type DrawerOverlayProps, type DrawerPortalProps, type DrawerRootProps, type DrawerSide, type DrawerSize, type DrawerTitleProps, type DrawerTriggerProps, Dropdown, type DropdownBlockProps, type DropdownContentProps, type DropdownGroupLabelProps, type DropdownGroupProps, type DropdownHeaderDescriptionProps, type DropdownHeaderLeadingProps, type DropdownHeaderMainProps, type DropdownHeaderProps, type DropdownHeaderRowProps, type DropdownHeaderTitleProps, type DropdownHeaderTrailingProps, type DropdownInsetGap, type DropdownInsetPadding, type DropdownInsetProps, type DropdownItemIconProps, type DropdownItemProps, type DropdownRootProps, type DropdownSeparatorProps, type DropdownSize, type DropdownTriggerProps, type InteractionState as E, ExampleFrame, type ExampleFramePreviewLayout, type ExampleFrameRootProps, type ExampleFrameStageProps, type ExampleFrameViewport, type RadioVariant as F, FileUpload, type FileUploadActionsRowProps, type FileUploadAppearance, type FileUploadBrowseLabelProps, type FileUploadBrowseLinkProps, type FileUploadChipLabelProps, type FileUploadChipProps, type FileUploadDropBodyProps, type FileUploadFormatBadgeColor, type FileUploadFormatBadgeProps, type FileUploadHintProps, type FileUploadIconProps, type FileUploadItemActionsProps, type FileUploadItemFooterProps, type FileUploadItemMainProps, type FileUploadItemMetaProps, type FileUploadItemMetaSepProps, type FileUploadItemNameProps, type FileUploadItemProgressProps, type FileUploadItemProps, type FileUploadItemRowProps, type FileUploadItemStackProps, type FileUploadItemTextGroupProps, type FileUploadItemTryAgainProps, type FileUploadItemVariant, type FileUploadRootProps, type FileUploadSize, type FileUploadTitleProps, type SelectVariant as G, type SelectionState as H, Hint, type HintRootProps, type HintSize, HorizontalStepper, type HorizontalStepperItemIndicatorProps, type HorizontalStepperItemProps, type HorizontalStepperRootProps, type HorizontalStepperSeparatorIconProps, Icon as I, Input, type InputAffixProps, type InputFieldProps, type InputIconProps, type InputInlineAffixProps, type InputRootProps, type InputWrapperProps, type SwitchSize as J, type KbdSize as K, Kbd, type SwitchVariant as L, Label, type LabelRootProps, type LabelSize, LinkButton, type LinkButtonRootProps, type LinkButtonSize, type ModalVariant as M, Modal, type ModalBodyProps, type ModalCloseProps, type ModalContentProps, type ModalDescriptionProps, type ModalFooterProps, type ModalHeaderProps, type ModalOverlayProps, type ModalPortalProps, type ModalRootProps, type ModalSize, type ModalTitleProps, type ModalTriggerProps, type NamedIconProps as N, type NotificationAction, NotificationCard, type NotificationOptions, type NotificationPosition, NotificationProvider, type NotificationProviderProps, type NotificationRecord, type NotificationSize, type NotificationType, type TextareaVariant as O, asyncStates as P, PageContent, type PageContentBodyProps, type PageContentDescriptionProps, type PageContentHeaderProps, type PageContentMaxWidth, type PageContentRootProps, type PageContentTitleProps, PageShell, type PageShellContentAreaProps, type PageShellNavAreaProps, type PageShellRootProps, Pagination, type PaginationRootProps, type PaginationSize, Popover, type PopoverContentProps, type PopoverInsetGap, type PopoverInsetPadding, type PopoverInsetProps, type PopoverRootProps, type PopoverSize, type PopoverTriggerProps, ProgressBar, type ProgressBarRootProps, type ProgressBarSize, ProgressCircle, buttonModes as Q, type RadioSize as R, Radio, type RadioErrorProps, type RadioHintProps, type RadioLabelProps, type RadioRootProps, type SelectSize as S, SegmentedControl, type SegmentedControlItemProps, type SegmentedControlRootProps, Select, type SelectContentProps, type SelectGroupLabelProps, type SelectGroupProps, type SelectItemIconProps, type SelectItemProps, type SelectRootProps, type SelectSeparatorProps, type SelectTriggerIconProps, type SelectTriggerProps, type SelectValueProps, Sidebar, type SidebarContentProps, type SidebarContextBarBodyProps, type SidebarContextBarFooterProps, type SidebarContextBarHeaderProps, type SidebarContextBarProps, type SidebarContextItem, type SidebarContextItemButtonProps, type SidebarFooterProps, type SidebarGroupLabelProps, type SidebarGroupProps, type SidebarHeaderMainProps, type SidebarHeaderProps, type SidebarHeaderRowProps, type SidebarIdentityButtonProps, type SidebarMenuActionProps, type SidebarMenuButtonProps, type SidebarMenuIconProps, type SidebarMenuItemProps, type SidebarMenuLabelProps, type SidebarMenuLinkProps, type SidebarMenuProps, type SidebarMenuRouterLinkProps, type SidebarMenuTrailingProps, type SidebarNavCategoryCountProps, type SidebarNavCategoryLabelProps, type SidebarNavCategoryPanelProps, type SidebarNavCategoryProps, type SidebarNavCategoryTriggerProps, type SidebarNavDocTreeProps, type SidebarNavPanelBodyProps, type SidebarNavPanelHeadingProps, type SidebarNavPanelProps, type SidebarPanelSwitchProps, type SidebarResponsive, type SidebarRootProps, type SidebarSize, type SidebarTextProps, type SidebarToggleButtonProps, type SidebarVariant, Slider, type SliderRootProps, type SliderSize, type StepStatus, Stepper, type StepperAlignItemState, type StepperArrowProps, type StepperContentProps, type StepperIndicatorProps, type StepperOrientation, type StepperRootProps, type StepperSeparatorIconProps, type StepperSize, type StepperStepProps, Switch, type SwitchErrorProps, type SwitchHintProps, type SwitchLabelProps, type SwitchRootProps, type TextareaSize as T, Tabs, type TabsIconProps, type TabsLabelProps, type TabsListProps, type TabsOrientation, type TabsPanelProps, type TabsRootProps, type TabsSize, type TabsTabProps, Tag, type TagIconProps, type TagRootProps, type TagSize, Textarea, type TextareaCharCounterProps, type TextareaErrorProps, type TextareaHintProps, type TextareaRootProps, Tooltip, type TooltipContentProps, type TooltipProviderProps, type TooltipRootProps, type TooltipSide, type TooltipSize, type TooltipTriggerProps, Typography, type TypographyAs, type TypographyRootProps, type TypographySize, type TypographyTone, type TypographyTracking, type TypographyWeight, componentSizes as U, type ValidationState as V, VerticalStepper, type VerticalStepperArrowProps, type VerticalStepperItemIndicatorProps, type VerticalStepperItemProps, type VerticalStepperRootProps, componentVariants as W, disclosureStates as X, iconRegistry as Y, interactionStates as Z, selectionStates as _, type AsyncState as a, type ButtonMode as b, type ButtonSize as c, type ButtonVariant as d, type CheckboxVariant as e, IconCheck as f, formatTimeInputValue, IconChevronRight as g, IconCircleDot as h, IconClose as i, IconCloudUpload as j, IconCopy as k, IconDownload as l, IconEye as m, mergeTimeIntoDate, IconEyeOff as n, IconHouse as o, IconLayoutGrid as p, IconLock as q, IconMail as r, IconMoon as s, type IconName as t, IconNavItemDot as u, useNotificationStore, useNotifications, useOptionalControlSize, useSidebarContext, useSidebarNavTo, type IconSize as v, IconSun as w, type IconTone as x, type InputSize as y, type InputVariant as z };