themelia-react-ui 0.0.0-stage → 1.0.1

package/dist/components/primitives/money.d.ts

@@ -0,0 +1,79 @@
+import { type ComponentPropsWithoutRef, type ReactNode, type Ref } from 'react';
+import { type TextProps } from '../typography';
+import type { TextSize } from '../../lib/ui-provider';
+import { type MoneyDisplayMode, type MoneyFormatMode } from '../../lib/ui-provider';
+type SpanProps = Omit<ComponentPropsWithoutRef<'span'>, 'children' | 'color'>;
+export type MoneyUnit = 'major' | 'minor';
+export type MoneyLayout = 'inline' | 'stacked';
+export type MoneySecondaryEmphasis = 'discrete' | 'muted' | 'match' | 'hidden';
+/** A secondary monetary value rendered by the canonical `<Money>` primitive. */
+export interface MoneyValue {
+    /** Numeric amount or an unformatted decimal string. */
+    amount?: number | string | null;
+    /** ISO 4217 currency code. Falls back to `UIProvider.money.defaultCurrency`. */
+    currency?: string | null;
+    /** Unit of the incoming amount. `minor` converts cents/pence before formatting. */
+    unit?: MoneyUnit;
+    /** Number of minor units in one major unit. Defaults to 100. */
+    minorUnitScale?: number;
+    /** Optional consumer-resolved symbol. Intl placement is preserved. */
+    symbol?: string | null;
+    /** Intl currency label style when the resolved format mode uses currency formatting. */
+    currencyDisplay?: Intl.NumberFormatOptions['currencyDisplay'];
+    /** Minimum decimal digits. Defaults to the currency's Intl convention. */
+    minimumFractionDigits?: number;
+    /** Maximum decimal digits. Defaults to the currency's Intl convention. */
+    maximumFractionDigits?: number;
+    /** Per-value override for the UIProvider money format policy. */
+    formatMode?: MoneyFormatMode;
+}
+export interface MoneyProps extends SpanProps, MoneyValue {
+    /** Ref to the semantic root selected by `tag`. */
+    ref?: Ref<HTMLElement>;
+    /** BCP-47 locale override. Falls back to `UIProvider.formatting.locale`. */
+    locale?: string;
+    /** Content rendered when the amount is absent or cannot be parsed. */
+    emptyLabel?: ReactNode;
+    /** Typography size for both primary and secondary monetary values. */
+    size?: TextSize;
+    /** Inline text alignment. Defaults to right alignment for numeric scanning. */
+    align?: TextProps['align'];
+    /** Typography weight for the primary value. */
+    weight?: TextProps['weight'];
+    /** Primary or secondary semantic text tone. */
+    type?: TextProps['type'];
+    /** Semantic root element used by the typography primitive. */
+    tag?: TextProps['tag'];
+    /** Line-height preset applied to the root value. */
+    lineHeight?: TextProps['lineHeight'];
+    /** Applies the typography primitive's monospace numeric treatment. */
+    numeric?: TextProps['numeric'];
+    /**
+     * Optional converted/display value. Passing it is an explicit request to
+     * render both values unless `displayMode="default_only"` or
+     * `secondaryEmphasis="hidden"` is set.
+     */
+    secondary?: MoneyValue | null;
+    /**
+     * Controls whether the secondary value is visible. `dynamic` shows it only
+     * when the two currency codes differ. When omitted, an explicitly supplied
+     * `secondary` renders; an enabled UIProvider money policy can narrow it.
+     */
+    displayMode?: MoneyDisplayMode;
+    /** Pair layout. Falls back to the UIProvider `dualPricingDisplay` policy. */
+    layout?: MoneyLayout;
+    /** Visual prominence of a secondary value. */
+    secondaryEmphasis?: MoneySecondaryEmphasis;
+    /** Inline separator. Defaults to a quiet middle dot; pass an arrow for conversion flows. */
+    separator?: ReactNode;
+}
+/**
+ * Canonical monetary display primitive.
+ *
+ * It owns major/minor-unit conversion, locale-aware formatting, empty values,
+ * and optional inline/stacked dual-currency display. Consumers should use
+ * this component instead of composing separate money-display or currency-pair
+ * wrappers.
+ */
+export declare function Money({ amount, currency, unit, minorUnitScale, symbol, locale, currencyDisplay, minimumFractionDigits, maximumFractionDigits, formatMode, emptyLabel, size, align, weight, type, tag, lineHeight, numeric, secondary, displayMode, layout, secondaryEmphasis, separator, className, ref, ...props }: MoneyProps): import("react").JSX.Element;
+export {};

