@allxsmith/bestax-bulma 2.6.2 → 3.0.1

package/dist/types/components/Carousel.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+export interface CarouselItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    active?: boolean;
+}
+export declare const CarouselItem: React.ForwardRefExoticComponent<CarouselItemProps & React.RefAttributes<HTMLDivElement>>;
+type IconLibrary = 'fa' | 'mdi' | 'ion' | 'material-icons' | 'material-symbols';
+export interface CarouselProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange' | 'color'>, BulmaClassesProps {
+    value?: number;
+    autoplay?: boolean;
+    interval?: number;
+    pauseOnHover?: boolean;
+    repeat?: boolean;
+    hasDrag?: boolean;
+    arrow?: boolean;
+    arrowHover?: boolean;
+    indicator?: boolean;
+    indicatorInside?: boolean;
+    indicatorPosition?: 'bottom' | 'top';
+    indicatorStyle?: 'circles' | 'dots' | 'lines' | 'bars';
+    iconPrev?: string;
+    iconNext?: string;
+    iconLibrary?: IconLibrary;
+    iconVariant?: string;
+    iconSize?: 'small' | 'medium' | 'large';
+    iconFeatures?: string | string[];
+    arrowBackground?: boolean;
+    arrowColor?: 'light' | 'dark';
+    ariaLabel?: string;
+    onChange?: (value: number) => void;
+    children?: React.ReactNode;
+}
+export declare const Carousel: React.ForwardRefExoticComponent<CarouselProps & React.RefAttributes<HTMLDivElement>>;
+export default Carousel;

package/dist/types/components/Collapse.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+export interface CollapseProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'color'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    open?: boolean;
+    defaultOpen?: boolean;
+    onOpen?: () => void;
+    onClose?: () => void;
+    trigger?: React.ReactNode;
+    animation?: 'fade' | 'slide' | false;
+    position?: 'top' | 'bottom';
+    ariaId?: string;
+    bordered?: boolean;
+    triggerClassName?: string;
+    contentClassName?: string;
+}
+export declare const Collapse: React.FC<CollapseProps>;
+export default Collapse;

package/dist/types/components/Dialog.d.ts

@@ -0,0 +1,47 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+export type DialogType = 'default' | 'success' | 'danger' | 'warning' | 'info';
+export interface DialogProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'color'>, Omit<BulmaClassesProps, 'color'> {
+    isOpen: boolean;
+    title?: string;
+    message: string | React.ReactNode;
+    type?: DialogType;
+    confirmText?: string;
+    cancelText?: string;
+    onConfirm?: () => void;
+    onCancel?: () => void;
+    showCancel?: boolean;
+    canCancel?: boolean;
+    focusCancel?: boolean;
+    icon?: React.ReactNode;
+}
+export declare const Dialog: React.ForwardRefExoticComponent<DialogProps & React.RefAttributes<HTMLDivElement>>;
+export interface AlertOptions {
+    title?: string;
+    message: string | React.ReactNode;
+    type?: DialogType;
+    confirmText?: string;
+    icon?: React.ReactNode;
+}
+export interface ConfirmOptions extends AlertOptions {
+    cancelText?: string;
+    focusCancel?: boolean;
+}
+export interface PromptOptions extends ConfirmOptions {
+    placeholder?: string;
+    defaultValue?: string;
+}
+type DialogResolve = (value?: void | boolean | string) => void;
+type DialogState = {
+    type: 'alert' | 'confirm' | 'prompt';
+    options: PromptOptions;
+    resolve: DialogResolve;
+};
+export declare const dialog: {
+    alert: (options: AlertOptions | string) => Promise<void>;
+    confirm: (options: ConfirmOptions | string) => Promise<boolean>;
+    close: (value?: string | boolean | void | undefined) => void;
+    subscribe: (listener: (dialog: DialogState | null) => void) => (() => void);
+};
+export declare const DialogContainer: React.FC;
+export default Dialog;

package/dist/types/components/Loading.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+export type LoadingOverlay = 'light' | 'dark' | 'opaque';
+export type LoadingColor = 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+export interface LoadingProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'color'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor' | 'size' | 'overlay'> {
+    active?: boolean;
+    isFullPage?: boolean;
+    size?: 'small' | 'medium' | 'large';
+    color?: LoadingColor;
+    canCancel?: boolean;
+    onCancel?: () => void;
+    overlayClassName?: string;
+    iconClassName?: string;
+    indicator?: React.ReactNode;
+    overlay?: LoadingOverlay;
+}
+export declare const Loading: React.FC<LoadingProps>;
+export default Loading;

