@kazee-ds/react 0.0.0-stage → 0.5.0

package/dist/types/Alert.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from 'react';
+import type { BadgeTone } from './Badge.js';
+export interface AlertProps {
+    title: string;
+    description?: string;
+    tone?: BadgeTone;
+    announcement?: 'off' | 'polite' | 'assertive';
+    children?: ReactNode;
+    actions?: ReactNode;
+    id?: string;
+}
+export declare function Alert({ title, description, tone, announcement, children, actions, id, }: AlertProps): import("react").JSX.Element;

package/dist/types/Badge.d.ts

@@ -0,0 +1,7 @@
+import type { HTMLAttributes } from 'react';
+export type BadgeTone = 'neutral' | 'info' | 'success' | 'warning' | 'danger';
+export interface BadgeProps extends HTMLAttributes<HTMLSpanElement> {
+    tone?: BadgeTone;
+}
+/** Static status text. Dynamic announcements belong in an application-owned live region. */
+export declare function Badge({ tone, className, ...props }: BadgeProps): import("react").JSX.Element;

package/dist/types/Breadcrumb.d.ts

@@ -0,0 +1,8 @@
+import type { BreadcrumbItem } from './dashboard-types.js';
+export interface BreadcrumbProps {
+    items: BreadcrumbItem[];
+    label?: string;
+    dir?: 'ltr' | 'rtl';
+    id?: string;
+}
+export declare function Breadcrumb({ items, label, dir, id }: BreadcrumbProps): import("react").JSX.Element;

package/dist/types/Button.d.ts

@@ -0,0 +1,53 @@
+import { type ButtonProps as AriaButtonProps } from 'react-aria-components/Button';
+import { type ReactNode } from 'react';
+export type ButtonVariant = 'primary' | 'secondary' | 'danger' | 'outline' | 'tertiary' | 'ghost' | 'danger-soft' | 'ai';
+export type ButtonSize = 'sm' | 'md' | 'lg';
+/** The event passed to `onPress`: pointer type, modifier keys, and the target element. */
+export type ButtonPressEvent = Parameters<NonNullable<AriaButtonProps['onPress']>>[0];
+/** Public flags supplied to the Button render function. */
+export interface ButtonRenderProps {
+    isPending: boolean;
+    isDisabled: boolean;
+    isHovered: boolean;
+    isPressed: boolean;
+    isFocused: boolean;
+    isFocusVisible: boolean;
+}
+/**
+ * The props the design system supports on `Button`. Anything not listed here is not part of the
+ * public API, even if the underlying React Aria button would accept it.
+ */
+export interface ButtonProps {
+    /** Label or content of the button. */
+    children?: ReactNode | ((state: ButtonRenderProps) => ReactNode);
+    /** Square icon button. Supply aria-label or aria-labelledby. */
+    isIconOnly?: boolean;
+    /** Blocks actions while retaining focus. Render a Spinner through children if desired. */
+    isPending?: boolean;
+    /** Visual style. Use `danger` for destructive actions such as delete. */
+    variant?: ButtonVariant;
+    /** Size of the button. */
+    size?: ButtonSize;
+    /** Fill the container width. Icon-only buttons retain their square shape. */
+    fullWidth?: boolean;
+    /** Disables the button. The button is not focusable and `onPress` is not called. */
+    isDisabled?: boolean;
+    /**
+     * Called when the button is activated by mouse, touch, keyboard, or screen reader. Use this
+     * instead of `onClick`.
+     */
+    onPress?: (event: ButtonPressEvent) => void;
+    /** Button type inside a form. Defaults to `button`. */
+    type?: 'button' | 'submit' | 'reset';
+    /** Accessible name when the button has no visible text, such as an icon-only button. */
+    'aria-label'?: string;
+    /** Id of an element that labels the button. */
+    'aria-labelledby'?: string;
+    /** Id of an element that describes the button. */
+    'aria-describedby'?: string;
+    /** Id of the button element. */
+    id?: string;
+    /** Focuses the button when it first renders. */
+    autoFocus?: boolean;
+}
+export declare function Button({ variant, size, isIconOnly, isPending, isDisabled, fullWidth, type, children, ...props }: ButtonProps): import("react").JSX.Element;