package/dist/components/primitives/name.d.ts

@@ -0,0 +1,16 @@
+import { type ReactNode } from 'react';
+import { type ValueProps } from './value';
+export interface NameFormatOptions {
+    /** Force title-casing even when the name already looks intentionally cased. */
+    force?: boolean;
+}
+export interface NameProps extends Omit<ValueProps, 'children'> {
+    /** Raw name value to normalize for display. */
+    value?: string | null;
+    /** String children are normalized when value is not provided. */
+    children?: ReactNode;
+    /** Force title-casing even when the name already looks intentionally cased. */
+    force?: boolean;
+}
+export declare function formatName(value: string | null | undefined, options?: NameFormatOptions): string;
+export declare function Name({ value, children, force, className, ref, ...props }: NameProps): import("react").JSX.Element;

package/dist/components/primitives/number.d.ts

@@ -0,0 +1,23 @@
+import { type ComponentPropsWithoutRef, type ReactNode, type Ref } from 'react';
+import { type TextProps } from '../typography';
+import type { TextSize } from '../../lib/ui-provider';
+type SpanProps = Omit<ComponentPropsWithoutRef<'span'>, 'children' | 'color'>;
+export interface NumberProps extends SpanProps {
+    value?: number | string | null;
+    locale?: string;
+    options?: Intl.NumberFormatOptions;
+    emptyLabel?: ReactNode;
+    size?: TextSize;
+    align?: TextProps['align'];
+    weight?: TextProps['weight'];
+    type?: TextProps['type'];
+    ref?: Ref<HTMLSpanElement>;
+}
+export interface PercentProps extends Omit<NumberProps, 'options'> {
+    scaled?: boolean;
+    options?: Intl.NumberFormatOptions;
+    ref?: Ref<HTMLSpanElement>;
+}
+export declare function Number({ value, locale, options, emptyLabel, size, align, weight, type, className, ref, ...props }: NumberProps): import("react").JSX.Element;
+export declare function Percent({ value, locale, scaled, options, emptyLabel, size, align, weight, type, className, ref, ...props }: PercentProps): import("react").JSX.Element;
+export {};

package/dist/components/primitives/value.d.ts

@@ -0,0 +1,23 @@
+import { type ComponentPropsWithoutRef, type ReactNode, type Ref } from 'react';
+import { type TextProps } from '../typography';
+import type { TextSize } from '../../lib/ui-provider';
+type SpanProps = Omit<ComponentPropsWithoutRef<'span'>, 'children' | 'color'>;
+export type ValueType = Extract<TextProps['type'], 'main' | 'secondary'>;
+export interface ValueProps extends SpanProps {
+    children?: ReactNode;
+    emptyLabel?: ReactNode;
+    size?: TextSize;
+    align?: TextProps['align'];
+    weight?: TextProps['weight'];
+    type?: ValueType;
+    ref?: Ref<HTMLSpanElement>;
+}
+export declare function Value({ children, emptyLabel, size, align, weight, type, className, ref, ...props }: ValueProps): import("react").JSX.Element;
+export declare function SecondaryValue({ children, emptyLabel, size, align, weight, type, className, ref, ...props }: ValueProps): import("react").JSX.Element;
+export declare function MutedValue({ children, emptyLabel, size, align, weight, type, className, ref, ...props }: ValueProps): import("react").JSX.Element;
+export declare function MonoValue({ children, emptyLabel, size, align, weight, type, className, ref, ...props }: ValueProps): import("react").JSX.Element;
+export interface EmptyValueProps extends Omit<ValueProps, 'emptyLabel'> {
+    ref?: Ref<HTMLSpanElement>;
+}
+export declare function EmptyValue({ children, size, align, weight, type, className, ref, ...props }: EmptyValueProps): import("react").JSX.Element;
+export {};

package/dist/components/typography/content-typography.d.ts

@@ -0,0 +1,4 @@
+/** Owned content rhythm; UI text roles remain free of surrounding spacing. */
+export declare const contentTypographyClassName = "themelia-content";
+/** Editable content shares the control inset and readable native text recipe. */
+export declare const editableContentClassName = "themelia-content font-sans text-sm leading-relaxed text-foreground px-control py-control-y-offset focus-visible:outline-none";

package/dist/components/typography/display-label.d.ts

@@ -0,0 +1,5 @@
+import { type TextProps } from './text';
+export interface DisplayLabelProps extends Omit<TextProps, 'size' | 'type' | 'weight' | 'lineHeight'> {
+    tone?: 'default' | 'inverse';
+}
+export declare function DisplayLabel({ tag, tone, className, ...props }: DisplayLabelProps): import("react").JSX.Element;

