@noxickon/onyx 0.0.4-dev.8 → 1.0.0

package/dist/index.d.ts

@@ -1,406 +1,1920 @@
-import { default as default_2 } from 'react';
+import { AnchorHTMLAttributes } from 'react';
+import { AnimationEventHandler } from 'react';
+import { ButtonHTMLAttributes } from 'react';
+import { ClipboardEventHandler } from 'react';
+import { CompositionEventHandler } from 'react';
+import { CSSProperties } from 'react';
+import { DetailedReactHTMLElement } from 'react';
+import { DialogHTMLAttributes } from 'react';
+import { DragEventHandler } from 'react';
+import { FocusEventHandler } from 'react';
+import { FormEventHandler } from 'react';
+import { FormHTMLAttributes } from 'react';
 import { HTMLAttributes } from 'react';
+import { IconProps } from '@mdi/react/dist/IconProps';
+import { InputEventHandler } from 'react';
+import { InputHTMLAttributes } from 'react';
+import { JSX } from 'react/jsx-runtime';
+import { KeyboardEventHandler } from 'react';
+import { LabelHTMLAttributes } from 'react';
+import { LiHTMLAttributes } from 'react';
+import { MouseEventHandler } from 'react';
+import { OlHTMLAttributes } from 'react';
+import { PointerEventHandler } from 'react';
+import { ReactEventHandler } from 'react';
 import { ReactNode } from 'react';