package/dist/types/ButtonGroup.d.ts

@@ -0,0 +1,18 @@
+import { type ReactNode } from 'react';
+import { type ButtonSize, type ButtonVariant } from './Button.js';
+export interface ButtonGroupProps {
+    label: string;
+    children: ReactNode;
+    variant?: ButtonVariant;
+    size?: ButtonSize;
+    isDisabled?: boolean;
+    fullWidth?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+    dir?: 'ltr' | 'rtl';
+}
+export declare function ButtonGroupSeparator(): import("react").JSX.Element;
+declare function Root({ children, label, variant, size, isDisabled, fullWidth, orientation, dir, }: ButtonGroupProps): import("react").JSX.Element;
+export declare const ButtonGroup: typeof Root & {
+    Separator: typeof ButtonGroupSeparator;
+};
+export {};

package/dist/types/Card.d.ts

@@ -0,0 +1,14 @@
+import type { HTMLAttributes, ReactNode } from 'react';
+export interface CardProps extends HTMLAttributes<HTMLDivElement> {
+    title?: string;
+    description?: string;
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+    /** Custom leading header content; replaces title/description, preserving actions. */
+    header?: ReactNode;
+    /** Badge or supplementary controls next to the title, outside its heading. */
+    titleExtras?: ReactNode;
+    actions?: ReactNode;
+    footer?: ReactNode;
+}
+/** A content container; place links and buttons inside rather than making it clickable. */
+export declare function Card({ title, description, headingLevel, actions, header, titleExtras, footer, children, className, ...props }: CardProps): import("react").JSX.Element;

package/dist/types/Chart.d.ts

@@ -0,0 +1,15 @@
+import type { ChartDatum } from './dashboard-types.js';
+export interface ChartProps {
+    label: string;
+    data: ChartDatum[];
+    type?: 'bar' | 'line';
+    description?: string;
+    locale?: string;
+    formatOptions?: Intl.NumberFormatOptions;
+    categoryLabel?: string;
+    valueLabel?: string;
+    emptyMessage?: string;
+    id?: string;
+    dir?: 'ltr' | 'rtl';
+}
+export declare function Chart({ label, data, type, description, locale, formatOptions, categoryLabel, valueLabel, emptyMessage, id, dir, }: ChartProps): import("react").JSX.Element;

package/dist/types/Checkbox.d.ts

@@ -0,0 +1,16 @@
+import { type FieldFeedbackProps } from './field.js';
+export interface CheckboxProps extends FieldFeedbackProps {
+    label: string;
+    isSelected?: boolean;
+    defaultSelected?: boolean;
+    onChange?: (selected: boolean) => void;
+    isDisabled?: boolean;
+    isRequired?: boolean;
+    /** Presentational mixed state; the application clears it after a change. */
+    isIndeterminate?: boolean;
+    name?: string;
+    value?: string;
+    id?: string;
+    dir?: 'ltr' | 'rtl';
+}
+export declare function Checkbox({ label, description, errorMessage, isInvalid, isSelected, defaultSelected, onChange, isDisabled, isRequired, isIndeterminate, name, value, id, dir, }: CheckboxProps): import("react").JSX.Element;

package/dist/types/Combobox.d.ts

@@ -0,0 +1,27 @@
+import { type ReactNode } from 'react';
+import { type SelectOption } from './selection-options.js';
+export interface ComboboxProps {
+    label: string;
+    options: SelectOption[];
+    value?: string | null;
+    defaultValue?: string | null;
+    onChange?: (value: string | null) => void;
+    /** Decorative noninteractive icon before the value/input. */
+    startContent?: ReactNode;
+    placeholder?: string;
+    name?: string;
+    isDisabled?: boolean;
+    isRequired?: boolean;
+    isInvalid?: boolean;
+    description?: string;
+    errorMessage?: string;
+    requiredMessage?: string;
+    isClearable?: boolean;
+    clearLabel?: string;
+    toggleLabel?: string;
+    emptyMessage?: string;
+    dir?: 'ltr' | 'rtl';
+    renderOption?: (option: SelectOption) => ReactNode;
+}
+/** Searchable single selection. Draft text is never submitted as a value. */
+export declare function Combobox(props: ComboboxProps): import("react").JSX.Element;