package/dist/types/components/Navbar.d.ts

@@ -12,6 +12,7 @@ export interface NavbarProps extends React.HTMLAttributes<HTMLElement>, Omit<Bul
 export declare const Navbar: React.FC<NavbarProps> & {
     Brand: typeof NavbarBrand;
     Item: typeof NavbarItem;
+    Link: typeof NavbarLink;
     Burger: typeof NavbarBurger;
     Menu: typeof NavbarMenu;
     Start: typeof NavbarStart;
@@ -63,6 +64,15 @@ export interface NavbarStartEndProps extends React.HTMLAttributes<HTMLDivElement
 }
 export declare const NavbarStart: React.FC<NavbarStartEndProps>;
 export declare const NavbarEnd: React.FC<NavbarStartEndProps>;
+export interface NavbarLinkProps extends Omit<React.AnchorHTMLAttributes<HTMLAnchorElement>, 'color'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    as?: React.ElementType;
+    arrowless?: boolean;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const NavbarLink: React.FC<NavbarLinkProps>;
 export interface NavbarDropdownProps extends React.HTMLAttributes<HTMLDivElement> {
     className?: string;
     right?: boolean;

package/dist/types/components/Panel.d.ts

@@ -1,5 +1,6 @@
 import React from 'react';
 import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+import { IconProps } from '../elements/Icon';
 export interface PanelProps extends React.HTMLAttributes<HTMLElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
     color?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger' | 'black' | 'dark' | 'light' | 'white';
     className?: string;
@@ -18,10 +19,7 @@ export interface PanelBlockProps extends React.AnchorHTMLAttributes<HTMLAnchorEl
     active?: boolean;
     children?: React.ReactNode;
 }
-export interface PanelIconProps extends React.HTMLAttributes<HTMLSpanElement> {
-    className?: string;
-    children?: React.ReactNode;
-}
+export type PanelIconProps = Omit<IconProps, 'containerClassName'>;
 export interface PanelInputBlockProps extends React.HTMLAttributes<HTMLDivElement> {
     value?: string;
     onChange?: React.ChangeEventHandler<HTMLInputElement>;

package/dist/types/components/Sidebar.d.ts

@@ -0,0 +1,37 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+export type SidebarPosition = 'left' | 'right';
+export interface SidebarProps extends Omit<React.HTMLAttributes<HTMLElement>, 'children' | 'color'>, BulmaClassesProps {
+    isOpen: boolean;
+    onClose?: () => void;
+    position?: SidebarPosition;
+    width?: string;
+    fullWidth?: boolean;
+    overlay?: boolean;
+    overlayClose?: boolean;
+    escapeClose?: boolean;
+    canCancel?: boolean;
+    children?: React.ReactNode;
+    inline?: boolean;
+}
+interface SidebarHeaderProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+interface SidebarTitleProps extends React.HTMLAttributes<HTMLParagraphElement> {
+    children?: React.ReactNode;
+}
+type SidebarCloseProps = React.ButtonHTMLAttributes<HTMLButtonElement>;
+interface SidebarBodyProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+interface SidebarFooterProps extends React.HTMLAttributes<HTMLDivElement> {
+    children?: React.ReactNode;
+}
+export declare const Sidebar: React.ForwardRefExoticComponent<SidebarProps & React.RefAttributes<HTMLElement>> & {
+    Header: React.FC<SidebarHeaderProps>;
+    Title: React.FC<SidebarTitleProps>;
+    Close: React.FC<SidebarCloseProps>;
+    Body: React.FC<SidebarBodyProps>;
+    Footer: React.FC<SidebarFooterProps>;
+};
+export default Sidebar;

package/dist/types/components/Steps.d.ts

@@ -0,0 +1,45 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+export type StepsSize = 'small' | 'medium' | 'large';
+export type StepsColor = 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+export interface StepItemProps {
+    label?: React.ReactNode;
+    icon?: React.ReactNode;
+    completedIcon?: React.ReactNode;
+    clickable?: boolean;
+    className?: string;
+}
+export interface StepsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'color'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor' | 'size'> {
+    value?: number;
+    items?: StepItemProps[];
+    size?: StepsSize;
+    color?: StepsColor;
+    hasMarker?: boolean;
+    animated?: boolean;
+    rounded?: boolean;
+    vertical?: boolean;
+    labelPosition?: 'bottom' | 'right' | 'left';
+    mobileMode?: 'minimal' | 'compact' | 'right';
+    showStepNumbers?: boolean;
+    hasNavigation?: boolean;
+    prevLabel?: string;
+    nextLabel?: string;
+    onPrev?: () => void;
+    onNext?: () => void;
+    onStepClick?: (step: number) => void;
+}
+export interface StepProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, 'color'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    isActive?: boolean;
+    isCompleted?: boolean;
+    label?: React.ReactNode;
+    icon?: React.ReactNode;
+    clickable?: boolean;
+    onClick?: () => void;
+    stepNumber?: number;
+    completedIcon?: React.ReactNode;
+}
+export declare const Step: React.FC<StepProps>;
+export declare const Steps: React.FC<StepsProps> & {
+    Step: typeof Step;
+};
+export default Steps;