+import { ReactPortal } from 'react';
+import { Ref } from 'react';
+import { TableHTMLAttributes } from 'react';
+import { TdHTMLAttributes } from 'react';
+import { TextareaHTMLAttributes } from 'react';
+import { ThHTMLAttributes } from 'react';
+import { ToggleEventHandler } from 'react';
+import { TouchEventHandler } from 'react';
+import { TransitionEventHandler } from 'react';
+import { UIEventHandler } from 'react';
+import { WheelEventHandler } from 'react';
+
+export declare type AccordionType = 'single' | 'multiple';
+
+declare interface BaseInputButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'type' | 'children'> {
+    children?: React.ReactNode;
+    path?: string;
+}
+
+declare interface BaseInputCounterProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    currentLength?: number;
+    disabled?: boolean;
+    maxLength: number;
+    size?: 'sm' | 'md';
+}
+
+declare interface BaseInputIconProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'type' | 'children'> {
+    children?: React.ReactNode;
+    path?: string;
+}
+
+declare interface BaseNotificationItemProps {
+    children?: ReactNode;
+    icon?: string;
+    img?: string;
+    message?: string;
+    timestamp?: Date;
+    title?: string;
+    type?: 'default' | 'info' | 'success' | 'warning' | 'error';
+    unread?: boolean;
+}
+
+declare const COLOR_STYLES: {
+    readonly purple: {
+        readonly background: "bg-purple-500/10";
+        readonly backgroundSolid: "bg-purple-500";
+        readonly text: "text-purple-400";
+        readonly border: "border border-purple-500/20";
+        readonly stroke: "stroke-purple-500";
+    };
+    readonly lime: {
+        readonly background: "bg-lime-400/10";
+        readonly backgroundSolid: "bg-lime-400";
+        readonly text: "text-lime-300";
+        readonly border: "border border-lime-400/20";
+        readonly stroke: "stroke-lime-400";
+    };
+    readonly red: {
+        readonly background: "bg-red-500/10";
+        readonly backgroundSolid: "bg-red-500";
+        readonly text: "text-red-400";
+        readonly border: "border border-red-500/20";
+        readonly stroke: "stroke-red-500";
+    };
+    readonly yellow: {
+        readonly background: "bg-yellow-500/10";
+        readonly backgroundSolid: "bg-yellow-500";
+        readonly text: "text-yellow-400";
+        readonly border: "border border-yellow-500/20";
+        readonly stroke: "stroke-yellow-500";
+    };
+    readonly green: {
+        readonly background: "bg-green-500/10";
+        readonly backgroundSolid: "bg-green-500";
+        readonly text: "text-green-400";
+        readonly border: "border border-green-500/20";
+        readonly stroke: "stroke-green-500";
+    };
+    readonly blue: {
+        readonly background: "bg-blue-500/10";
+        readonly backgroundSolid: "bg-blue-500";
+        readonly text: "text-blue-400";
+        readonly border: "border border-blue-500/20";
+        readonly stroke: "stroke-blue-500";
+    };
+    readonly indigo: {
+        readonly background: "bg-indigo-500/10";
+        readonly backgroundSolid: "bg-indigo-500";
+        readonly text: "text-indigo-400";
+        readonly border: "border border-indigo-500/20";
+        readonly stroke: "stroke-indigo-500";
+    };
+    readonly pink: {
+        readonly background: "bg-pink-500/10";
+        readonly backgroundSolid: "bg-pink-500";
+        readonly text: "text-pink-400";
+        readonly border: "border border-pink-500/20";
+        readonly stroke: "stroke-pink-500";
+    };
+    readonly amber: {
+        readonly background: "bg-amber-500/10";
+        readonly backgroundSolid: "bg-amber-500";
+        readonly text: "text-amber-400";
+        readonly border: "border border-amber-500/20";
+        readonly stroke: "stroke-amber-500";
+    };
+    readonly emerald: {
+        readonly background: "bg-emerald-500/10";
+        readonly backgroundSolid: "bg-emerald-500";
+        readonly text: "text-emerald-400";
+        readonly border: "border border-emerald-500/20";
+        readonly stroke: "stroke-emerald-500";
+    };
+    readonly teal: {
+        readonly background: "bg-teal-500/10";
+        readonly backgroundSolid: "bg-teal-500";
+        readonly text: "text-teal-400";
+        readonly border: "border border-teal-500/20";
+        readonly stroke: "stroke-teal-500";
+    };
+    readonly cyan: {
+        readonly background: "bg-cyan-500/10";
+        readonly backgroundSolid: "bg-cyan-500";
+        readonly text: "text-cyan-400";
+        readonly border: "border border-cyan-500/20";
+        readonly stroke: "stroke-cyan-500";
+    };
+    readonly sky: {
+        readonly background: "bg-sky-500/10";
+        readonly backgroundSolid: "bg-sky-500";
+        readonly text: "text-sky-400";
+        readonly border: "border border-sky-500/20";
+        readonly stroke: "stroke-sky-500";
+    };
+    readonly violet: {
+        readonly background: "bg-violet-500/10";
+        readonly backgroundSolid: "bg-violet-500";
+        readonly text: "text-violet-400";
+        readonly border: "border border-violet-500/20";
+        readonly stroke: "stroke-violet-500";
+    };
+    readonly fuchsia: {
+        readonly background: "bg-fuchsia-500/10";
+        readonly backgroundSolid: "bg-fuchsia-500";
+        readonly text: "text-fuchsia-400";
+        readonly border: "border border-fuchsia-500/20";
+        readonly stroke: "stroke-fuchsia-500";
+    };
+    readonly orange: {
+        readonly background: "bg-orange-500/10";
+        readonly backgroundSolid: "bg-orange-500";
+        readonly text: "text-orange-400";
+        readonly border: "border border-orange-500/20";
+        readonly stroke: "stroke-orange-500";
+    };
+    readonly rose: {
+        readonly background: "bg-rose-500/10";
+        readonly backgroundSolid: "bg-rose-500";
+        readonly text: "text-rose-400";
+        readonly border: "border border-rose-500/20";
+        readonly stroke: "stroke-rose-500";
+    };
+    readonly gray: {
+        readonly background: "bg-gray-1100/10";
+        readonly backgroundSolid: "bg-gray-1100";
+        readonly text: "text-gray-1100";
+        readonly border: "border border-gray-1100/20";
+        readonly stroke: "stroke-gray-1100";
+    };
+};
+
+declare type ColorStyleName = keyof typeof COLOR_STYLES;
+
+export declare type DrawerSide = 'left' | 'right' | 'top' | 'bottom';
+
+declare const FormField: ({ children, className, ...domProps }: FormFieldProps) => JSX.Element;
+
+export declare interface FormFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const FormFields: ({ children, className, ...domProps }: FormFieldsProps) => JSX.Element;
+
+export declare interface FormFieldsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const FormGroup: ({ children, className, ...domProps }: FormGroupProps) => JSX.Element;
+
+export declare interface FormGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare type HeadingElement = 'h1' | 'h2' | 'h3' | 'h4' | 'h5' | 'h6' | 'div';
+
+declare type HeadingLevel = 1 | 2 | 3 | 4 | 5 | 6 | 7;
+
+export declare const OxAccordion: typeof OxAccordion_2 & {
+    Content: typeof OxAccordionContent;
+    Header: typeof OxAccordionHeader;
+    Item: typeof OxAccordionItem;
+};
+
+declare const OxAccordion_2: ({ children, className, defaultValue, onValueChange, type, value: controlledValue, ...domProps }: OxAccordionProps) => JSX.Element;
+
+declare const OxAccordionContent: ({ children, className, ...domProps }: OxAccordionContentProps) => JSX.Element;
+
+export declare interface OxAccordionContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+declare const OxAccordionHeader: ({ children, className, ...domProps }: OxAccordionHeaderProps) => JSX.Element;
+
+export declare interface OxAccordionHeaderProps extends React.HTMLAttributes<HTMLButtonElement> {
+    children: ReactNode;
+}
+
+declare const OxAccordionItem: ({ children, className, disabled, value, ...domProps }: OxAccordionItemProps) => JSX.Element;
+
+export declare interface OxAccordionItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    disabled?: boolean;
+    value: string;
+}
+
+export declare interface OxAccordionProps extends React.HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+    defaultValue?: string | string[];
+    onValueChange?: (value: string | string[]) => void;
+    type?: AccordionType;
+    value?: string | string[];
+}
+
+export declare const OxAlert: typeof OxAlert_2 & {
+    Icon: typeof OxAlertIcon;
+};
+
+declare const OxAlert_2: ({ "aria-live": ariaLive, children, className, role, type, ...domProps }: OxAlertProps) => JSX.Element;
+
+declare const OxAlertIcon: ({ className, iconClass, iconDivClass, path, size, ...props }: OxAlertIconProps) => JSX.Element;
+
+export declare interface OxAlertIconProps extends Omit<OxIconProps, 'path'> {
+    iconClass?: string;
+    iconDivClass?: string;
+    path?: string;
+}
+
+export declare interface OxAlertProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+    icon?: string;
+    iconClass?: string;
+    iconDivClass?: string;
+    type?: OxAlertType;
+}
+
+export declare type OxAlertType = 'success' | 'error' | 'warning' | 'info' | 'default';
+
+export declare const OxAvatar: typeof OxAvatar_2 & {
+    Field: typeof OxAvatarField;
+};
+
+declare const OxAvatar_2: ({ alt, className, fallback, isLoading: externalIsLoading, shape, showStatus, size, skeleton, src, status, ...domProps }: OxAvatarProps) => JSX.Element;
+
+declare const OxAvatarField: ({ children, className, ...domProps }: OxAvatarFieldProps) => JSX.Element;
+
+export declare interface OxAvatarFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+export declare interface OxAvatarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    alt: string;
+    fallback?: string | ReactNode;
+    isLoading?: boolean;
+    shape?: 'rectangle' | 'circle';
+    showStatus?: boolean;
+    size?: OxAvatarSize;
+    skeleton?: boolean;
+    src?: string;
+    status?: 'online' | 'offline' | 'away' | 'busy';
+}
+
+export declare type OxAvatarSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl' | '3xl';
+
+export declare const OxBadge: ({ bgColor, children, className, color, size, style: styleProp, textColor, ...domProps }: OxBadgeProps) => JSX.Element;
+
+export declare interface OxBadgeProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    bgColor?: string;
+    children: ReactNode;
+    color?: ColorStyleName;
+    size?: 'sm' | 'md';
+    textColor?: string;
+}
+
+export declare const OxBreadcrumb: typeof OxBreadcrumb_2 & {
+    Item: typeof OxBreadcrumbItem;
+    Link: typeof OxBreadcrumbLink;
+    Separator: typeof OxBreadcrumbSeparator;
+};
+
+declare const OxBreadcrumb_2: ({ children, className, ...domProps }: OxBreadcrumbProps) => JSX.Element;
+
+declare const OxBreadcrumbItem: ({ children, className, current, ...domProps }: OxBreadcrumbItemProps) => JSX.Element;
+
+export declare interface OxBreadcrumbItemProps extends Omit<HTMLAttributes<HTMLLIElement>, 'children'> {
+    children: ReactNode;
+    current?: boolean;
+}
+
+declare const OxBreadcrumbLink: ({ children, className, href, ...domProps }: OxBreadcrumbLinkProps) => JSX.Element;
+
+export declare interface OxBreadcrumbLinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> {
+    children: ReactNode;
+    href: string;
+}
+
+export declare interface OxBreadcrumbProps extends Omit<HTMLAttributes<HTMLOListElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxBreadcrumbSeparator: ({ children, className, ...domProps }: OxBreadcrumbSeparatorProps) => JSX.Element;
+
+export declare type OxBreadcrumbSeparatorProps = HTMLAttributes<HTMLLIElement>;
+
+export declare const OxButton: typeof OxButton_2 & {
+    Icon: typeof OxButtonIcon;
+};
+
+declare const OxButton_2: ({ children, className, disabled, fullWidth, isLoading, size, type, variant, ...domProps }: OxButtonProps) => JSX.Element;
+
+declare const OxButtonIcon: ({ path, size: propSize, ...props }: OxButtonIconProps) => JSX.Element;
+
+export declare type OxButtonIconProps = OxIconProps;
+
+export declare interface OxButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'type'> {
+    fullWidth?: boolean;
+    isLoading?: boolean;
+    ref?: Ref<HTMLButtonElement>;
+    size?: 'sm' | 'md';
+    type?: 'button' | 'submit' | 'reset';
+    variant?: 'primary' | 'secondary' | 'ghost' | 'link' | 'danger';
+}
+
+export declare const OxCalendar: ({ className, onChange, value, ...domProps }: OxCalendarProps) => JSX.Element;
+
+export declare interface OxCalendarProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    onChange?: (value: string) => void;
+    value?: string;
+}
+
+export declare const OxCard: typeof OxCard_2 & {
+    Body: typeof OxCardBody;
+    Footer: typeof OxCardFooter;
+    Header: typeof OxCardHeader;
+};
+
+declare const OxCard_2: ({ children, className, color, equalHeight, hoverVariant, hoverable, padding, ...domProps }: OxCardProps) => JSX.Element;
+
+declare const OxCardBody: ({ children, className, flexGrow, ...domProps }: OxCardBodyProps) => JSX.Element;
+
+export declare interface OxCardBodyProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+    flexGrow?: boolean;
+}
+
+declare const OxCardFooter: ({ children, className, ...domProps }: OxCardFooterProps) => JSX.Element;
+
+export declare interface OxCardFooterProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxCardHeader: ({ action, children, className, icon, iconColor, subtitle, title, ...domProps }: OxCardHeaderProps) => JSX.Element;
+
+export declare interface OxCardHeaderProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
+    action?: ReactNode;
+    icon?: string;
+    iconColor?: ColorStyleName;
+    subtitle?: ReactNode;
+    title?: ReactNode;
+}
+
+export declare interface OxCardProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+    color?: ColorStyleName;
+    equalHeight?: boolean;
+    hoverable?: boolean;
+    hoverVariant?: 'none' | 'lift' | 'glow' | 'border';
+    padding?: 'none' | 'sm' | 'md';
+}
+
+export declare const OxCheckbox: typeof OxCheckbox_2 & {
+    Field: typeof OxCheckboxField;
+    Group: typeof OxCheckboxGroup;
+};
+
+declare const OxCheckbox_2: ({ checked, className, defaultChecked, disabled, error, id: propId, indeterminate, name, onChange, onCheckedChange, required, size, value, ...domProps }: OxCheckboxProps) => JSX.Element;
+
+declare const OxCheckboxField: ({ children, className, ...domProps }: OxCheckboxFieldProps) => JSX.Element;
+
+export declare interface OxCheckboxFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxCheckboxGroup: ({ children, className, disabled, name, onChange, size, value, ...domProps }: OxCheckboxGroupProps) => JSX.Element;
+
+export declare interface OxCheckboxGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'children'> {
+    children: ReactNode;
+    disabled?: boolean;
+    name: string;
+    onChange?: (value: (string | number)[]) => void;
+    size?: 'sm' | 'md';
+    value?: (string | number)[];
+}
+
+export declare interface OxCheckboxProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size' | 'value' | 'children'> {
+    error?: boolean;
+    indeterminate?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    size?: 'sm' | 'md';
+    value?: string | number;
+}
+
+declare const OxDateButton: (props: BaseInputButtonProps) => JSX.Element;
+
+declare const OxDateContainer: ({ children, className, customValidationMessage, defaultValue, disabled, error, onChange, pickOnly, readOnly, required, showValidation, showValidationTooltip, size, value, ...domProps }: OxDateInputContainerProps) => JSX.Element;
+
+declare const OxDateIcon: (props: BaseInputIconProps) => JSX.Element;
+
+export declare const OxDateInput: typeof OxDateInput_2 & {
+    Button: typeof OxDateButton;
+    Container: typeof OxDateContainer;
+    Icon: typeof OxDateIcon;
+    PickerButton: typeof OxDatePickerButton;
+};
+
+declare const OxDateInput_2: () => JSX.Element;
+
+declare type OxDateInputButton = BaseInputButtonProps;
+
+declare interface OxDateInputContainerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    customValidationMessage?: string;
+    defaultValue?: string;
+    disabled?: boolean;
+    error?: boolean;
+    onChange?: (value: string) => void;
+    pickOnly?: boolean;
+    readOnly?: boolean;
+    required?: boolean;
+    showValidation?: boolean;
+    showValidationTooltip?: boolean;
+    size?: 'sm' | 'md';
+    value?: string;
+}
+
+declare const OxDatePickerButton: ({ children, ...props }: OxDateInputButton) => JSX.Element;
+
+export declare const OxDescription: ({ children, className, disabled, ...domProps }: OxDescriptionProps) => JSX.Element;
+
+export declare const OxDescriptionList: typeof OxDescriptionList_2 & {
+    Term: typeof OxDescriptionListTerm;
+    Value: typeof OxDescriptionListValue;
+};
+
+declare const OxDescriptionList_2: ({ children, className, ...domProps }: OxDescriptionListProps) => JSX.Element;
+
+declare interface OxDescriptionListProps extends Omit<HTMLAttributes<HTMLDListElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDescriptionListTerm: ({ children, className, ...domProps }: OxDescriptionListTermProps) => JSX.Element;
+
+declare interface OxDescriptionListTermProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDescriptionListValue: ({ children, className, ...domProps }: OxDescriptionListValueProps) => JSX.Element;
+
+declare interface OxDescriptionListValueProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    children?: ReactNode;
+}
+
+declare interface OxDescriptionProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+    disabled?: boolean;
+}
+
+export declare const OxDialog: typeof OxDialog_2 & {
+    Body: typeof OxDialogBody;
+    Footer: typeof OxDialogFooter;
+    Header: typeof OxDialogHeader;
+};
+
+declare const OxDialog_2: ({ children, className, closeOnOutsideClick, isOpen, onClose, persistent, showCloseButton, size, ...domProps }: OxDialogProps) => ReactPortal | null;
+
+declare const OxDialogBody: ({ children, className, ...domProps }: OxDialogBodyProps) => JSX.Element;
+
+export declare interface OxDialogBodyProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDialogFooter: ({ children, className, ...domProps }: OxDialogFooterProps) => JSX.Element;
+
+export declare interface OxDialogFooterProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDialogHeader: ({ children, className, ...domProps }: OxDialogHeaderProps) => JSX.Element;
+
+export declare interface OxDialogHeaderProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+export declare interface OxDialogProps extends Omit<DialogHTMLAttributes<HTMLDialogElement>, 'children' | 'onClose'> {
+    children: ReactNode;
+    closeOnOutsideClick?: boolean;
+    isOpen: boolean;
+    onClose: () => void;
+    persistent?: boolean;
+    showCloseButton?: boolean;
+    size?: OxDialogSize;
+}
+
+export declare type OxDialogSize = 'sm' | 'md' | 'lg' | 'xl';
+
+export declare const OxDrawer: typeof OxDrawer_2 & {
+    Body: typeof OxDrawerBody;
+    Content: typeof OxDrawerContent;
+    Footer: typeof OxDrawerFooter;
+    Header: typeof OxDrawerHeader;
+    Trigger: typeof OxDrawerTrigger;
+};
+
+declare const OxDrawer_2: ({ children, defaultOpen, onOpenChange, open: controlledOpen, }: OxDrawerProps) => JSX.Element;
+
+declare const OxDrawerBody: ({ children, className, ...domProps }: OxDrawerBodyProps) => JSX.Element;
+
+export declare interface OxDrawerBodyProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDrawerContent: ({ children, className, closeOnOutsideClick, side, ...domProps }: OxDrawerContentProps) => ReactPortal | null;
+
+export declare interface OxDrawerContentProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+    closeOnOutsideClick?: boolean;
+    side?: DrawerSide;
+}
+
+declare const OxDrawerFooter: ({ children, className, ...domProps }: OxDrawerFooterProps) => JSX.Element;
+
+export declare interface OxDrawerFooterProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDrawerHeader: ({ children, className, ...domProps }: OxDrawerHeaderProps) => JSX.Element;
+
+export declare interface OxDrawerHeaderProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+export declare interface OxDrawerProps {
+    children: ReactNode;
+    defaultOpen?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+}
+
+declare const OxDrawerTrigger: ({ children, className, disabled, onClick, ...domProps }: OxDrawerTriggerProps) => JSX.Element;
+
+export declare interface OxDrawerTriggerProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'children'> {
+    children: ReactNode;
+    disabled?: boolean;
+}
+
+export declare const OxDropdown: typeof OxDropdown_2 & {
+    Body: typeof OxDropdownBody;
+    Button: typeof OxDropdownButton;
+    Footer: typeof OxDropdownFooter;
+    Header: typeof OxDropdownHeader;
+    Icon: typeof OxDropdownIcon;
+    Label: typeof OxDropdownLabel;
+    Link: typeof OxDropdownLink;
+    Separator: typeof OxDropdownSeparator;
+    Shortcut: typeof OxDropdownShortcut;
+    Trigger: typeof OxDropdownTrigger;
+};
+
+declare const OxDropdown_2: ({ align, children, className, defaultOpen, disabled, onOpenChange, open: controlledOpen, side, size, ...domProps }: OxDropdownProps) => JSX.Element;
+
+export declare interface OxDropdownActionProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDropdownBody: ({ children, className, ...domProps }: OxDropdownBodyProps) => JSX.Element;
+
+export declare interface OxDropdownBodyProps extends Omit<HTMLAttributes<HTMLUListElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDropdownButton: ({ children, className, disabled, onClick, ...domProps }: OxDropdownActionProps) => JSX.Element;
+
+declare const OxDropdownFooter: ({ children, className, ...domProps }: OxDropdownFooterProps) => JSX.Element;
+
+export declare interface OxDropdownFooterProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDropdownHeader: ({ children, className, ...domProps }: OxDropdownHeaderProps) => JSX.Element;
+
+export declare interface OxDropdownHeaderProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDropdownIcon: ({ path, size: propSize, ...props }: OxDropdownIconProps) => JSX.Element;
+
+export declare type OxDropdownIconProps = OxIconProps;
+
+declare const OxDropdownLabel: ({ children, className, ...domProps }: OxDropdownLabelProps) => JSX.Element;
+
+export declare interface OxDropdownLabelProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDropdownLink: ({ children, className, disabled, href, ...domProps }: OxDropdownLinkProps) => JSX.Element;
+
+export declare interface OxDropdownLinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'children'> {
+    children: ReactNode;
+    disabled?: boolean;
+}
+
+export declare interface OxDropdownProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    align?: OxFloatingAlign;
+    children: ReactNode;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    side?: OxFloatingPosition;
+    size?: 'sm' | 'md';
+}
+
+declare const OxDropdownSeparator: ({ className, ...domProps }: OxDropdownSeparatorProps) => JSX.Element;
+
+export declare type OxDropdownSeparatorProps = Omit<OxSeparatorProps, 'orientation' | 'vertical'>;
+
+declare const OxDropdownShortcut: ({ children, className, ...domProps }: OxDropdownShortcutProps) => JSX.Element;
+
+export declare interface OxDropdownShortcutProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxDropdownTrigger: ({ animateIcon, asChild, children, className, disabled: propsDisabled, hideIcon, icon, outline, ...domProps }: OxDropdownTriggerProps) => JSX.Element;
+
+export declare interface OxDropdownTriggerProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    animateIcon?: boolean;
+    asChild?: boolean;
+    children: ReactNode;
+    hideIcon?: boolean;
+    icon?: string;
+    outline?: boolean;
+}
+
+export declare const OxError: ({ children, className, icon, ...domProps }: OxErrorProps) => JSX.Element | null;
+
+declare interface OxErrorProps extends HTMLAttributes<HTMLDivElement> {
+    icon?: string;
+}
+
+export declare const OxFileUpload: typeof OxFileUpload_2 & {
+    Area: typeof OxFileUploadArea;
+    Button: typeof OxFileUploadButton;
+    Overlay: typeof OxFileUploadOverlay;
+};
+
+declare const OxFileUpload_2: ({ accept, children, className, disabled, maxFiles, maxSize, minSize, multiple, onError, onFileSelect, ...domProps }: OxFileUploadProps) => JSX.Element;
+
+declare const OxFileUploadArea: ({ children, className, ...domProps }: OxFileUploadAreaProps) => JSX.Element;
+
+export declare interface OxFileUploadAreaProps extends HTMLAttributes<HTMLDivElement> {
+    children?: ReactNode;
+}
+
+declare const OxFileUploadButton: ({ children, className, size, variant, ...domProps }: OxFileUploadButtonProps) => JSX.Element;
+
+export declare interface OxFileUploadButtonProps extends Omit<HTMLAttributes<HTMLButtonElement>, 'onClick'> {
+    children?: ReactNode;
+    size?: 'sm' | 'md';
+    variant?: 'primary' | 'secondary' | 'ghost' | 'link' | 'danger';
+}
+
+declare const OxFileUploadOverlay: ({ children, className, ...domProps }: OxFileUploadOverlayProps) => JSX.Element;
+
+export declare interface OxFileUploadOverlayProps extends HTMLAttributes<HTMLDivElement> {
+    children: ReactNode;
+}
+
+export declare interface OxFileUploadProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onError'> {
+    accept?: string[];
+    children: ReactNode;
+    disabled?: boolean;
+    maxFiles?: number;
+    maxSize?: string;
+    minSize?: string;
+    multiple?: boolean;
+    onError?: (error: string) => void;
+    onFileSelect?: (files: File[]) => void;
+}
+
+export declare const OxFloating: ({ align, animationDuration, ariaHaspopup, asChild, children, className, content, contentClassName, contentRole, contentStyle, disabled, hoverDelay, id: propId, offset, onOpenChange, open: controlledOpen, portal, position, trigger, useAriaControls, }: OxFloatingProps) => JSX.Element;
+
+export declare type OxFloatingAlign = 'start' | 'center' | 'end';
+
+export declare type OxFloatingPosition = 'top' | 'bottom' | 'left' | 'right';
+
+export declare interface OxFloatingProps {
+    align?: OxFloatingAlign;
+    animationDuration?: number;
+    ariaHaspopup?: 'menu' | 'dialog' | 'listbox' | 'tree' | 'grid' | true;
+    asChild?: boolean;
+    children: ReactNode;
+    className?: string;
+    content: ReactNode;
+    contentClassName?: string;
+    contentRole?: 'tooltip' | 'menu' | 'dialog' | 'listbox' | undefined;
+    contentStyle?: CSSProperties;
+    disabled?: boolean;
+    hoverDelay?: number;
+    id?: string;
+    offset?: number;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    portal?: boolean;
+    position?: OxFloatingPosition;
+    trigger?: OxFloatingTrigger;
+    useAriaControls?: boolean;
+}
+
+export declare type OxFloatingTrigger = 'hover' | 'click' | 'manual' | 'focus';
+
+export declare const OxForm: typeof OxForm_2 & {
+    Field: typeof FormField;
+    Fields: typeof FormFields;
+    Group: typeof FormGroup;
+};
+
+declare const OxForm_2: ({ children, className, fullWidth, noValidate, ...domProps }: OxFormProps) => JSX.Element;
+
+export declare interface OxFormProps extends Omit<FormHTMLAttributes<HTMLFormElement>, 'children'> {
+    children: ReactNode;
+    fullWidth?: boolean;
+}
+
+export declare const OxHeading: ({ as, children, className, level, ...domProps }: OxHeadingProps) => DetailedReactHTMLElement<    {
+role?: string | undefined;
+"aria-level"?: number | undefined;
+slot?: string | undefined | undefined;
+style?: CSSProperties | undefined;
+title?: string | undefined | undefined;
+hidden?: boolean | undefined | undefined;
+defaultValue?: string | number | readonly string[] | undefined;
+dir?: string | undefined | undefined;
+defaultChecked?: boolean | undefined | undefined;
+suppressContentEditableWarning?: boolean | undefined | undefined;
+suppressHydrationWarning?: boolean | undefined | undefined;
+accessKey?: string | undefined | undefined;
+autoCapitalize?: "off" | "none" | "on" | "sentences" | "words" | "characters" | undefined | (string & {}) | undefined;
+autoFocus?: boolean | undefined | undefined;
+contentEditable?: (boolean | "true" | "false") | "inherit" | "plaintext-only" | undefined;
+contextMenu?: string | undefined | undefined;
+draggable?: (boolean | "true" | "false") | undefined;
+enterKeyHint?: "enter" | "done" | "go" | "next" | "previous" | "search" | "send" | undefined | undefined;
+id?: string | undefined | undefined;
+lang?: string | undefined | undefined;
+nonce?: string | undefined | undefined;
+spellCheck?: (boolean | "true" | "false") | undefined;
+tabIndex?: number | undefined | undefined;
+translate?: "yes" | "no" | undefined | undefined;
+radioGroup?: string | undefined | undefined;
+about?: string | undefined | undefined;
+content?: string | undefined | undefined;
+datatype?: string | undefined | undefined;
+inlist?: any;
+prefix?: string | undefined | undefined;
+property?: string | undefined | undefined;
+rel?: string | undefined | undefined;
+resource?: string | undefined | undefined;
+rev?: string | undefined | undefined;
+typeof?: string | undefined | undefined;
+vocab?: string | undefined | undefined;
+autoCorrect?: string | undefined | undefined;
+autoSave?: string | undefined | undefined;
+color?: string | undefined | undefined;
+itemProp?: string | undefined | undefined;
+itemScope?: boolean | undefined | undefined;
+itemType?: string | undefined | undefined;
+itemID?: string | undefined | undefined;
+itemRef?: string | undefined | undefined;
+results?: number | undefined | undefined;
+security?: string | undefined | undefined;
+unselectable?: "on" | "off" | undefined | undefined;
+popover?: "" | "auto" | "manual" | "hint" | undefined | undefined;
+popoverTargetAction?: "toggle" | "show" | "hide" | undefined | undefined;
+popoverTarget?: string | undefined | undefined;
+inert?: boolean | undefined | undefined;
+inputMode?: "none" | "text" | "tel" | "url" | "email" | "numeric" | "decimal" | "search" | undefined | undefined;
+is?: string | undefined | undefined;
+exportparts?: string | undefined | undefined;
+part?: string | undefined | undefined;
+"aria-activedescendant"?: string | undefined | undefined;
+"aria-atomic"?: (boolean | "true" | "false") | undefined;
+"aria-autocomplete"?: "none" | "inline" | "list" | "both" | undefined | undefined;
+"aria-braillelabel"?: string | undefined | undefined;
+"aria-brailleroledescription"?: string | undefined | undefined;
+"aria-busy"?: (boolean | "true" | "false") | undefined;
+"aria-checked"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+"aria-colcount"?: number | undefined | undefined;
+"aria-colindex"?: number | undefined | undefined;
+"aria-colindextext"?: string | undefined | undefined;
+"aria-colspan"?: number | undefined | undefined;
+"aria-controls"?: string | undefined | undefined;
+"aria-current"?: boolean | "false" | "true" | "page" | "step" | "location" | "date" | "time" | undefined | undefined;
+"aria-describedby"?: string | undefined | undefined;
+"aria-description"?: string | undefined | undefined;
+"aria-details"?: string | undefined | undefined;
+"aria-disabled"?: (boolean | "true" | "false") | undefined;
+"aria-dropeffect"?: "none" | "copy" | "execute" | "link" | "move" | "popup" | undefined | undefined;
+"aria-errormessage"?: string | undefined | undefined;
+"aria-expanded"?: (boolean | "true" | "false") | undefined;
+"aria-flowto"?: string | undefined | undefined;
+"aria-grabbed"?: (boolean | "true" | "false") | undefined;
+"aria-haspopup"?: boolean | "false" | "true" | "menu" | "listbox" | "tree" | "grid" | "dialog" | undefined | undefined;
+"aria-hidden"?: (boolean | "true" | "false") | undefined;
+"aria-invalid"?: boolean | "false" | "true" | "grammar" | "spelling" | undefined | undefined;
+"aria-keyshortcuts"?: string | undefined | undefined;
+"aria-label"?: string | undefined | undefined;
+"aria-labelledby"?: string | undefined | undefined;
+"aria-live"?: "off" | "assertive" | "polite" | undefined | undefined;
+"aria-modal"?: (boolean | "true" | "false") | undefined;
+"aria-multiline"?: (boolean | "true" | "false") | undefined;
+"aria-multiselectable"?: (boolean | "true" | "false") | undefined;
+"aria-orientation"?: "horizontal" | "vertical" | undefined | undefined;
+"aria-owns"?: string | undefined | undefined;
+"aria-placeholder"?: string | undefined | undefined;
+"aria-posinset"?: number | undefined | undefined;
+"aria-pressed"?: boolean | "false" | "mixed" | "true" | undefined | undefined;
+"aria-readonly"?: (boolean | "true" | "false") | undefined;
+"aria-relevant"?: "additions" | "additions removals" | "additions text" | "all" | "removals" | "removals additions" | "removals text" | "text" | "text additions" | "text removals" | undefined | undefined;
+"aria-required"?: (boolean | "true" | "false") | undefined;
+"aria-roledescription"?: string | undefined | undefined;
+"aria-rowcount"?: number | undefined | undefined;
+"aria-rowindex"?: number | undefined | undefined;
+"aria-rowindextext"?: string | undefined | undefined;
+"aria-rowspan"?: number | undefined | undefined;
+"aria-selected"?: (boolean | "true" | "false") | undefined;
+"aria-setsize"?: number | undefined | undefined;
+"aria-sort"?: "none" | "ascending" | "descending" | "other" | undefined | undefined;
+"aria-valuemax"?: number | undefined | undefined;
+"aria-valuemin"?: number | undefined | undefined;
+"aria-valuenow"?: number | undefined | undefined;
+"aria-valuetext"?: string | undefined | undefined;
+dangerouslySetInnerHTML?: {
+__html: string | TrustedHTML;
+} | undefined | undefined;
+onCopy?: ClipboardEventHandler<HTMLElement> | undefined;
+onCopyCapture?: ClipboardEventHandler<HTMLElement> | undefined;
+onCut?: ClipboardEventHandler<HTMLElement> | undefined;
+onCutCapture?: ClipboardEventHandler<HTMLElement> | undefined;
+onPaste?: ClipboardEventHandler<HTMLElement> | undefined;
+onPasteCapture?: ClipboardEventHandler<HTMLElement> | undefined;
+onCompositionEnd?: CompositionEventHandler<HTMLElement> | undefined;
+onCompositionEndCapture?: CompositionEventHandler<HTMLElement> | undefined;
+onCompositionStart?: CompositionEventHandler<HTMLElement> | undefined;
+onCompositionStartCapture?: CompositionEventHandler<HTMLElement> | undefined;
+onCompositionUpdate?: CompositionEventHandler<HTMLElement> | undefined;
+onCompositionUpdateCapture?: CompositionEventHandler<HTMLElement> | undefined;
+onFocus?: FocusEventHandler<HTMLElement> | undefined;
+onFocusCapture?: FocusEventHandler<HTMLElement> | undefined;
+onBlur?: FocusEventHandler<HTMLElement> | undefined;
+onBlurCapture?: FocusEventHandler<HTMLElement> | undefined;
+onChange?: FormEventHandler<HTMLElement> | undefined;
+onChangeCapture?: FormEventHandler<HTMLElement> | undefined;
+onBeforeInput?: InputEventHandler<HTMLElement> | undefined;
+onBeforeInputCapture?: FormEventHandler<HTMLElement> | undefined;
+onInput?: FormEventHandler<HTMLElement> | undefined;
+onInputCapture?: FormEventHandler<HTMLElement> | undefined;
+onReset?: FormEventHandler<HTMLElement> | undefined;
+onResetCapture?: FormEventHandler<HTMLElement> | undefined;
+onSubmit?: FormEventHandler<HTMLElement> | undefined;
+onSubmitCapture?: FormEventHandler<HTMLElement> | undefined;
+onInvalid?: FormEventHandler<HTMLElement> | undefined;
+onInvalidCapture?: FormEventHandler<HTMLElement> | undefined;
+onLoad?: ReactEventHandler<HTMLElement> | undefined;
+onLoadCapture?: ReactEventHandler<HTMLElement> | undefined;
+onError?: ReactEventHandler<HTMLElement> | undefined;
+onErrorCapture?: ReactEventHandler<HTMLElement> | undefined;
+onKeyDown?: KeyboardEventHandler<HTMLElement> | undefined;
+onKeyDownCapture?: KeyboardEventHandler<HTMLElement> | undefined;
+onKeyPress?: KeyboardEventHandler<HTMLElement> | undefined;
+onKeyPressCapture?: KeyboardEventHandler<HTMLElement> | undefined;
+onKeyUp?: KeyboardEventHandler<HTMLElement> | undefined;
+onKeyUpCapture?: KeyboardEventHandler<HTMLElement> | undefined;
+onAbort?: ReactEventHandler<HTMLElement> | undefined;
+onAbortCapture?: ReactEventHandler<HTMLElement> | undefined;
+onCanPlay?: ReactEventHandler<HTMLElement> | undefined;
+onCanPlayCapture?: ReactEventHandler<HTMLElement> | undefined;
+onCanPlayThrough?: ReactEventHandler<HTMLElement> | undefined;
+onCanPlayThroughCapture?: ReactEventHandler<HTMLElement> | undefined;
+onDurationChange?: ReactEventHandler<HTMLElement> | undefined;
+onDurationChangeCapture?: ReactEventHandler<HTMLElement> | undefined;
+onEmptied?: ReactEventHandler<HTMLElement> | undefined;
+onEmptiedCapture?: ReactEventHandler<HTMLElement> | undefined;
+onEncrypted?: ReactEventHandler<HTMLElement> | undefined;
+onEncryptedCapture?: ReactEventHandler<HTMLElement> | undefined;
+onEnded?: ReactEventHandler<HTMLElement> | undefined;
+onEndedCapture?: ReactEventHandler<HTMLElement> | undefined;
+onLoadedData?: ReactEventHandler<HTMLElement> | undefined;
+onLoadedDataCapture?: ReactEventHandler<HTMLElement> | undefined;
+onLoadedMetadata?: ReactEventHandler<HTMLElement> | undefined;
+onLoadedMetadataCapture?: ReactEventHandler<HTMLElement> | undefined;
+onLoadStart?: ReactEventHandler<HTMLElement> | undefined;
+onLoadStartCapture?: ReactEventHandler<HTMLElement> | undefined;
+onPause?: ReactEventHandler<HTMLElement> | undefined;
+onPauseCapture?: ReactEventHandler<HTMLElement> | undefined;
+onPlay?: ReactEventHandler<HTMLElement> | undefined;
+onPlayCapture?: ReactEventHandler<HTMLElement> | undefined;
+onPlaying?: ReactEventHandler<HTMLElement> | undefined;
+onPlayingCapture?: ReactEventHandler<HTMLElement> | undefined;
+onProgress?: ReactEventHandler<HTMLElement> | undefined;
+onProgressCapture?: ReactEventHandler<HTMLElement> | undefined;
+onRateChange?: ReactEventHandler<HTMLElement> | undefined;
+onRateChangeCapture?: ReactEventHandler<HTMLElement> | undefined;
+onSeeked?: ReactEventHandler<HTMLElement> | undefined;
+onSeekedCapture?: ReactEventHandler<HTMLElement> | undefined;
+onSeeking?: ReactEventHandler<HTMLElement> | undefined;
+onSeekingCapture?: ReactEventHandler<HTMLElement> | undefined;
+onStalled?: ReactEventHandler<HTMLElement> | undefined;
+onStalledCapture?: ReactEventHandler<HTMLElement> | undefined;
+onSuspend?: ReactEventHandler<HTMLElement> | undefined;
+onSuspendCapture?: ReactEventHandler<HTMLElement> | undefined;
+onTimeUpdate?: ReactEventHandler<HTMLElement> | undefined;
+onTimeUpdateCapture?: ReactEventHandler<HTMLElement> | undefined;
+onVolumeChange?: ReactEventHandler<HTMLElement> | undefined;
+onVolumeChangeCapture?: ReactEventHandler<HTMLElement> | undefined;
+onWaiting?: ReactEventHandler<HTMLElement> | undefined;
+onWaitingCapture?: ReactEventHandler<HTMLElement> | undefined;
+onAuxClick?: MouseEventHandler<HTMLElement> | undefined;
+onAuxClickCapture?: MouseEventHandler<HTMLElement> | undefined;
+onClick?: MouseEventHandler<HTMLElement> | undefined;
+onClickCapture?: MouseEventHandler<HTMLElement> | undefined;
+onContextMenu?: MouseEventHandler<HTMLElement> | undefined;
+onContextMenuCapture?: MouseEventHandler<HTMLElement> | undefined;
+onDoubleClick?: MouseEventHandler<HTMLElement> | undefined;
+onDoubleClickCapture?: MouseEventHandler<HTMLElement> | undefined;
+onDrag?: DragEventHandler<HTMLElement> | undefined;
+onDragCapture?: DragEventHandler<HTMLElement> | undefined;
+onDragEnd?: DragEventHandler<HTMLElement> | undefined;
+onDragEndCapture?: DragEventHandler<HTMLElement> | undefined;
+onDragEnter?: DragEventHandler<HTMLElement> | undefined;
+onDragEnterCapture?: DragEventHandler<HTMLElement> | undefined;
+onDragExit?: DragEventHandler<HTMLElement> | undefined;
+onDragExitCapture?: DragEventHandler<HTMLElement> | undefined;
+onDragLeave?: DragEventHandler<HTMLElement> | undefined;
+onDragLeaveCapture?: DragEventHandler<HTMLElement> | undefined;
+onDragOver?: DragEventHandler<HTMLElement> | undefined;
+onDragOverCapture?: DragEventHandler<HTMLElement> | undefined;
+onDragStart?: DragEventHandler<HTMLElement> | undefined;
+onDragStartCapture?: DragEventHandler<HTMLElement> | undefined;
+onDrop?: DragEventHandler<HTMLElement> | undefined;
+onDropCapture?: DragEventHandler<HTMLElement> | undefined;
+onMouseDown?: MouseEventHandler<HTMLElement> | undefined;
+onMouseDownCapture?: MouseEventHandler<HTMLElement> | undefined;
+onMouseEnter?: MouseEventHandler<HTMLElement> | undefined;
+onMouseLeave?: MouseEventHandler<HTMLElement> | undefined;
+onMouseMove?: MouseEventHandler<HTMLElement> | undefined;
+onMouseMoveCapture?: MouseEventHandler<HTMLElement> | undefined;
+onMouseOut?: MouseEventHandler<HTMLElement> | undefined;
+onMouseOutCapture?: MouseEventHandler<HTMLElement> | undefined;
+onMouseOver?: MouseEventHandler<HTMLElement> | undefined;
+onMouseOverCapture?: MouseEventHandler<HTMLElement> | undefined;
+onMouseUp?: MouseEventHandler<HTMLElement> | undefined;
+onMouseUpCapture?: MouseEventHandler<HTMLElement> | undefined;
+onSelect?: ReactEventHandler<HTMLElement> | undefined;
+onSelectCapture?: ReactEventHandler<HTMLElement> | undefined;
+onTouchCancel?: TouchEventHandler<HTMLElement> | undefined;
+onTouchCancelCapture?: TouchEventHandler<HTMLElement> | undefined;
+onTouchEnd?: TouchEventHandler<HTMLElement> | undefined;
+onTouchEndCapture?: TouchEventHandler<HTMLElement> | undefined;
+onTouchMove?: TouchEventHandler<HTMLElement> | undefined;
+onTouchMoveCapture?: TouchEventHandler<HTMLElement> | undefined;
+onTouchStart?: TouchEventHandler<HTMLElement> | undefined;
+onTouchStartCapture?: TouchEventHandler<HTMLElement> | undefined;
+onPointerDown?: PointerEventHandler<HTMLElement> | undefined;
+onPointerDownCapture?: PointerEventHandler<HTMLElement> | undefined;
+onPointerMove?: PointerEventHandler<HTMLElement> | undefined;
+onPointerMoveCapture?: PointerEventHandler<HTMLElement> | undefined;
+onPointerUp?: PointerEventHandler<HTMLElement> | undefined;
+onPointerUpCapture?: PointerEventHandler<HTMLElement> | undefined;
+onPointerCancel?: PointerEventHandler<HTMLElement> | undefined;
+onPointerCancelCapture?: PointerEventHandler<HTMLElement> | undefined;
+onPointerEnter?: PointerEventHandler<HTMLElement> | undefined;
+onPointerLeave?: PointerEventHandler<HTMLElement> | undefined;
+onPointerOver?: PointerEventHandler<HTMLElement> | undefined;
+onPointerOverCapture?: PointerEventHandler<HTMLElement> | undefined;
+onPointerOut?: PointerEventHandler<HTMLElement> | undefined;
+onPointerOutCapture?: PointerEventHandler<HTMLElement> | undefined;
+onGotPointerCapture?: PointerEventHandler<HTMLElement> | undefined;
+onGotPointerCaptureCapture?: PointerEventHandler<HTMLElement> | undefined;
+onLostPointerCapture?: PointerEventHandler<HTMLElement> | undefined;
+onLostPointerCaptureCapture?: PointerEventHandler<HTMLElement> | undefined;
+onScroll?: UIEventHandler<HTMLElement> | undefined;
+onScrollCapture?: UIEventHandler<HTMLElement> | undefined;
+onScrollEnd?: UIEventHandler<HTMLElement> | undefined;
+onScrollEndCapture?: UIEventHandler<HTMLElement> | undefined;
+onWheel?: WheelEventHandler<HTMLElement> | undefined;
+onWheelCapture?: WheelEventHandler<HTMLElement> | undefined;
+onAnimationStart?: AnimationEventHandler<HTMLElement> | undefined;
+onAnimationStartCapture?: AnimationEventHandler<HTMLElement> | undefined;
+onAnimationEnd?: AnimationEventHandler<HTMLElement> | undefined;
+onAnimationEndCapture?: AnimationEventHandler<HTMLElement> | undefined;
+onAnimationIteration?: AnimationEventHandler<HTMLElement> | undefined;
+onAnimationIterationCapture?: AnimationEventHandler<HTMLElement> | undefined;
+onToggle?: ToggleEventHandler<HTMLElement> | undefined;
+onBeforeToggle?: ToggleEventHandler<HTMLElement> | undefined;
+onTransitionCancel?: TransitionEventHandler<HTMLElement> | undefined;
+onTransitionCancelCapture?: TransitionEventHandler<HTMLElement> | undefined;
+onTransitionEnd?: TransitionEventHandler<HTMLElement> | undefined;
+onTransitionEndCapture?: TransitionEventHandler<HTMLElement> | undefined;
+onTransitionRun?: TransitionEventHandler<HTMLElement> | undefined;
+onTransitionRunCapture?: TransitionEventHandler<HTMLElement> | undefined;
+onTransitionStart?: TransitionEventHandler<HTMLElement> | undefined;
+onTransitionStartCapture?: TransitionEventHandler<HTMLElement> | undefined;
+className: string;
+'data-ox-slot': string;
+}, HTMLElement>;
+
+declare interface OxHeadingProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    as?: HeadingElement;
+    children: ReactNode;
+    level?: HeadingLevel;
+}
+
+export declare const OxIcon: ({ className, path, placeholder, size, ...props }: OxIconProps) => JSX.Element;
+
+export declare interface OxIconProps extends Omit<IconProps, 'path'> {
+    path?: string;
+    placeholder?: boolean;
+}
+
+export declare const OxJsonField: typeof OxJsonField_2 & {
+    Node: typeof OxJsonNode;
+};
+
+declare const OxJsonField_2: ({ className, value, ...domProps }: OxJsonFieldProps) => JSX.Element;
+
+export declare interface OxJsonFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    value: string | OxJsonValue;
+}
+
+declare const OxJsonNode: ({ data, level }: OxJsonNodeProps) => JSX.Element;
+
+export declare interface OxJsonNodeProps {
+    data: OxJsonValue;
+    level: number;
+}
+
+export declare type OxJsonValue = string | number | boolean | null | undefined | OxJsonValue[] | {
+    [key: string]: OxJsonValue;
+};
+
+export declare const OxLabel: ({ children, className, disabled, htmlFor, required, ...domProps }: OxLabelProps) => JSX.Element;
+
+declare interface OxLabelProps extends Omit<LabelHTMLAttributes<HTMLLabelElement>, 'children'> {
+    children: ReactNode;
+    disabled?: boolean;
+    required?: boolean;
+}
+
+export declare const OxLegend: ({ children, className, disabled, required, ...domProps }: OxLegendProps) => JSX.Element;
+
+declare interface OxLegendProps extends Omit<HTMLAttributes<HTMLLegendElement>, 'children'> {
+    children: ReactNode;
+    disabled?: boolean;
+    required?: boolean;
+}
+
+export declare const OxLink: ({ children, className, disabled, href, size, variant, ...domProps }: OxLinkProps) => JSX.Element;
+
+export declare interface OxLinkProps extends AnchorHTMLAttributes<HTMLAnchorElement> {
+    disabled?: boolean;
+    size?: 'sm' | 'md';
+    variant?: 'primary' | 'secondary' | 'ghost' | 'link' | 'danger';
+}
+
+export declare interface OxNotificationItemProps {
+    icon?: string;
+    id: string;
+    img?: string;
+    message?: string;
+    read: boolean;
+    timestamp: Date;
+    title: string;
+    type?: 'default' | 'info' | 'success' | 'warning' | 'error';
+}
+
+export declare const OxNotifications: typeof OxNotifications_2 & {
+    Body: typeof OxNotificationsBody;
+    Button: typeof OxNotificationsButton;
+    Link: typeof OxNotificationsLink;
+    Trigger: typeof OxNotificationsTrigger;
+};
+
+declare const OxNotifications_2: ({ children, disabled, emptyMessage, items, onItemClick, onMarkAllRead, unreadCount, ...domProps }: OxNotificationsProps) => JSX.Element;
+
+declare const OxNotificationsBody: ({ children, className, ...domProps }: OxNotificationsBodyProps) => JSX.Element;
+
+export declare interface OxNotificationsBodyProps extends Omit<HTMLAttributes<HTMLUListElement>, 'children'> {
+    children?: ReactNode;
+}
+
+declare const OxNotificationsButton: ({ children, className, icon, img, message, timestamp, title, type, unread, ...domProps }: OxNotificationsButtonProps) => JSX.Element;
+
+export declare interface OxNotificationsButtonProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'type' | 'onClick'>, BaseNotificationItemProps {
+}
+
+export declare type OxNotificationsIconProps = OxIconProps;
+
+declare const OxNotificationsLink: ({ children, className, href, icon, img, message, timestamp, title, type, unread, ...domProps }: OxNotificationsLinkProps) => JSX.Element;
+
+export declare interface OxNotificationsLinkProps extends Omit<AnchorHTMLAttributes<HTMLAnchorElement>, 'children' | 'type' | 'onClick'>, BaseNotificationItemProps {
+    href: string;
+}
+
+export declare interface OxNotificationsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children?: ReactNode;
+    disabled?: boolean;
+    emptyMessage?: string;
+    items?: OxNotificationItemProps[];
+    onItemClick?: (item: OxNotificationItemProps) => void;
+    onMarkAllRead?: () => void;
+    unreadCount?: number;
+}
+
+declare const OxNotificationsTrigger: ({ children, className, customIcon, unreadCount: propUnreadCount, ...domProps }: OxNotificationsTriggerProps) => JSX.Element;
+
+export declare interface OxNotificationsTriggerProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    children?: ReactNode;
+    customIcon?: string;
+    unreadCount?: number;
+}
+
+declare const OxNumberButton: (props: OxNumberInputButton) => JSX.Element;
+
+declare const OxNumberContainer: ({ children, defaultValue, disabled, error, locale, max, maximumFractionDigits, min, minimumFractionDigits, onChange, required, showValidationTooltip, size, steps, useGrouping, value, ...domProps }: OxNumberContainerProps) => JSX.Element;
+
+export declare interface OxNumberContainerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    customValidationMessage?: string;
+    defaultValue?: number;
+    disabled?: boolean;
+    error?: boolean;
+    locale?: string;
+    max?: number;
+    maximumFractionDigits?: number;
+    min?: number;
+    minimumFractionDigits?: number;
+    onChange?: (value: number | undefined) => void;
+    required?: boolean;
+    showValidation?: boolean;
+    showValidationTooltip?: boolean;
+    size?: 'sm' | 'md';
+    steps?: number;
+    useGrouping?: boolean;
+    value?: number;
+}
+
+declare const OxNumberDecrementButton: () => JSX.Element;
+
+declare const OxNumberIcon: (props: OxNumberInputIcon) => JSX.Element;
+
+declare const OxNumberIncrementButton: () => JSX.Element;
+
+export declare const OxNumberInput: typeof OxNumberInput_2 & {
+    Button: typeof OxNumberButton;
+    Container: typeof OxNumberContainer;
+    DecrementButton: typeof OxNumberDecrementButton;
+    Icon: typeof OxNumberIcon;
+    IncrementButton: typeof OxNumberIncrementButton;
+};
+
+declare const OxNumberInput_2: ({ "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, className, ...domProps }: OxNumberInputProps) => JSX.Element;
+
+export declare type OxNumberInputButton = BaseInputButtonProps;
+
+export declare type OxNumberInputIcon = BaseInputIconProps;
+
+export declare interface OxNumberInputProps {
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    className?: string;
+    id?: string;
+    placeholder?: string;
+}
+
+export declare const OxOtpInput: ({ className, disabled, error, length, onComplete, onValueChange, placeholder, size, type, }: OxOtpInputProps) => JSX.Element;
+
+export declare interface OxOtpInputProps {
+    className?: string;
+    disabled?: boolean;
+    error?: boolean;
+    length?: number;
+    onComplete?: (value: string) => void;
+    onValueChange?: (value: string) => void;
+    placeholder?: string;
+    size?: OxOtpInputSize;
+    type?: OxOtpInputType;
+}
+
+export declare type OxOtpInputSize = 'sm' | 'md';
+
+export declare type OxOtpInputType = 'numeric' | 'alphanumeric' | 'text';
+
+export declare const OxPagination: typeof OxPagination_2 & {
+    Ellipsis: typeof OxPaginationEllipsis;
+    Link: typeof OxPaginationLink;
+    Next: typeof OxPaginationNext;
+    Previous: typeof OxPaginationPrevious;
+};
+
+declare const OxPagination_2: ({ children, className, ...domProps }: OxPaginationProps) => JSX.Element;
+
+declare const OxPaginationEllipsis: ({ className, size, ...domProps }: OxPaginationEllipsisProps) => JSX.Element;
+
+export declare interface OxPaginationEllipsisProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    size?: OxPaginationSize;
+}
+
+export declare interface OxPaginationItemProps extends Omit<HTMLAttributes<HTMLLIElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxPaginationLink: ({ className, disabled, isActive, onClick, page, size, ...domProps }: OxPaginationLinkProps) => JSX.Element;
+
+export declare interface OxPaginationLinkProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onClick' | 'children'> {
+    isActive?: boolean;
+    onClick: (page: number) => void;
+    page: number;
+    size?: OxPaginationSize;
+}
+
+declare const OxPaginationNext: ({ className, disabled, onClick, short, size, ...domProps }: OxPaginationNextProps) => JSX.Element;
+
+export declare interface OxPaginationNextProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onClick' | 'children'> {
+    onClick: () => void;
+    short?: boolean;
+    size?: OxPaginationSize;
+}
+
+declare const OxPaginationPrevious: ({ className, disabled, onClick, short, size, ...domProps }: OxPaginationPreviousProps) => JSX.Element;
+
+export declare interface OxPaginationPreviousProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onClick' | 'children'> {
+    onClick: () => void;
+    short?: boolean;
+    size?: OxPaginationSize;
+}
+
+export declare interface OxPaginationProps extends Omit<HTMLAttributes<HTMLElement>, 'children'> {
+    children: ReactNode;
+}
+
+export declare type OxPaginationSize = 'sm' | 'md';
+
+export declare const OxPopover: typeof OxPopover_2 & {
+    Content: typeof OxPopoverContent;
+    Trigger: typeof OxPopoverTrigger;
+};
+
+declare const OxPopover_2: ({ align, children, defaultOpen, disabled, onOpenChange, open: controlledOpen, side, ...domProps }: OxPopoverProps) => JSX.Element;
+
+declare const OxPopoverContent: ({ children, className, showCloseButton, ...domProps }: OxPopoverContentProps) => JSX.Element;
+
+export declare interface OxPopoverContentProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: React.ReactNode;
+    showCloseButton?: boolean;
+}
+
+export declare interface OxPopoverProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    align?: OxFloatingAlign;
+    children: React.ReactNode;
+    defaultOpen?: boolean;
+    disabled?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    open?: boolean;
+    side?: OxFloatingPosition;
+}
+
+declare const OxPopoverTrigger: ({ children, ...domProps }: OxPopoverTriggerProps) => JSX.Element;
+
+export declare interface OxPopoverTriggerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: React.ReactNode;
+}
+
+export declare const OxProgress: typeof OxProgress_2 & {
+    Circular: typeof OxProgressCircular;
+};
+
+declare const OxProgress_2: ({ buffer, className, max, value, variant, ...domProps }: OxProgressProps) => JSX.Element;
+
+declare const OxProgressCircular: ({ className, max, showPercentage, size, value, variant, ...domProps }: OxProgressCircularProps) => JSX.Element;
+
+export declare interface OxProgressCircularProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    max?: number;
+    showPercentage?: boolean;
+    size?: 'sm' | 'md';
+    value?: number;
+    variant?: ColorStyleName;
+}
+
+export declare interface OxProgressProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    buffer?: number;
+    max?: number;
+    value?: number;
+    variant?: ColorStyleName;
+}
+
+export declare const OxRadio: typeof OxRadio_2 & {
+    Field: typeof OxRadioField;
+    Group: typeof OxRadioGroup;
+};
+
+declare const OxRadio_2: ({ checked, className, defaultChecked, disabled, error, id: propId, name, onChange, onCheckedChange, required, size, value, ...domProps }: OxRadioProps) => JSX.Element;
+
+declare const OxRadioField: ({ children, className, ...domProps }: OxRadioFieldProps) => JSX.Element;
+
+export declare interface OxRadioFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+declare const OxRadioGroup: ({ children, className, disabled, name, onChange, size, value, ...domProps }: OxRadioGroupProps) => JSX.Element;
+
+export declare interface OxRadioGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'children'> {
+    children: ReactNode;
+    disabled?: boolean;
+    name: string;
+    onChange?: (value: string | number) => void;
+    size?: 'sm' | 'md';
+    value?: string | number;
+}
+
+export declare interface OxRadioProps extends Omit<InputHTMLAttributes<HTMLInputElement>, 'type' | 'size'> {
+    error?: boolean;
+    onCheckedChange?: (checked: boolean) => void;
+    size?: 'sm' | 'md';
+    value?: string | number;
+}
+
+export declare const OxSelect: typeof OxSelect_2 & {
+    Content: typeof OxSelectContent;
+    Icon: typeof OxSelectIcon;
+    Label: typeof OxSelectLabel;
+    Option: typeof OxSelectOption;
+    OptionGroup: typeof OxSelectOptionGroup;
+    Trigger: typeof OxSelectTrigger;
+};
 