package/dist/types/DataTable.d.ts

@@ -0,0 +1,18 @@
+import type { ReactNode } from 'react';
+import type { DataTableColumn, DataTableRow, TableSort } from './data-table-types.js';
+export interface DataTableProps {
+    caption: string;
+    columns: DataTableColumn[];
+    rows: DataTableRow[];
+    sort?: TableSort | null;
+    onSortChange?: (sort: TableSort) => void;
+    isLoading?: boolean;
+    isDisabled?: boolean;
+    emptyMessage?: string;
+    loadingMessage?: string;
+    errorMessage?: string;
+    renderCell?: (row: DataTableRow, column: DataTableColumn) => ReactNode;
+    dir?: 'ltr' | 'rtl';
+    id?: string;
+}
+export declare function DataTable({ caption, columns, rows, sort, onSortChange, isLoading, isDisabled, emptyMessage, loadingMessage, errorMessage, renderCell, dir, id, }: DataTableProps): import("react").JSX.Element;

package/dist/types/DateRangePicker.d.ts

@@ -0,0 +1,12 @@
+import { type DateRange, type DateRangeOptions } from './date-range-model.js';
+export interface DateRangePickerProps extends DateRangeOptions {
+    value?: DateRange | null;
+    onChange?: (value: DateRange | null) => void;
+    onApply?: (value: DateRange | null) => void;
+    onOpenChange?: (open: boolean) => void;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+    isRequired?: boolean;
+    isInvalid?: boolean;
+}
+export declare function DateRangePicker(props: DateRangePickerProps): import("react").JSX.Element;

package/dist/types/Dialog.d.ts

@@ -0,0 +1,29 @@
+import { type ReactNode } from 'react';
+import type { ButtonVariant } from './Button.js';
+import type { DialogSize, DialogPlacement, DialogScroll, DialogBackdrop } from './overlay-model.js';
+export interface DialogProps {
+    triggerLabel: string;
+    title: string;
+    description?: string;
+    children?: ReactNode;
+    footer?: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    isDisabled?: boolean;
+    closeLabel?: string;
+    dir?: 'ltr' | 'rtl';
+    triggerContent?: ReactNode;
+    triggerIconOnly?: boolean;
+    triggerVariant?: ButtonVariant;
+    size?: DialogSize;
+    placement?: DialogPlacement;
+    scroll?: DialogScroll;
+    backdrop?: DialogBackdrop;
+    isDismissable?: boolean;
+    isKeyboardDismissDisabled?: boolean;
+    showCloseButton?: boolean;
+    showFooterClose?: boolean;
+    closeIconLabel?: string;
+}
+export declare function Dialog(props: DialogProps): import("react").JSX.Element;

package/dist/types/DropdownMenu.d.ts

@@ -0,0 +1,25 @@
+import { type ReactNode } from 'react';
+import { type MenuSelectionMode, type MenuPlacement } from './overlay-model.js';
+import type { DropdownMenuItem } from './dashboard-types.js';
+import type { ButtonVariant } from './Button.js';
+export interface DropdownMenuProps {
+    triggerLabel: string;
+    items: DropdownMenuItem[];
+    onAction?: (id: string) => void;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    isDisabled?: boolean;
+    dir?: 'ltr' | 'rtl';
+    triggerContent?: ReactNode;
+    triggerIconOnly?: boolean;
+    triggerVariant?: ButtonVariant;
+    renderIcon?: (item: DropdownMenuItem) => ReactNode;
+    selectionMode?: MenuSelectionMode;
+    selectedKeys?: string[];
+    defaultSelectedKeys?: string[];
+    onSelectionChange?: (keys: string[]) => void;
+    closeOnSelect?: boolean;
+    placement?: MenuPlacement;
+}
+export declare function DropdownMenu(props: DropdownMenuProps): import("react").JSX.Element;

