ixia-ui-react 1.7.0 → 2.0.0

package/dist/index-BygR7cUT.d.ts

@@ -0,0 +1,22 @@
+import { VariantProps } from "class-variance-authority";
+import React, { ComponentProps } from "react";
+import { Slider } from "@base-ui/react";
+declare const sliderVariants: (props?: ({
+  size?: "large" | "medium" | "small" | null | undefined;
+  tone?: "accent" | "brand" | "error" | "info" | "neutral" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type SliderProps = ComponentProps<typeof Slider.Root> & VariantProps<typeof sliderVariants> & {
+  showIndicator?: boolean;
+  showThumbOnHover?: boolean;
+  showTooltip?: boolean;
+};
+type SliderThumbProps = ComponentProps<typeof Slider.Thumb> & {
+  hide?: boolean;
+};
+declare function Slider$2({ size, tone, defaultValue, min, max, step, showIndicator, showTooltip, showThumbOnHover, value, onValueChange, className, 'aria-label': ariaLabel, ref, ...props }: SliderProps): import("react").JSX.Element;
+declare function SliderThumb({ className, ref, hide, ...props }: SliderThumbProps): React.JSX.Element;
+declare const Slider$1: typeof Slider$2 & {
+  Thumb: typeof SliderThumb;
+};
+export { SliderThumbProps as i, SliderThumb as n, SliderProps as r, Slider$1 as t };
+//# sourceMappingURL=index-BygR7cUT.d.ts.map

package/dist/index-BzTOLSgZ.d.ts

@@ -0,0 +1,9 @@
+import { VariantProps } from "class-variance-authority";
+import React$1 from "react";
+declare const textAreaVariants: (props?: ({
+  variant?: "ghost" | "outline" | "primary" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type TextAreaProps = React.ComponentProps<'textarea'> & VariantProps<typeof textAreaVariants>;
+declare function TextArea({ variant, className, ref, ...props }: TextAreaProps): React$1.JSX.Element;
+export { TextAreaProps as n, TextArea as t };
+//# sourceMappingURL=index-BzTOLSgZ.d.ts.map

package/dist/index-C15xiG9O.d.ts

@@ -0,0 +1,14 @@
+import { VariantProps } from "class-variance-authority";
+import { Toggle, ToggleState } from "@base-ui/react";
+declare const toggleVariants: (props?: ({
+  size?: "large" | "medium" | "small" | null | undefined;
+  tone?: "accent" | "brand" | "error" | "info" | "neutral" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string, toggleGroupHoverVariants: (props?: ({
+  tone?: "accent" | "brand" | "error" | "info" | "neutral" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type ToggleProps = Omit<React.ComponentProps<typeof Toggle>, 'children'> & VariantProps<typeof toggleVariants> & {
+  children?: React.ReactNode | ((state: ToggleState) => React.ReactNode);
+};
+declare function Toggle$1({ size, tone, className, children, ref, ...props }: ToggleProps): import("react").JSX.Element;
+export { ToggleProps as n, Toggle$1 as t };
+//# sourceMappingURL=index-C15xiG9O.d.ts.map

package/dist/index-C2zco6-C.d.ts

@@ -0,0 +1,15 @@
+import { VariantProps } from "class-variance-authority";
+import React$1 from "react";
+import { Radio, RadioGroup } from "@base-ui/react";
+declare const radioVariants: (props?: ({
+  variant?: "elevated" | "inSurface" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type RadioProps = React.ComponentProps<typeof Radio.Root> & VariantProps<typeof radioVariants>;
+type RadioGroupProps = React.ComponentProps<typeof RadioGroup>;
+declare function Radio$1({ variant, className, children, ref, ...props }: RadioProps): import("react").JSX.Element;
+declare function RadioGroup$2({ className, ref, ...props }: RadioGroupProps): React$1.JSX.Element;
+declare const RadioGroup$1: typeof RadioGroup$2 & {
+  Radio: typeof Radio$1;
+};
+export { RadioProps as i, Radio$1 as n, RadioGroupProps as r, RadioGroup$1 as t };
+//# sourceMappingURL=index-C2zco6-C.d.ts.map

package/dist/index-CIDOd4Z8.d.ts

@@ -0,0 +1,56 @@
+import { VariantProps } from "class-variance-authority";
+import { ReactNode } from "react";
+import { Select } from "@base-ui/react/select";
+declare const selectVariants: (props?: ({
+  size?: "large" | "medium" | "small" | null | undefined;
+  variant?: "ghost" | "primary" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type SelectChangeEventDetails = NonNullable<React.ComponentProps<typeof Select.Root>['onValueChange']> extends ((value: never, details: infer Details) => void) ? Details : never;
+type SelectValue$1<Value, Multiple extends boolean | undefined> = Multiple extends true ? Value[] : Value;
+interface SelectProps<Value, Multiple extends boolean | undefined = false> extends Omit<Select.Root.Props<Value, Multiple>, 'defaultValue' | 'isItemEqualToValue' | 'items' | 'itemToStringLabel' | 'itemToStringValue' | 'onValueChange' | 'value'> {
+  defaultValue?: SelectValue$1<Value, Multiple> | null;
+  isItemEqualToValue?: (itemValue: Value, value: Value) => boolean;
+  items?: Record<string, ReactNode> | readonly {
+    label: ReactNode;
+    value: Value;
+  }[];
+  itemToStringLabel?: (itemValue: Value) => string;
+  itemToStringValue?: (itemValue: Value) => string;
+  onValueChange?: (value: SelectValue$1<Value, Multiple> | (Multiple extends true ? never : null), eventDetails: SelectChangeEventDetails) => void;
+  value?: SelectValue$1<Value, Multiple> | null;
+}
+type SelectTriggerProps = React.ComponentProps<typeof Select.Trigger> & VariantProps<typeof selectVariants>;
+type SelectValueProps = React.ComponentProps<typeof Select.Value>;
+type SelectIconProps = React.ComponentProps<typeof Select.Icon>;
+type SelectPopupProps = React.ComponentProps<typeof Select.Positioner>;
+type SelectItemProps = React.ComponentProps<typeof Select.Item>;
+type SelectListProps = React.ComponentProps<typeof Select.List>;
+type SelectGroupProps = React.ComponentProps<typeof Select.Group>;
+type SelectGroupLabelProps = React.ComponentProps<typeof Select.GroupLabel>;
+type SelectDescriptionProps = React.ComponentProps<'span'>;
+type SelectTitleProps = React.ComponentProps<'span'>;
+declare function Select$2<Value, Multiple extends boolean | undefined = false>(props: SelectProps<Value, Multiple>): import("react").JSX.Element;
+declare function SelectDescription({ className, ref, ...props }: SelectDescriptionProps): import("react").JSX.Element;
+declare function SelectGroup({ className, ref, ...props }: SelectGroupProps): import("react").JSX.Element;
+declare function SelectGroupLabel({ className, ref, ...props }: SelectGroupLabelProps): import("react").JSX.Element;
+declare function SelectIcon({ className, ref, ...props }: SelectIconProps): import("react").JSX.Element;
+declare function SelectItem({ className, children, ref, ...props }: SelectItemProps): import("react").JSX.Element;
+declare function SelectList({ className, ref, ...props }: SelectListProps): import("react").JSX.Element;
+declare function SelectPopup({ className, children, ref, ...props }: SelectPopupProps): import("react").JSX.Element;
+declare function SelectTitle({ className, children, ref, ...props }: SelectTitleProps): import("react").JSX.Element;
+declare function SelectTrigger({ variant, size, className, ref, ...props }: SelectTriggerProps): import("react").JSX.Element;
+declare function SelectValue({ className, ref, ...props }: SelectValueProps): import("react").JSX.Element;
+declare const Select$1: typeof Select$2 & {
+  Description: typeof SelectDescription;
+  Group: typeof SelectGroup;
+  GroupLabel: typeof SelectGroupLabel;
+  Icon: typeof SelectIcon;
+  Item: typeof SelectItem;
+  List: typeof SelectList;
+  Popup: typeof SelectPopup;
+  Title: typeof SelectTitle;
+  Trigger: typeof SelectTrigger;
+  Value: typeof SelectValue;
+};
+export { SelectValueProps as S, SelectListProps as _, SelectPopup as a, SelectTitleProps as b, SelectIcon as c, SelectDescription as d, SelectDescriptionProps as f, SelectItemProps as g, SelectIconProps as h, SelectTitle as i, SelectGroupLabel as l, SelectGroupProps as m, SelectValue as n, SelectList as o, SelectGroupLabelProps as p, SelectTrigger as r, SelectItem as s, Select$1 as t, SelectGroup as u, SelectPopupProps as v, SelectTriggerProps as x, SelectProps as y };
+//# sourceMappingURL=index-CIDOd4Z8.d.ts.map

package/dist/index-CQti9gFb.d.ts

@@ -0,0 +1,49 @@
+import { VariantProps } from "class-variance-authority";
+import { Menu } from "@base-ui/react/menu";
+type MenuProps = React.ComponentProps<typeof Menu.Root>;
+type MenuTriggerProps = React.ComponentProps<typeof Menu.Trigger>;
+type MenuPopupProps = React.ComponentProps<typeof Menu.Positioner>;
+type MenuSeparatorProps = React.ComponentProps<typeof Menu.Separator>;
+type MenuCheckboxItemProps = React.ComponentProps<typeof Menu.CheckboxItem>;
+type MenuRadioGroupProps = React.ComponentProps<typeof Menu.RadioGroup>;
+type MenuRadioItemProps = React.ComponentProps<typeof Menu.RadioItem>;
+type MenuGroupProps = React.ComponentProps<typeof Menu.Group>;
+type MenuGroupLabelProps = React.ComponentProps<typeof Menu.GroupLabel>;
+type MenuSubmenuProps = React.ComponentProps<typeof Menu.SubmenuRoot>;
+type MenuShortcutProps = React.ComponentProps<'div'>;
+declare const menuItemVariants: (props?: ({
+  tone?: "accent" | "brand" | "error" | "info" | "neutral" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string, menuSubmenuTriggerVariants: (props?: ({
+  tone?: "accent" | "brand" | "error" | "info" | "neutral" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type MenuItemProps = React.ComponentProps<typeof Menu.Item> & VariantProps<typeof menuItemVariants>;
+type MenuSubmenuTriggerProps = React.ComponentProps<typeof Menu.SubmenuTrigger> & VariantProps<typeof menuSubmenuTriggerVariants>;
+declare function Menu$2({ ...props }: MenuProps): import("react").JSX.Element;
+declare function MenuCheckboxItem({ className, children, ref, ...props }: MenuCheckboxItemProps): import("react").JSX.Element;
+declare function MenuGroup({ className, ref, ...props }: MenuGroupProps): import("react").JSX.Element;
+declare function MenuGroupLabel({ className, ref, ...props }: MenuGroupLabelProps): import("react").JSX.Element;
+declare function MenuItem({ tone, className, children, ref, ...props }: MenuItemProps): import("react").JSX.Element;
+declare function MenuPopup({ className, children, ref, ...props }: MenuPopupProps): import("react").JSX.Element;
+declare function MenuRadioGroup({ className, ref, ...props }: MenuRadioGroupProps): import("react").JSX.Element;
+declare function MenuRadioItem({ className, children, ref, ...props }: MenuRadioItemProps): import("react").JSX.Element;
+declare function MenuSeparator({ className, ref, ...props }: MenuSeparatorProps): import("react").JSX.Element;
+declare function MenuShortcut({ className, ref, ...props }: MenuShortcutProps): import("react").JSX.Element;
+declare function MenuSubmenu({ ...props }: MenuSubmenuProps): import("react").JSX.Element;
+declare function MenuSubmenuTrigger({ tone, className, children, ref, ...props }: MenuSubmenuTriggerProps): import("react").JSX.Element;
+declare function MenuTrigger({ className, children, ref, ...props }: MenuTriggerProps): import("react").JSX.Element;
+declare const Menu$1: typeof Menu$2 & {
+  CheckboxItem: typeof MenuCheckboxItem;
+  Group: typeof MenuGroup;
+  GroupLabel: typeof MenuGroupLabel;
+  Item: typeof MenuItem;
+  Popup: typeof MenuPopup;
+  RadioGroup: typeof MenuRadioGroup;
+  RadioItem: typeof MenuRadioItem;
+  Separator: typeof MenuSeparator;
+  Shortcut: typeof MenuShortcut;
+  Submenu: typeof MenuSubmenu;
+  SubmenuTrigger: typeof MenuSubmenuTrigger;
+  Trigger: typeof MenuTrigger;
+};
+export { MenuShortcutProps as C, MenuTriggerProps as E, MenuSeparatorProps as S, MenuSubmenuTriggerProps as T, MenuItemProps as _, MenuShortcut as a, MenuRadioGroupProps as b, MenuRadioGroup as c, MenuGroupLabel as d, MenuGroup as f, MenuGroupProps as g, MenuGroupLabelProps as h, MenuSubmenu as i, MenuPopup as l, MenuCheckboxItemProps as m, MenuTrigger as n, MenuSeparator as o, MenuCheckboxItem as p, MenuSubmenuTrigger as r, MenuRadioItem as s, Menu$1 as t, MenuItem as u, MenuPopupProps as v, MenuSubmenuProps as w, MenuRadioItemProps as x, MenuProps as y };
+//# sourceMappingURL=index-CQti9gFb.d.ts.map

package/dist/index-CiE-Rqit.d.ts

@@ -0,0 +1,70 @@
+import { t as Checkbox } from "./index-x4f8gnaI.js";
+import { t as Select } from "./index-CIDOd4Z8.js";
+import { r as InputGroupInput, t as InputGroup } from "./index-DdFxZ3Xr.js";
+import { t as Input } from "./index-BsV-u_jc.js";
+import { n as Radio, t as RadioGroup } from "./index-C2zco6-C.js";
+import { t as Slider } from "./index-BygR7cUT.js";
+import { t as Switch } from "./index-Db_QGr6S.js";
+import { t as TextArea } from "./index-BzTOLSgZ.js";
+import { t as Toggle } from "./index-C15xiG9O.js";
+import { VariantProps } from "class-variance-authority";
+type FieldDescriptionProps = React.ComponentProps<'p'>;
+type FieldErrorProps = React.ComponentProps<'ul'>;
+type FieldInputGroupProps = React.ComponentProps<typeof InputGroup>;
+type FieldInputGroupInputProps = React.ComponentProps<typeof InputGroupInput>;
+type FieldInputProps = React.ComponentProps<typeof Input>;
+type FieldLabelProps = React.ComponentProps<'div'> & VariantProps<typeof fieldLabelVariants> & {
+  showRequired?: boolean;
+};
+type FieldSelectProps = React.ComponentProps<typeof Select>;
+type FieldSliderProps = React.ComponentProps<typeof Slider>;
+type FieldTextAreaProps = React.ComponentProps<typeof TextArea>;
+type FieldCheckboxProps = React.ComponentProps<typeof Checkbox>;
+type FieldRadioProps = React.ComponentProps<typeof Radio>;
+type FieldRadioGroupProps = React.ComponentProps<typeof RadioGroup>;
+type FieldSwitchProps = React.ComponentProps<typeof Switch>;
+type FieldToggleProps = React.ComponentProps<typeof Toggle>;
+type FieldProps = React.ComponentProps<'div'>;
+type FieldSetProps = React.ComponentProps<'div'>;
+type FieldRowProps = React.ComponentProps<'div'>;
+declare const fieldLabelVariants: (props?: ({
+  size?: "large" | "medium" | "small" | null | undefined;
+  variant?: "primary" | "secondary" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Field$1({ className, children, ref, ...props }: FieldProps): import("react").JSX.Element;
+declare function FieldCheckbox({ children, ...props }: FieldCheckboxProps): import("react").JSX.Element;
+declare function FieldDescription({ className, ref, ...props }: FieldDescriptionProps): import("react").JSX.Element;
+declare function FieldErrors({ className, children, ref, ...props }: FieldErrorProps): import("react").JSX.Element | undefined;
+declare function FieldInput({ className, ref, ...props }: FieldInputProps): import("react").JSX.Element;
+declare function FieldInputGroup({ className, ref, ...props }: FieldInputGroupProps): import("react").JSX.Element;
+declare function FieldInputGroupInput({ className, ref, ...props }: FieldInputGroupInputProps): import("react").JSX.Element;
+declare function FieldLabel({ size, variant, showRequired, className, children, ref, ...props }: FieldLabelProps): import("react").JSX.Element;
+declare function FieldRadio({ ...props }: FieldRadioProps): import("react").JSX.Element;
+declare function FieldRadioGroup({ ...props }: FieldRadioGroupProps): import("react").JSX.Element;
+declare function FieldRow({ className, ref, ...props }: FieldRowProps): import("react").JSX.Element;
+declare function FieldSelect({ children, ...props }: FieldSelectProps): import("react").JSX.Element;
+declare function FieldSet({ className, ref, ...props }: FieldSetProps): import("react").JSX.Element;
+declare function FieldSlider({ className, ref, ...props }: FieldSliderProps): import("react").JSX.Element;
+declare function FieldSwitch({ children, ...props }: FieldSwitchProps): import("react").JSX.Element;
+declare function FieldTextArea({ className, ref, ...props }: FieldTextAreaProps): import("react").JSX.Element;
+declare function FieldToggle({ ...props }: FieldToggleProps): import("react").JSX.Element;
+declare const Field: typeof Field$1 & {
+  Checkbox: typeof FieldCheckbox;
+  Description: typeof FieldDescription;
+  Errors: typeof FieldErrors;
+  Input: typeof FieldInput;
+  InputGroup: typeof FieldInputGroup;
+  InputGroupInput: typeof FieldInputGroupInput;
+  Label: typeof FieldLabel;
+  Radio: typeof FieldRadio;
+  RadioGroup: typeof FieldRadioGroup;
+  Row: typeof FieldRow;
+  Select: typeof FieldSelect;
+  Set: typeof FieldSet;
+  Slider: typeof FieldSlider;
+  Switch: typeof FieldSwitch;
+  TextArea: typeof FieldTextArea;
+  Toggle: typeof FieldToggle;
+};
+export { FieldSetProps as A, FieldInputProps as C, FieldRadioProps as D, FieldRadioGroupProps as E, FieldSwitchProps as M, FieldTextAreaProps as N, FieldRowProps as O, FieldToggleProps as P, FieldInputGroupProps as S, FieldProps as T, FieldCheckbox as _, FieldSlider as a, FieldErrorProps as b, FieldRow as c, FieldLabel as d, FieldInputGroupInput as f, FieldDescription as g, FieldErrors as h, FieldSwitch as i, FieldSliderProps as j, FieldSelectProps as k, FieldRadioGroup as l, FieldInput as m, FieldToggle as n, FieldSet as o, FieldInputGroup as p, FieldTextArea as r, FieldSelect as s, Field as t, FieldRadio as u, FieldCheckboxProps as v, FieldLabelProps as w, FieldInputGroupInputProps as x, FieldDescriptionProps as y };
+//# sourceMappingURL=index-CiE-Rqit.d.ts.map

package/dist/index-D1kkOg9k.d.ts

@@ -0,0 +1,14 @@
+import { VariantProps } from "class-variance-authority";
+import { Separator } from "@base-ui/react/separator";
+declare const separatorVariants: (props?: ({
+  orientation?: "horizontal" | "vertical" | null | undefined;
+  style?: "rounded" | "square" | null | undefined;
+  variant?: "default" | "strong" | null | undefined;
+  weight?: "medium" | "thick" | "thin" | "thinnest" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type SeparatorProps = Omit<React.ComponentProps<typeof Separator>, 'style'> & VariantProps<typeof separatorVariants> & {
+  labelClassName?: string;
+};
+declare function Separator$1({ orientation, weight, style, variant, children, className, labelClassName, ref, ...props }: SeparatorProps): import("react").JSX.Element;
+export { SeparatorProps as n, Separator$1 as t };
+//# sourceMappingURL=index-D1kkOg9k.d.ts.map

package/dist/index-DLfdAked.d.ts

@@ -0,0 +1,34 @@
+import { VariantProps } from "class-variance-authority";
+import { Meter } from "@base-ui/react";
+type MeterProps = React.ComponentProps<typeof Meter.Root> & VariantProps<typeof meterVariants>;
+type MeterLabelProps = React.ComponentProps<typeof Meter.Label>;
+type MeterValueProps = React.ComponentProps<typeof Meter.Value>;
+type MeterTrackProps = React.ComponentProps<typeof Meter.Track>;
+type MeterIndicatorProps = React.ComponentProps<typeof Meter.Indicator>;
+type MeterHeaderProps = React.ComponentProps<'div'>;
+type MeterFooterProps = React.ComponentProps<'div'>;
+type MeterSubtitleProps = React.ComponentProps<'span'>;
+declare const meterVariants: (props?: ({
+  orientation?: "horizontal" | "vertical" | null | undefined;
+  size?: "large" | "medium" | "small" | null | undefined;
+  tone?: "accent" | "brand" | "error" | "info" | "neutral" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function Meter$2({ orientation, size, tone, className, ref, ...props }: MeterProps): import("react").JSX.Element;
+declare function MeterFooter({ className, ref, ...props }: MeterFooterProps): import("react").JSX.Element;
+declare function MeterHeader({ className, ref, ...props }: MeterHeaderProps): import("react").JSX.Element;
+declare function MeterIndicator({ className, ref, ...props }: MeterIndicatorProps): import("react").JSX.Element;
+declare function MeterLabel({ className, ref, ...props }: MeterLabelProps): import("react").JSX.Element;
+declare function MeterSubtitle({ className, ref, ...props }: MeterSubtitleProps): import("react").JSX.Element;
+declare function MeterTrack({ className, ref, ...props }: MeterTrackProps): import("react").JSX.Element;
+declare function MeterValue({ className, ref, ...props }: MeterValueProps): import("react").JSX.Element;
+declare const Meter$1: typeof Meter$2 & {
+  Footer: typeof MeterFooter;
+  Header: typeof MeterHeader;
+  Indicator: typeof MeterIndicator;
+  Label: typeof MeterLabel;
+  Subtitle: typeof MeterSubtitle;
+  Track: typeof MeterTrack;
+  Value: typeof MeterValue;
+};
+export { MeterLabel as a, MeterFooter as c, MeterIndicatorProps as d, MeterLabelProps as f, MeterValueProps as g, MeterTrackProps as h, MeterSubtitle as i, MeterFooterProps as l, MeterSubtitleProps as m, MeterValue as n, MeterIndicator as o, MeterProps as p, MeterTrack as r, MeterHeader as s, Meter$1 as t, MeterHeaderProps as u };
+//# sourceMappingURL=index-DLfdAked.d.ts.map

package/dist/index-DMaW_XF1.d.ts

@@ -0,0 +1,24 @@
+import { VariantProps } from "class-variance-authority";
+import React, { ComponentProps } from "react";
+import { Avatar } from "@base-ui/react/avatar";
+declare const avatarVariants: (props?: ({
+  size?: "large" | "medium" | "small" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string, avatarBadgeVariants: (props?: ({
+  position?: "bottomLeft" | "bottomRight" | "topLeft" | "topRight" | null | undefined;
+  tone?: "accent" | "brand" | "error" | "info" | "neutral" | "success" | "warning" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type AvatarProps = ComponentProps<typeof Avatar.Root> & VariantProps<typeof avatarVariants>;
+type AvatarImageProps = ComponentProps<typeof Avatar.Image>;
+type AvatarFallbackProps = ComponentProps<typeof Avatar.Fallback>;
+type AvatarBadgeProps = ComponentProps<'div'> & VariantProps<typeof avatarBadgeVariants>;
+declare function Avatar$2({ size, className, ref, ...props }: AvatarProps): import("react").JSX.Element;
+declare function AvatarBadge({ tone, position, className, ref, ...props }: AvatarBadgeProps): import("react").JSX.Element;
+declare function AvatarFallback({ className, ref, ...props }: AvatarFallbackProps): import("react").JSX.Element;
+declare function AvatarImage({ className, ref, ...props }: AvatarImageProps): React.JSX.Element;
+declare const Avatar$1: typeof Avatar$2 & {
+  Badge: typeof AvatarBadge;
+  Fallback: typeof AvatarFallback;
+  Image: typeof AvatarImage;
+};
+export { AvatarBadgeProps as a, AvatarProps as c, AvatarBadge as i, AvatarImage as n, AvatarFallbackProps as o, AvatarFallback as r, AvatarImageProps as s, Avatar$1 as t };
+//# sourceMappingURL=index-DMaW_XF1.d.ts.map

package/dist/index-Db_QGr6S.d.ts

@@ -0,0 +1,5 @@
+import { Switch } from "@base-ui/react/switch";
+type SwitchProps = React.ComponentProps<'button'> & Switch.Root.Props;
+declare function Switch$1({ children, className, ref, ...props }: SwitchProps): import("react").JSX.Element;
+export { SwitchProps as n, Switch$1 as t };
+//# sourceMappingURL=index-Db_QGr6S.d.ts.map

package/dist/index-DdFxZ3Xr.d.ts

@@ -0,0 +1,22 @@
+import { n as inputVariants } from "./input.types-816rEVWU.js";
+import { t as Separator } from "./index-D1kkOg9k.js";
+import { VariantProps } from "class-variance-authority";
+import { Input } from "@base-ui/react/input";
+declare const inputGroupAddonVariants: (props?: ({
+  size?: "large" | "medium" | "small" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type InputGroupAddonProps = React.ComponentProps<'div'> & VariantProps<typeof inputGroupAddonVariants>;
+type InputGroupInputProps = Omit<React.ComponentProps<typeof Input>, 'size'> & VariantProps<typeof inputVariants>;
+type InputGroupProps = React.ComponentProps<'div'> & VariantProps<typeof inputVariants>;
+type InputGroupSeparatorProps = React.ComponentProps<typeof Separator>;
+declare function InputGroup$1({ variant, size, className, ref, ...props }: InputGroupProps): import("react").JSX.Element;
+declare function InputGroupAddon({ size, className, ref, ...props }: InputGroupAddonProps): import("react").JSX.Element;
+declare function InputGroupInput({ size, className, ref, ...props }: InputGroupInputProps): import("react").JSX.Element;
+declare function InputGroupSeparator({ className, ref, ...props }: InputGroupSeparatorProps): import("react").JSX.Element;
+declare const InputGroup: typeof InputGroup$1 & {
+  Addon: typeof InputGroupAddon;
+  Input: typeof InputGroupInput;
+  Separator: typeof InputGroupSeparator;
+};
+export { InputGroupAddonProps as a, InputGroupSeparatorProps as c, InputGroupAddon as i, InputGroupSeparator as n, InputGroupInputProps as o, InputGroupInput as r, InputGroupProps as s, InputGroup as t };
+//# sourceMappingURL=index-DdFxZ3Xr.d.ts.map

package/dist/index-DfNHJF0t.d.ts

@@ -0,0 +1,33 @@
+import { t as Button } from "./index-bVyqfhJS.js";
+import { VariantProps } from "class-variance-authority";
+import { Popover } from "@base-ui/react/popover";
+declare const popoverPanelVariants: (props?: ({
+  elevation?: "high" | "low" | "medium" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string, popoverHandle: Popover.Handle<import("react").ComponentType<{}>>;
+type PopoverProps = React.ComponentProps<typeof Popover.Root>;
+type PopoverTriggerProps = React.ComponentProps<typeof Popover.Trigger>;
+type PopoverPanelProps = React.ComponentProps<typeof Popover.Positioner> & VariantProps<typeof popoverPanelVariants>;
+type PopoverTitleProps = React.ComponentProps<typeof Popover.Title>;
+type PopoverDescriptionProps = React.ComponentProps<typeof Popover.Description>;
+type PopoverHeaderProps = React.ComponentProps<'div'>;
+type PopoverContentProps = React.ComponentProps<'div'>;
+type PopoverButtonProps = React.ComponentProps<typeof Button>;
+declare function Popover$2({ ...props }: PopoverProps): import("react").JSX.Element;
+declare function PopoverButton({ variant, tone, className, children, ref, ...props }: PopoverButtonProps): import("react").JSX.Element;
+declare function PopoverContent({ className, ref, ...props }: PopoverContentProps): import("react").JSX.Element;
+declare function PopoverDescription({ className, ref, ...props }: PopoverDescriptionProps): import("react").JSX.Element;
+declare function PopoverHeader({ className, ref, ...props }: PopoverHeaderProps): import("react").JSX.Element;
+declare function PopoverPanel({ elevation, className, ref, children, ...props }: PopoverPanelProps): import("react").JSX.Element;
+declare function PopoverTitle({ className, ref, ...props }: PopoverTitleProps): import("react").JSX.Element;
+declare function PopoverTrigger({ className, children, ref, ...props }: PopoverTriggerProps): import("react").JSX.Element;
+declare const Popover$1: typeof Popover$2 & {
+  Button: typeof PopoverButton;
+  Content: typeof PopoverContent;
+  Description: typeof PopoverDescription;
+  Header: typeof PopoverHeader;
+  Panel: typeof PopoverPanel;
+  Title: typeof PopoverTitle;
+  Trigger: typeof PopoverTrigger;
+};
+export { popoverHandle as _, PopoverHeader as a, PopoverButton as c, PopoverDescriptionProps as d, PopoverHeaderProps as f, PopoverTriggerProps as g, PopoverTitleProps as h, PopoverPanel as i, PopoverButtonProps as l, PopoverProps as m, PopoverTrigger as n, PopoverDescription as o, PopoverPanelProps as p, PopoverTitle as r, PopoverContent as s, Popover$1 as t, PopoverContentProps as u };
+//# sourceMappingURL=index-DfNHJF0t.d.ts.map

package/dist/index-DyQYoAUf.d.ts

@@ -0,0 +1,29 @@
+import { VariantProps } from "class-variance-authority";
+import React, { ComponentProps } from "react";
+import { Tabs } from "@base-ui/react/tabs";
+declare function Tabs$2({ variant, size, tone, fill, showBorder, className, ref, ...props }: TabsProps): import("react").JSX.Element;
+type TabsPanelProps = ComponentProps<typeof Tabs.Panel>;
+type TabsTabProps = ComponentProps<typeof Tabs.Tab>;
+type TabsIndicatorProps = ComponentProps<typeof Tabs.Indicator>;
+type TabsListProps = ComponentProps<typeof Tabs.List>;
+declare const tabsVariants: (props?: ({
+  fill?: boolean | null | undefined;
+  showBorder?: boolean | null | undefined;
+  size?: "large" | "medium" | "small" | null | undefined;
+  tone?: "accent" | "brand" | "error" | "info" | "neutral" | "success" | "warning" | null | undefined;
+  variant?: "default" | "ghost" | "underline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type TabsProps = React.ComponentProps<typeof Tabs.Root> & VariantProps<typeof tabsVariants>;
+type TabsTabValue = TabsTabProps['value'];
+declare function TabsIndicator({ className, ...props }: TabsIndicatorProps): import("react").JSX.Element;
+declare function TabsList({ children, className, ...props }: TabsListProps): import("react").JSX.Element;
+declare function TabsPanel({ className, ...props }: TabsPanelProps): import("react").JSX.Element;
+declare function TabsTab({ className, children, ...props }: TabsTabProps): import("react").JSX.Element;
+declare const Tabs$1: typeof Tabs$2 & {
+  Indicator: typeof TabsIndicator;
+  List: typeof TabsList;
+  Panel: typeof TabsPanel;
+  Tab: typeof TabsTab;
+};
+export { TabsIndicator as a, TabsPanelProps as c, TabsTabValue as d, Tabs$2 as f, TabsList as i, TabsProps as l, TabsTab as n, TabsIndicatorProps as o, TabsPanel as r, TabsListProps as s, Tabs$1 as t, TabsTabProps as u };
+//# sourceMappingURL=index-DyQYoAUf.d.ts.map

package/dist/index-N2CBSUDu.d.ts

@@ -0,0 +1,14 @@
+import { t as Button } from "./index-bVyqfhJS.js";
+import { Collapsible } from "@base-ui/react/collapsible";
+type CollapsibleProps = React.ComponentProps<typeof Collapsible.Root>;
+type CollapsibleTriggerProps = React.ComponentProps<typeof Button>;
+type CollapsiblePanelProps = React.ComponentProps<typeof Collapsible.Panel>;
+declare function Collapsible$2({ className, ref, ...props }: CollapsibleProps): import("react").JSX.Element;
+declare function CollapsiblePanel({ className, ref, ...props }: CollapsiblePanelProps): import("react").JSX.Element;
+declare function CollapsibleTrigger({ className, children, ref, ...props }: CollapsibleTriggerProps): import("react").JSX.Element;
+declare const Collapsible$1: typeof Collapsible$2 & {
+  Panel: typeof CollapsiblePanel;
+  Trigger: typeof CollapsibleTrigger;
+};
+export { CollapsibleProps as a, CollapsiblePanelProps as i, CollapsibleTrigger as n, CollapsibleTriggerProps as o, CollapsiblePanel as r, Collapsible$1 as t };
+//# sourceMappingURL=index-N2CBSUDu.d.ts.map

package/dist/index-PuhTRMce.d.ts

@@ -0,0 +1,11 @@
+import { VariantProps } from "class-variance-authority";
+import { Slider } from "@base-ui/react";
+type ColorChannelSliderProps = React.ComponentProps<typeof Slider.Root> & VariantProps<typeof colorChannelSliderVariants> & {
+  trackStyle: string[];
+};
+declare const colorChannelSliderVariants: (props?: ({
+  size?: "large" | "medium" | "small" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+declare function ColorChannelSlider({ size, trackStyle, className, children, 'aria-label': ariaLabel, ref, ...props }: ColorChannelSliderProps): import("react").JSX.Element;
+export { ColorChannelSliderProps as n, ColorChannelSlider as t };
+//# sourceMappingURL=index-PuhTRMce.d.ts.map

package/dist/index-Wb_tILYa.d.ts

@@ -0,0 +1,24 @@
+import React from "react";
+type IconProps = React.ComponentProps<'svg'>;
+type IconComponent = React.ComponentType<IconProps>;
+type IconName = 'add' | 'chevronDown' | 'chevronLeft' | 'chevronRight' | 'chevronUp' | 'chevronsUpDown' | 'close' | 'columnFilter' | 'copy' | 'delete' | 'download' | 'ellipsis' | 'error' | 'fieldError' | 'fileUpload' | 'filter' | 'firstPage' | 'folder' | 'folderExpandAll' | 'folderOpen' | 'hidden' | 'info' | 'lastPage' | 'layers' | 'locked' | 'minus' | 'percent' | 'search' | 'selected' | 'sort' | 'sortAscending' | 'sortDescending' | 'spinner' | 'success' | 'unlocked' | 'upload' | 'visible' | 'warning' | '3d';
+type IconRegistry = Record<IconName, IconComponent>;
+type IconOverrides = Partial<IconRegistry>;
+type IconWeight = 'thin' | 'light' | 'regular' | 'bold' | 'fill' | 'duotone';
+type IconRenderProps = IconProps & {
+  name: IconName;
+  weight?: IconWeight;
+};
+interface IconProviderProps {
+  icons?: IconOverrides;
+  weight?: IconWeight;
+  children?: React.ReactNode;
+}
+declare function Icon({ name, weight, ...props }: IconRenderProps): React.JSX.Element;
+/**
+ * Replaces the default Phosphor icons and sets their weight for every library component below it.
+ * Providers can be nested; inner providers override only the icon names and weight they set.
+ */
+declare function IconProvider({ icons, weight, children }: IconProviderProps): React.JSX.Element;
+export { IconOverrides as a, IconRegistry as c, IconName as i, IconRenderProps as l, Icon as n, IconProps as o, IconComponent as r, IconProviderProps as s, IconProvider as t, IconWeight as u };
+//# sourceMappingURL=index-Wb_tILYa.d.ts.map

package/dist/index-bVyqfhJS.d.ts

@@ -0,0 +1,4 @@
+import { t as ButtonProps } from "./button.types-BFKrBCGd.js";
+declare function Button({ tone, variant, size, className, children, ...props }: ButtonProps): import("react").JSX.Element;
+export { Button as t };
+//# sourceMappingURL=index-bVyqfhJS.d.ts.map

package/dist/index-x4f8gnaI.d.ts

@@ -0,0 +1,15 @@
+import { VariantProps } from "class-variance-authority";
+import { ComponentProps } from "react";
+import { Checkbox } from "@base-ui/react/checkbox";
+declare const checkboxVariants: (props?: ({
+  variant?: "elevated" | "inSurface" | "outline" | null | undefined;
+} & import("class-variance-authority/types").ClassProp) | undefined) => string;
+type CheckboxRootProps = ComponentProps<typeof Checkbox.Root> & VariantProps<typeof checkboxVariants>;
+type CheckboxIndicatorProps = ComponentProps<typeof Checkbox.Indicator>;
+declare function Checkbox$2({ variant, children, className, ref, ...props }: CheckboxRootProps): import("react").JSX.Element;
+declare function CheckboxIndicator({ className, ...props }: CheckboxIndicatorProps): import("react").JSX.Element;
+declare const Checkbox$1: typeof Checkbox$2 & {
+  Indicator: typeof CheckboxIndicator;
+};
+export { CheckboxRootProps as i, CheckboxIndicator as n, CheckboxIndicatorProps as r, Checkbox$1 as t };
+//# sourceMappingURL=index-x4f8gnaI.d.ts.map

package/dist/input/index.d.ts

@@ -0,0 +1,3 @@
+import { t as InputProps } from "../input.types-816rEVWU.js";
+import { t as Input } from "../index-BsV-u_jc.js";
+export { Input, type InputProps };

package/dist/input/index.js

@@ -0,0 +1 @@
+export { t as Input } from "../input-Laj6dwtK.js";