-declare type CardColor = 'purple' | 'blue' | 'emerald' | 'orange' | 'rose' | 'amber' | 'cyan' | 'indigo';
+declare const OxSelect_2: ({ children, className, defaultValue, disabled, error, id: propId, multiple, onChange, required, size, value, wrapperClassName, }: OxSelectProps) => JSX.Element;
 
-declare type FloatingAlign = 'start' | 'center' | 'end';
+declare const OxSelectContent: ({ children, className, ...domProps }: OxSelectContentProps) => JSX.Element;
 
-declare type FloatingPosition = 'top' | 'bottom' | 'left' | 'right';
+export declare interface OxSelectContentProps extends Omit<HTMLAttributes<HTMLUListElement>, 'children'> {
+    children: ReactNode;
+}
 
-declare type FloatingTrigger = 'hover' | 'click' | 'manual' | 'focus';
+declare const OxSelectIcon: ({ className, path, ...domProps }: OxSelectIconProps) => JSX.Element;
 
-export declare const OxAvatar: default_2.FC<OxAvatarProps>;
+export declare interface OxSelectIconProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    path: string;
+}
 
-export declare const OxAvatarImage: default_2.FC<OxAvatarImageProps>;
+declare const OxSelectLabel: ({ children, className, ...domProps }: OxSelectLabelProps) => JSX.Element;
 