package/dist/types/Empty.d.ts

@@ -0,0 +1,10 @@
+import type { ReactNode } from 'react';
+export interface EmptyProps {
+    title: string;
+    description?: string;
+    headingLevel?: 2 | 3 | 4 | 5 | 6;
+    actions?: ReactNode;
+    children?: ReactNode;
+    id?: string;
+}
+export declare function Empty({ title, description, headingLevel, actions, children, id }: EmptyProps): import("react").JSX.Element;

package/dist/types/FieldComponent.d.ts

@@ -0,0 +1,33 @@
+import { type ReactNode } from 'react';
+/** Bind these props to exactly one native input, textarea, or select. */
+export interface FieldControlProps {
+    id: string;
+    name: string;
+    className: string;
+    disabled: boolean;
+    readOnly: boolean;
+    required: boolean;
+    'aria-required': true | undefined;
+    'aria-invalid': true | undefined;
+    'aria-describedby': string | undefined;
+}
+export interface FieldRenderProps {
+    controlProps: FieldControlProps;
+    isInvalid: boolean;
+    errorMessage: string | undefined;
+}
+/** Experimental composition API; the application owns the control value. */
+export interface FieldProps {
+    label: string;
+    name: string;
+    children: (field: FieldRenderProps) => ReactNode;
+    id?: string;
+    description?: string;
+    errorMessage?: string;
+    isInvalid?: boolean;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+    isRequired?: boolean;
+    dir?: 'ltr' | 'rtl';
+}
+export declare function Field({ label, name, children, id, description, errorMessage, isInvalid, isDisabled, isReadOnly, isRequired, dir, }: FieldProps): import("react").JSX.Element;

package/dist/types/Form.d.ts

@@ -0,0 +1,17 @@
+import type { FormEvent, ReactNode } from 'react';
+import { type ValidationErrors } from './form-context.js';
+/** Experimental client form. Submission always prevents page navigation. */
+export interface FormProps {
+    children: ReactNode;
+    validationErrors?: ValidationErrors;
+    onSubmit?: (data: FormData, event: FormEvent<HTMLFormElement>) => void;
+    /** Prevent default and reset application state when using controlled values. */
+    onReset?: (event: FormEvent<HTMLFormElement>) => void;
+    /** Skips browser constraints; explicit aria-invalid state still blocks submission. */
+    noValidate?: boolean;
+    id?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    dir?: 'ltr' | 'rtl';
+}
+export declare function Form({ children, validationErrors, onSubmit, onReset, noValidate, id, 'aria-label': ariaLabel, 'aria-labelledby': labelledBy, dir, }: FormProps): import("react").JSX.Element;

package/dist/types/Input.d.ts

@@ -0,0 +1,47 @@
+import { type FocusEventHandler, type KeyboardEventHandler, type ReactNode } from 'react';
+export type InputSize = 'sm' | 'md' | 'lg';
+export type InputType = 'text' | 'email' | 'password' | 'search' | 'tel' | 'url';
+export type InputVariant = 'primary' | 'secondary';
+export type InputMode = 'none' | 'text' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
+export type InputEnterKeyHint = 'enter' | 'done' | 'go' | 'next' | 'previous' | 'search' | 'send';
+/** A labeled single-line string field. Numeric/date parsing is a separate contract. */
+export interface InputProps {
+    label: string;
+    value?: string;
+    defaultValue?: string;
+    /** Receives the string value, not a DOM event. Clear with an empty string. */
+    onChange?: (value: string) => void;
+    description?: string;
+    /** Shown only when isInvalid is true; the application owns validation. */
+    errorMessage?: string;
+    isInvalid?: boolean;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+    isRequired?: boolean;
+    placeholder?: string;
+    type?: InputType;
+    size?: InputSize;
+    variant?: InputVariant;
+    /** Fill the available width. Defaults to true to preserve the existing field layout. */
+    fullWidth?: boolean;
+    /** Leading/trailing content. Mark decorative icons aria-hidden; name interactive buttons. */
+    prefix?: ReactNode;
+    suffix?: ReactNode;
+    name?: string;
+    id?: string;
+    autoComplete?: string;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    inputMode?: InputMode;
+    enterKeyHint?: InputEnterKeyHint;
+    autoFocus?: boolean;
+    spellCheck?: boolean;
+    form?: string;
+    onFocus?: FocusEventHandler<HTMLInputElement>;
+    onBlur?: FocusEventHandler<HTMLInputElement>;
+    onKeyDown?: KeyboardEventHandler<HTMLInputElement>;
+    onKeyUp?: KeyboardEventHandler<HTMLInputElement>;
+    dir?: 'ltr' | 'rtl';
+}
+export declare const Input: import("react").ForwardRefExoticComponent<InputProps & import("react").RefAttributes<HTMLInputElement>>;