package/dist/types/components/Tabs.d.ts

@@ -1,6 +1,6 @@
 import React from 'react';
 import { BulmaClassesProps } from '../helpers/useBulmaClasses';
-export interface TabsProps extends React.HTMLAttributes<HTMLDivElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+export interface TabsProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
     align?: 'centered' | 'right' | 'left';
     size?: 'small' | 'medium' | 'large';
     fullwidth?: boolean;
@@ -8,23 +8,59 @@ export interface TabsProps extends React.HTMLAttributes<HTMLDivElement>, Omit<Bu
     toggle?: boolean;
     rounded?: boolean;
     color?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger' | 'black' | 'dark' | 'light' | 'white';
+    value?: number;
+    onChange?: (index: number) => void;
+    defaultValue?: number;
+    vertical?: boolean;
+    side?: 'left' | 'right';
+    expanded?: boolean;
     className?: string;
     children?: React.ReactNode;
 }
+export declare const Tabs: React.FC<TabsProps> & {
+    List: typeof TabList;
+    Tab: typeof Tab;
+    Item: typeof TabItem;
+    Content: typeof TabsContent & {
+        Item: typeof TabContentItem;
+    };
+};
 export interface TabListProps extends React.HTMLAttributes<HTMLUListElement> {
     className?: string;
     children?: React.ReactNode;
 }