-export declare interface OxAvatarImageProps {
-    alt: string;
-    className?: string;
-    fallback?: string | ReactNode;
-    showStatus?: boolean;
-    size?: OxAvatarSize;
-    skeleton?: boolean;
-    src: string;
-    status?: 'online' | 'offline' | 'away' | 'busy';
-    type?: 'rounded' | 'square';
+export declare interface OxSelectLabelProps extends Omit<HTMLAttributes<HTMLSpanElement>, 'children'> {
+    children: ReactNode;
 }
 
-export declare interface OxAvatarProps {
+declare const OxSelectOption: ({ children, className, disabled, value, ...domProps }: OxSelectOptionProps) => JSX.Element;
+
+declare const OxSelectOptionGroup: ({ children, className, label, ...domProps }: OxSelectOptionGroupProps) => JSX.Element;
+
+export declare interface OxSelectOptionGroupProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
     children: ReactNode;
-    className?: string;
+    label: string;
+}
+
+export declare interface OxSelectOptionProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'value' | 'children'> {
+    children: ReactNode;
+    value: string | number | null;
 }
 
-export declare type OxAvatarSize = 'sm' | 'md' | 'lg' | 'xl' | '2xl';
+export declare interface OxSelectProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'children' | 'defaultValue'> {
+    children: ReactNode;
+    defaultValue?: string | string[] | number | number[] | null;
+    disabled?: boolean;
+    error?: boolean;
+    multiple?: boolean;
+    onChange?: (value: string | number | null | (string | number | null)[], name?: string) => void;
+    required?: boolean;
+    size?: 'sm' | 'md';
+    value?: string | string[] | number | number[] | null;
+    wrapperClassName?: string;
+}
 
-export declare const OxAvatarText: default_2.FC<OxAvatarTextProps>;
+declare const OxSelectTrigger: ({ badgeColor, className, displayAsBadges, placeholder, size: propSize, ...domProps }: OxSelectTriggerProps) => JSX.Element;
 
-export declare interface OxAvatarTextProps {
-    className?: string;
-    size?: OxAvatarSize;
-    subtext?: string;
-    username: string;
+export declare interface OxSelectTriggerProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children' | 'size' | 'disabled' | 'required'> {
+    badgeColor?: ColorStyleName;
+    displayAsBadges?: boolean;
+    placeholder?: string;
+    size?: 'sm' | 'md';
 }
 
-export declare const OxBadge: default_2.FC<OxBadgeProps>;
+export declare const OxSeparator: ({ className, decorative, orientation, ...domProps }: OxSeparatorProps) => JSX.Element;
 
-export declare type OxBadgeColor = 'purple' | 'lime' | 'red' | 'yellow' | 'green' | 'blue' | 'indigo' | 'pink' | 'amber' | 'emerald' | 'teal' | 'cyan' | 'sky' | 'violet' | 'fuchsia' | 'gray';
+export declare interface OxSeparatorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    decorative?: boolean;
+    orientation?: 'horizontal' | 'vertical';
+}
 