package/dist/components/typography/heading.d.ts

@@ -0,0 +1,16 @@
+import type { HTMLAttributes, ReactNode, Ref } from 'react';
+import type { TextSize } from '../../lib/ui-provider';
+import { textAlignments } from './text.styles';
+export type HeadingTag = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6';
+export interface HeadingProps extends HTMLAttributes<HTMLHeadingElement> {
+    ref?: Ref<HTMLHeadingElement>;
+    tag?: HeadingTag;
+    subHeading?: ReactNode;
+    subHeadingClassName?: string;
+    subHeadingSize?: TextSize;
+    containerClassName?: string;
+    align?: keyof typeof textAlignments;
+    divider?: boolean;
+}
+/** Semantic heading levels share Themelia's restrained admin heading scale. */
+export declare function Heading({ tag: Tag, subHeading, subHeadingClassName, subHeadingSize, containerClassName, align, divider, className, children, ref, ...props }: HeadingProps): import("react").JSX.Element;

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

@@ -0,0 +1,10 @@
+export { Text } from './text';
+export type { TextProps } from './text';
+export { Heading } from './heading';
+export type { HeadingProps, HeadingTag } from './heading';
+export { DisplayLabel } from './display-label';
+export type { DisplayLabelProps } from './display-label';
+export { Label } from './label';
+export type { LabelProps } from './label';
+export { TextLink } from './text-link';
+export type { TextLinkProps } from './text-link';

package/dist/components/typography/label.d.ts

@@ -0,0 +1,8 @@
+import type { LabelHTMLAttributes, ReactNode, Ref } from 'react';
+import type { ComponentScale } from '../../lib/component-vocabulary';
+export interface LabelProps extends Omit<LabelHTMLAttributes<HTMLLabelElement>, 'content'> {
+    content?: ReactNode;
+    size?: ComponentScale;
+    ref?: Ref<HTMLLabelElement>;
+}
+export declare function Label({ content, children, size, className, ref, ...props }: LabelProps): import("react").JSX.Element;

package/dist/components/typography/rich-text/index.d.ts

@@ -0,0 +1,2 @@
+export { RichText } from './rich-text';
+export type { RichTextProps } from './rich-text';

package/dist/components/typography/rich-text/rich-text.d.ts

@@ -0,0 +1,6 @@
+import type { TextProps } from '../text';
+export interface RichTextProps extends Omit<TextProps, 'children' | 'content' | 'dangerouslySetInnerHTML'> {
+    /** HTML sanitized through the package allowlist before rendering. */
+    html?: string | null;
+}
+export declare const RichText: import("react").ForwardRefExoticComponent<RichTextProps & import("react").RefAttributes<HTMLElement>>;

package/dist/components/typography/text-link.d.ts

@@ -0,0 +1,7 @@
+import type { AnchorHTMLAttributes, Ref } from 'react';
+import type { TextProps } from './text';
+export interface TextLinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'type'>, Pick<TextProps, 'type' | 'size' | 'weight' | 'align' | 'lineHeight'> {
+    underline?: boolean;
+    ref?: Ref<HTMLAnchorElement>;
+}
+export declare function TextLink({ type, size, weight, align, lineHeight, underline, className, ref, ...props }: TextLinkProps): import("react").JSX.Element;

package/dist/components/typography/text.d.ts

@@ -0,0 +1,17 @@
+import { type ComponentPropsWithoutRef, type ReactNode } from 'react';
+import { type TextSize } from '../../lib/ui-provider';
+import { type textTypes, type textWeights, type textAlignments, type textLineHeights } from './text.styles';
+export interface TextProps extends Omit<ComponentPropsWithoutRef<'p'>, 'children'> {
+    /** Plain text fallback; children take precedence, including zero and empty strings. */
+    content?: string;
+    children?: ReactNode;
+    type?: keyof typeof textTypes;
+    size?: TextSize;
+    weight?: keyof typeof textWeights;
+    align?: keyof typeof textAlignments;
+    lineHeight?: keyof typeof textLineHeights;
+    invert?: boolean;
+    numeric?: boolean;
+    tag?: 'div' | 'p' | 'span';
+}
+export declare const Text: import("react").ForwardRefExoticComponent<TextProps & import("react").RefAttributes<HTMLElement>>;

package/dist/components/typography/text.styles.d.ts