+export declare const TabList: React.FC<TabListProps>;
+type IconLibrary = 'fa' | 'mdi' | 'ion' | 'material-icons' | 'material-symbols';
+export interface TabProps extends Omit<React.LiHTMLAttributes<HTMLLIElement>, 'onClick'> {
+    index: number;
+    disabled?: boolean;
+    icon?: string;
+    iconLibrary?: IconLibrary;
+    iconVariant?: string;
+    iconSize?: 'small' | 'medium' | 'large';
+    iconFeatures?: string | string[];
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare const Tab: React.FC<TabProps>;
 export interface TabItemProps extends React.LiHTMLAttributes<HTMLLIElement> {
     active?: boolean;
     className?: string;
     children?: React.ReactNode;
     onClick?: React.MouseEventHandler<HTMLLIElement>;
 }
-export declare const Tabs: React.FC<TabsProps> & {
-    List: typeof TabList;
-    Item: typeof TabItem;
-};
-export declare const TabList: React.FC<TabListProps>;
 export declare const TabItem: React.FC<TabItemProps>;
+export interface TabsContentProps extends React.HTMLAttributes<HTMLDivElement> {
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare const TabsContent: React.FC<TabsContentProps> & {
+    Item: typeof TabContentItem;
+};
+export interface TabContentItemProps extends React.HTMLAttributes<HTMLDivElement> {
+    index: number;
+    className?: string;
+    children?: React.ReactNode;
+}
+export declare const TabContentItem: React.FC<TabContentItemProps>;
 export default Tabs;

package/dist/types/components/Toast.d.ts

@@ -0,0 +1,46 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+export type ToastType = 'default' | 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+export type ToastPosition = 'top-left' | 'top-center' | 'top-right' | 'bottom-left' | 'bottom-center' | 'bottom-right';
+export interface ToastProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'color'>, Omit<BulmaClassesProps, 'color'> {
+    message: string;
+    type?: ToastType;
+    actionType?: ToastType;
+    position?: ToastPosition;
+    duration?: number;
+    indefinite?: boolean;
+    dismissible?: boolean;
+    closable?: boolean;
+    rounded?: boolean;
+    pauseOnHover?: boolean;
+    cancelable?: boolean;
+    actionText?: string;
+    cancelText?: string;
+    onAction?: () => void;
+    onClose?: () => void;
+    container?: string | HTMLElement;
+    inline?: boolean;
+}
+export declare const Toast: React.ForwardRefExoticComponent<ToastProps & React.RefAttributes<HTMLDivElement>>;
+export interface ToastOptions extends Omit<ToastProps, 'message'> {
+    message: string;
+    queue?: boolean;
+}
+export interface ToastInstance {
+    id: string;
+    props: ToastOptions;
+}
+export declare const toast: {
+    show: (options: ToastOptions) => string;
+    success: (message: string, options?: Partial<ToastOptions>) => string;
+    danger: (message: string, options?: Partial<ToastOptions>) => string;
+    warning: (message: string, options?: Partial<ToastOptions>) => string;
+    info: (message: string, options?: Partial<ToastOptions>) => string;
+    close: (id: string) => void;
+    closeAll: () => void;
+    subscribe: (listener: (toasts: ToastInstance[]) => void) => (() => void);
+};
+export declare const ToastContainer: React.FC<{
+    position?: ToastPosition;
+}>;
+export default Toast;

package/dist/types/components/Tooltip.d.ts

@@ -0,0 +1,22 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+export type TooltipPosition = 'top' | 'bottom' | 'left' | 'right' | 'auto';
+export type TooltipColor = 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger' | 'dark' | 'light';
+export type TooltipSize = 'small' | 'medium' | 'large';
+export interface TooltipProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'color' | 'content'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    label?: string;
+    content?: React.ReactNode;
+    position?: TooltipPosition;
+    color?: TooltipColor;
+    size?: TooltipSize;
+    active?: boolean;
+    multiline?: boolean;
+    animated?: boolean;
+    square?: boolean;
+    dashed?: boolean;
+    delay?: number;
+    closeDelay?: number;
+    tooltipClassName?: string;
+}
+export declare const Tooltip: React.FC<TooltipProps>;
+export default Tooltip;

package/dist/types/elements/Button.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
 export interface ButtonProps extends Omit<React.ButtonHTMLAttributes<HTMLButtonElement>, 'color' | 'onClick'>, Omit<BulmaClassesProps, 'color' | 'backgroundColor' | 'size'> {
-    color?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+    color?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger' | 'white' | 'light' | 'dark' | 'black' | 'text' | 'ghost';
     size?: 'small' | 'normal' | 'medium' | 'large';
     isLight?: boolean;
     isRounded?: boolean;

package/dist/types/elements/Code.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface CodeProps extends React.HTMLAttributes<HTMLElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const Code: React.FC<CodeProps>;

package/dist/types/elements/Divider.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface DividerProps extends React.HTMLAttributes<HTMLHRElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+}
+export declare const Divider: React.FC<DividerProps>;

package/dist/types/elements/Emphasis.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface EmphasisProps extends React.HTMLAttributes<HTMLElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const Emphasis: React.FC<EmphasisProps>;

package/dist/types/elements/Figure.d.ts

@@ -0,0 +1,17 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface FigureCaptionProps extends React.HTMLAttributes<HTMLElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export interface FigureProps extends React.HTMLAttributes<HTMLElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const Figure: React.FC<FigureProps> & {
+    Caption: React.FC<FigureCaptionProps>;
+};

package/dist/types/elements/Icon.d.ts

@@ -34,6 +34,7 @@ export interface IconProps extends React.HTMLAttributes<HTMLSpanElement>, BulmaC
     size?: 'small' | 'medium' | 'large';
     ariaLabel?: string;
     style?: React.CSSProperties;
+    containerClassName?: string;
 }
 export declare const Icon: React.FC<IconProps>;
 export {};

package/dist/types/elements/Link.d.ts

@@ -0,0 +1,10 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface LinkProps extends React.AnchorHTMLAttributes<HTMLAnchorElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    isActive?: boolean;
+    children?: React.ReactNode;
+}
+export declare const Link: React.FC<LinkProps>;

package/dist/types/elements/LinkButton.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+import { ButtonProps } from './Button';
+export interface LinkButtonProps extends Omit<ButtonProps, 'color' | 'isOutlined' | 'isInverted' | 'isLight'> {
+    variant?: 'text' | 'ghost' | 'underline';
+    color?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger' | 'white' | 'light' | 'dark' | 'black';
+}
+export declare const LinkButton: React.FC<LinkButtonProps>;
+export default LinkButton;

package/dist/types/elements/ListItem.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface ListItemProps extends React.LiHTMLAttributes<HTMLLIElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const ListItem: React.FC<ListItemProps>;

package/dist/types/elements/Notification.d.ts

@@ -3,9 +3,40 @@ import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
 export interface NotificationProps extends React.HTMLAttributes<HTMLDivElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
     className?: string;
     color?: (typeof validColors)[number];
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
     isLight?: boolean;
     hasDelete?: boolean;
     onDelete?: () => void;
     children?: React.ReactNode;
 }
 export declare const Notification: React.FC<NotificationProps>;