-export declare interface OxBadgeProps {
-    bgColor?: string;
-    children: ReactNode;
-    className?: string;
-    color?: OxBadgeColor;
-    size?: 'sm' | 'md' | 'lg';
-    textColor?: string;
+export declare const OxSkeleton: ({ animate, className, color, fullWidth, height, shape, width, ...domProps }: OxSkeletonProps) => JSX.Element;
+
+export declare interface OxSkeletonProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    animate?: boolean;
+    color?: ColorStyleName;
+    fullWidth?: boolean;
+    height?: string | number;
+    shape?: 'rectangle' | 'circle';
+    width?: string | number;
 }
 
-export declare const OxButton: default_2.FC<OxButtonProps>;
+export declare const OxSkeletonText: ({ animate, className, color, fullWidth, height, lines, width, ...domProps }: OxSkeletonTextProps) => JSX.Element;
 
-export declare interface OxButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'type' | 'disabled' | 'className' | 'children'> {
-    children?: React.ReactNode;
-    className?: string;
+export declare interface OxSkeletonTextProps extends Omit<OxSkeletonProps, 'shape' | 'width'> {
+    lines?: number;
+    width?: string | number | (string | number)[];
+}
+
+export declare const OxSlider: ({ "aria-label": ariaLabel, "aria-labelledby": ariaLabelledby, className, defaultValue, disabled, max, min, onChange, onChangeCommitted, orientation, showValue, size, step, value: controlledValue, ...domProps }: OxSliderProps) => JSX.Element;
+
+export declare interface OxSliderProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'defaultValue' | 'children'> {
+    defaultValue?: number | [number, number];
     disabled?: boolean;
-    fullWidth?: boolean;
-    icon?: string;
-    iconAlign?: 'left' | 'right';
-    isLoading?: boolean;
-    size?: 'sm' | 'md' | 'lg';
-    type?: 'button' | 'submit' | 'reset';
-    variant?: 'primary' | 'secondary' | 'ghost' | 'link';
+    marks?: boolean | number[];
+    max?: number;
+    min?: number;
+    onChange?: (value: number | [number, number]) => void;
+    onChangeCommitted?: (value: number | [number, number]) => void;
+    orientation?: 'horizontal' | 'vertical';
+    showValue?: boolean;
+    size?: 'sm' | 'md';
+    step?: number;
+    value?: number | [number, number];
 }
 
-export declare const OxCard: default_2.FC<OxCardProps>;
+export declare const OxSpinner: ({ className, size, variant, ...domProps }: OxSpinnerProps) => JSX.Element;
 
-export declare const OxCardContent: default_2.FC<OxCardContentProps>;
+export declare interface OxSpinnerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    size?: 'sm' | 'md' | number;
+    variant?: ColorStyleName;
+}
 
