@wavv/ui 2.2.4 → 2.2.5

package/build/components/Accordion/Accordion.d.ts

@@ -1,10 +1,28 @@
 import { type DisclosureGroupProps } from 'react-aria-components';
 import type { Margin, MaxHeight, Width } from '../types';
-type Props = Width & MaxHeight & Margin & DisclosureGroupProps;
+type Props = {
+    allowsMultipleExpanded?: DisclosureGroupProps['allowsMultipleExpanded'];
+    expandedKeys?: DisclosureGroupProps['expandedKeys'];
+    defaultExpandedKeys?: DisclosureGroupProps['defaultExpandedKeys'];
+    onExpandedChange?: DisclosureGroupProps['onExpandedChange'];
+    /** Disables all items in the accordion */
+    disabled?: DisclosureGroupProps['isDisabled'];
+    className?: DisclosureGroupProps['className'];
+    style?: DisclosureGroupProps['style'];
+} & Width & MaxHeight & Margin & Omit<DisclosureGroupProps, 'isDisabled'>;
 declare const Accordion: {
-    ({ children, maxHeight, ...props }: Props): import("react/jsx-runtime").JSX.Element;
+    ({ children, maxHeight, disabled, ...props }: Props): import("react/jsx-runtime").JSX.Element;
     Item: {
-        ({ children, ...props }: import("react-aria-components").DisclosureProps): import("react/jsx-runtime").JSX.Element;
+        ({ children, disabled, ...props }: {
+            id?: import("react-aria-components").DisclosureProps["id"];
+            isExpanded?: import("react-aria-components").DisclosureProps["isExpanded"];
+            defaultExpanded?: import("react-aria-components").DisclosureProps["defaultExpanded"];
+            onExpandedChange?: import("react-aria-components").DisclosureProps["onExpandedChange"];
+            disabled?: import("react-aria-components").DisclosureProps["isDisabled"];
+            children?: import("react-aria-components").DisclosureProps["children"];
+            className?: import("react-aria-components").DisclosureProps["className"];
+            style?: import("react-aria-components").DisclosureProps["style"];
+        } & Omit<import("react-aria-components").DisclosureProps, "isDisabled">): import("react/jsx-runtime").JSX.Element;
         displayName: string;
     };
     Header: {
@@ -404,6 +422,9 @@ declare const Accordion: {
     };
     Panel: {
         ({ children, maxHeight, ...props }: {
+            children: import("react-aria-components").DisclosurePanelProps["children"];
+            className?: import("react-aria-components").DisclosurePanelProps["className"];
+            style?: import("react-aria-components").DisclosurePanelProps["style"];
             background?: string;
         } & MaxHeight & import("react-aria-components").DisclosurePanelProps): import("react/jsx-runtime").JSX.Element;
         displayName: string;

package/build/components/Accordion/Accordion.js

@@ -5,10 +5,11 @@ import { marginProps, maxWidthHeightProps, widthHeightProps } from "../helpers/s
 import Header from "./Header.js";
 import Item from "./Item.js";
 import Panel from "./Panel.js";
-const Accordion = ({ children, maxHeight, ...props })=>/*#__PURE__*/ jsx(Container, {
+const Accordion = ({ children, maxHeight, disabled, ...props })=>/*#__PURE__*/ jsx(Container, {
         style: {
             maxHeight
         },
+        isDisabled: disabled,
         ...props,
         children: children
     });

package/build/components/Accordion/Item.d.ts

@@ -1,6 +1,17 @@
 import { type DisclosureProps } from 'react-aria-components';
+type Props = {
+    id?: DisclosureProps['id'];
+    isExpanded?: DisclosureProps['isExpanded'];
+    defaultExpanded?: DisclosureProps['defaultExpanded'];
+    onExpandedChange?: DisclosureProps['onExpandedChange'];
+    /** Disables the item */
+    disabled?: DisclosureProps['isDisabled'];
+    children?: DisclosureProps['children'];
+    className?: DisclosureProps['className'];
+    style?: DisclosureProps['style'];
+} & Omit<DisclosureProps, 'isDisabled'>;
 declare const Item: {
-    ({ children, ...props }: DisclosureProps): import("react/jsx-runtime").JSX.Element;
+    ({ children, disabled, ...props }: Props): import("react/jsx-runtime").JSX.Element;
     displayName: string;
 };
 export default Item;

package/build/components/Accordion/Item.js

@@ -1,7 +1,8 @@
 import { jsx } from "react/jsx-runtime";
 import styled from "@emotion/styled";
 import { Disclosure } from "react-aria-components";
-const Item = ({ children, ...props })=>/*#__PURE__*/ jsx(ItemContainer, {
+const Item = ({ children, disabled, ...props })=>/*#__PURE__*/ jsx(ItemContainer, {
+        isDisabled: disabled,
         ...props,
         children: children
     });
@@ -18,6 +19,16 @@ const ItemContainer = styled(Disclosure)(({ theme })=>({
                     transform: 'rotate(90deg)'
                 }
             }
+        },
+        '&[data-disabled="true"]': {
+            cursor: 'not-allowed',
+            '& > div:first-of-type': {
+                pointerEvents: 'none',
+                userSelect: 'none',
+                '& > *': {
+                    opacity: 0.4
+                }
+            }
         }
     }));
 Item.displayName = 'Accordion.Item';

package/build/components/Accordion/Panel.d.ts

@@ -1,6 +1,9 @@
 import { type DisclosurePanelProps } from 'react-aria-components';
 import type { MaxHeight } from '../types';
 type PanelProps = {
+    children: DisclosurePanelProps['children'];
+    className?: DisclosurePanelProps['className'];
+    style?: DisclosurePanelProps['style'];
     background?: string;
 } & MaxHeight & DisclosurePanelProps;
 declare const Panel: {

package/build/components/Button/Button.d.ts

@@ -2,7 +2,7 @@ import type { Margin } from '../types';
 import type { BasicButtonProps, ButtonComponentProps } from './ButtonTypes';
 declare const _default: (({ content, children, dropdown, options, ref, ...rest }: ButtonComponentProps) => import("react/jsx-runtime").JSX.Element) & {
     Group: ({ children, disabled, outline, size, tiny, small, large, secondary, negative, positive, caution, collapse, ...props }: ({
-        children: (import("react").ReactElement<BasicButtonProps | ButtonComponentProps, string | import("react").JSXElementConstructor<any>> | import("react").ReactElement<import("../Tooltip").TooltipProps, string | import("react").JSXElementConstructor<any>>) | (import("react").ReactElement<BasicButtonProps | ButtonComponentProps, string | import("react").JSXElementConstructor<any>> | import("react").ReactElement<import("../Tooltip").TooltipProps, string | import("react").JSXElementConstructor<any>>)[];
+        children: (import("react").ReactElement<BasicButtonProps | ButtonComponentProps, string | import("react").JSXElementConstructor<any>> | import("react").ReactElement<import("../Tooltip").Props, string | import("react").JSXElementConstructor<any>>) | (import("react").ReactElement<BasicButtonProps | ButtonComponentProps, string | import("react").JSXElementConstructor<any>> | import("react").ReactElement<import("../Tooltip").Props, string | import("react").JSXElementConstructor<any>>)[];
         disabled?: boolean;
         size?: import("../types").Sizes;
         tiny?: boolean;

package/build/components/Button/Group.d.ts

@@ -1,5 +1,5 @@
 import { type ReactElement } from 'react';
-import type { TooltipProps } from '../Tooltip';
+import type { Props as TooltipProps } from '../Tooltip';
 import type { Attributes } from '../typeDefs/elementTypes';
 import type { Margin, Sizes, Width } from '../types';
 import type { BasicButtonProps, ButtonComponentProps, ButtonStyles } from './ButtonTypes';

package/build/components/Calendar.d.ts

@@ -6,6 +6,9 @@ type Props = {
     date?: Date;
     /** The function to be called when a date is selected */
     onChange: (date: Date) => void;
-} & CalendarBaseProps & Omit<CalendarProps<CalendarDate>, 'onChange'>;
+    firstDayOfWeek?: CalendarProps<CalendarDate>['firstDayOfWeek'];
+    className?: CalendarProps<CalendarDate>['className'];
+    style?: CalendarProps<CalendarDate>['style'];
+} & CalendarBaseProps & Pick<CalendarProps<CalendarDate>, 'firstDayOfWeek' | 'className' | 'style'>;
 declare const Calendar: ({ date, onChange, preventPast, preventFuture, noShadow, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default Calendar;

package/build/components/Checkbox.d.ts

@@ -17,9 +17,10 @@ type Props = {
     partial?: boolean;
     /** Sets the gap between the label and the checkbox */
     gap?: number;
-    /** The function called with the checkbox value after the checkbox is changed */
-    onChange?: (val: boolean) => void;
-} & Margin & Omit<CheckboxProps, 'value' | 'isDisabled' | 'isReadOnly' | 'isSelected'>;
+    onChange?: CheckboxProps['onChange'];
+    className?: CheckboxProps['className'];
+    style?: CheckboxProps['style'];
+} & Margin & Omit<CheckboxProps, 'value' | 'isDisabled' | 'isReadOnly' | 'isSelected' | 'isIndeterminate'>;
 declare const Checkbox: ({ label, labelPosition, checked, partial, disabled, readOnly, onChange, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export declare const ControlContainer: import("@emotion/styled").StyledComponent<CheckboxProps & import("react").RefAttributes<HTMLLabelElement> & {
     theme?: import("@emotion/react").Theme;

package/build/components/Checkbox.js

@@ -1,6 +1,5 @@
 import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import styled from "@emotion/styled";
-import { useEffect, useState } from "react";
 import { Checkbox } from "react-aria-components";
 import icons_Checkbox from "../assets/icons/Checkbox.js";
 import CheckboxOff from "../assets/icons/CheckboxOff.js";
@@ -9,33 +8,26 @@ import { ControlLabel } from "./FormControl.js";
 import { marginProps } from "./helpers/styledProps.js";
 import Icon from "./Icon/index.js";
 const Checkbox_Checkbox = ({ label, labelPosition, checked, partial, disabled, readOnly, onChange, ...props })=>{
-    const [on, setOn] = useState(checked || false);
     const labelRight = 'right' === labelPosition;
-    const handleChange = ()=>{
-        const value = partial ? true : !on;
-        setOn(value);
-        if (onChange) onChange(value);
-    };
-    useEffect(()=>{
-        const checkedSet = 'boolean' == typeof checked;
-        const value = checkedSet ? checked : on;
-        setOn(value);
-    }, [
-        checked,
-        on
-    ]);
+    const isControlled = 'boolean' == typeof checked;
     return /*#__PURE__*/ jsx(ControlContainer, {
         labelRight: labelRight,
-        isSelected: on,
-        isIndeterminate: partial,
+        ...isControlled ? {
+            isSelected: checked
+        } : {},
+        ...true === partial ? {
+            isIndeterminate: true
+        } : {},
         isDisabled: disabled,
         isReadOnly: readOnly,
-        onChange: handleChange,
+        onChange: onChange,
         ...props,
         children: ({ isIndeterminate, isSelected })=>{
+            const isChecked = isSelected;
+            const isPartial = partial || isIndeterminate;
             let svg = /*#__PURE__*/ jsx(CheckboxOff, {});
-            if (partial || isIndeterminate) svg = /*#__PURE__*/ jsx(CheckboxPartial, {});
-            else if (on || isSelected) svg = /*#__PURE__*/ jsx(icons_Checkbox, {});
+            if (isPartial) svg = /*#__PURE__*/ jsx(CheckboxPartial, {});
+            else if (isChecked) svg = /*#__PURE__*/ jsx(icons_Checkbox, {});
             return /*#__PURE__*/ jsxs(Fragment, {
                 children: [
                     label && /*#__PURE__*/ jsx(ControlLabel, {

package/build/components/ComboBox.d.ts

@@ -1,4 +1,4 @@
-import { type ComboBoxProps } from 'react-aria-components';
+import type { ComboBoxProps } from './typeDefs/reactAriaTypes';
 import type { OpenStateProps, SelectInputProps } from './typeDefs/selectionTypes';
 type Props = {
     /** Use when loading options asynchronously with onTextChange */
@@ -8,7 +8,7 @@ type Props = {
     /** The function to be called when the input text does not match any options */
     onCreate?: (text: string) => void;
     ref?: React.Ref<HTMLInputElement>;
-} & SelectInputProps & OpenStateProps & Omit<ComboBoxProps<object>, 'children' | 'onSelectionChange' | 'isOpen' | 'isDisabled' | 'isInvalid' | 'isRequired' | 'defaultSelectedKey'>;
+} & SelectInputProps & OpenStateProps & ComboBoxProps;
 declare const _default: (({ backgroundColor, menuBackground, children, fontSize, disabled, invalid, required, readOnly, loading, loadingResults, label, options, placeholder, placeholderColor, description, errorMessage, textOnly, value, defaultValue, width, height, maxHeight, iconLeft, leftElement, rightElement, allowRepeatSelection, allowsEmptyCollection, position, fixedPosition, open, onOpenChange, before, after, onChange, onCreate, afterShow, afterHide, onTextChange, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element) & {
     Item: ({ id, value, header, body, leftElement, rightElement, inline, disabled, ...props }: import("..").SelectItem & Omit<import("react-aria-components").ListBoxItemProps<object>, "id" | "value" | "isDisabled">) => import("react/jsx-runtime").JSX.Element;
     Section: ({ id, title, children }: {

package/build/components/DropdownMenu.d.ts

@@ -1,9 +1,9 @@
 import { type ReactElement, type ReactNode } from 'react';
-import { type MenuProps as AriaMenuProps, type ButtonProps } from 'react-aria-components';
+import { type ButtonProps } from 'react-aria-components';
+import type { DropdownMenuProps } from './typeDefs/reactAriaTypes';
 import type { ListOption, OpenStateProps, SelectInputProps } from './typeDefs/selectionTypes';
 import type { ThemeProp } from './types';
 type SelectProps = Pick<SelectInputProps, 'children' | 'afterShow' | 'afterHide' | 'position' | 'fixedPosition' | 'before' | 'after' | 'menuBackground'>;
-type MenuProps = Omit<AriaMenuProps<ListOption>, 'selectionMode' | 'selectedKeys' | 'onSelectionChange'>;
 type NoSelection = {
     selectionMode?: never;
     selectedKeys?: never;
@@ -23,7 +23,7 @@ type MultiSelection = {
     onSelectionChange?: (items: 'all' | string[]) => void;
 };
 type SelectionProps = NoSelection | SingleSelection | MultiSelection;
-type DropdownMenuProps = {
+type Props = {
     /** The options to be displayed in the menu */
     options?: ListOption[];
     /** The element that will trigger the opening of the menu */
@@ -36,9 +36,9 @@ type DropdownMenuProps = {
     offset?: number;
     /** Opens the menu on right-click instead of left-click */
     triggerOnContextMenu?: boolean;
-} & SelectProps & MenuProps & SelectionProps & OpenStateProps;
+} & SelectProps & DropdownMenuProps & SelectionProps & OpenStateProps;
 declare const DropdownMenu: {
-    ({ children, position, fixedPosition, trigger, isTriggerButton, triggerProps, triggerOnContextMenu, menuBackground, options, offset, selectionMode, selectedKeys, before, after, open, afterShow, afterHide, onSelectionChange, onOpenChange, ...props }: DropdownMenuProps): import("react/jsx-runtime").JSX.Element;
+    ({ children, position, fixedPosition, trigger, isTriggerButton, triggerProps, triggerOnContextMenu, menuBackground, options, offset, selectionMode, selectedKeys, before, after, open, afterShow, afterHide, onSelectionChange, onOpenChange, ...props }: Props): import("react/jsx-runtime").JSX.Element;
     Item: {
         ({ id, value, children, header, body, leftElement, rightElement, inline, disabled, checkbox, onClick, ...props }: import("./DropdownMenuParts/MenuItem").Props): import("react/jsx-runtime").JSX.Element;
         displayName: string;

package/build/components/Form.d.ts

@@ -40,8 +40,10 @@ declare const Form: {
         checked?: boolean;
         partial?: boolean;
         gap?: number;
-        onChange?: (val: boolean) => void;
-    } & Margin & Omit<import("react-aria-components").CheckboxProps, "value" | "isDisabled" | "isReadOnly" | "isSelected">) => import("react/jsx-runtime").JSX.Element;
+        onChange?: import("react-aria-components").CheckboxProps["onChange"];
+        className?: import("react-aria-components").CheckboxProps["className"];
+        style?: import("react-aria-components").CheckboxProps["style"];
+    } & Margin & Omit<import("react-aria-components").CheckboxProps, "value" | "isDisabled" | "isIndeterminate" | "isSelected" | "isReadOnly">) => import("react/jsx-runtime").JSX.Element;
     Label: ({ children, iconLeft, iconRight, disabled, pill, ...rest }: {
         children?: ReactNode;
         iconLeft?: import("./helpers/getIcon").IconType;

package/build/components/Inputs/DatePicker.d.ts

@@ -1,10 +1,14 @@
 import { type DatePickerProps, type DateValue } from 'react-aria-components';
 import type { DateInputProps } from '../typeDefs/selectionTypes';
-type PickerProps = Omit<DatePickerProps<DateValue>, 'value' | 'onChange' | 'isOpen' | 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired'>;
+type PickerProps = Pick<DatePickerProps<DateValue>, 'autoFocus' | 'firstDayOfWeek' | 'className' | 'style'>;
 type Props = {
     value?: Date;
     onChange: (date: Date) => void;
     ref?: React.Ref<HTMLInputElement>;
+    autoFocus?: PickerProps['autoFocus'];
+    firstDayOfWeek?: PickerProps['firstDayOfWeek'];
+    className?: PickerProps['className'];
+    style?: PickerProps['style'];
 } & DateInputProps & PickerProps;
 declare const DatePicker: ({ value, label, iconLeft, iconRight, loading, fontSize, placeholderColor, disabled, readOnly, invalid, required, description, errorMessage, preventPast, preventFuture, hidePicker, onChange, afterShow, afterHide, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default DatePicker;

package/build/components/Inputs/DateRangePicker.d.ts

@@ -1,11 +1,15 @@
 import { type DateRangePickerProps, type DateValue } from 'react-aria-components';
 import type { DateInputProps } from '../typeDefs/selectionTypes';
-type PickerProps = Omit<DateRangePickerProps<DateValue>, 'value' | 'onChange' | 'isOpen' | 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired'>;
+type PickerProps = Pick<DateRangePickerProps<DateValue>, 'autoFocus' | 'firstDayOfWeek' | 'className' | 'style'>;
 type Props = {
     startValue?: Date;
     endValue?: Date;
     onChange: (start: Date, end: Date) => void;
     ref?: React.Ref<HTMLInputElement>;
+    autoFocus?: PickerProps['autoFocus'];
+    firstDayOfWeek?: PickerProps['firstDayOfWeek'];
+    className?: PickerProps['className'];
+    style?: PickerProps['style'];
 } & DateInputProps & PickerProps;
 declare const DateRangePicker: ({ startValue, endValue, label, iconLeft, iconRight, loading, fontSize, placeholderColor, disabled, readOnly, invalid, required, description, errorMessage, preventPast, preventFuture, hidePicker, onChange, afterShow, afterHide, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default DateRangePicker;

package/build/components/Inputs/NumberInput.d.ts

@@ -1,10 +1,10 @@
-import { type NumberFieldProps } from 'react-aria-components';
 import type { InputProps } from '../typeDefs/inputTypes';
+import type { NumberFieldProps } from '../typeDefs/reactAriaTypes';
 type Props = {
     /** Hides the increment/decrement arrow controls */
     hideControls?: boolean;
     /** Display a comma separator for large numbers (default true) */
     separator?: boolean;
-} & InputProps & Omit<NumberFieldProps, 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired'>;
+} & InputProps & NumberFieldProps;
 declare const NumberInput: ({ value, label, placeholder, iconLeft, iconRight, loading, fontSize, placeholderColor, disabled, readOnly, invalid, required, description, errorMessage, hideControls, separator, onChange, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default NumberInput;

package/build/components/Inputs/PhoneInput.d.ts

@@ -1,7 +1,7 @@
-import { type TextFieldProps } from 'react-aria-components';
 import type { InputProps } from '../typeDefs/inputTypes';
+import type { TextFieldProps } from '../typeDefs/reactAriaTypes';
 type Props = {
     onChange?: (formatted: string, raw: string) => void;
-} & InputProps & Omit<TextFieldProps, 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired' | 'onChange'>;
+} & InputProps & Omit<TextFieldProps, 'onChange'>;
 declare const PhoneInput: ({ value, label, placeholder, iconLeft, iconRight, leftElement, rightElement, loading, fontSize, placeholderColor, disabled, readOnly, invalid, required, description, errorMessage, onChange, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default PhoneInput;

package/build/components/Inputs/SearchInput.d.ts

@@ -1,5 +1,5 @@
-import { type SearchFieldProps } from 'react-aria-components';
 import type { InputProps, TextInputProps } from '../typeDefs/inputTypes';
-type Props = TextInputProps & InputProps & Omit<SearchFieldProps, 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired'>;
+import type { SearchFieldProps } from '../typeDefs/reactAriaTypes';
+type Props = TextInputProps & InputProps & SearchFieldProps;
 declare const SearchInput: ({ value, label, placeholder, iconLeft, iconRight, leftElement, rightElement, loading, fontSize, placeholderColor, disabled, readOnly, invalid, required, description, errorMessage, accepts, onChange, onInput, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default SearchInput;

package/build/components/Inputs/TextArea.d.ts

@@ -1,7 +1,5 @@
-import { type TextFieldProps } from 'react-aria-components';
 import type { InputProps, TextAreaProps } from '../typeDefs/inputTypes';
-type Props = TextAreaProps & InputProps & Omit<TextFieldProps, 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired'> & {
-    asTrigger?: boolean;
-};
+import type { TextFieldProps } from '../typeDefs/reactAriaTypes';
+type Props = TextAreaProps & InputProps & TextFieldProps;
 declare const TextAreaComponent: ({ value, label, placeholder, iconLeft, iconRight, loading, fontSize, placeholderColor, disabled, readOnly, invalid, required, description, errorMessage, accepts, asTrigger, height, maxHeight, onChange, onInput, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default TextAreaComponent;

package/build/components/Inputs/TextInput.d.ts

@@ -1,7 +1,5 @@
-import { type TextFieldProps } from 'react-aria-components';
 import type { InputProps, TextInputProps } from '../typeDefs/inputTypes';
-type Props = TextInputProps & InputProps & Omit<TextFieldProps, 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired'> & {
-    asTrigger?: boolean;
-};
+import type { TextFieldProps } from '../typeDefs/reactAriaTypes';
+type Props = TextFieldProps & TextInputProps & InputProps;
 declare const TextInput: ({ value, label, placeholder, iconLeft, iconRight, leftElement, rightElement, loading, fontSize, placeholderColor, disabled, readOnly, invalid, required, description, errorMessage, accepts, asTrigger, onChange, onInput, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default TextInput;

package/build/components/Inputs/TimeInput.d.ts

@@ -1,9 +1,8 @@
-import { type TimeFieldProps, type TimeValue } from 'react-aria-components';
 import type { InputProps } from '../typeDefs/inputTypes';
-type FieldProps = Omit<TimeFieldProps<TimeValue>, 'value' | 'onChange' | 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired'>;
+import type { TimeFieldProps } from '../typeDefs/reactAriaTypes';
 type Props = {
     value?: string;
     onChange: (time: string) => void;
-} & InputProps & FieldProps;
+} & InputProps & TimeFieldProps;
 declare const TimeInput: ({ value, label, iconLeft, iconRight, loading, fontSize, placeholderColor, disabled, readOnly, invalid, required, description, errorMessage, onChange, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default TimeInput;

package/build/components/Modal.d.ts

@@ -1,6 +1,5 @@
 import { type CSSProperties, type ReactNode, type RefObject } from 'react';
 import { type HeadingProps } from 'react-aria-components';
-import type { ThemeProp } from '../theme';
 import type { Attributes } from './typeDefs/elementTypes';
 import type { FlexPosition, Height, Margin, MaxWidthHeight, MinWidthHeight, Padding, PositionType, WidthHeight } from './types';
 type ModalContainerAttributes = Attributes<HTMLDivElement>;
@@ -58,27 +57,42 @@ type ModalProps = {
 declare const Modal: {
     ({ children, visible, width, height, onClose, closeIcon, preventOverlayClose, overlayBlur, overlayColor, backgroundColor, small, noOverlay, inert, drawer, drawerDirection, scopeRef, centerX, centerY, position, top, bottom, right, left, zIndex, ...props }: ModalProps): import("react/jsx-runtime").JSX.Element;
     Header: {
-        ({ children, ...props }: HeadingProps): import("react/jsx-runtime").JSX.Element;
+        ({ children, ...props }: HeaderProps): import("react/jsx-runtime").JSX.Element;
         displayName: string;
     };
-    Text: import("@emotion/styled").StyledComponent<{
-        theme?: import("@emotion/react").Theme;
-        as?: React.ElementType;
-    } & {
-        primary?: boolean;
-        fontSize?: number | string;
-    } & ThemeProp, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
-    Body: import("@emotion/styled").StyledComponent<{
-        theme?: import("@emotion/react").Theme;
-        as?: React.ElementType;
-    } & Height & Margin, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
-    Footer: import("@emotion/styled").StyledComponent<{
-        theme?: import("@emotion/react").Theme;
-        as?: React.ElementType;
-    } & {
-        justify?: FlexPosition;
-        inline?: boolean;
-        gap?: number | string;
-    } & Margin, import("react").DetailedHTMLProps<import("react").HTMLAttributes<HTMLDivElement>, HTMLDivElement>, {}>;
+    Text: {
+        ({ children, ...props }: TextProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Body: {
+        ({ children, ...props }: BodyProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+    Footer: {
+        ({ children, ...props }: FooterProps): import("react/jsx-runtime").JSX.Element;
+        displayName: string;
+    };
+};
+type HeaderProps = {
+    className?: HeadingProps['className'];
+    style?: HeadingProps['style'];
+} & HeadingProps;
+type TextProps = {
+    children: ReactNode;
+    primary?: boolean;
+    fontSize?: number | string;
+    className?: string;
+    style?: CSSProperties;
 };
+type BodyProps = {
+    children: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+} & Height & Margin;
+type FooterProps = {
+    children: ReactNode;
+    justify?: FlexPosition;
+    inline?: boolean;
+    gap?: number | string;
+} & Margin;
 export default Modal;

package/build/components/Modal.js

@@ -88,15 +88,27 @@ const ModalHeader = styled(Heading)(({ theme })=>({
         margin: 0,
         marginBottom: 8
     }));
-const Text = styled.div(({ theme, primary, fontSize })=>({
+const Text = ({ children, ...props })=>/*#__PURE__*/ jsx(ModalText, {
+        ...props,
+        children: children
+    });
+const ModalText = styled.div(({ theme, primary, fontSize })=>({
         color: primary ? theme.modal.color.header : theme.modal.color.body,
         fontSize: fontSize || theme.font.size.lg
     }));
-const Body = styled.div(({ height })=>({
+const Body = ({ children, ...props })=>/*#__PURE__*/ jsx(ModalBody, {
+        ...props,
+        children: children
+    });
+const ModalBody = styled.div(({ height })=>({
         height,
         overflow: height ? 'auto' : void 0
     }), marginProps);
-const Footer = styled.div(({ justify = 'end', inline, gap })=>{
+const Footer = ({ children, ...props })=>/*#__PURE__*/ jsx(ModalFooter, {
+        ...props,
+        children: children
+    });
+const ModalFooter = styled.div(({ justify = 'end', inline, gap })=>{
     const justifyOptions = {
         start: 'flex-start',
         end: 'flex-end',

package/build/components/MultiSelect/SearchDropdown.d.ts

@@ -1,4 +1,4 @@
-import { type ComboBoxProps } from 'react-aria-components';
+import type { ComboBoxProps } from '../typeDefs/reactAriaTypes';
 import type { MultiSelectItem, MultiSelectOption, SelectInputProps } from '../typeDefs/selectionTypes';
 import type { TagItem } from '../typeDefs/tagTypes';
 type Props = {
@@ -12,6 +12,6 @@ type Props = {
     onTextChange?: (text: string) => void;
     onValidChange?: (valid: boolean) => void;
     ref?: React.Ref<HTMLInputElement>;
-} & Omit<SelectInputProps, 'options'> & Omit<ComboBoxProps<object>, 'children' | 'onSelectionChange' | 'onInputChange' | 'isOpen' | 'isDisabled' | 'isInvalid' | 'isRequired' | 'defaultSelectedKey'>;
+} & Omit<SelectInputProps, 'options'> & ComboBoxProps;
 declare const SearchDropdown: ({ options, items, triggerRef, placeholder, placeholderColor, fontSize, position, fixedPosition, maxHeight, disabled, accepts, addItem, removeItem, afterShow, afterHide, onTextChange, onValidChange, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default SearchDropdown;

package/build/components/Popover.d.ts

@@ -9,8 +9,18 @@ type Props = {
     isTriggerButton?: boolean;
     /** Props to pass to the trigger's container (unless isTriggerButton is true) */
     triggerProps?: ButtonProps;
-    /** Offset of the menu from the trigger */
-    offset?: number;
-} & Omit<PopoverProps, 'trigger' | 'isOpen'> & SelectProps & OpenStateProps;
+    children?: PopoverProps['children'];
+    offset?: PopoverProps['offset'];
+    crossOffset?: PopoverProps['crossOffset'];
+    isNonModal?: PopoverProps['isNonModal'];
+    isKeyboardDismissDisabled?: PopoverProps['isKeyboardDismissDisabled'];
+    shouldCloseOnInteractOutside?: PopoverProps['shouldCloseOnInteractOutside'];
+    boundaryElement?: PopoverProps['boundaryElement'];
+    scrollRef?: PopoverProps['scrollRef'];
+    shouldUpdatePosition?: PopoverProps['shouldUpdatePosition'];
+    defaultOpen?: PopoverProps['defaultOpen'];
+    className?: PopoverProps['className'];
+    style?: PopoverProps['style'];
+} & Omit<PopoverProps, 'trigger' | 'placement' | 'isOpen' | 'onOpenChange' | 'shouldFlip'> & SelectProps & OpenStateProps;
 declare const Popover: ({ children, position, fixedPosition, trigger, isTriggerButton, triggerProps, offset, afterShow, afterHide, open, onOpenChange, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default Popover;

package/build/components/RangeCalendar.d.ts

@@ -8,6 +8,9 @@ type Props = {
     endDate?: Date;
     /** The function to be called when a date range is selected */
     onChange: (start: Date, end: Date) => void;
-} & CalendarBaseProps & Omit<RangeCalendarProps<CalendarDate>, 'onChange'>;
+    firstDayOfWeek?: RangeCalendarProps<CalendarDate>['firstDayOfWeek'];
+    className?: RangeCalendarProps<CalendarDate>['className'];
+    style?: RangeCalendarProps<CalendarDate>['style'];
+} & CalendarBaseProps & Pick<RangeCalendarProps<CalendarDate>, 'firstDayOfWeek' | 'className' | 'style'>;
 declare const RangeCalendar: ({ startDate, endDate, onChange, preventPast, preventFuture, noShadow, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default RangeCalendar;

package/build/components/Select.d.ts

@@ -1,10 +1,10 @@
-import { type SelectProps } from 'react-aria-components';
-import type { OpenStateProps, SelectInputProps, SelectItem } from './typeDefs/selectionTypes';
-type Props = SelectInputProps & OpenStateProps & {
+import type { SelectProps } from './typeDefs/reactAriaTypes';
+import type { OpenStateProps, SelectInputProps } from './typeDefs/selectionTypes';
+type Props = {
     ref?: React.Ref<HTMLButtonElement>;
-} & Omit<SelectProps<SelectItem>, 'children' | 'onSelectionChange' | 'isOpen' | 'isDisabled' | 'isInvalid' | 'isRequired' | 'defaultSelectedKey' | 'selectionMode' | 'value' | 'onChange' | 'validate'>;
+} & SelectInputProps & OpenStateProps & SelectProps;
 declare const _default: (({ backgroundColor, menuBackground, children, fontSize, fontWeight, color, disabled, invalid, required, readOnly, loading, label, options, placeholder, placeholderColor, description, errorMessage, textOnly, value, defaultValue, width, height, maxHeight, allowRepeatSelection, hideCaret, position, fixedPosition, borderRadius, iconLeft, leftElement, rightElement, before, after, open, onOpenChange, onChange, afterShow, afterHide, ref, ...props }: Props) => import("react/jsx-runtime").JSX.Element) & {
-    Item: ({ id, value, header, body, leftElement, rightElement, inline, disabled, ...props }: SelectItem & Omit<import("react-aria-components").ListBoxItemProps<object>, "id" | "value" | "isDisabled">) => import("react/jsx-runtime").JSX.Element;
+    Item: ({ id, value, header, body, leftElement, rightElement, inline, disabled, ...props }: import("..").SelectItem & Omit<import("react-aria-components").ListBoxItemProps<object>, "id" | "value" | "isDisabled">) => import("react/jsx-runtime").JSX.Element;
     Section: ({ id, title, children }: {
         id?: string;
         title?: string;

package/build/components/Table/Body.d.ts

@@ -1,5 +1,5 @@
 import type { ReactNode } from 'react';
-import { type TableLoadMoreItemProps } from 'react-aria-components';
+import { type TableBodyProps, type TableLoadMoreItemProps } from 'react-aria-components';
 type Props = {
     children?: ReactNode;
     /** The function to be called when the end of a scrolling async table has been reached */
@@ -10,7 +10,9 @@ type Props = {
     loading?: boolean;
     /** If true, shows a loading spinner at the bottom of the body */
     fetching?: boolean;
-    className?: string;
-} & Pick<TableLoadMoreItemProps, 'scrollOffset'>;
+    scrollOffset?: TableLoadMoreItemProps['scrollOffset'];
+    className?: TableBodyProps<unknown>['className'];
+    style?: TableBodyProps<unknown>['style'];
+} & Pick<TableLoadMoreItemProps, 'scrollOffset'> & Pick<TableBodyProps<unknown>, 'className' | 'style'>;
 declare const Body: ({ children, emptyFallback, fetching, loading, scrollOffset, onLoadMore, ...rest }: Props) => import("react/jsx-runtime").JSX.Element;
 export default Body;

package/build/components/Table/Cell.d.ts

@@ -1,6 +1,5 @@
 import { type ReactNode } from 'react';
 import { type CellProps } from 'react-aria-components';
-import type { Padding } from '../types';
 import { type ContentProps } from './contentStyles';
 type Props = {
     children?: ReactNode;
@@ -8,6 +7,10 @@ type Props = {
     defaultValue?: string;
     /** Number of lines to clamp */
     clampLines?: number;
-} & Padding & ContentProps & Omit<CellProps, 'children'>;
+    textValue?: CellProps['textValue'];
+    colSpan?: CellProps['colSpan'];
+    className?: CellProps['className'];
+    style?: CellProps['style'];
+} & ContentProps & Omit<CellProps, 'children'>;
 declare const Cell: ({ children, defaultValue, direction, justify, align, gap, clampLines, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default Cell;

package/build/components/Table/Column.d.ts

@@ -1,6 +1,5 @@
 import { type MouseEvent, type ReactNode } from 'react';
 import { type ColumnProps } from 'react-aria-components';
-import type { Padding } from '../types';
 import { type ContentProps } from './contentStyles';
 import type { SortDir } from './types';
 type Props = {
@@ -12,6 +11,14 @@ type Props = {
     sorted?: SortDir;
     /** The property of the data object to sort by */
     sortKey?: string;
-} & Padding & ContentProps & Omit<ColumnProps, 'children' | 'allowsSorting'>;
+    isRowHeader?: ColumnProps['isRowHeader'];
+    textValue?: ColumnProps['textValue'];
+    width?: ColumnProps['width'];
+    minWidth?: ColumnProps['minWidth'];
+    maxWidth?: ColumnProps['maxWidth'];
+    defaultWidth?: ColumnProps['defaultWidth'];
+    className?: ColumnProps['className'];
+    style?: ColumnProps['style'];
+} & ContentProps & Omit<ColumnProps, 'children' | 'allowsSorting'>;
 declare const Column: ({ children, sortKey, sorted, onClick, resize, direction, justify, align, gap, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default Column;

package/build/components/Table/Header.js

@@ -2,8 +2,8 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import styled from "@emotion/styled";
 import { useContext, useEffect } from "react";
 import { TableHeader } from "react-aria-components";
+import Checkbox from "../Checkbox.js";
 import mergePadding from "../helpers/mergePadding.js";
-import Check from "./Check.js";
 import Column from "./Column.js";
 import context from "./context.js";
 const Header = ({ children, backgroundColor, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, ...rest })=>{
@@ -32,7 +32,7 @@ const Header = ({ children, backgroundColor, padding, paddingTop, paddingRight,
         children: [
             /*#__PURE__*/ jsx(Column, {
                 width: 70,
-                children: 'multiple' === selectionMode && /*#__PURE__*/ jsx(Check, {
+                children: 'multiple' === selectionMode && /*#__PURE__*/ jsx(Checkbox, {
                     slot: "selection"
                 })
             }),

package/build/components/Table/Row.js

@@ -2,9 +2,9 @@ import { Fragment, jsx, jsxs } from "react/jsx-runtime";
 import styled from "@emotion/styled";
 import { useContext, useEffect } from "react";
 import { Row } from "react-aria-components";
+import Checkbox from "../Checkbox.js";
 import mergePadding from "../helpers/mergePadding.js";
 import Cell from "./Cell.js";
-import Check from "./Check.js";
 import context from "./context.js";
 const Row_Row = ({ children, onClick, disabled, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, ...rest })=>{
     const { setRowPadding, selectionMode } = useContext(context);
@@ -31,7 +31,7 @@ const Row_Row = ({ children, onClick, disabled, padding, paddingTop, paddingRigh
     const cellsToRender = selectionMode ? /*#__PURE__*/ jsxs(Fragment, {
         children: [
             /*#__PURE__*/ jsx(Cell, {
-                children: /*#__PURE__*/ jsx(Check, {
+                children: /*#__PURE__*/ jsx(Checkbox, {
                     slot: "selection"
                 })
             }),

package/build/components/Table/Table.d.ts

@@ -9,7 +9,20 @@ type Props<T> = {
     backgroundLevel?: 0 | 1 | 2 | 3 | 4 | 5;
     /** Enabled Table.Columns to be resizable (using the `resize` prop) */
     resizable?: boolean;
-} & TableChildren<T> & MarginPadding & MaxHeight & Omit<TableProps, 'children' | 'sortDescriptor' | 'onSortChange' | 'onScroll'>;
+    disabledBehavior?: TableProps['disabledBehavior'];
+    disabledKeys?: TableProps['disabledKeys'];
+    selectionMode?: TableProps['selectionMode'];
+    selectionBehavior?: TableProps['selectionBehavior'];
+    disallowEmptySelection?: TableProps['disallowEmptySelection'];
+    escapeKeyBehavior?: TableProps['escapeKeyBehavior'];
+    selectedKeys?: TableProps['selectedKeys'];
+    defaultSelectedKeys?: TableProps['defaultSelectedKeys'];
+    shouldSelectOnPressUp?: TableProps['shouldSelectOnPressUp'];
+    className?: TableProps['className'];
+    style?: TableProps['style'];
+    onRowAction?: TableProps['onRowAction'];
+    onSelectionChange?: TableProps['onSelectionChange'];
+} & TableChildren<T> & MarginPadding & MaxHeight & Omit<TableProps, 'children' | 'sortDescriptor' | 'onSortChange' | 'onScroll' | 'dragAndDropHooks'>;
 declare const Table: {
     <DataType extends Data>({ children, data, backgroundColor, backgroundLevel, maxHeight, resizable, selectionMode, ...props }: Props<DataType>): import("react/jsx-runtime").JSX.Element;
     Header: ({ children, backgroundColor, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, ...rest }: {
@@ -23,20 +36,30 @@ declare const Table: {
         onClick?: (event: import("react").MouseEvent) => void;
         sorted?: import("./types").SortDir;
         sortKey?: string;
-    } & Padding & {
+        isRowHeader?: import("react-aria-components").ColumnProps["isRowHeader"];
+        textValue?: import("react-aria-components").ColumnProps["textValue"];
+        width?: import("react-aria-components").ColumnProps["width"];
+        minWidth?: import("react-aria-components").ColumnProps["minWidth"];
+        maxWidth?: import("react-aria-components").ColumnProps["maxWidth"];
+        defaultWidth?: import("react-aria-components").ColumnProps["defaultWidth"];
+        className?: import("react-aria-components").ColumnProps["className"];
+        style?: import("react-aria-components").ColumnProps["style"];
+    } & {
         direction?: import("../types").FlexDirection;
         justify?: import("../types").FlexPosition;
         align?: import("../types").FlexPosition;
         gap?: number | string;
-    } & Omit<import("react-aria-components").ColumnProps, "children" | "allowsSorting">) => import("react/jsx-runtime").JSX.Element;
+    } & Padding & Omit<import("react-aria-components").ColumnProps, "children" | "allowsSorting">) => import("react/jsx-runtime").JSX.Element;
     Body: ({ children, emptyFallback, fetching, loading, scrollOffset, onLoadMore, ...rest }: {
         children?: ReactNode;
         onLoadMore?: () => void;
         emptyFallback?: ReactNode;
         loading?: boolean;
         fetching?: boolean;
-        className?: string;
-    } & Pick<import("react-aria-components").TableLoadMoreItemProps, "scrollOffset">) => import("react/jsx-runtime").JSX.Element;
+        scrollOffset?: import("react-aria-components").TableLoadMoreItemProps["scrollOffset"];
+        className?: import("react-aria-components").TableBodyProps<unknown>["className"];
+        style?: import("react-aria-components").TableBodyProps<unknown>["style"];
+    } & Pick<import("react-aria-components").TableLoadMoreItemProps, "scrollOffset"> & Pick<import("react-aria-components").TableBodyProps<unknown>, "className" | "style">) => import("react/jsx-runtime").JSX.Element;
     Row: ({ children, onClick, disabled, padding, paddingTop, paddingRight, paddingBottom, paddingLeft, ...rest }: {
         children: ReactNode;
         id?: string;
@@ -431,11 +454,15 @@ declare const Table: {
         children?: ReactNode;
         defaultValue?: string;
         clampLines?: number;
-    } & Padding & {
+        textValue?: import("react-aria-components").CellProps["textValue"];
+        colSpan?: import("react-aria-components").CellProps["colSpan"];
+        className?: import("react-aria-components").CellProps["className"];
+        style?: import("react-aria-components").CellProps["style"];
+    } & {
         direction?: import("../types").FlexDirection;
         justify?: import("../types").FlexPosition;
         align?: import("../types").FlexPosition;
         gap?: number | string;
-    } & Omit<import("react-aria-components").CellProps, "children">) => import("react/jsx-runtime").JSX.Element;
+    } & Padding & Omit<import("react-aria-components").CellProps, "children">) => import("react/jsx-runtime").JSX.Element;
 };
 export default Table;

package/build/components/Tabs.d.ts

@@ -7,7 +7,14 @@ type Props = {
     detached?: boolean;
     panelPosition?: 'top' | 'bottom';
     disabled?: boolean;
-} & Omit<TabsProps, 'children' | 'isDisabled'> & Margin & WidthHeight & MaxWidthHeight;
+    disabledKeys?: TabsProps['disabledKeys'];
+    selectedKey?: TabsProps['selectedKey'];
+    defaultSelectedKey?: TabsProps['defaultSelectedKey'];
+    keyboardActivation?: TabsProps['keyboardActivation'];
+    className?: TabsProps['className'];
+    style?: TabsProps['style'];
+    onSelectionChange?: TabsProps['onSelectionChange'];
+} & Omit<TabsProps, 'children' | 'isDisabled' | 'orientation'> & Margin & WidthHeight & MaxWidthHeight;
 declare const Tabs: {
     ({ children, detached, panelPosition, disabled, ...props }: Props): import("react/jsx-runtime").JSX.Element;
     List: {
@@ -23,12 +30,15 @@ declare const Tabs: {
         displayName: string;
     };
 };
-type ListProps = TabListProps<any> & {
+type ListProps = {
     /** Controls whether tabs fill the container width or fit to their content */
     tabWidth?: 'fit' | 'fill';
     /** Sets the border radius for the tab items */
     borderRadius?: number;
-} & Padding;
+    children?: TabListProps<any>['children'];
+    className?: TabListProps<any>['className'];
+    style?: TabListProps<any>['style'];
+} & Omit<TabListProps<any>, 'items' | 'dependencies'> & Padding;
 export declare const List: {
     ({ tabWidth, borderRadius, padding, paddingTop, paddingBottom, paddingRight, paddingLeft, ...props }: ListProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
@@ -48,7 +58,13 @@ type ItemProps = {
     gap?: string | number;
     /** Disables the tab from being selected */
     disabled?: boolean;
-} & Omit<TabProps, 'children' | 'isDisabled' | 'id'>;
+    className?: TabProps['className'];
+    style?: TabProps['style'];
+    onPress?: TabProps['onPress'];
+    onHoverChange?: TabProps['onHoverChange'];
+    onHoverStart?: TabProps['onHoverStart'];
+    onHoverEnd?: TabProps['onHoverEnd'];
+} & Omit<TabProps, 'children' | 'isDisabled' | 'id' | 'href' | 'hrefLang' | 'rel' | 'target' | 'download' | 'ping' | 'referrerPolicy' | 'routerOptions' | 'onClick'>;
 export declare const Item: {
     ({ children, icon, iconColor, iconPosition, disabled, ...props }: ItemProps): import("react/jsx-runtime").JSX.Element;
     displayName: string;
@@ -56,6 +72,10 @@ export declare const Item: {
 type PanelProps = {
     /** The unique id that matches the id of the tab */
     id: string;
+    shouldForceMount?: TabPanelProps['shouldForceMount'];
+    children?: TabPanelProps['children'];
+    className?: TabPanelProps['className'];
+    style?: TabPanelProps['style'];
 } & Omit<TabPanelProps, 'id'>;
 export declare const Panel: {
     (props: PanelProps): import("react/jsx-runtime").JSX.Element;

package/build/components/ToggleButton/ToggleButton.d.ts

@@ -24,6 +24,10 @@ type Props = {
     iconRight?: IconName;
     /** The border radius of the toggle button */
     borderRadius?: string | number;
+    isSelected?: ToggleButtonProps['isSelected'];
+    defaultSelected?: ToggleButtonProps['defaultSelected'];
+    className?: ToggleButtonProps['className'];
+    style?: ToggleButtonProps['style'];
 } & Omit<ToggleButtonProps, 'children' | 'id' | 'isDisabled'> & MarginPadding;
 declare const ToggleButton: ({ children, disabled, size, positive, negative, caution, secondary, iconLeft, iconRight, borderRadius, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default ToggleButton;

package/build/components/ToggleButton/ToggleButtonGroup.d.ts

@@ -17,6 +17,14 @@ type Props = {
     joined?: boolean;
     /** The gap between the toggle buttons */
     gap?: string | number;
-} & Omit<ToggleButtonGroupProps, 'isDisabled'> & MarginPadding & WidthHeight;
+    children?: ToggleButtonGroupProps['children'];
+    selectionMode?: ToggleButtonGroupProps['selectionMode'];
+    disallowEmptySelection?: ToggleButtonGroupProps['disallowEmptySelection'];
+    selectedKeys?: ToggleButtonGroupProps['selectedKeys'];
+    defaultSelectedKeys?: ToggleButtonGroupProps['defaultSelectedKeys'];
+    className?: ToggleButtonGroupProps['className'];
+    style?: ToggleButtonGroupProps['style'];
+    onSelectionChange?: ToggleButtonGroupProps['onSelectionChange'];
+} & Omit<ToggleButtonGroupProps, 'isDisabled' | 'orientation'> & MarginPadding & WidthHeight;
 declare const ToggleButtonGroup: ({ disabled, secondary, negative, positive, caution, joined, gap, size, height, ...props }: Props) => import("react/jsx-runtime").JSX.Element;
 export default ToggleButtonGroup;

package/build/components/Tooltip.d.ts

@@ -2,7 +2,7 @@ import { type ReactNode } from 'react';
 import { type TooltipTriggerComponentProps } from 'react-aria-components';
 import type { Attributes } from './typeDefs/elementTypes';
 import type { Placement, ThemeProp } from './types';
-export type TooltipProps = {
+export type Props = {
     children?: ReactNode;
     /** The element that will trigger the opening of the Tooltip */
     trigger: ReactNode;
@@ -35,9 +35,12 @@ export type TooltipProps = {
     afterShow?: () => void;
     /** The function called after the Tooltip closes */
     afterHide?: () => void;
-} & Omit<TooltipTriggerComponentProps, 'children' | 'trigger' | 'isDisabled' | 'isOpen'>;
+    delay?: TooltipTriggerComponentProps['delay'];
+    closeDelay?: TooltipTriggerComponentProps['closeDelay'];
+    defaultOpen?: TooltipTriggerComponentProps['defaultOpen'];
+} & Pick<TooltipTriggerComponentProps, 'delay' | 'closeDelay' | 'defaultOpen'>;
 declare const Tooltip: {
-    ({ trigger, triggerProps, children, content, position, offset, zIndex, width, maxWidth, textAlign, open, disabled, bgColor, color, className, afterShow, afterHide, ...props }: TooltipProps): import("react/jsx-runtime").JSX.Element;
+    ({ trigger, triggerProps, children, content, position, offset, zIndex, width, maxWidth, textAlign, open, disabled, bgColor, color, className, afterShow, afterHide, ...props }: Props): import("react/jsx-runtime").JSX.Element;
     Header: import("@emotion/styled").StyledComponent<{
         theme?: import("@emotion/react").Theme;
         as?: React.ElementType;

package/build/components/Tree/Tree.d.ts

@@ -7,10 +7,23 @@ type Props = {
     selectedKeys?: Set<React.Key>;
     /** Handler that is called when the selection changes */
     onSelectionChange?: (keys: Set<React.Key>) => void;
-} & WidthHeight & Padding & Omit<TreeProps<object>, 'selectedKeys' | 'onSelectionChange'>;
+    expandedKeys?: TreeProps<object>['expandedKeys'];
+    defaultExpandedKeys?: TreeProps<object>['defaultExpandedKeys'];
+    renderEmptyState?: TreeProps<object>['renderEmptyState'];
+    disabledBehavior?: TreeProps<object>['disabledBehavior'];
+    escapeKeyBehavior?: TreeProps<object>['escapeKeyBehavior'];
+    autoFocus?: TreeProps<object>['autoFocus'];
+    shouldSelectOnPressUp?: TreeProps<object>['shouldSelectOnPressUp'];
+    disabledKeys?: TreeProps<object>['disabledKeys'];
+    children?: TreeProps<object>['children'];
+    className?: TreeProps<object>['className'];
+    style?: TreeProps<object>['style'];
+    onAction?: TreeProps<object>['onAction'];
+    onExpandedChange?: TreeProps<object>['onExpandedChange'];
+} & WidthHeight & Padding & Omit<TreeProps<object>, 'items' | 'selectionMode' | 'selectionBehavior' | 'selectedKeys' | 'onSelectionChange' | 'disallowEmptySelection' | 'dragAndDropHooks' | 'dependencies'>;
 declare const Tree: {
     ({ backgroundColor, expandedKeys: expandedKeysProp, onExpandedChange, defaultExpandedKeys, selectedKeys, onSelectionChange, ...props }: Props): import("react/jsx-runtime").JSX.Element;
-    Item: ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, ...props }: {
+    Item: ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, disabled, ...props }: {
         title: string;
         children?: import("react").ReactNode;
         content?: import("react").ReactNode;
@@ -18,6 +31,15 @@ declare const Tree: {
         iconRight?: import("../helpers/getIcon").IconType;
         expandOnSelect?: boolean;
         indent?: number;
-    } & Omit<import("react-aria-components").TreeItemProps<string>, "children" | "value" | "textValue">) => import("react/jsx-runtime").JSX.Element;
+        disabled?: boolean;
+        id?: import("react-aria-components").TreeItemProps<string>["id"];
+        className?: import("react-aria-components").TreeItemProps<string>["className"];
+        style?: import("react-aria-components").TreeItemProps<string>["style"];
+        onAction?: import("react-aria-components").TreeItemProps<string>["onAction"];
+        onPress?: import("react-aria-components").TreeItemProps<string>["onPress"];
+        onHoverStart?: import("react-aria-components").TreeItemProps<string>["onHoverStart"];
+        onHoverEnd?: import("react-aria-components").TreeItemProps<string>["onHoverEnd"];
+        onHoverChange?: import("react-aria-components").TreeItemProps<string>["onHoverChange"];
+    } & Pick<import("react-aria-components").TreeItemProps<string>, "className" | "style" | "id" | "aria-label" | "onPress" | "onPressStart" | "onPressEnd" | "onPressChange" | "onAction" | "onHoverStart" | "onHoverEnd" | "onHoverChange">) => import("react/jsx-runtime").JSX.Element;
 };
 export default Tree;

package/build/components/Tree/TreeItem.d.ts

@@ -16,6 +16,15 @@ type ItemProps = {
     expandOnSelect?: boolean;
     /** The indentation level of the item (default: 1 === 16px) */
     indent?: number;
-} & Omit<TreeItemProps<string>, 'textValue' | 'value' | 'children'>;
-declare const Item: ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, ...props }: ItemProps) => import("react/jsx-runtime").JSX.Element;
+    disabled?: boolean;
+    id?: TreeItemProps<string>['id'];
+    className?: TreeItemProps<string>['className'];
+    style?: TreeItemProps<string>['style'];
+    onAction?: TreeItemProps<string>['onAction'];
+    onPress?: TreeItemProps<string>['onPress'];
+    onHoverStart?: TreeItemProps<string>['onHoverStart'];
+    onHoverEnd?: TreeItemProps<string>['onHoverEnd'];
+    onHoverChange?: TreeItemProps<string>['onHoverChange'];
+} & Pick<TreeItemProps<string>, 'id' | 'className' | 'style' | 'onAction' | 'onHoverStart' | 'onHoverEnd' | 'onHoverChange' | 'onPress' | 'onPressStart' | 'onPressEnd' | 'onPressChange' | 'aria-label'>;
+declare const Item: ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, disabled, ...props }: ItemProps) => import("react/jsx-runtime").JSX.Element;
 export default Item;

package/build/components/Tree/TreeItem.js

@@ -6,12 +6,13 @@ import getIcon from "../helpers/getIcon.js";
 import Icon from "../Icon/index.js";
 import AriaButton from "../Inputs/helpers/AriaButton.js";
 import { TreeContext } from "./TreeContext.js";
-const Item = ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, ...props })=>{
+const Item = ({ children, title, id, iconLeft, iconRight, expandOnSelect, indent, content, disabled, ...props })=>{
     const { requestExpand } = useContext(TreeContext);
     return /*#__PURE__*/ jsxs(TreeItemContainer, {
         id: id || title,
         textValue: title,
         indent: indent,
+        isDisabled: disabled,
         ...expandOnSelect && children ? {
             onPress: ()=>{
                 requestExpand?.([

package/build/components/helpers/getIcon.d.ts

@@ -1,7 +1,7 @@
 import { type ReactElement } from 'react';
 import type { IconName } from '../Icon/Icon';
 import { type IconProps } from '../Icon/Icon';
-import type { TooltipProps } from '../Tooltip';
+import type { Props as TooltipProps } from '../Tooltip';
 export type IconType = IconName | IconProps | ReactElement<IconProps> | ReactElement<TooltipProps>;
 type ReducedIconProps = Omit<IconProps, 'name' | 'svg' | 'external'>;
 declare const getIcon: (icon: IconType, props?: ReducedIconProps) => ReactElement<IconProps | TooltipProps>;

package/build/components/typeDefs/inputTypes.d.ts

@@ -48,6 +48,7 @@ export type InputBaseProps = {
 export type TextInputProps = {
     /** A regex string, similar to `pattern`, but prevents input outside the pattern */
     accepts?: string;
+    asTrigger?: boolean;
 };
 export type TextAreaProps = TextInputProps & {
     /** Maximum height of the textarea. Content will scroll after this height is reached */

package/build/components/typeDefs/reactAriaTypes.d.ts

@@ -0,0 +1,126 @@
+import type { ComboBoxProps as AriaComboBoxProps, MenuProps as AriaMenuProps, SelectProps as AriaSelectProps, NumberFieldProps as NumberProps, SearchFieldProps as SearchProps, TextFieldProps as TextProps, TimeFieldProps as TimeBaseProps, TimeValue } from 'react-aria-components';
+import type { ListOption, SelectItem } from './selectionTypes';
+/** INPUTS */
+type TimeProps = TimeBaseProps<TimeValue>;
+export type TextFieldProps = {
+    value?: TextProps['value'];
+    defaultValue?: TextProps['defaultValue'];
+    enterKeyHint?: TextProps['enterKeyHint'];
+    validate?: TextProps['validate'];
+    autoFocus?: TextProps['autoFocus'];
+    autoComplete?: TextProps['autoComplete'];
+    maxLength?: TextProps['maxLength'];
+    minLength?: TextProps['minLength'];
+    pattern?: TextProps['pattern'];
+    type?: TextProps['type'];
+    inputMode?: TextProps['inputMode'];
+    autoCorrect?: TextProps['autoCorrect'];
+    spellCheck?: TextProps['spellCheck'];
+    name?: TextProps['name'];
+    form?: TextProps['form'];
+    validationBehavior?: TextProps['validationBehavior'];
+    className?: TextProps['className'];
+    style?: TextProps['style'];
+    onChange?: TextProps['onChange'];
+    onInput?: TextProps['onInput'];
+} & Omit<TextProps, 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired' | 'children'>;
+export type SearchFieldProps = {
+    value?: SearchProps['value'];
+    defaultValue?: SearchProps['defaultValue'];
+    enterKeyHint?: SearchProps['enterKeyHint'];
+    validate?: SearchProps['validate'];
+    autoFocus?: SearchProps['autoFocus'];
+    autoComplete?: SearchProps['autoComplete'];
+    maxLength?: SearchProps['maxLength'];
+    minLength?: SearchProps['minLength'];
+    pattern?: SearchProps['pattern'];
+    type?: SearchProps['type'];
+    inputMode?: SearchProps['inputMode'];
+    autoCorrect?: SearchProps['autoCorrect'];
+    spellCheck?: SearchProps['spellCheck'];
+    name?: SearchProps['name'];
+    form?: SearchProps['form'];
+    validationBehavior?: SearchProps['validationBehavior'];
+    className?: SearchProps['className'];
+    style?: SearchProps['style'];
+    onChange?: SearchProps['onChange'];
+    onInput?: SearchProps['onInput'];
+} & Omit<SearchProps, 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired' | 'children'>;
+export type NumberFieldProps = {
+    value?: NumberProps['value'];
+    defaultValue?: NumberProps['defaultValue'];
+    isWheelDisabled?: NumberProps['isWheelDisabled'];
+    formatOptions?: NumberProps['formatOptions'];
+    validate?: NumberProps['validate'];
+    autoFocus?: NumberProps['autoFocus'];
+    minValue?: NumberProps['minValue'];
+    maxValue?: NumberProps['maxValue'];
+    step?: NumberProps['step'];
+    name?: NumberProps['name'];
+    form?: NumberProps['form'];
+    validationBehavior?: NumberProps['validationBehavior'];
+    className?: NumberProps['className'];
+    style?: NumberProps['style'];
+    onChange?: NumberProps['onChange'];
+    onInput?: NumberProps['onInput'];
+} & Omit<NumberProps, 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired' | 'children'>;
+export type TimeFieldProps = {
+    hourCycle?: TimeProps['hourCycle'];
+    granularity?: TimeProps['granularity'];
+    minValue?: TimeProps['minValue'];
+    maxValue?: TimeProps['maxValue'];
+    validate?: TimeProps['validate'];
+    autoFocus?: TimeProps['autoFocus'];
+    name?: TimeProps['name'];
+    form?: TimeProps['form'];
+    validationBehavior?: TimeProps['validationBehavior'];
+    className?: TimeProps['className'];
+    style?: TimeProps['style'];
+} & Omit<TimeProps, 'value' | 'defaultValue' | 'isDisabled' | 'isReadOnly' | 'isInvalid' | 'isRequired' | 'children' | 'onChange'>;
+/** SELECTS */
+type Combo = AriaComboBoxProps<object>;
+export type ComboBoxProps = {
+    defaultFilter?: Combo['defaultFilter'];
+    formValue?: Combo['formValue'];
+    allowsEmptyCollection?: Combo['allowsEmptyCollection'];
+    shouldFocusWrap?: Combo['shouldFocusWrap'];
+    allowsCustomValue?: Combo['allowsCustomValue'];
+    menuTrigger?: Combo['menuTrigger'];
+    disabledKeys?: Combo['disabledKeys'];
+    validate?: Combo['validate'];
+    autoFocus?: Combo['autoFocus'];
+    name?: Combo['name'];
+    form?: Combo['form'];
+    validationBehavior?: Combo['validationBehavior'];
+    className?: Combo['className'];
+    style?: Combo['style'];
+    onOpenChange?: Combo['onOpenChange'];
+} & Omit<Combo, 'children' | 'defaultItems' | 'items' | 'onSelectionChange' | 'onInputChange' | 'selectedKey' | 'defaultSelectedKey' | 'inputValue' | 'defaultInputValue' | 'isOpen' | 'isDisabled' | 'isInvalid' | 'isRequired'>;
+type Select = AriaSelectProps<SelectItem>;
+export type SelectProps = {
+    autoComplete?: Select['autoComplete'];
+    name?: Select['name'];
+    form?: Select['form'];
+    defaultOpen?: Select['defaultOpen'];
+    disabledKeys?: Select['disabledKeys'];
+    defaultValue?: Select['defaultValue'];
+    autoFocus?: Select['autoFocus'];
+    validationBehavior?: Select['validationBehavior'];
+    className?: Select['className'];
+    style?: Select['style'];
+    onOpenChange?: Select['onOpenChange'];
+} & Omit<Select, 'placeholder' | 'selectionMode' | 'value' | 'children' | 'isOpen' | 'isDisabled' | 'isInvalid' | 'isRequired' | 'defaultSelectedKey' | 'selectionMode' | 'onChange' | 'validate' | 'onSelectionChange'>;
+type MenuProps = AriaMenuProps<ListOption>;
+export type DropdownMenuProps = {
+    renderEmptyState?: MenuProps['renderEmptyState'];
+    escapeKeyBehavior?: MenuProps['escapeKeyBehavior'];
+    autoFocus?: MenuProps['autoFocus'];
+    shouldFocusWrap?: MenuProps['shouldFocusWrap'];
+    disabledKeys?: MenuProps['disabledKeys'];
+    disallowEmptySelection?: MenuProps['disallowEmptySelection'];
+    className?: MenuProps['className'];
+    style?: MenuProps['style'];
+    onAction?: MenuProps['onAction'];
+    onClose?: MenuProps['onClose'];
+} & Omit<MenuProps, 'items' | 'selectionMode' | 'selectedKeys' | 'defaultSelectedKeys' | 'children' | 'dependencies' | 'onSelectionChange'>;
+export {};

package/build/components/typeDefs/selectionTypes.d.ts

@@ -68,6 +68,7 @@ export type SelectInputProps = {
     after?: ReactNode;
     /** The function to be called when an option is selected */
     onChange?: (key: string) => void;
+    maxHeight?: PopoverProps['maxHeight'];
 } & Omit<InputProps, 'iconRight'> & ShowHideCallbacks & Pick<PopoverProps, 'maxHeight'>;
 export type CalendarBaseProps = {
     /** Prevents selection of dates in the past (relative to the set date or current date). */

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@wavv/ui",
-	"version": "2.2.4",
+	"version": "2.2.5",
 	"type": "module",
 	"exports": {
 		".": {

package/build/components/Table/Check.d.ts

@@ -1,3 +0,0 @@
-import { type CheckboxProps } from 'react-aria-components';
-declare const Check: ({ ...props }: CheckboxProps) => import("react/jsx-runtime").JSX.Element;
-export default Check;

package/build/components/Table/Check.js

@@ -1,35 +0,0 @@
-import { jsx } from "react/jsx-runtime";
-import styled from "@emotion/styled";
-import { Checkbox } from "react-aria-components";
-import icons_Checkbox from "../../assets/icons/Checkbox.js";
-import CheckboxOff from "../../assets/icons/CheckboxOff.js";
-import CheckboxPartial from "../../assets/icons/CheckboxPartial.js";
-import Icon from "../Icon/index.js";
-const Check = ({ ...props })=>/*#__PURE__*/ jsx(CheckContainer, {
-        ...props,
-        children: ({ isIndeterminate, isSelected, isDisabled })=>{
-            let svg = /*#__PURE__*/ jsx(CheckboxOff, {});
-            if (isIndeterminate) svg = /*#__PURE__*/ jsx(CheckboxPartial, {});
-            else if (isSelected) svg = /*#__PURE__*/ jsx(icons_Checkbox, {});
-            return /*#__PURE__*/ jsx(Icon, {
-                svg: svg,
-                pointer: !isDisabled
-            });
-        }
-    });
-const CheckContainer = styled(Checkbox)(({ theme: { formControl }, isDisabled })=>({
-        '&[data-hovered] > div': {
-            color: isDisabled ? void 0 : formControl.color.hover
-        },
-        '&[data-selected] > div, &[data-indeterminate] > div': {
-            color: formControl.color.active
-        },
-        '&[data-hovered][data-selected] > div': {
-            color: isDisabled ? void 0 : formControl.color.activeHover
-        },
-        '&[data-disabled] > div': {
-            color: formControl.color.disabled
-        }
-    }));
-const Table_Check = Check;
-export { Table_Check as default };