@kazee-ds/react 0.5.5 → 0.7.0

package/dist/types/Textarea.d.ts

@@ -1,5 +1,8 @@
+import { InputRoot, type InputCompositionProps } from './control-composition.js';
+import type { TextAreaProps as AriaTextAreaProps } from 'react-aria-components/TextField';
+import { type StylingProps } from './styling.js';
 /** A labeled multiline string field; validation is owned by the application. */
-export interface TextareaProps {
+export interface TextareaProps extends StylingProps<'root' | 'label' | 'input' | 'description' | 'error'> {
     label: string;
     value?: string;
     defaultValue?: string;
@@ -21,4 +24,12 @@ export interface TextareaProps {
     maxLength?: number;
     dir?: 'ltr' | 'rtl';
 }
-export declare function Textarea({ label, value, defaultValue, onChange, description, errorMessage, isInvalid, isDisabled, isReadOnly, isRequired, placeholder, rows, resize, name, id, autoComplete, maxLength, dir, }: TextareaProps): import("react").JSX.Element;
+declare function TextareaControl({ className, ...props }: Omit<AriaTextAreaProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+declare function TextareaRoot(props: TextareaProps | InputCompositionProps): import("react").JSX.Element;
+export declare const Textarea: typeof TextareaRoot & {
+    Root: typeof InputRoot;
+    Control: typeof TextareaControl;
+};
+export {};

package/dist/types/TimeControls.d.ts

@@ -0,0 +1,14 @@
+import { type HTMLAttributes } from 'react';
+import { type TemporalConstraints } from './temporal-model.js';
+export interface TimeControlProps extends Omit<TemporalConstraints, 'kind'>, Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue'> {
+    value?: string | null;
+    defaultValue?: string | null;
+    onChange?: (value: string) => void;
+    label?: string;
+    locale?: string;
+    hourCycle?: 12 | 24;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+}
+export declare function TimeList({ value, defaultValue, onChange, label, locale, hourCycle, isDisabled, isReadOnly, className, minTime, maxTime, hourStep, minuteStep, secondStep, granularity, isTimeUnavailable, ...props }: TimeControlProps): import("react").JSX.Element;
+export declare function TimeClock({ value, defaultValue, onChange, label, locale, hourCycle, isDisabled, isReadOnly, className, minTime, maxTime, hourStep, minuteStep, secondStep, granularity, isTimeUnavailable, ...props }: TimeControlProps): import("react").JSX.Element;

package/dist/types/Toast.d.ts

@@ -1,6 +1,8 @@
-import { type ReactNode } from 'react';
+import { type StylingProps } from './styling.js';
+import { type ReactNode, type HTMLAttributes, type ComponentProps } from 'react';
+import { Button, Text, UNSTABLE_ToastContent as ToastContent } from 'react-aria-components';
 import { type ToastEntry, type ToastManager, type ToastPlacement } from './toast-model.js';
-export interface ToastProviderProps {
+export interface ToastProviderProps extends StylingProps<'root' | 'list'> {
     children?: ReactNode;
     manager?: ToastManager;
     placement?: ToastPlacement;
@@ -16,9 +18,9 @@ export interface ToastProviderProps {
     /** Customize presentation with the exported Toast component, retaining region behavior. */
     renderToast?: (entry: ToastEntry) => ReactNode;
 }
-export declare function ToastProvider({ children, manager: suppliedManager, placement, label, closeLabel, hotkey, dir, showProgress, showCloseButton, swipeThreshold, renderToast, }: ToastProviderProps): import("react").JSX.Element;
+export declare function ToastProvider({ className, classNames, style, children, manager: suppliedManager, placement, label, closeLabel, hotkey, dir, showProgress, showCloseButton, swipeThreshold, renderToast, }: ToastProviderProps): import("react").JSX.Element;
 export declare function useToast(): ToastManager;
-export interface ToastProps {
+export interface ToastProps extends StylingProps<'root' | 'indicator' | 'body' | 'title' | 'description' | 'actions' | 'action' | 'close' | 'progress'> {
     entry: ToastEntry;
     /** Override the provider's close button visibility for this toast. */
     showCloseButton?: boolean;
@@ -26,7 +28,29 @@ export interface ToastProps {
     showProgress?: boolean;
     indicator?: ReactNode;
     children?: ReactNode;
-    /** Additional class appended to the shared toast class. */
-    className?: string;
 }
-export declare function Toast({ entry, indicator, children, className, showCloseButton: closeOverride, showProgress: progressOverride, }: ToastProps): import("react").JSX.Element;
+export declare function ToastRoot(props: ToastProps): import("react").JSX.Element;
+export declare function ToastIndicator({ className, children, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;
+export declare function ToastBody({ className, ...props }: ComponentProps<typeof ToastContent>): import("react").JSX.Element;
+export declare function ToastTitle({ className, children, ...props }: ComponentProps<typeof Text>): import("react").JSX.Element;
+export declare function ToastDescription({ className, children, ...props }: ComponentProps<typeof Text>): import("react").JSX.Element | null;
+export declare function ToastActions({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function ToastActionButton({ className, children, cancel, onPress, ...props }: ComponentProps<typeof Button> & {
+    cancel?: boolean;
+}): import("react").JSX.Element | null;
+export declare function ToastCloseButton({ className, children, ...props }: ComponentProps<typeof Button>): import("react").JSX.Element;
+export declare function ToastProgress({ className, style, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element | null;
+declare function CompactToast(props: ToastProps): import("react").JSX.Element;
+export declare const Toast: typeof CompactToast & {
+    Root: typeof ToastRoot;
+    Provider: typeof ToastProvider;
+    Indicator: typeof ToastIndicator;
+    Content: typeof ToastBody;
+    Title: typeof ToastTitle;
+    Description: typeof ToastDescription;
+    Actions: typeof ToastActions;
+    ActionButton: typeof ToastActionButton;
+    CloseButton: typeof ToastCloseButton;
+    Progress: typeof ToastProgress;
+};
+export {};

package/dist/types/ToggleButton.d.ts

@@ -1,9 +1,10 @@
+import { type StylingProps } from './styling.js';
 import { type ReactNode } from 'react';
 import { type ToggleButtonRenderProps as AriaRenderProps } from 'react-aria-components/ToggleButton';
 import type { ButtonPressEvent, ButtonSize } from './Button.js';
-export type ToggleButtonVariant = 'default' | 'ghost';
+export type ToggleButtonVariant = 'default' | 'ghost' | 'chip';
 export type ToggleButtonRenderProps = Omit<AriaRenderProps, 'state'>;
-export interface ToggleButtonProps {
+export interface ToggleButtonProps extends StylingProps {
     id?: string;
     children?: ReactNode | ((state: ToggleButtonRenderProps) => ReactNode);
     variant?: ToggleButtonVariant;
@@ -20,4 +21,5 @@ export interface ToggleButtonProps {
     autoFocus?: boolean;
 }
 export declare const ToggleButtonSizeContext: import("react").Context<ButtonSize>;
-export declare function ToggleButton({ children, variant, size, isIconOnly, ...props }: ToggleButtonProps): import("react").JSX.Element;
+export declare const ToggleButtonVariantContext: import("react").Context<ToggleButtonVariant>;
+export declare function ToggleButton({ children, variant, size, isIconOnly, className: consumerClassName, classNames, style, ...props }: ToggleButtonProps): import("react").JSX.Element;

package/dist/types/ToggleButtonGroup.d.ts

@@ -1,10 +1,13 @@
+import { type StylingProps } from './styling.js';
 import type { ReactNode } from 'react';
 import type { ButtonSize } from './Button.js';
+import { type ToggleButtonVariant } from './ToggleButton.js';
 import { ButtonGroupSeparator } from './ButtonGroup.js';
-interface Common {
+interface Common extends StylingProps {
     label: string;
     children: ReactNode;
     size?: ButtonSize;
+    variant?: ToggleButtonVariant;
     isDisabled?: boolean;
     isDetached?: boolean;
     fullWidth?: boolean;

package/dist/types/ToggleGroup.d.ts

@@ -1,8 +1,12 @@
+import { type ToggleButtonGroupProps } from './ToggleButtonGroup.js';
+import { ToggleButton as ComposedToggleItem } from './ToggleButton.js';
+import { ButtonGroupSeparator } from './ButtonGroup.js';
+import { type StylingProps } from './styling.js';
 import { type ReactNode } from 'react';
 import { type ToggleGroupItem, type ToggleGroupVariant } from './toggle-group-model.js';
 import type { ButtonSize } from './Button.js';
 export type { ToggleGroupItem, ToggleGroupMode, ToggleGroupVariant } from './toggle-group-model.js';
-interface ToggleGroupCommonProps {
+interface ToggleGroupCommonProps extends StylingProps<'root' | 'item' | 'icon' | 'label'> {
     label: string;
     items: ToggleGroupItem[];
     isDisabled?: boolean;
@@ -25,9 +29,20 @@ export type ToggleGroupProps = ToggleGroupCommonProps & ({
     defaultValue?: string[];
     onChange?: (value: string[]) => void;
 });
-export declare function ToggleGroup(props: Extract<ToggleGroupProps, {
+declare function ToggleGroupRoot(props: Extract<ToggleGroupProps, {
+    selectionMode: 'multiple';
+}> | Extract<ToggleButtonGroupProps, {
     selectionMode: 'multiple';
 }>): ReactNode;
-export declare function ToggleGroup(props: Exclude<ToggleGroupProps, {
+declare function ToggleGroupRoot(props: Exclude<ToggleGroupProps, {
+    selectionMode: 'multiple';
+}> | Exclude<ToggleButtonGroupProps, {
     selectionMode: 'multiple';
 }>): ReactNode;
+export declare const ToggleGroup: typeof ToggleGroupRoot & {
+    Root: ((props: ToggleButtonGroupProps) => import("react").JSX.Element) & {
+        Separator: typeof ButtonGroupSeparator;
+    };
+    Item: typeof ComposedToggleItem;
+    Separator: typeof ButtonGroupSeparator;
+};

package/dist/types/Tooltip.d.ts

@@ -1,6 +1,10 @@
+import type { TooltipRootProps } from './structural-parts.js';
+import { TooltipRoot } from './structural-parts.js';
+import { type StylingProps } from './styling.js';
 import type { ReactNode } from 'react';
 import type { ButtonVariant, ButtonSize } from './Button.js';
-export interface TooltipProps {
+export type TooltipPart = 'root' | 'trigger' | 'panel';
+export interface TooltipProps extends StylingProps<TooltipPart> {
     triggerLabel: string;
     text: string;
     triggerContent?: ReactNode;
@@ -13,4 +17,10 @@ export interface TooltipProps {
     isDisabled?: boolean;
     dir?: 'ltr' | 'rtl';
 }
-export declare function Tooltip({ triggerLabel, text, triggerContent, triggerIconOnly, triggerVariant, triggerSize, open, defaultOpen, onOpenChange, isDisabled, dir, }: TooltipProps): import("react").JSX.Element;
+declare function TooltipComponent(props: TooltipProps | TooltipRootProps): import("react").JSX.Element;
+export declare const Tooltip: typeof TooltipComponent & {
+    Root: typeof TooltipRoot;
+    Trigger: ({ className, ...props }: import("react-aria-components").ButtonProps & import("react").RefAttributes<HTMLButtonElement>) => import("react").ReactElement<import("react-aria-components").ButtonProps & import("react").RefAttributes<HTMLButtonElement>, string | import("react").JSXElementConstructor<any>>;
+    Content: ({ className, ...props }: import("react-aria-components").TooltipProps & import("react").RefAttributes<HTMLDivElement>) => import("react").ReactElement<import("react-aria-components").TooltipProps & import("react").RefAttributes<HTMLDivElement>, string | import("react").JSXElementConstructor<any>>;
+};
+export {};

package/dist/types/choice-composition.d.ts

@@ -0,0 +1,35 @@
+import { type HTMLAttributes } from 'react';
+import { type CheckboxProps as AriaCheckboxProps } from 'react-aria-components/Checkbox';
+import { type SwitchFieldProps } from 'react-aria-components/Switch';
+import { type RadioGroupProps as AriaRadioGroupProps, type RadioProps } from 'react-aria-components/RadioGroup';
+import { type SwitchVisualProps } from './switch-visual.js';
+type ChoiceElementProps = HTMLAttributes<HTMLSpanElement>;
+export type CheckboxCompositionProps = Omit<AriaCheckboxProps, 'className'> & {
+    className?: string;
+    label?: never;
+};
+export declare function CheckboxComposition({ className, children, ...props }: CheckboxCompositionProps): import("react").JSX.Element;
+export declare function CheckboxControl({ className, ...props }: ChoiceElementProps): import("react").JSX.Element;
+export declare function CheckboxIndicator({ className, children, ...props }: ChoiceElementProps): import("react").JSX.Element;
+export declare function ChoiceContent({ className, ...props }: ChoiceElementProps): import("react").JSX.Element;
+export type SwitchCompositionProps = Omit<SwitchFieldProps, 'className' | 'children'> & SwitchVisualProps & {
+    className?: string;
+    label?: never;
+    children?: import('react').ReactNode | ((state: import('react-aria-components/Switch').SwitchFieldRenderProps & Partial<import('react-aria-components/Switch').SwitchButtonRenderProps>) => import('react').ReactNode);
+};
+export declare function SwitchComposition({ className, children, size, tone, variant, ...props }: SwitchCompositionProps): import("react").JSX.Element;
+export declare function SwitchControl({ className, ...props }: ChoiceElementProps): import("react").JSX.Element;
+export declare function SwitchThumb({ className, ...props }: ChoiceElementProps): import("react").JSX.Element;
+export declare function SwitchIcon({ className, ...props }: ChoiceElementProps): import("react").JSX.Element;
+export type RadioGroupCompositionProps = Omit<AriaRadioGroupProps, 'className'> & {
+    className?: string;
+    options?: never;
+    label?: never;
+};
+export declare function RadioGroupComposition({ className, ...props }: RadioGroupCompositionProps): import("react").JSX.Element;
+export declare function RadioItem({ className, children, ...props }: Omit<RadioProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function RadioControl({ className, ...props }: ChoiceElementProps): import("react").JSX.Element;
+export declare function RadioIndicator({ className, ...props }: ChoiceElementProps): import("react").JSX.Element;
+export {};

package/dist/types/combobox-composition.d.ts

@@ -0,0 +1,22 @@
+import { type ComboBoxProps, type InputProps, type ButtonProps, type PopoverProps } from 'react-aria-components/ComboBox';
+import { type HTMLAttributes } from 'react';
+export type ComboboxCompositionProps = Omit<ComboBoxProps<object>, 'className' | 'onChange' | 'value' | 'defaultValue'> & {
+    className?: string;
+    options?: never;
+    label?: never;
+    value?: string | null;
+    defaultValue?: string | null;
+    onChange?: (value: string | null) => void;
+};
+export declare function ComboboxComposition({ className, onChange, ...props }: ComboboxCompositionProps): import("react").JSX.Element;
+export declare function ComboboxInputGroup({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function ComboboxInput({ className, ...props }: Omit<InputProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function ComboboxTrigger({ className, children, ...props }: Omit<ButtonProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function ComboboxPopover({ className, ...props }: Omit<PopoverProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function ComboboxClearButton({ className, children, 'aria-label': label, ...props }: Omit<HTMLAttributes<HTMLButtonElement>, 'onClick'>): import("react").JSX.Element;

package/dist/types/control-composition.d.ts

@@ -0,0 +1,73 @@
+import { type Ref, type ComponentProps, type HTMLAttributes } from 'react';
+import { Button } from 'react-aria-components/Button';
+import { type SelectProps as AriaSelectProps, type SelectValueProps } from 'react-aria-components/Select';
+import { type PopoverProps } from 'react-aria-components/Popover';
+import { type ListBoxProps, type ListBoxItemProps, type ListBoxSectionProps } from 'react-aria-components/ListBox';
+import { type TextProps } from 'react-aria-components/Text';
+import { Header } from 'react-aria-components/Header';
+import { type FieldErrorProps } from 'react-aria-components/FieldError';
+import { type TextFieldProps, type InputProps as AriaInputProps } from 'react-aria-components/TextField';
+import { type GroupProps } from 'react-aria-components/Group';
+import { type StylingProps } from './styling.js';
+export type SelectPart = 'root' | 'label' | 'control' | 'trigger' | 'value' | 'indicator' | 'clearButton' | 'popover' | 'list' | 'item' | 'itemIndicator' | 'description' | 'error';
+export type SelectCompositionProps<M extends 'single' | 'multiple' = 'single'> = Omit<AriaSelectProps<object, M>, 'className' | 'style' | 'onChange' | 'value' | 'defaultValue'> & StylingProps<SelectPart> & {
+    options?: never;
+    label?: never;
+    value?: AriaSelectProps<object, M>['value'];
+    defaultValue?: AriaSelectProps<object, M>['defaultValue'];
+    onChange?: (value: M extends 'multiple' ? string[] : string | null) => void;
+    onClear?: () => void;
+    size?: import('./Select.js').SelectSize;
+    variant?: import('./Select.js').SelectVariant;
+    fullWidth?: boolean;
+    hideLabel?: boolean;
+};
+export declare function SelectComposition<M extends 'single' | 'multiple' = 'single'>({ className, style, classNames, onClear, onChange, size, variant, fullWidth, hideLabel, ...props }: SelectCompositionProps<M>): import("react").JSX.Element;
+export declare function SelectControl({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function SelectTrigger({ ref, className, children, onKeyDown, ...props }: Omit<ComponentProps<typeof Button>, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function SelectValuePart<T>({ className, ...props }: Omit<SelectValueProps<T>, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function SelectIndicator({ className, children, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;
+/** Nested clear is decorative to AT; Backspace/Delete on the trigger supplies keyboard clearing. Outside Trigger it is a named native button. */
+export declare function SelectClearButton({ className, children, 'aria-label': label, ...props }: Pick<HTMLAttributes<HTMLSpanElement>, 'className' | 'children' | 'style' | 'aria-label' | 'id'>): import("react").JSX.Element;
+export declare function SelectPopover({ className, ...props }: Omit<PopoverProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function ListBoxRoot<T extends object>({ className, ...props }: Omit<ListBoxProps<T>, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function ListBoxItemPart<T extends object>({ className, children, ...props }: Omit<ListBoxItemProps<T>, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function ListBoxSectionPart<T extends object>({ className, ...props }: ListBoxSectionProps<T>): import("react").JSX.Element;
+export declare function ListBoxItemIndicator({ className, children, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;
+export declare const ListBox: typeof ListBoxRoot & {
+    Item: typeof ListBoxItemPart;
+    Section: typeof ListBoxSectionPart;
+    ItemIndicator: typeof ListBoxItemIndicator;
+};
+export declare function Description({ className, ...props }: TextProps): import("react").JSX.Element;
+export declare function FieldError({ className, ...props }: Omit<FieldErrorProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export type InputCompositionProps = Omit<TextFieldProps, 'className'> & {
+    className?: string;
+    label?: never;
+    size?: import('./Input.js').InputSize;
+    variant?: import('./Input.js').InputVariant;
+    hideLabel?: boolean;
+};
+export declare function InputRoot({ className, size, variant, hideLabel, value, defaultValue, onChange, ...props }: Omit<InputCompositionProps, 'label'>): import("react").JSX.Element;
+export declare const InputControlRefContext: import("react").Context<Ref<HTMLInputElement> | undefined>;
+export declare const InputControl: import("react").ForwardRefExoticComponent<Omit<AriaInputProps, "className"> & {
+    className?: string;
+} & import("react").RefAttributes<HTMLInputElement>>;
+export declare function InputGroup({ className, ...props }: Omit<GroupProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function InputPrefix({ className, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;
+export declare function InputSuffix({ className, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;
+export { Header };

package/dist/types/date-range-composition.d.ts

@@ -0,0 +1,46 @@
+import { type HTMLAttributes, type InputHTMLAttributes, type ButtonHTMLAttributes, type ReactNode, type RefObject } from 'react';
+import { type ButtonProps } from 'react-aria-components/Button';
+import { type PopoverProps } from 'react-aria-components/Popover';
+import type { DateRange } from './date-range-model.js';
+export interface DateRangeCompositionContextValue {
+    id: string;
+    text: string;
+    labels: {
+        apply: string;
+        clear: string;
+        cancel: string;
+    };
+    draft: DateRange;
+    disabled: boolean;
+    readOnly: boolean;
+    invalid: boolean;
+    feedbackId?: string;
+    min?: string;
+    max?: string;
+    dir?: 'ltr' | 'rtl';
+    trigger: RefObject<HTMLButtonElement | null>;
+    calendar: ReactNode;
+    panel: ReactNode;
+    edit: (part: 'start' | 'end', value: string) => void;
+    apply: () => void;
+    clear: () => void;
+    cancel: () => void;
+}
+export declare const DateRangeCompositionContext: import("react").Context<DateRangeCompositionContextValue | null>;
+export declare function DateRangeTrigger({ className, children, ...props }: Omit<ButtonProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function DateRangeValue({ className, children, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;
+export declare function DateRangeIndicator({ className, children, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;
+export declare function DateRangePopover({ className, children, ...props }: Omit<PopoverProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+/** Render the standard model-bound panel, or compose a custom panel through children. */
+export declare function DateRangeContent({ className, children, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function DateRangeCalendar({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function DateRangeInput({ part, className, onChange, ...props }: Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'value' | 'defaultValue'> & {
+    part: 'start' | 'end';
+}): import("react").JSX.Element;
+export declare function DateRangeApplyButton({ className, onClick, children, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
+export declare function DateRangeClearButton({ className, onClick, children, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
+export declare function DateRangeCancelButton({ className, onClick, children, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;

package/dist/types/date-range-model.d.ts

@@ -27,7 +27,9 @@ export interface DateRangeOptions extends DateRangeConstraints {
     dir?: 'ltr' | 'rtl';
     visibleMonths?: 1 | 2;
     weekStartsOn?: 0 | 1;
-    display?: 'popover' | 'inline';
+    display?: 'popover' | 'inline' | 'dialog' | 'auto';
+    commitMode?: 'apply' | 'immediate';
+    showActions?: boolean;
     showInputs?: boolean;
     showMonthYearPicker?: boolean;
     triggerDisplay?: 'text' | 'icon';

package/dist/types/field.d.ts

@@ -3,7 +3,12 @@ export interface FieldFeedbackProps {
     errorMessage?: string;
     isInvalid?: boolean;
 }
-export declare function useFeedback({ description, errorMessage, isInvalid }: FieldFeedbackProps): {
+export declare function useFeedback({ description, errorMessage, isInvalid, classNames, }: FieldFeedbackProps & {
+    classNames?: {
+        description?: string;
+        error?: string;
+    };
+}): {
     describedBy: string | undefined;
     feedback: import("react").JSX.Element;
 };

package/dist/types/index.d.ts

@@ -36,7 +36,12 @@ export type { NumberFieldProps } from './NumberField.js';
 export { Card } from './Card.js';
 export type { CardProps } from './Card.js';
 export { Badge } from './Badge.js';
-export type { BadgeProps, BadgeTone } from './Badge.js';
+export type { BadgeProps, BadgeTone, BadgeVariant } from './Badge.js';
+export { Avatar, AvatarRoot, AvatarImage, AvatarFallback, AvatarBadge } from './Avatar.js';
+export type { AvatarProps, AvatarImageProps, AvatarFallbackProps, AvatarBadgeProps, } from './Avatar.js';
+export { AvatarGroup, AvatarGroupRoot, AvatarGroupCount } from './AvatarGroup.js';
+export type { AvatarGroupProps } from './AvatarGroup.js';
+export type { Tone, ComponentSize, IndicatorPlacement, AvatarVariant, ImageLoadingStatus, } from './visual.js';
 export { Skeleton } from './Skeleton.js';
 export type { SkeletonProps } from './Skeleton.js';
 export { Separator } from './Separator.js';
@@ -85,3 +90,43 @@ export { ToastProvider, Toast, useToast } from './Toast.js';
 export type { ToastProviderProps, ToastProps } from './Toast.js';
 export { createToastManager } from './toast-model.js';
 export type { ToastTone, ToastPlacement, ToastCloseReason, ToastAction, ToastOptions, ToastEntry, ToastManagerOptions, ToastPromiseMessages, ToastManager, } from './toast-model.js';
+export type { StylingProps } from './styling.js';
+export { ListBox, Description, FieldError, Header } from './control-composition.js';
+export type { SelectCompositionProps, InputCompositionProps } from './control-composition.js';
+export type { CheckboxCompositionProps, SwitchCompositionProps, RadioGroupCompositionProps, } from './choice-composition.js';
+export type { NumberFieldCompositionProps } from './number-composition.js';
+export type { ComboboxCompositionProps } from './combobox-composition.js';
+export { CardRoot, CardHeader, CardHeading, CardTitleRow, CardTitle, CardDescription, CardActions, CardContent, CardFooter, } from './Card.js';
+export type { CardPart } from './Card.js';
+export { TabsRoot, TabsListContainer, TabsList, TabsTab, TabsPanel, TabsIndicator, TabsSeparator, } from './Tabs.js';
+export type { TabsPart, TabsRootProps } from './Tabs.js';
+export { PaginationRoot, PaginationPageButton, PaginationPrevious, PaginationNext, PaginationSummary, PaginationContent, PaginationItem, PaginationEllipsis, } from './Pagination.js';
+export type { PaginationPart, PaginationRootProps } from './Pagination.js';
+export { BreadcrumbRoot, BreadcrumbList, BreadcrumbItemPart, BreadcrumbLink, BreadcrumbCurrent, BreadcrumbSeparator, } from './Breadcrumb.js';
+export type { BreadcrumbPart } from './Breadcrumb.js';
+export { AlertTitle, AlertDescription, AlertContent, AlertActions, AlertIndicator, } from './Alert.js';
+export type { AlertPart } from './Alert.js';
+export type { EmptyPart } from './Empty.js';
+export type { SidebarPart } from './Sidebar.js';
+export type { ChartPart } from './Chart.js';
+export type { DataTablePart } from './DataTable.js';
+export { DialogRoot, DialogTriggerPart, DialogBackdrop as DialogBackdropPart, DialogPanel, DialogContent, OverlayHeader, OverlayBody, OverlayFooter, OverlayHeading, OverlayDescription, DialogCloseButton, PopoverTrigger, PopoverContent, PopoverDialog, PopoverCloseButton, TooltipRoot, TooltipTriggerPart, TooltipContent, DropdownRoot, DropdownTrigger, DropdownPopover, DropdownList, DropdownItem, DropdownSection, DropdownHeading, DropdownSeparator, TableRoot, TableScrollContainer, TableHeader, TableBody, TableFooter, TableRow, TableColumn, TableCell, TableCaption, } from './structural-parts.js';
+export type { DialogRootProps, TooltipRootProps, DropdownRootProps } from './structural-parts.js';
+export { EmptyRoot, EmptyTitle, EmptyDescription, EmptyActions, SidebarRoot, SidebarHeader, SidebarTitle, SidebarToggle, SidebarNavigation, SidebarList, SidebarItem, SidebarLink, ChartRoot, ChartTitle, ChartDescription, ChartPlot, DataTableRoot, DataTableSortButton, DataTableStatus, DataTableError, } from './layout-parts.js';
+export type { SidebarRootProps, DataTableRootProps } from './layout-parts.js';
+export { ToastRoot, ToastIndicator, ToastBody, ToastTitle, ToastDescription, ToastActions, ToastActionButton, ToastCloseButton, ToastProgress, } from './Toast.js';
+export { DropdownItemIndicator, DropdownSubmenuTrigger, DropdownSubmenuIndicator, } from './structural-parts.js';
+export { DataTableColumn as DataTableColumnPart, DataTableEmpty } from './layout-parts.js';
+export { Calendar, RangeCalendar, MonthPicker, YearPicker, MonthYearNavigation, } from './Calendar.js';
+export type { CalendarProps, RangeCalendarProps, MonthPickerProps, YearPickerProps, MonthYearNavigationProps, } from './Calendar.js';
+export { DateField, TimeField, DateTimeField, DateRangeField, TimeRangeField, DateTimeRangeField, } from './TemporalField.js';
+export type { TemporalFieldProps, TemporalRangeFieldProps } from './TemporalField.js';
+export { TimeList, TimeClock } from './TimeControls.js';
+export type { TimeControlProps } from './TimeControls.js';
+export { DatePicker, TimePicker, TimeRangePicker, DateTimePicker, DateTimeRangePicker, } from './TemporalPicker.js';
+export type { TemporalPickerProps, TemporalPickerOptions, TemporalPreset, TemporalValue, } from './TemporalPicker.js';
+export type { TemporalConstraints, TemporalRange, TemporalKind, TemporalError, } from './temporal-model.js';
+export { SwitchGroup } from './switch-visual.js';
+export type { SwitchVisualProps } from './switch-visual.js';
+export { InputClearButton } from './input-clear.js';
+export type { CardInteractionProps } from './Card.js';

package/dist/types/input-clear.d.ts

@@ -0,0 +1,24 @@
+import { type RefObject, type ButtonHTMLAttributes } from 'react';
+export declare const InputClearContext: import("react").Context<{
+    value: string;
+    disabled?: boolean;
+    readOnly?: boolean;
+    clear: () => void;
+} | null>;
+export declare function useClearableInput({ value, defaultValue, onChange, isDisabled, isReadOnly, }: {
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+}, element: RefObject<HTMLElement | null>): {
+    value: string;
+    update: (next: string) => void;
+    context: {
+        value: string;
+        disabled: boolean | undefined;
+        readOnly: boolean | undefined;
+        clear: () => void;
+    };
+};
+export declare function InputClearButton({ className, children, onClick, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element | null;

package/dist/types/label-context.d.ts

@@ -0,0 +1,8 @@
+/** Item labels use Text slots rather than introducing native label elements. */
+export declare const ItemLabelContext: import("react").Context<boolean>;
+/** Field feedback parts share styling without coupling labels to a specific control. */
+export declare const FieldPartClassesContext: import("react").Context<{
+    label?: string;
+    description?: string;
+    error?: string;
+}>;

package/dist/types/layout-parts.d.ts

@@ -0,0 +1,44 @@
+import { type HTMLAttributes, type AnchorHTMLAttributes, type ButtonHTMLAttributes, type SVGAttributes, type ThHTMLAttributes, type TdHTMLAttributes } from 'react';
+import type { TableSort } from './data-table-types.js';
+export declare function EmptyRoot({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function EmptyTitle({ className, headingLevel, ...props }: HTMLAttributes<HTMLHeadingElement> & {
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+}): import("react").JSX.Element;
+export declare function EmptyDescription({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): import("react").JSX.Element;
+export declare function EmptyActions({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export interface SidebarRootProps extends HTMLAttributes<HTMLElement> {
+    label: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}
+export declare function SidebarRoot({ label, open, defaultOpen, onOpenChange, id, className, ...props }: SidebarRootProps): import("react").JSX.Element;
+export declare function SidebarHeader({ className, ...props }: HTMLAttributes<HTMLDivElement>): import("react").JSX.Element;
+export declare function SidebarTitle({ className, ...props }: HTMLAttributes<HTMLSpanElement>): import("react").JSX.Element;
+export declare function SidebarToggle({ className, onClick, ...props }: ButtonHTMLAttributes<HTMLButtonElement>): import("react").JSX.Element;
+export declare function SidebarNavigation(props: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+export declare function SidebarList(props: HTMLAttributes<HTMLUListElement>): import("react").JSX.Element;
+export declare function SidebarItem(props: HTMLAttributes<HTMLLIElement>): import("react").JSX.Element;
+export declare function SidebarLink({ className, isDisabled, href, onClick, children, ...props }: AnchorHTMLAttributes<HTMLAnchorElement> & {
+    isDisabled?: boolean;
+}): import("react").JSX.Element;
+export declare function ChartRoot({ className, ...props }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+export declare function ChartTitle({ className, ...props }: HTMLAttributes<HTMLElement>): import("react").JSX.Element;
+export declare function ChartDescription({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): import("react").JSX.Element;
+export declare function ChartPlot({ className, ...props }: SVGAttributes<SVGSVGElement>): import("react").JSX.Element;
+export interface DataTableRootProps extends HTMLAttributes<HTMLDivElement> {
+    sort?: TableSort | null;
+    onSortChange?: (sort: TableSort) => void;
+    isLoading?: boolean;
+    isDisabled?: boolean;
+}
+export declare function DataTableRoot({ sort, onSortChange, isLoading, isDisabled, className, ...props }: DataTableRootProps): import("react").JSX.Element;
+export declare function DataTableSortButton({ columnId, className, onClick, disabled, ...props }: ButtonHTMLAttributes<HTMLButtonElement> & {
+    columnId: string;
+}): import("react").JSX.Element;
+export declare function DataTableColumn({ columnId, scope, ...props }: ThHTMLAttributes<HTMLTableCellElement> & {
+    columnId?: string;
+}): import("react").JSX.Element;
+export declare function DataTableEmpty({ className, ...props }: TdHTMLAttributes<HTMLTableCellElement>): import("react").JSX.Element;
+export declare function DataTableStatus({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): import("react").JSX.Element;
+export declare function DataTableError({ className, ...props }: HTMLAttributes<HTMLParagraphElement>): import("react").JSX.Element;

package/dist/types/number-composition.d.ts

@@ -0,0 +1,24 @@
+import { type NumberFieldProps as AriaNumberFieldProps, type GroupProps, type InputProps, type ButtonProps } from 'react-aria-components/NumberField';
+export type NumberFieldCompositionProps = Omit<AriaNumberFieldProps, 'className' | 'value' | 'defaultValue' | 'onChange' | 'minValue' | 'maxValue'> & {
+    className?: string;
+    label?: never;
+    locale?: string;
+    value?: number | null;
+    defaultValue?: number | null;
+    onChange?: (value: number | null) => void;
+    min?: number;
+    max?: number;
+};
+export declare function NumberFieldComposition({ className, locale, value, defaultValue, onChange, min, max, ...props }: NumberFieldCompositionProps): import("react").JSX.Element;
+export declare function NumberFieldGroup({ className, ...props }: Omit<GroupProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function NumberFieldInput({ className, ...props }: Omit<InputProps, 'className'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function NumberFieldIncrement({ className, ...props }: Omit<ButtonProps, 'className' | 'slot'> & {
+    className?: string;
+}): import("react").JSX.Element;
+export declare function NumberFieldDecrement({ className, ...props }: Omit<ButtonProps, 'className' | 'slot'> & {
+    className?: string;
+}): import("react").JSX.Element;