-export declare interface OxCardContentProps extends React.HTMLAttributes<HTMLDivElement> {
-    children: React.ReactNode;
-    className?: string;
-    flexGrow?: boolean;
+export declare type OxStatusContent = {
+    icon?: string;
+    message: string;
+    showAction: boolean;
+    title: string;
+};
+
+export declare const OxStatusDisplay: ({ action, children, className, inline, message, onBack, size, title, type, ...domProps }: OxStatusDisplayProps) => JSX.Element;
+
+export declare interface OxStatusDisplayProps extends HTMLAttributes<HTMLDivElement> {
+    action?: ReactNode;
+    inline?: boolean;
+    message?: string;
+    onBack?: () => void;
+    size?: 'sm' | 'md';
+    title?: string;
+    type: OxStatusType;
 }
 
-export declare const OxCardFooter: default_2.FC<OxCardFooterProps>;
+export declare type OxStatusType = 'loading' | 'empty' | 'offline' | 'success' | 'warning' | 'info' | 401 | 403 | 404 | 408 | 429 | 500 | 502 | 503 | 504;
+
+export declare const OxStepper: typeof OxStepper_2 & {
+    Actions: typeof OxStepperActions;
+    Item: typeof OxStepperItem;
+};
+
+declare const OxStepper_2: ({ children, className, color, currentStep, onStepChange, orientation, type, ...domProps }: OxStepperProps) => JSX.Element;
+
+declare const OxStepperActions: ({ children, className, ...domProps }: OxStepperActionsProps) => JSX.Element;
 
-export declare interface OxCardFooterProps extends HTMLAttributes<HTMLDivElement> {
+export declare interface OxStepperActionsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
     children: ReactNode;
-    className?: string;
 }
 
-export declare const OxCardHeader: default_2.FC<OxCardHeaderProps>;
+export declare interface OxStepperConnectorProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    state?: StepState;
+    stepIndex: number;
+}
 