package/dist/types/Label.d.ts

@@ -0,0 +1,8 @@
+import type { ReactNode } from 'react';
+export interface LabelProps {
+    children: ReactNode;
+    htmlFor?: string;
+    id?: string;
+}
+/** Associates visible text with a separately rendered control. */
+export declare function Label({ children, htmlFor, id }: LabelProps): import("react").JSX.Element;

package/dist/types/Listbox.d.ts

@@ -0,0 +1,17 @@
+import { type FieldFeedbackProps } from './field.js';
+import { type ListboxOption, type ListboxSelectionMode } from './listbox-selection.js';
+export interface ListboxProps extends FieldFeedbackProps {
+    label: string;
+    options: ListboxOption[];
+    /** Always an array; empty selection is []. */
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+    selectionMode?: ListboxSelectionMode;
+    isDisabled?: boolean;
+    name?: string;
+    id?: string;
+    dir?: 'ltr' | 'rtl';
+    emptyMessage?: string;
+}
+export declare function Listbox({ label, options, value, defaultValue, onChange, selectionMode, isDisabled, description, errorMessage, isInvalid, name, id, dir, emptyMessage, }: ListboxProps): import("react").JSX.Element;

package/dist/types/NumberField.d.ts

@@ -0,0 +1,24 @@
+export interface NumberFieldProps {
+    label: string;
+    value?: number | null;
+    defaultValue?: number | null;
+    /** Committed numeric value; empty or non-finite values become null. */
+    onChange?: (value: number | null) => void;
+    min?: number;
+    max?: number;
+    step?: number;
+    locale?: string;
+    formatOptions?: Intl.NumberFormatOptions;
+    description?: string;
+    errorMessage?: string;
+    isInvalid?: boolean;
+    isDisabled?: boolean;
+    isReadOnly?: boolean;
+    isRequired?: boolean;
+    name?: string;
+    id?: string;
+    dir?: 'ltr' | 'rtl';
+    incrementLabel?: string;
+    decrementLabel?: string;
+}
+export declare function NumberField({ label, value, defaultValue, onChange, min, max, step, locale, formatOptions, description, errorMessage, isInvalid, isDisabled, isReadOnly, isRequired, name, id, dir, incrementLabel, decrementLabel, }: NumberFieldProps): import("react").JSX.Element;

package/dist/types/OverlayDirection.d.ts

@@ -0,0 +1,5 @@
+import type { ReactNode } from 'react';
+export declare function OverlayDirection({ dir, children }: {
+    dir?: 'ltr' | 'rtl';
+    children: ReactNode;
+}): string | number | bigint | boolean | import("react").JSX.Element | Iterable<ReactNode> | Promise<string | number | bigint | boolean | import("react").ReactPortal | import("react").ReactElement<unknown, string | import("react").JSXElementConstructor<any>> | Iterable<ReactNode> | null | undefined> | null | undefined;

package/dist/types/Pagination.d.ts