@@ -0,0 +1,50 @@
+export declare const textTypes: {
+    readonly main: "text-foreground";
+    readonly inverse: "text-inverse-foreground";
+    readonly secondary: "text-muted-foreground";
+    readonly discrete: "text-muted-foreground";
+    readonly error: "text-destructive";
+    readonly success: "text-success";
+    readonly primary: "text-primary-accent";
+};
+export declare const textSizes: {
+    readonly inherit: "[font-size:inherit]";
+    readonly xxs: "text-xxs";
+    readonly xs: "text-xs";
+    readonly pxs: "text-pxs";
+    readonly sm: "text-sm";
+    readonly base: "text-base";
+    readonly lg: "text-lg";
+    readonly xl: "text-xl";
+};
+export declare const textWeights: {
+    readonly normal: "font-normal";
+    readonly regular: "font-normal";
+    readonly medium: "font-medium";
+    readonly semibold: "font-semibold";
+    readonly bold: "font-bold";
+};
+export declare const textAlignments: {
+    readonly left: "text-left";
+    readonly center: "text-center";
+    readonly right: "text-right";
+};
+export declare const textLineHeights: {
+    readonly normal: "leading-normal";
+    readonly relaxed: "leading-relaxed";
+    readonly loose: "leading-loose";
+    readonly tight: "leading-tight";
+    readonly snug: "leading-snug";
+    readonly none: "leading-none";
+};
+export declare const textVariants: (props?: ({
+    type?: "primary" | "secondary" | "success" | "main" | "inverse" | "discrete" | "error" | null | undefined;
+    size?: "sm" | "lg" | "inherit" | "xxs" | "xs" | "pxs" | "base" | "xl" | null | undefined;
+    weight?: "bold" | "normal" | "medium" | "regular" | "semibold" | null | undefined;
+    align?: "center" | "left" | "right" | null | undefined;
+    lineHeight?: "none" | "normal" | "loose" | "relaxed" | "tight" | "snug" | null | undefined;
+    numeric?: boolean | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare function resolveTextClassNames(options: Parameters<typeof textVariants>[0] & {
+    className?: string;
+}): string;

package/dist/components/ui/accordion.d.ts

@@ -0,0 +1,6 @@
+import { Accordion as AccordionPrimitive } from "@base-ui/react/accordion";
+declare function Accordion({ className, ...props }: AccordionPrimitive.Root.Props): import("react").JSX.Element;
+declare function AccordionItem({ className, ...props }: AccordionPrimitive.Item.Props): import("react").JSX.Element;
+declare function AccordionTrigger({ className, children, ...props }: AccordionPrimitive.Trigger.Props): import("react").JSX.Element;
+declare function AccordionContent({ className, children, render, ...props }: AccordionPrimitive.Panel.Props): import("react").JSX.Element;
+export { Accordion, AccordionItem, AccordionTrigger, AccordionContent };

package/dist/components/ui/alert-dialog.d.ts

@@ -0,0 +1,21 @@
+import { type ThemePortalContainer } from '../../lib/theme-scope';
+import * as React from "react";
+import { AlertDialog as AlertDialogPrimitive } from "@base-ui/react/alert-dialog";
+import { Button } from "./button";
+declare function AlertDialog({ ...props }: AlertDialogPrimitive.Root.Props): React.JSX.Element;
+declare function AlertDialogTrigger({ ...props }: AlertDialogPrimitive.Trigger.Props): React.JSX.Element;
+declare function AlertDialogPortal({ container, ...props }: AlertDialogPrimitive.Portal.Props): React.JSX.Element;
+declare function AlertDialogOverlay({ className, ...props }: AlertDialogPrimitive.Backdrop.Props): React.JSX.Element;
+declare function AlertDialogContent({ className, container, size, ...props }: AlertDialogPrimitive.Popup.Props & {
+    size?: "default" | "sm";
+} & {
+    container?: ThemePortalContainer;
+}): React.JSX.Element;
+declare function AlertDialogHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogMedia({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AlertDialogTitle({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Title>): React.JSX.Element;
+declare function AlertDialogDescription({ className, ...props }: React.ComponentProps<typeof AlertDialogPrimitive.Description>): React.JSX.Element;
+declare function AlertDialogAction({ className, ...props }: React.ComponentProps<typeof Button>): React.JSX.Element;
+declare function AlertDialogCancel({ className, variant, size, ...props }: AlertDialogPrimitive.Close.Props & Pick<React.ComponentProps<typeof Button>, "variant" | "size">): React.JSX.Element;
+export { AlertDialog, AlertDialogAction, AlertDialogCancel, AlertDialogContent, AlertDialogDescription, AlertDialogFooter, AlertDialogHeader, AlertDialogMedia, AlertDialogOverlay, AlertDialogPortal, AlertDialogTitle, AlertDialogTrigger, };

package/dist/components/ui/avatar.d.ts

@@ -0,0 +1,11 @@
+import { Avatar as AvatarPrimitive } from "@base-ui/react/avatar";
+import * as React from "react";
+declare function Avatar({ className, size, ...props }: AvatarPrimitive.Root.Props & {
+    size?: "default" | "sm" | "lg";
+}): React.JSX.Element;
+declare function AvatarImage({ className, ...props }: AvatarPrimitive.Image.Props): React.JSX.Element;
+declare function AvatarFallback({ className, ...props }: AvatarPrimitive.Fallback.Props): React.JSX.Element;
+declare function AvatarBadge({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function AvatarGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function AvatarGroupCount({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { Avatar, AvatarImage, AvatarFallback, AvatarGroup, AvatarGroupCount, AvatarBadge, };

package/dist/components/ui/badge.d.ts

@@ -0,0 +1,5 @@
+import * as React from 'react';
+declare function Badge({ className, asChild, children, ...props }: React.ComponentProps<'span'> & {
+    asChild?: boolean;
+}): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export { Badge };

package/dist/components/ui/breadcrumb.d.ts

@@ -0,0 +1,11 @@
+import * as React from 'react';
+declare function Breadcrumb({ ...props }: React.ComponentProps<'nav'>): React.JSX.Element;
+declare function BreadcrumbList({ className, ...props }: React.ComponentProps<'ol'>): React.JSX.Element;
+declare function BreadcrumbItem({ className, ...props }: React.ComponentProps<'li'>): React.JSX.Element;
+declare function BreadcrumbLink({ asChild, className, ...props }: React.ComponentProps<'a'> & {
+    asChild?: boolean;
+}): React.JSX.Element;
+declare function BreadcrumbPage({ className, ...props }: React.ComponentProps<'span'>): React.JSX.Element;
+declare function BreadcrumbSeparator({ children, className, ...props }: React.ComponentProps<'li'>): React.JSX.Element;
+declare function BreadcrumbEllipsis({ className, ...props }: React.ComponentProps<'span'>): React.JSX.Element;
+export { Breadcrumb, BreadcrumbList, BreadcrumbItem, BreadcrumbLink, BreadcrumbPage, BreadcrumbSeparator, BreadcrumbEllipsis, };

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

@@ -0,0 +1,12 @@
+import { useRender } from "@base-ui/react/use-render";
+import * as React from "react";
+import { Separator } from "./separator";
+declare const buttonGroupVariants: ({ orientation }?: {
+    orientation?: "horizontal" | "vertical";
+}) => "button-group-vertical" | "button-group-horizontal";
+declare function ButtonGroup({ className, orientation, ...props }: React.ComponentProps<"div"> & {
+    orientation?: "horizontal" | "vertical";
+}): React.JSX.Element;
+declare function ButtonGroupText({ className, render, ...props }: useRender.ComponentProps<"div">): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+declare function ButtonGroupSeparator({ className, orientation, ...props }: React.ComponentProps<typeof Separator>): React.JSX.Element;
+export { ButtonGroup, ButtonGroupSeparator, ButtonGroupText, buttonGroupVariants, };

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

@@ -0,0 +1,12 @@
+import { Button as ButtonPrimitive } from '@base-ui/react/button';
+import { type VariantProps } from 'class-variance-authority';
+import * as React from 'react';
+/** Internal presentation only; public buttons own the stable tone/style API. */
+export declare const buttonVariants: (props?: ({
+    variant?: "secondary" | "destructive" | "default" | "outline" | "ghost" | "link" | null | undefined;
+    size?: "sm" | "lg" | "xs" | "default" | "icon" | "icon-sm" | "icon-lg" | "icon-xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+export declare namespace Button {
+    type Props = ButtonPrimitive.Props & VariantProps<typeof buttonVariants>;
+}
+export declare const Button: React.ForwardRefExoticComponent<Omit<Button.Props, "ref"> & React.RefAttributes<HTMLElement>>;

package/dist/components/ui/calendar.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+import { DayPicker, type DayButton, type Locale } from "react-day-picker";
+import { Button } from "./button";
+declare function Calendar({ className, classNames, showOutsideDays, captionLayout, buttonVariant, locale, formatters, components, ...props }: React.ComponentProps<typeof DayPicker> & {
+    buttonVariant?: React.ComponentProps<typeof Button>["variant"];
+}): React.JSX.Element;
+declare function CalendarDayButton({ className, day, modifiers, locale, ...props }: React.ComponentProps<typeof DayButton> & {
+    locale?: Partial<Locale>;
+}): React.JSX.Element;
+export { Calendar, CalendarDayButton };

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

@@ -0,0 +1,11 @@
+import * as React from "react";
+declare function Card({ className, size, ...props }: React.ComponentProps<"div"> & {
+    size?: "default" | "sm";
+}): React.JSX.Element;
+declare function CardHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardTitle({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardDescription({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardAction({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardContent({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function CardFooter({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+export { Card, CardHeader, CardFooter, CardTitle, CardAction, CardDescription, CardContent, };

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

@@ -0,0 +1,6 @@
+import { Checkbox as CheckboxPrimitive } from "@base-ui/react/checkbox";
+export interface CheckboxProps extends Omit<CheckboxPrimitive.Root.Props, 'onChange'> {
+    onCheckedChange?: (checked: boolean | 'indeterminate') => void;
+}
+declare function Checkbox({ className, onCheckedChange, ...props }: CheckboxProps): import("react").JSX.Element;
+export { Checkbox };

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

@@ -0,0 +1,9 @@
+import { Collapsible as CollapsiblePrimitive } from "@base-ui/react/collapsible";
+import * as React from "react";
+declare function Collapsible({ ...props }: CollapsiblePrimitive.Root.Props): React.JSX.Element;
+declare function CollapsibleTrigger({ asChild, nativeButton, render, children, ...props }: CollapsiblePrimitive.Trigger.Props & {
+    asChild?: boolean;
+    nativeButton?: boolean;
+}): React.JSX.Element;
+declare function CollapsibleContent({ className, render, ...props }: CollapsiblePrimitive.Panel.Props): React.JSX.Element;
+export { Collapsible, CollapsibleTrigger, CollapsibleContent };

package/dist/components/ui/combobox.d.ts

@@ -0,0 +1,40 @@
+import { Combobox as ComboboxPrimitive } from '@base-ui/react/combobox';
+import * as React from 'react';
+declare const Combobox: typeof ComboboxPrimitive.Root;
+declare function ComboboxInput({ className, ...props }: ComboboxPrimitive.Input.Props): React.JSX.Element;
+declare function ComboboxTrigger({ className, children, ...props }: ComboboxPrimitive.Trigger.Props): React.JSX.Element;
+declare function ComboboxValue({ placeholder, ...props }: ComboboxPrimitive.Value.Props & {
+    placeholder?: React.ReactNode;
+}): React.JSX.Element;
+declare function ComboboxClear({ className, ...props }: ComboboxPrimitive.Clear.Props): React.JSX.Element;
+export type ComboboxSize = 'sm' | 'md' | 'lg';
+type ComboboxInputTriggerProps = Omit<ComboboxPrimitive.Input.Props, 'size'> & {
+    showClear?: boolean;
+    size?: ComboboxSize;
+    error?: boolean;
+};
+declare function ComboboxInputTrigger({ className, showClear, size, error, ...props }: ComboboxInputTriggerProps): React.JSX.Element;
+declare function ComboboxPortal({ container, ...props }: ComboboxPrimitive.Portal.Props): React.JSX.Element;
+declare function ComboboxPositioner({ className, positionMethod, sideOffset, ...props }: ComboboxPrimitive.Positioner.Props): React.JSX.Element;
+declare function ComboboxPopup({ className, ...props }: ComboboxPrimitive.Popup.Props): React.JSX.Element;
+declare function ComboboxList({ className, ...props }: ComboboxPrimitive.List.Props): React.JSX.Element;
+declare function ComboboxItem({ className, children, size, ...props }: ComboboxPrimitive.Item.Props & {
+    size?: ComboboxSize;
+}): React.JSX.Element;
+declare function ComboboxItemIndicator({ className, children, ...props }: ComboboxPrimitive.ItemIndicator.Props): React.JSX.Element;
+declare function ComboboxEmpty({ className, children, ...props }: ComboboxPrimitive.Empty.Props): React.JSX.Element;
+declare function ComboboxStatus({ className, ...props }: ComboboxPrimitive.Status.Props): React.JSX.Element;
+declare function ComboboxGroup({ className, ...props }: ComboboxPrimitive.Group.Props): React.JSX.Element;
+declare function ComboboxGroupLabel({ className, ...props }: ComboboxPrimitive.GroupLabel.Props): React.JSX.Element;
+declare const ComboboxCollection: typeof ComboboxPrimitive.Collection;
+declare function ComboboxSeparator({ className, ...props }: ComboboxPrimitive.Separator.Props): React.JSX.Element;
+declare function ComboboxChips({ className, size, error, ...props }: React.ComponentPropsWithRef<typeof ComboboxPrimitive.Chips> & {
+    size?: ComboboxSize;
+    error?: boolean;
+}): React.JSX.Element;
+declare function ComboboxChip({ className, children, ...props }: ComboboxPrimitive.Chip.Props): React.JSX.Element;
+declare function ComboboxChipsInput({ className, ...props }: ComboboxPrimitive.Input.Props): React.JSX.Element;
+declare function ComboboxBackdrop({ className, ...props }: ComboboxPrimitive.Backdrop.Props): React.JSX.Element;
+declare function ComboboxArrow({ className, ...props }: ComboboxPrimitive.Arrow.Props): React.JSX.Element;
+declare const useComboboxFilter: typeof ComboboxPrimitive.useFilter;
+export { Combobox, ComboboxInput, ComboboxInputTrigger, ComboboxTrigger, ComboboxValue, ComboboxClear, ComboboxPortal, ComboboxPositioner, ComboboxPopup, ComboboxList, ComboboxItem, ComboboxItemIndicator, ComboboxEmpty, ComboboxStatus, ComboboxGroup, ComboboxGroupLabel, ComboboxCollection, ComboboxSeparator, ComboboxChips, ComboboxChip, ComboboxChipsInput, ComboboxBackdrop, ComboboxArrow, useComboboxFilter, };

package/dist/components/ui/command.d.ts

@@ -0,0 +1,50 @@
+import * as React from 'react';
+export type CommandFilter = (value: string, search: string, keywords?: string[]) => number;
+export type CommandProps = React.ComponentPropsWithRef<'div'> & {
+    asChild?: boolean;
+    label?: string;
+    shouldFilter?: boolean;
+    filter?: CommandFilter;
+    defaultValue?: string;
+    value?: string;
+    onValueChange?: (value: string) => void;
+    loop?: boolean;
+    disablePointerSelection?: boolean;
+    vimBindings?: boolean;
+};
+declare function Command({ children, className, asChild, label, shouldFilter, filter, value, defaultValue, onValueChange, loop, disablePointerSelection, vimBindings, ref, onKeyDown, onKeyDownCapture, ...props }: CommandProps): React.JSX.Element;
+type CommandInputProps = Omit<React.ComponentPropsWithRef<'input'>, 'value' | 'onChange' | 'type'> & {
+    value?: string;
+    onValueChange?: (value: string) => void;
+    asChild?: boolean;
+};
+declare function CommandInput({ className, value, onValueChange, asChild, children, ...props }: CommandInputProps): React.JSX.Element;
+declare function CommandList({ className, label, asChild, children, ...props }: React.ComponentPropsWithRef<'div'> & {
+    label?: string;
+    asChild?: boolean;
+}): React.JSX.Element;
+declare function CommandEmpty({ className, ...props }: React.ComponentPropsWithRef<'div'>): React.JSX.Element | null;
+declare function CommandGroup({ className, heading, value: _value, forceMount, children, asChild, ...props }: React.ComponentPropsWithRef<'div'> & {
+    heading?: React.ReactNode;
+    value?: string;
+    forceMount?: boolean;
+    asChild?: boolean;
+}): React.JSX.Element;
+type CommandItemProps = Omit<React.ComponentPropsWithRef<'div'>, 'onSelect' | 'children'> & {
+    children?: React.ReactNode | ((state: {
+        isHighlighted: boolean;
+    }) => React.ReactNode);
+    value?: string;
+    onSelect?: (value: string) => void;
+    keywords?: string[];
+    forceMount?: boolean;
+    disabled?: boolean;
+    asChild?: boolean;
+};
+declare function CommandItem({ className, children, value: valueProp, keywords, forceMount, disabled, onSelect, onClick, asChild, ref, ...props }: CommandItemProps): React.JSX.Element | null;
+declare function CommandSeparator({ className, alwaysRender, asChild, children, ...props }: React.ComponentPropsWithRef<'div'> & {
+    alwaysRender?: boolean;
+    asChild?: boolean;
+}): React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | null;
+declare function CommandShortcut({ className, ...props }: React.ComponentPropsWithRef<'span'>): React.JSX.Element;
+export { Command, CommandInput, CommandList, CommandEmpty, CommandGroup, CommandItem, CommandSeparator, CommandShortcut };

package/dist/components/ui/dialog.d.ts

@@ -0,0 +1,26 @@
+import { type ThemePortalContainer } from '../../lib/theme-scope';
+import { Dialog as DialogPrimitive } from "@base-ui/react/dialog";
+import * as React from "react";
+declare function Dialog({ ...props }: DialogPrimitive.Root.Props): React.JSX.Element;
+declare function DialogTrigger({ asChild, ...props }: DialogPrimitive.Trigger.Props & {
+    asChild?: boolean;
+}): React.JSX.Element;
+declare function DialogPortal({ container, ...props }: DialogPrimitive.Portal.Props): React.JSX.Element;
+declare function DialogClose({ ...props }: DialogPrimitive.Close.Props): React.JSX.Element;
+declare function DialogOverlay({ className, ...props }: DialogPrimitive.Backdrop.Props): React.JSX.Element;
+declare function DialogContent({ className, container, children, showCloseButton, ...props }: DialogPrimitive.Popup.Props & {
+    showCloseButton?: boolean;
+} & {
+    container?: ThemePortalContainer;
+}): React.JSX.Element;
+declare function DialogHeader({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare function DialogFooter({ className, showCloseButton, children, ...props }: React.ComponentProps<"div"> & {
+    showCloseButton?: boolean;
+}): React.JSX.Element;
+declare function DialogTitle({ className, asChild, ...props }: DialogPrimitive.Title.Props & {
+    asChild?: boolean;
+}): React.JSX.Element;
+declare function DialogDescription({ className, asChild, ...props }: DialogPrimitive.Description.Props & {
+    asChild?: boolean;
+}): React.JSX.Element;
+export { Dialog, DialogClose, DialogContent, DialogDescription, DialogFooter, DialogHeader, DialogOverlay, DialogPortal, DialogTitle, DialogTrigger, };

package/dist/components/ui/disclosure-panel.d.ts

@@ -0,0 +1,14 @@
+import * as React from 'react';
+import { useRender } from '@base-ui/react/use-render';
+type PanelState = {
+    open: boolean;
+    transitionStatus: string | undefined;
+};
+/** Keep the native panel and Base UI lifecycle; correct its collapsed-padding measurement. */
+export declare function DisclosurePanelElement<State extends PanelState>({ props, state, render, heightVariable, }: {
+    props: React.ComponentPropsWithRef<'div'>;
+    state: State;
+    render?: useRender.RenderProp<State>;
+    heightVariable: '--accordion-panel-height' | '--collapsible-panel-height';
+}): React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+export {};

package/dist/components/ui/empty.d.ts

@@ -0,0 +1,11 @@
+import { type VariantProps } from "class-variance-authority";
+declare function Empty({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare function EmptyHeader({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare const emptyMediaVariants: (props?: ({
+    variant?: "default" | "icon" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function EmptyMedia({ className, variant, ...props }: React.ComponentProps<"div"> & VariantProps<typeof emptyMediaVariants>): import("react").JSX.Element;
+declare function EmptyTitle({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+declare function EmptyDescription({ className, ...props }: React.ComponentProps<"p">): import("react").JSX.Element;
+declare function EmptyContent({ className, ...props }: React.ComponentProps<"div">): import("react").JSX.Element;
+export { Empty, EmptyHeader, EmptyTitle, EmptyDescription, EmptyContent, EmptyMedia, };

package/dist/components/ui/input-group.d.ts

@@ -0,0 +1,18 @@
+import { type VariantProps } from "class-variance-authority";
+import * as React from "react";
+import { Button } from "./button";
+declare function InputGroup({ className, ...props }: React.ComponentProps<"div">): React.JSX.Element;
+declare const inputGroupAddonVariants: (props?: ({
+    align?: "inline-end" | "inline-start" | "block-end" | "block-start" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupAddon({ className, align, ...props }: React.ComponentProps<"div"> & VariantProps<typeof inputGroupAddonVariants>): React.JSX.Element;
+declare const inputGroupButtonVariants: (props?: ({
+    size?: "sm" | "xs" | "icon-sm" | "icon-xs" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function InputGroupButton({ className, type, variant, size, ...props }: Omit<React.ComponentProps<typeof Button>, "size" | "type"> & VariantProps<typeof inputGroupButtonVariants> & {
+    type?: "button" | "submit" | "reset";
+}): React.JSX.Element;
+declare function InputGroupText({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+declare function InputGroupInput({ className, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+declare function InputGroupTextarea({ className, ...props }: React.ComponentProps<"textarea">): React.JSX.Element;
+export { InputGroup, InputGroupAddon, InputGroupButton, InputGroupText, InputGroupInput, InputGroupTextarea, };

package/dist/components/ui/input.d.ts

@@ -0,0 +1,3 @@
+import * as React from "react";
+declare function Input({ className, type, ...props }: React.ComponentProps<"input">): React.JSX.Element;
+export { Input };