+export type NotificationPosition = 'top-left' | 'top' | 'top-right' | 'bottom-left' | 'bottom' | 'bottom-right';
+export interface NotificationOptions {
+    message: string | React.ReactNode;
+    color?: (typeof validColors)[number];
+    isLight?: boolean;
+    duration?: number;
+    position?: NotificationPosition;
+    queue?: boolean;
+    hasDelete?: boolean;
+    indefinite?: boolean;
+    pauseOnHover?: boolean;
+}
+interface NotificationInstance {
+    id: string;
+    options: NotificationOptions;
+}
+export declare const notification: {
+    show: (options: NotificationOptions) => string;
+    success: (message: string | React.ReactNode, options?: Partial<NotificationOptions>) => string;
+    danger: (message: string | React.ReactNode, options?: Partial<NotificationOptions>) => string;
+    warning: (message: string | React.ReactNode, options?: Partial<NotificationOptions>) => string;
+    info: (message: string | React.ReactNode, options?: Partial<NotificationOptions>) => string;
+    close: (id: string) => void;
+    closeAll: () => void;
+    subscribe: (listener: (items: NotificationInstance[]) => void) => (() => void);
+};
+export declare const NotificationContainer: React.FC<{
+    position?: NotificationPosition;
+}>;
+export {};

package/dist/types/elements/OrderedList.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface OrderedListProps extends React.OlHTMLAttributes<HTMLOListElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const OrderedList: React.FC<OrderedListProps>;

package/dist/types/elements/Paragraph.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface ParagraphProps extends React.HTMLAttributes<HTMLParagraphElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const Paragraph: React.FC<ParagraphProps>;

package/dist/types/elements/Pre.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface PreProps extends React.HTMLAttributes<HTMLPreElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const Pre: React.FC<PreProps>;

package/dist/types/elements/Span.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface SpanProps extends React.HTMLAttributes<HTMLSpanElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const Span: React.FC<SpanProps>;

package/dist/types/elements/Strong.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface StrongProps extends React.HTMLAttributes<HTMLElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const Strong: React.FC<StrongProps>;

package/dist/types/elements/UnorderedList.d.ts

@@ -0,0 +1,9 @@
+import React from 'react';
+import { BulmaClassesProps, validColors } from '../helpers/useBulmaClasses';
+export interface UnorderedListProps extends React.HTMLAttributes<HTMLUListElement>, Omit<BulmaClassesProps, 'color' | 'backgroundColor'> {
+    className?: string;
+    textColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    bgColor?: (typeof validColors)[number] | 'inherit' | 'current';
+    children?: React.ReactNode;
+}
+export declare const UnorderedList: React.FC<UnorderedListProps>;

package/dist/types/form/Autocomplete.d.ts

@@ -0,0 +1,42 @@
+import React from 'react';
+import { BulmaClassesProps } from '../helpers/useBulmaClasses';
+import { FormFieldProps } from './fieldProps';
+export interface AutocompleteItem {
+    value: string;
+    label?: string;
+    disabled?: boolean;
+    [key: string]: unknown;
+}
+export interface AutocompleteProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onSelect' | 'onInput'>, Omit<BulmaClassesProps, 'color'>, FormFieldProps {
+    data: AutocompleteItem[] | string[];
+    value?: string;
+    selected?: AutocompleteItem | string | null;
+    placeholder?: string;
+    field?: string;
+    clearable?: boolean;
+    openOnFocus?: boolean;
+    keepFirst?: boolean;
+    keepOpen?: boolean;
+    selectOnClickOutside?: boolean;
+    maxHeight?: number;
+    dropdown?: boolean;
+    loading?: boolean;
+    disabled?: boolean;
+    checkInfiniteScroll?: boolean;
+    infiniteScrollDistance?: number;
+    color?: 'primary' | 'link' | 'info' | 'success' | 'warning' | 'danger';
+    size?: 'small' | 'medium' | 'large';
+    name?: string;
+    form?: string;
+    required?: boolean;
+    onInput?: (value: string) => void;
+    onSelect?: (item: AutocompleteItem | string | null) => void;
+    onActiveChange?: (active: boolean) => void;
+    onInfiniteScroll?: () => void;
+    itemTemplate?: (item: AutocompleteItem | string) => React.ReactNode;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    empty?: React.ReactNode;
+}
+export declare const Autocomplete: React.ForwardRefExoticComponent<AutocompleteProps & React.RefAttributes<HTMLInputElement>>;
+export default Autocomplete;