@@ -0,0 +1,16 @@
+export interface PaginationProps {
+    totalItems: number;
+    pageSize?: number;
+    value?: number;
+    defaultValue?: number;
+    onChange?: (page: number) => void;
+    isDisabled?: boolean;
+    siblingCount?: number;
+    label?: string;
+    previousLabel?: string;
+    nextLabel?: string;
+    pageLabel?: string;
+    dir?: 'ltr' | 'rtl';
+    id?: string;
+}
+export declare function Pagination({ totalItems, pageSize, value, defaultValue, onChange, isDisabled, siblingCount, label, previousLabel, nextLabel, pageLabel, dir, id, }: PaginationProps): import("react").JSX.Element;

package/dist/types/Popover.d.ts

@@ -0,0 +1,14 @@
+import { type ReactNode } from 'react';
+export interface PopoverProps {
+    triggerLabel: string;
+    title: string;
+    description?: string;
+    children?: ReactNode;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    isDisabled?: boolean;
+    closeLabel?: string;
+    dir?: 'ltr' | 'rtl';
+}
+export declare function Popover({ triggerLabel, title, description, children, open, defaultOpen, onOpenChange, isDisabled, closeLabel, dir, }: PopoverProps): import("react").JSX.Element;

package/dist/types/RadioGroup.d.ts

@@ -0,0 +1,20 @@
+import { type FieldFeedbackProps } from './field.js';
+export interface RadioOption {
+    id: string;
+    label: string;
+    isDisabled?: boolean;
+}
+export interface RadioGroupProps extends FieldFeedbackProps {
+    label: string;
+    options: RadioOption[];
+    value?: string;
+    defaultValue?: string;
+    onChange?: (value: string) => void;
+    isDisabled?: boolean;
+    isRequired?: boolean;
+    name?: string;
+    id?: string;
+    orientation?: 'vertical' | 'horizontal';
+    dir?: 'ltr' | 'rtl';
+}
+export declare function RadioGroup({ label, options, value, defaultValue, onChange, description, errorMessage, isInvalid, isDisabled, isRequired, name, id, orientation, dir, }: RadioGroupProps): import("react").JSX.Element;

package/dist/types/Select.d.ts

@@ -0,0 +1,50 @@
+import { type ReactNode } from 'react';
+import { type SelectOption } from './selection-options.js';
+export type { SelectOption } from './selection-options.js';
+export type SelectSize = 'sm' | 'md' | 'lg';
+export type SelectVariant = 'primary' | 'secondary' | 'outline';
+interface SelectCommonProps {
+    /** Activates an option even when it is already selected (for linked editors). */
+    onAction?: (value: string) => void;
+    label: string;
+    options: SelectOption[];
+    size?: SelectSize;
+    variant?: SelectVariant;
+    /** Hide visually while retaining the accessible label. */
+    hideLabel?: boolean;
+    /** Defaults to true to preserve the existing full-width trigger. */
+    fullWidth?: boolean;
+    /** Decorative noninteractive icon before the value/input. */
+    startContent?: ReactNode;
+    placeholder?: string;
+    isDisabled?: boolean;
+    isRequired?: boolean;
+    isInvalid?: boolean;
+    description?: string;
+    errorMessage?: string;
+    requiredMessage?: string;
+    name?: string;
+    dir?: 'ltr' | 'rtl';
+    isClearable?: boolean;
+    clearLabel?: string;
+    onClear?: () => void;
+    renderOption?: (option: SelectOption) => ReactNode;
+    renderValue?: (selected: SelectOption[]) => ReactNode;
+}
+export type SelectProps = SelectCommonProps & ({
+    selectionMode?: 'single';
+    value?: string | null;
+    defaultValue?: string | null;
+    onChange?: (value: string) => void;
+} | {
+    selectionMode: 'multiple';
+    value?: string[];
+    defaultValue?: string[];
+    onChange?: (value: string[]) => void;
+});
+export declare function Select(props: Extract<SelectProps, {
+    selectionMode: 'multiple';
+}>): ReactNode;
+export declare function Select(props: Exclude<SelectProps, {
+    selectionMode: 'multiple';
+}>): ReactNode;

package/dist/types/SelectGroup.d.ts