-export declare interface OxCardHeaderProps extends Omit<HTMLAttributes<HTMLDivElement>, 'title'> {
-    action?: ReactNode;
-    children?: ReactNode;
-    className?: string;
-    color?: CardColor;
+declare const OxStepperItem: ({ children, className, description, icon, state: propState, stepIndex, title, ...domProps }: OxStepperItemProps) => JSX.Element;
+
+export declare interface OxStepperItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+    description?: string;
     icon?: string;
-    iconColor?: CardColor;
-    subtitle?: ReactNode;
-    title?: ReactNode;
+    state?: StepState;
+    stepIndex?: number;
+    title: string;
 }
 
-export declare interface OxCardProps extends HTMLAttributes<HTMLDivElement> {
-    backdropBlur?: boolean;
+export declare interface OxStepperProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
     children: ReactNode;
-    className?: string;
-    color?: CardColor;
-    equalHeight?: boolean;
-    hoverable?: boolean;
-    hoverVariant?: 'none' | 'lift' | 'glow' | 'border';
-    padding?: 'none' | 'sm' | 'md' | 'lg';
-    variant?: 'default' | 'outline' | 'gradient';
+    color?: ColorStyleName;
+    currentStep?: number;
+    onStepChange?: (step: number) => void;
+    orientation?: StepperOrientation;
+    type?: StepperType;
 }
 
-export declare const OxCheckbox: default_2.FC<OxCheckboxProps>;
+export declare const OxSwitch: typeof OxSwitch_2 & {
+    Field: typeof OxSwitchField;
+};
 