@@ -0,0 +1,13 @@
+import { type ReactNode } from 'react';
+import { type SelectSize, type SelectVariant } from './Select.js';
+export interface SelectGroupProps {
+    label: string;
+    children: ReactNode;
+    size?: SelectSize;
+    variant?: SelectVariant;
+    fullWidth?: boolean;
+    isDisabled?: boolean;
+    dir?: 'ltr' | 'rtl';
+}
+/** Joins direct Select children. Each child retains its own value and accessible label. */
+export declare function SelectGroup({ label, children, size, variant, fullWidth, isDisabled, dir, }: SelectGroupProps): import("react").JSX.Element;

package/dist/types/SelectionValidation.d.ts

@@ -0,0 +1,8 @@
+export declare function SelectionValidation({ hasValue, required, disabled, onInvalid, onReset, onResetStart, }: {
+    hasValue: boolean;
+    required?: boolean;
+    disabled?: boolean;
+    onInvalid: () => void;
+    onReset: (cancelled: boolean) => void;
+    onResetStart: () => void;
+}): import("react").JSX.Element;

package/dist/types/Separator.d.ts

@@ -0,0 +1,6 @@
+import type { HTMLAttributes } from 'react';
+export interface SeparatorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children' | 'role' | 'aria-hidden' | 'aria-orientation'> {
+    orientation?: 'horizontal' | 'vertical';
+    decorative?: boolean;
+}
+export declare function Separator({ orientation, decorative, className, ...props }: SeparatorProps): import("react").JSX.Element;

package/dist/types/Sidebar.d.ts

@@ -0,0 +1,13 @@
+import type { NavigationItem } from './dashboard-types.js';
+export interface SidebarProps {
+    label: string;
+    items: NavigationItem[];
+    currentId?: string;
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    toggleLabel?: string;
+    dir?: 'ltr' | 'rtl';
+    id?: string;
+}
+export declare function Sidebar({ label, items, currentId, open, defaultOpen, onOpenChange, toggleLabel, dir, id, }: SidebarProps): import("react").JSX.Element;

package/dist/types/Skeleton.d.ts

@@ -0,0 +1,7 @@
+import type { HTMLAttributes } from 'react';
+export interface SkeletonProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children' | 'aria-hidden'> {
+    shape?: 'rectangle' | 'circle';
+    animated?: boolean;
+}
+/** Decorative placeholder. Set aria-busy and loading text on the surrounding content. */
+export declare function Skeleton({ shape, animated, className, ...props }: SkeletonProps): import("react").JSX.Element;

package/dist/types/Spinner.d.ts

@@ -0,0 +1,10 @@
+export type SpinnerSize = 'sm' | 'md' | 'lg';
+export type SpinnerColor = 'current' | 'primary';
+export interface SpinnerProps {
+    size?: SpinnerSize;
+    color?: SpinnerColor;
+    label?: string;
+    id?: string;
+}
+/** Decorative by default. Use label for a standalone loading status; omit it inside a labeled Button. */
+export declare function Spinner({ size, color, label, id }: SpinnerProps): import("react").JSX.Element;

package/dist/types/Switch.d.ts

@@ -0,0 +1,13 @@
+import type { FieldFeedbackProps } from './field.js';
+export interface SwitchProps extends FieldFeedbackProps {
+    label: string;
+    isSelected?: boolean;
+    defaultSelected?: boolean;
+    onChange?: (selected: boolean) => void;
+    isDisabled?: boolean;
+    name?: string;
+    value?: string;
+    id?: string;
+    dir?: 'ltr' | 'rtl';
+}
+export declare function Switch({ label, description, errorMessage, isInvalid, isSelected, defaultSelected, onChange, isDisabled, name, value, id, dir, }: SwitchProps): import("react").JSX.Element;

package/dist/types/Table.d.ts

@@ -0,0 +1,5 @@
+import type { TableHTMLAttributes } from 'react';
+export interface TableProps extends TableHTMLAttributes<HTMLTableElement> {
+    caption: string;
+}
+export declare function Table({ caption, children, className, ...props }: TableProps): import("react").JSX.Element;