-export declare interface OxCheckboxProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'type' | 'id' | 'name' | 'checked' | 'defaultChecked' | 'onChange' | 'value' | 'className' | 'required' | 'disabled' | 'size'> {
+declare const OxSwitch_2: ({ checked, className, disabled, error, id: propId, onChange, required, size, ...domProps }: OxSwitchProps) => JSX.Element;
+
+declare const OxSwitchField: ({ children, className, ...domProps }: OxSwitchFieldProps) => JSX.Element;
+
+export declare interface OxSwitchFieldProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+export declare interface OxSwitchProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'type' | 'size' | 'onChange' | 'children'> {
     checked?: boolean;
-    className?: string;
-    defaultChecked?: boolean;
-    description?: string;
-    disabled?: boolean;
     error?: boolean;
-    errorMessage?: string;
-    id?: string;
-    label?: string;
-    name?: string;
-    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onChange?: (checked: boolean) => void;
     required?: boolean;
-    size?: 'sm' | 'md' | 'lg';
-    value?: string | number | readonly string[];
+    size?: 'sm' | 'md';
 }
 
-export declare const OxDescription: default_2.FC<OxDescriptionProps>;
-
-export declare interface OxDescriptionProps {
-    children: React.ReactNode;
-    className?: string;
-    disabled?: boolean;
-    id?: string;
-}
+export declare const OxTable: typeof OxTable_2 & {
+    Body: typeof OxTableBody;
+    Cell: typeof OxTableCell;
+    Controls: typeof OxTableControls;
+    Footer: typeof OxTableFooter;
+    Head: typeof OxTableHead;
+    Header: typeof OxTableHeader;
+    Row: typeof OxTableRow;
+};
 
-export declare const OxDropdown: default_2.FC<OxDropdownProps>;
+declare const OxTable_2: ({ allRowIds, children, className, onSelectionChange, selectable, selectedRows, ...domProps }: OxTableProps) => JSX.Element;
 
-export declare const OxDropdownContent: default_2.FC<OxDropdownContentProps>;
+declare const OxTableBody: ({ children, className, ...domProps }: OxTableBodyProps) => JSX.Element;
 
-export declare interface OxDropdownContentProps {
-    align?: FloatingAlign;
-    children: default_2.ReactNode;
-    className?: string;
-    side?: FloatingPosition;
+export declare interface OxTableBodyProps extends Omit<HTMLAttributes<HTMLTableSectionElement>, 'children'> {
+    children: ReactNode;
 }
 
-export declare const OxDropdownFooter: React.FC<OxDropdownFooterProps>;
+declare const OxTableCell: ({ children, className, ...domProps }: OxTableCellProps) => JSX.Element;
 
-export declare interface OxDropdownFooterProps {
-    children: default_2.ReactNode;
-    className?: string;
+export declare interface OxTableCellProps extends Omit<TdHTMLAttributes<HTMLTableCellElement>, 'children'> {
+    children?: ReactNode;
 }
 
-export declare const OxDropdownHeader: React.FC<OxDropdownHeaderProps>;
+declare const OxTableControls: ({ children, className, ...domProps }: OxTableControlsProps) => JSX.Element;
 
-export declare interface OxDropdownHeaderProps {
-    children: default_2.ReactNode;
-    className?: string;
+export declare interface OxTableControlsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
 }
 
-export declare const OxDropdownItem: default_2.FC<OxDropdownItemProps>;
+declare const OxTableFooter: ({ children, className, ...domProps }: OxTableFooterProps) => JSX.Element;
 
-export declare interface OxDropdownItemProps {
-    children: default_2.ReactNode;
-    className?: string;
-    disabled?: boolean;
-    icon?: string;
-    onClick?: (event: default_2.MouseEvent<HTMLButtonElement>) => void;
-    unstyled?: boolean;
+export declare interface OxTableFooterProps extends Omit<HTMLAttributes<HTMLTableSectionElement>, 'children'> {
+    children: ReactNode;
 }
 
-export declare interface OxDropdownProps {
-    children: default_2.ReactNode;
-    className?: string;
-    defaultOpen?: boolean;
-    disabled?: boolean;
-    onOpenChange?: (open: boolean) => void;
-    open?: boolean;
-}
+declare const OxTableHead: ({ children, className, ...domProps }: OxTableHeadProps) => JSX.Element;
 
-export declare const OxDropdownSeparator: default_2.FC<OxDropdownSeparatorProps>;
+declare const OxTableHeader: ({ children, className, ...domProps }: OxTableHeaderProps) => JSX.Element;
 
-export declare interface OxDropdownSeparatorProps {
-    className?: string;
+export declare interface OxTableHeaderProps extends Omit<HTMLAttributes<HTMLTableSectionElement>, 'children'> {
+    children: ReactNode;
 }
 
-export declare const OxDropdownShortcut: default_2.FC<OxDropdownShortcutProps>;
+export declare interface OxTableHeadProps extends Omit<ThHTMLAttributes<HTMLTableCellElement>, 'children'> {
+    children?: ReactNode;
+}
 
-export declare interface OxDropdownShortcutProps {
-    children: default_2.ReactNode;
-    className?: string;
+export declare interface OxTableProps extends Omit<TableHTMLAttributes<HTMLTableElement>, 'children'> {
+    allRowIds?: string[];
+    children: ReactNode;
+    onSelectionChange?: (selectedRows: string[]) => void;
+    selectable?: boolean;
+    selectedRows?: string[];
 }
 
-export declare const OxDropdownTrigger: default_2.FC<OxDropdownTriggerProps>;
+declare const OxTableRow: ({ children, className, rowId, ...domProps }: OxTableRowProps) => JSX.Element;
 
-export declare interface OxDropdownTriggerProps extends Omit<default_2.ButtonHTMLAttributes<HTMLButtonElement>, 'disabled' | 'className' | 'children' | 'type'> {
-    animateIcon?: boolean;
-    children: default_2.ReactNode;
-    className?: string;
-    disabled?: boolean;
-    icon?: string;
-    outline?: boolean;
-    unstyled?: boolean;
+export declare interface OxTableRowProps extends Omit<HTMLAttributes<HTMLTableRowElement>, 'children'> {
+    children: ReactNode;
+    rowId?: string;
 }
 
-export declare const OxErrorMessage: default_2.FC<OxErrorMessageProps>;
+export declare const OxTabs: typeof OxTabs_2 & {
+    Content: typeof OxTabsContent;
+    List: typeof OxTabsList;
+    Trigger: typeof OxTabsTrigger;
+};
 
-export declare interface OxErrorMessageProps {
-    children?: React.ReactNode;
-    className?: string;
-    icon?: string;
-    id?: string;
+declare const OxTabs_2: ({ children, className, defaultValue, onValueChange, value, ...domProps }: OxTabsProps) => JSX.Element;
+
+declare const OxTabsContent: ({ children, className, value, ...domProps }: OxTabsContentProps) => JSX.Element | null;
+
+export declare interface OxTabsContentProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+    value: string;
 }
 
-export declare const OxForm: default_2.FC<OxFormProps>;
+declare const OxTabsList: ({ children, className, ...domProps }: OxTabsListProps) => JSX.Element;
 
-export declare interface OxFormProps extends Omit<React.FormHTMLAttributes<HTMLFormElement>, 'className' | 'noValidate'> {
-    children: React.ReactNode;
-    className?: string;
-    fullWidth?: boolean;
-    noValidate?: boolean;
+export declare interface OxTabsListProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+}
+
+export declare interface OxTabsProps extends Omit<HTMLAttributes<HTMLDivElement>, 'children'> {
+    children: ReactNode;
+    defaultValue?: string;
+    onValueChange?: (value: string) => void;
+    value?: string;
 }
 
-export declare const OxGuestRoute: ({ children, onAuthenticated, onLoading, }: OxGuestRouteProps) => ReactNode;
+declare const OxTabsTrigger: ({ children, className, disabled, value, ...domProps }: OxTabsTriggerProps) => JSX.Element;
 
-export declare interface OxGuestRouteProps {
-    children: React.ReactNode;
-    onAuthenticated?: React.ReactNode;
-    onLoading?: React.ReactNode;
+export declare interface OxTabsTriggerProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'children'> {
+    children: ReactNode;
+    value: string;
 }
 
-export declare const OxIcon: React.FC<OxIconProps>;
+export declare const OxTextarea: ({ className, disabled, error, id: propId, name, onChange, placeholder, required, rows, showMaxLength, size, value, ...domProps }: OxTextareaProps) => JSX.Element;
 
-export declare interface OxIconProps {
-    className?: string;
-    icon: string;
-    size?: number;
-    style?: React.CSSProperties;
+export declare interface OxTextareaProps extends Omit<TextareaHTMLAttributes<HTMLTextAreaElement>, 'children'> {
+    error?: boolean;
+    showMaxLength?: boolean;
+    size?: 'sm' | 'md';
 }
 
-export declare const OxInput: default_2.FC<OxInputProps>;
+declare const OxTextButton: (props: OxTextInputButton) => JSX.Element;
 
-export declare interface OxInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'size' | 'type' | 'name' | 'id' | 'value' | 'onChange' | 'className' | 'readOnly' | 'required' | 'disabled' | 'placeholder'> {
-    className?: string;
-    description?: string;
+declare const OxTextClearButton: () => JSX.Element;
+
+declare const OxTextContainer: ({ children, className, customValidationMessage, defaultValue, disabled, error, onChange, required, showValidation, showValidationTooltip, size, type, value, ...domProps }: OxTextInputContainerProps) => JSX.Element;
+
+declare const OxTextCounter: (props: OxTextInputCounter) => JSX.Element;
+
+declare const OxTextIcon: (props: OxTextInputIcon) => JSX.Element;
+
+export declare const OxTextInput: typeof OxTextInput_2 & {
+    Button: typeof OxTextButton;
+    ClearButton: typeof OxTextClearButton;
+    Container: typeof OxTextContainer;
+    Counter: typeof OxTextCounter;
+    Icon: typeof OxTextIcon;
+    VisibilityButton: typeof OxTextVisibilityButton;
+};
+
+declare const OxTextInput_2: ({ autoComplete, className, id, maxLength, placeholder, spellCheck, ...domProps }: OxTextInputProps) => JSX.Element;
+
+declare type OxTextInputButton = BaseInputButtonProps;
+
+declare interface OxTextInputContainerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    customValidationMessage?: string;
+    defaultValue?: string;
     disabled?: boolean;
     error?: boolean;
-    errorMessage?: string | string[];
-    icon?: string;
-    iconPosition?: 'left' | 'right';
+    onChange?: (value: string) => void;
+    required?: boolean;
+    showValidation?: boolean;
+    showValidationTooltip?: boolean;
+    size?: 'sm' | 'md';
+    type?: OxTextInputType;
+    value?: string;
+}
+
+declare type OxTextInputCounter = BaseInputCounterProps;
+
+declare type OxTextInputIcon = BaseInputIconProps;
+
+declare interface OxTextInputProps {
+    [key: `data-${string}`]: string | undefined;
+    'aria-describedby'?: string;
+    'aria-label'?: string;
+    'aria-labelledby'?: string;
+    autoComplete?: string;
+    className?: string;
     id?: string;
-    label?: string;
+    maxLength?: number;
+    minLength?: number;
     name?: string;
-    onChange?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    pattern?: string;
     placeholder?: string;
     readOnly?: boolean;
-    ref?: React.RefObject<HTMLInputElement>;
-    required?: boolean;
-    showMaxLength?: boolean;
-    type?: 'text' | 'password' | 'email' | 'number' | 'tel' | 'url' | 'search';
-    value?: string | number;
+    spellCheck?: boolean;
 }
 
-export declare const OxLabel: default_2.FC<OxLabelProps>;
+declare type OxTextInputType = 'email' | 'password' | 'search' | 'tel' | 'text' | 'url';
 
-export declare interface OxLabelProps {
-    children: React.ReactNode;
-    className?: string;
+declare const OxTextVisibilityButton: () => JSX.Element;
+
+declare const OxTimeButton: (props: BaseInputButtonProps) => JSX.Element;
+
+declare const OxTimeContainer: ({ children, className, customValidationMessage, defaultValue, disabled, error, onChange, required, showValidation, showValidationTooltip, size, value, ...domProps }: OxTimeInputContainerProps) => JSX.Element;
+
+declare const OxTimeIcon: (props: BaseInputIconProps) => JSX.Element;
+
+export declare const OxTimeInput: typeof OxTimeInput_2 & {
+    Button: typeof OxTimeButton;
+    Container: typeof OxTimeContainer;
+    Icon: typeof OxTimeIcon;
+};
+
+declare const OxTimeInput_2: () => JSX.Element;
+
+declare interface OxTimeInputContainerProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    customValidationMessage?: string;
+    defaultValue?: string;
     disabled?: boolean;
-    htmlFor?: string;
+    error?: boolean;
+    onChange?: (value: string) => void;
     required?: boolean;
+    showValidation?: boolean;
+    showValidationTooltip?: boolean;
+    size?: 'sm' | 'md';
+    value?: string;
 }
 
-export declare const OxNotificationDropdown: default_2.FC<OxNotificationDropdownProps>;
+export declare const OxTimeline: typeof OxTimeline_2 & {
+    Item: typeof OxTimelineItem;
+};
 
-export declare interface OxNotificationDropdownProps {
-    className?: string;
-    disabled?: boolean;
-    emptyMessage?: string;
-    maxHeight?: string;
-    notifications: OxNotificationProps[];
-    onMarkAllRead?: () => void;
-    onNotificationClick?: (notification: OxNotificationProps) => void;
-    unreadCount?: number;
-}
+declare const OxTimeline_2: ({ children, className, ...domProps }: OxTimelineProps) => JSX.Element;
 
-export declare interface OxNotificationProps {
+export declare type OxTimelineAlign = 'left' | 'right';
+
+declare const OxTimelineItem: ({ align, children, className, color, description, icon, label, showSeparator, timestamp, ...domProps }: OxTimelineItemProps) => JSX.Element;
+
+export declare interface OxTimelineItemProps extends LiHTMLAttributes<HTMLLIElement> {
+    align?: OxTimelineAlign;
+    color?: ColorStyleName;
+    description?: string;
     icon?: string;
-    id: string;
-    img?: string;
-    message?: string;
-    read: boolean;
-    timestamp: Date;
-    title: string;
-    type?: 'default' | 'info' | 'success' | 'warning' | 'error';
+    label: string;
+    showSeparator?: boolean;
+    timestamp?: string;
 }
 
-export declare const OxProtectedRoute: ({ children, onLoading, onUnauthenticated, }: OxProtectedRouteProps) => ReactNode;
-
-export declare interface OxProtectedRouteProps {
-    children: React.ReactNode;
-    onLoading?: React.ReactNode;
-    onUnauthenticated?: React.ReactNode;
+export declare interface OxTimelineProps extends Omit<OlHTMLAttributes<HTMLOListElement>, 'children'> {
+    children: ReactNode;
 }
 
-export declare const OxSelect: default_2.FC<OxSelectProps>;
+export declare const OxToast: ({ align, onRemove, position, toasts }: OxToastProps) => ReactPortal;
 
-export declare const OxSelectLabel: default_2.FC<OxSelectLabelProps>;
+export declare type OxToastAlign = 'left' | 'center' | 'right';
 
-export declare interface OxSelectLabelProps {
-    children: React.ReactNode;
-    className?: string;
+export declare interface OxToastContextApi {
+    (title: string, options?: OxToastOptions): string;
+    custom: (content: ReactNode, options?: {
+        duration?: number;
+    }) => string;
+    dismiss: (id?: string) => void;
+    error: (title: string, options?: OxToastOptions) => string;
+    info: (title: string, options?: OxToastOptions) => string;
+    success: (title: string, options?: OxToastOptions) => string;
+    warning: (title: string, options?: OxToastOptions) => string;
 }
 
-export declare const OxSelectOption: default_2.FC<OxSelectOptionProps>;
+export declare interface OxToastData {
+    color?: ColorStyleName;
+    customContent?: ReactNode;
+    description?: string;
+    duration?: number;
+    icon?: string;
+    id: string;
+    isRemoving?: boolean;
+    title: string;
+    type: OxToastType;
+}
 
-export declare interface OxSelectOptionProps {
-    children: React.ReactNode;
-    className?: string;
-    disabled?: boolean;
-    id?: string;
-    value: string | number | null;
+export declare interface OxToastItemProps {
+    index: number;
+    onRemove: (id: string) => void;
+    position: OxToastPosition;
+    toast: OxToastData;
 }
 
-export declare interface OxSelectProps {
-    badgeColor?: OxBadgeColor;
-    children: React.ReactNode;
-    className?: string;
-    defaultValue?: string | string[] | number | number[];
+export declare interface OxToastOptions {
+    color?: ColorStyleName;
     description?: string;
-    disabled?: boolean;
-    displayAsBadges?: boolean;
-    error?: boolean;
-    errorMessage?: string;
-    id?: string;
-    label?: string;
-    multiple?: boolean;
-    name?: string;
-    onChange?: (value: string | number | null | (string | number | null)[], name?: string) => void;
-    placeholder?: string;
-    required?: boolean;
+    duration?: number;
+    icon?: string;
 }
 
-export declare const OxSkeleton: default_2.FC<OxSkeletonProps>;
+export declare type OxToastPosition = 'top' | 'bottom';
 
-export declare interface OxSkeletonProps extends HTMLAttributes<HTMLDivElement> {
-    animate?: boolean;
-    className?: string;
-    color?: 'default' | 'purple' | 'blue' | 'gray';
-    fullWidth?: boolean;
-    height?: string | number;
-    shape?: 'rectangle' | 'circle';
-    width?: string | number;
+export declare interface OxToastProps {
+    align: OxToastAlign;
+    onRemove: (id: string) => void;
+    position: OxToastPosition;
+    toasts: OxToastData[];
 }
 
-export declare const OxSkeletonText: default_2.FC<OxSkeletonTextProps>;
+export declare const OxToastProvider: ({ align, children, maxToasts, position, }: OxToastProviderProps) => JSX.Element;
 
-export declare interface OxSkeletonTextProps extends Omit<OxSkeletonProps, 'shape' | 'width'> {
-    gap?: number;
-    lines?: number;
-    width?: number | number[];
+export declare interface OxToastProviderProps {
+    align?: OxToastAlign;
+    children: ReactNode;
+    maxToasts?: number;
+    position?: OxToastPosition;
 }
 
-export declare const OxTextarea: default_2.FC<OxTextareaProps>;
+export declare type OxToastType = 'success' | 'error' | 'warning' | 'info' | 'default';
 
-export declare interface OxTextareaProps extends Omit<React.TextareaHTMLAttributes<HTMLTextAreaElement>, 'id' | 'name' | 'className' | 'onChange' | 'value' | 'readOnly' | 'required' | 'disabled' | 'placeholder'> {
-    className?: string;
-    description?: string;
+export declare const OxToggle: typeof OxToggle_2 & {
+    Group: typeof OxToggleGroup;
+};
+
+declare const OxToggle_2: ({ children, className, disabled, id: propId, onPressedChange, pressed, size, value, ...domProps }: OxToggleProps) => JSX.Element;
+
+declare const OxToggleGroup: ({ children, className, disabled, name, onValueChange, size, type, value, ...domProps }: OxToggleGroupProps) => JSX.Element;
+
+export declare interface OxToggleGroupMultipleProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'children'> {
+    children: React.ReactNode;
     disabled?: boolean;
-    error?: boolean;
-    errorMessage?: string;
-    id?: string;
-    label?: string;
     name?: string;
-    onChange?: (event: React.ChangeEvent<HTMLTextAreaElement>) => void;
-    placeholder?: string;
-    readOnly?: boolean;
-    required?: boolean;
-    showMaxLength?: boolean;
+    onValueChange?: (value: string[]) => void;
+    size?: 'sm' | 'md';
+    type: 'multiple';
+    value?: string[];
+}
+
+export declare type OxToggleGroupProps = OxToggleGroupSingleProps | OxToggleGroupMultipleProps;
+
+export declare interface OxToggleGroupSingleProps extends Omit<HTMLAttributes<HTMLDivElement>, 'onChange' | 'children'> {
+    children: React.ReactNode;
+    disabled?: boolean;
+    name?: string;
+    onValueChange?: (value: string) => void;
+    size?: 'sm' | 'md';
+    type?: 'single';
+    value?: string;
+}
+
+export declare interface OxToggleProps extends Omit<ButtonHTMLAttributes<HTMLButtonElement>, 'onChange' | 'children'> {
+    children?: React.ReactNode;
+    onPressedChange?: (pressed: boolean) => void;
+    pressed?: boolean;
+    size?: 'sm' | 'md';
     value?: string;
 }
 
-export declare const OxTooltip: default_2.FC<OxTooltipProps>;
+export declare type OxToggleValue = string | string[];
+
+export declare const OxTooltip: ({ align, children, className, content, disabled, hoverDelay, id, onOpenChange, open, position, trigger, variant, }: OxTooltipProps) => JSX.Element;
 
 export declare interface OxTooltipProps {
-    align?: FloatingAlign;
-    children: React.ReactNode;
+    align?: OxFloatingAlign;
+    children: ReactNode;
     className?: string;
     content: string;
     disabled?: boolean;
+    hoverDelay?: number;
     id?: string;
     onOpenChange?: (open: boolean) => void;
     open?: boolean;
-    position?: FloatingPosition;
-    trigger?: FloatingTrigger;
+    position?: OxFloatingPosition;
+    trigger?: OxFloatingTrigger;
     variant?: 'default' | 'error' | 'warning' | 'success' | 'info';
 }
 
+export declare type SliderValue = number | [number, number];
+
+export declare type StepperOrientation = 'horizontal' | 'vertical';
+
+export declare type StepperType = 'linear' | 'non-linear';
+
+export declare type StepState = 'completed' | 'current' | 'upcoming' | 'error' | 'warning';
+
+export declare const useOxToast: () => OxToastContextApi;
+
 export { }