@lifeforge/ui/dist/index.d.ts

LifeForge UI component library

import * as react_jsx_runtime from 'react/jsx-runtime';
import { AnchorProps } from 'node_modules/@headlessui/react/dist/internal/floating';
import * as react from 'react';
import react__default, { ReactNode } from 'react';
import { DropzoneRootProps, DropzoneInputProps } from 'react-dropzone';
import { RecordModel } from 'pocketbase';
import * as zustand from 'zustand';
import { UseQueryResult } from '@tanstack/react-query';
import { ScrollbarProps } from 'react-custom-scrollbars';

interface ButtonProps {
    children?: React.ReactNode;
    icon: string;
    iconAtEnd?: boolean;
    iconClassName?: string;
    onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
    loading?: boolean;
    disabled?: boolean;
    className?: string;
    variant?: 'primary' | 'secondary' | 'tertiary' | 'plain';
    isRed?: boolean;
    namespace?: string;
    tKey?: string;
    tProps?: Record<string, unknown>;
}
type ButtonComponentProps<C extends React.ElementType = 'button'> = {
    as?: C;
} & ButtonProps & Omit<React.ComponentPropsWithoutRef<C>, keyof ButtonProps>;
declare function Button<C extends React.ElementType = 'button'>({ as, children, icon, onClick, ...props }: ButtonComponentProps<C>): react_jsx_runtime.JSX.Element;
declare const _default$4: typeof Button;

declare function Switch({ checked, onChange }: {
    checked: boolean;
    onChange: () => void;
}): react_jsx_runtime.JSX.Element;

declare function Checkbox({ checked, onChange, className }: {
    checked: boolean;
    onChange: (e: React.MouseEvent<HTMLButtonElement>) => void;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function FAB({ onClick, icon, text, hideWhen, alwaysShow, as, isRed, loading }: {
    onClick?: () => void;
    icon?: string;
    hideWhen?: 'sm' | 'md' | 'lg' | 'xl';
    alwaysShow?: boolean;
    text?: string;
    as?: React.ElementType;
    isRed?: boolean;
    loading?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function GoBackButton({ onClick }: {
    onClick: () => void;
}): react_jsx_runtime.JSX.Element;

interface MenuProps {
    children: React.ReactNode;
    anchor?: AnchorProps;
    classNames?: {
        wrapper?: string;
        button?: string;
        icon?: string;
        menu?: string;
    };
    iconClassName?: string;
    customIcon?: string;
    onClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
    onClose?: () => void;
}
declare function HamburgerMenu(props: MenuProps): react_jsx_runtime.JSX.Element;

declare function HamburgerSelectorWrapper({ icon, title, children, className }: {
    icon: string;
    title: string;
    children: React.ReactNode;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function MenuItem({ icon, text, isRed, onClick, isToggled, disabled, preventDefault, namespace, loading, className }: {
    icon?: string | React.ReactElement;
    text: string;
    isRed?: boolean;
    onClick: (e: React.MouseEvent<HTMLButtonElement>, close: () => void) => void;
    isToggled?: boolean;
    disabled?: boolean;
    preventDefault?: boolean;
    namespace?: string | false;
    loading?: boolean;
    className?: string;
}): react_jsx_runtime.JSX.Element;

interface ITextInputProps {
    icon: string;
    name: string;
    placeholder: string;
    value: string;
    setValue: (value: string) => void;
    inputMode?: 'text' | 'none' | 'tel' | 'url' | 'email' | 'numeric' | 'decimal' | 'search';
    actionButtonIcon?: string;
    actionButtonLoading?: boolean;
    autoFocus?: boolean;
    className?: string;
    darker?: boolean;
    disabled?: boolean;
    isPassword?: boolean;
    noAutoComplete?: boolean;
    onActionButtonClick?: (e: React.MouseEvent<HTMLButtonElement>) => void;
    onKeyDown?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
    ref?: React.RefObject<HTMLInputElement | null>;
    required?: boolean;
    namespace: string | false;
    tKey?: string;
}
declare function TextInput({ actionButtonIcon, actionButtonLoading, className, darker, disabled, icon, inputMode, isPassword, name, noAutoComplete, onActionButtonClick, onKeyDown, placeholder, ref, required, setValue, value, namespace, tKey }: ITextInputProps): react_jsx_runtime.JSX.Element;
declare const _default$3: react.MemoExoticComponent<typeof TextInput>;

interface ITextAreaInputProps {
    icon: string;
    name: string;
    placeholder: string;
    value: string;
    setValue: (value: string) => void;
    className?: string;
    darker?: boolean;
    disabled?: boolean;
    onActionButtonClick?: (e: react__default.MouseEvent<HTMLButtonElement>) => void;
    onKeyDown?: (e: react__default.KeyboardEvent<HTMLInputElement>) => void;
    required?: boolean;
    namespace: string | false;
    tKey?: string;
}
declare function TextAreaInput({ className, darker, disabled, icon, name, placeholder, required, setValue, value, namespace, tKey }: ITextAreaInputProps): react_jsx_runtime.JSX.Element;

declare function IconInput({ name, icon, disabled, setIcon, namespace, required }: {
    name: string;
    icon: string;
    disabled?: boolean;
    setIcon: (icon: string) => void;
    namespace: string;
    required?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ColorInput({ name, color, setColor, className, namespace, required, disabled }: {
    name: string;
    color: string;
    setColor: (value: string) => void;
    className?: string;
    namespace: string;
    required?: boolean;
    disabled?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ImageAndFileInput({ darker, icon, name, reminderText, image, preview, setData, onImageRemoved, required, namespace, disabled, enablePixabay, enableUrl, enableAI, defaultAIPrompt, acceptedMimeTypes }: {
    darker?: boolean;
    icon: string;
    name: string;
    reminderText?: string;
    image: string | File | null;
    preview: string | null;
    setData: (data: {
        image: string | File | null;
        preview: string | null;
    }) => void;
    onImageRemoved?: () => void;
    required?: boolean;
    namespace: string;
    disabled?: boolean;
    enablePixabay?: boolean;
    enableUrl?: boolean;
    enableAI?: boolean;
    defaultAIPrompt?: string;
    acceptedMimeTypes: Record<string, string[]>;
}): react_jsx_runtime.JSX.Element;

interface IGeneralProps<T> {
    name: string;
    icon: string;
    value: T;
    setValue: (value: T) => void;
    disabled?: boolean;
    className?: string;
    children: React.ReactNode;
    customActive?: boolean;
    required?: boolean;
    namespace: string | false;
    tKey?: string;
}
interface IListboxProps<T> extends IGeneralProps<T> {
    type: 'listbox';
    buttonContent: React.ReactElement;
    multiple?: boolean;
}
interface IComboboxProps<T> extends IGeneralProps<T> {
    type: 'combobox';
    setQuery: (query: string) => void;
    displayValue: (value: T) => string;
}
type IListboxOrComboboxInputProps<T> = IListboxProps<T> | IComboboxProps<T>;
declare function ListboxOrComboboxInput<T>(props: IListboxOrComboboxInputProps<T>): React.ReactElement;

interface DateInputProps {
    date: Date | null;
    setDate: (date: Date | null) => void;
    name: string;
    icon: string;
    className?: string;
    darker?: boolean;
    required?: boolean;
    hasTime?: boolean;
    namespace: string | false;
    disabled?: boolean;
}
declare function DateInput({ date, setDate, name, icon, className, darker, required, hasTime, namespace, disabled }: DateInputProps): react_jsx_runtime.JSX.Element;

declare function CurrencyInputComponent({ name, placeholder, icon, value, setValue, darker, className, required, namespace }: {
    reference?: React.RefObject<HTMLInputElement | null>;
    name: string;
    placeholder: string;
    icon: string;
    value: string | undefined;
    setValue: (value: string) => void;
    darker?: boolean;
    className?: string;
    required?: boolean;
    namespace: string;
}): react_jsx_runtime.JSX.Element;

declare function SearchInput({ lighter, searchQuery, setSearchQuery, stuffToSearch, onKeyUp, customIcon, onFilterIconClick, filterAmount, sideButtonIcon, sideButtonLoading, onSideButtonClick, className, namespace, tKey }: {
    lighter?: boolean;
    searchQuery: string;
    setSearchQuery: (query: string) => void;
    stuffToSearch: string;
    onKeyUp?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
    customIcon?: string;
    onFilterIconClick?: () => void;
    filterAmount?: number;
    sideButtonIcon?: string;
    sideButtonLoading?: boolean;
    onSideButtonClick?: () => void;
    className?: string;
    namespace: string;
    tKey?: string;
}): react_jsx_runtime.JSX.Element;

interface ITagsInputProps {
    name: string;
    icon: string;
    placeholder: string;
    value: string[];
    setValue: (tags: string[]) => void;
    maxTags?: number;
    disabled?: boolean;
    className?: string;
    darker?: boolean;
    existedTags?: Array<{
        name: string;
        icon: string;
        color: string;
    }>;
    required?: boolean;
    namespace: string;
    tKey?: string;
}
declare function TagsInput({ name, icon, placeholder, value, setValue, maxTags, disabled, className, darker, existedTags, required, namespace, tKey }: ITagsInputProps): react_jsx_runtime.JSX.Element;

interface ILocationEntry {
    formattedAddress: string;
    location: {
        longitude: number;
        latitude: number;
    };
    displayName: {
        text: string;
        languageCode: string;
    };
}
declare function LocationInput({ location, setLocation, namespace, label, required, disabled }: {
    location: ILocationEntry | null;
    setLocation: (value: ILocationEntry | null) => void;
    namespace: string;
    label?: string;
    required?: boolean;
    disabled?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ListboxOrComboboxOption({ value, text, icon, iconAtEnd, color, type, noCheckmark }: {
    value: unknown;
    text: string | React.ReactElement;
    icon?: string | React.ReactElement;
    iconAtEnd?: boolean;
    color?: string;
    type?: 'listbox' | 'combobox';
    noCheckmark?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ListboxOrComboboxOptions({ type, children, customWidth, lighter }: {
    type?: 'listbox' | 'combobox';
    children: React.ReactNode;
    customWidth?: string;
    lighter?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ListboxNullOption({ icon, value, hasBgColor, text }: {
    icon: string;
    value?: unknown;
    hasBgColor?: boolean;
    text?: string;
}): react_jsx_runtime.JSX.Element;

declare function FileAndImagePickerModal({ data: { enablePixabay, enableUrl, enableAI, defaultAIPrompt, acceptedMimeTypes, onSelect }, onClose }: {
    data: {
        enablePixabay?: boolean;
        enableUrl?: boolean;
        enableAI?: boolean;
        defaultAIPrompt?: string;
        acceptedMimeTypes: Record<string, string[]>;
        onSelect: (file: string | File, preview: string | null) => Promise<void>;
    };
    onClose: () => void;
}): react_jsx_runtime.JSX.Element;

declare function ColorPickerModal({ data: { color, setColor }, onClose }: {
    data: {
        color: string;
        setColor: (color: string) => void;
    };
    onClose: () => void;
}): react_jsx_runtime.JSX.Element;

declare function IconPickerModal({ data: { setSelectedIcon }, onClose }: {
    data: {
        setSelectedIcon: (icon: string) => void;
    };
    onClose: () => void;
}): react_jsx_runtime.JSX.Element;

declare function InputWrapper({ darker, className, disabled, inputRef, children }: {
    darker?: boolean;
    className?: string;
    disabled?: boolean;
    inputRef?: React.RefObject<HTMLInputElement | HTMLTextAreaElement | null>;
    children: React.ReactNode;
}): react_jsx_runtime.JSX.Element;

declare function InputIcon({ icon, active, isFocused, className }: {
    icon: string;
    active: boolean;
    isFocused?: boolean;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare const _default$2: react.MemoExoticComponent<typeof InputIcon>;

interface InputLabelProps {
    label: string;
    active: boolean;
    focused?: boolean;
    isCombobox?: boolean;
    isListboxOrCombobox?: boolean;
    required?: boolean;
}
declare function InputLabel({ label, active, focused, isListboxOrCombobox, isCombobox, required }: InputLabelProps): react_jsx_runtime.JSX.Element;
declare const _default$1: react.MemoExoticComponent<typeof InputLabel>;

declare function QRCodeScanner({ isOpen, onClose, formats, onScanned }: {
    isOpen: boolean;
    onClose: () => void;
    formats?: BarcodeFormat[];
    onScanned: (data: string) => void;
}): react_jsx_runtime.JSX.Element;

declare function DnDContainer({ getRootProps, getInputProps, isDragActive, setPreview, setFile }: {
    getRootProps: (props?: DropzoneRootProps) => DropzoneRootProps;
    getInputProps: (props?: DropzoneInputProps) => DropzoneInputProps;
    isDragActive: boolean;
    setPreview: (preview: string | null) => void;
    setFile: (file: File | string | null) => void;
}): react_jsx_runtime.JSX.Element;

declare function PreviewContainer({ preview, setPreview, file, setFile, fileName, onRemove }: {
    preview: string | null;
    setPreview: (preview: string | null) => void;
    file: File | null;
    setFile: (file: File | null) => void;
    fileName?: string;
    onRemove?: () => void;
}): react_jsx_runtime.JSX.Element;

interface ITextInputFieldProps {
    label: string;
    icon: string;
    type: 'text';
    isPassword?: boolean;
    placeholder: string;
    qrScanner?: boolean;
}
interface ITextAreaInputFieldProps {
    label: string;
    icon: string;
    type: 'textarea';
    placeholder: string;
}
interface IDateInputFieldProps {
    label: string;
    icon: string;
    type: 'datetime';
    hasTime?: boolean;
}
interface IListboxInputFieldProps {
    label: string;
    icon: string;
    type: 'listbox';
    options: Array<{
        value: string;
        text: string;
        icon?: string;
        color?: string;
    }>;
    nullOption?: string;
    multiple?: boolean;
}
interface IColorInputFieldProps {
    label: string;
    type: 'color';
}
interface IIconInputFieldProps {
    label: string;
    type: 'icon';
}
interface IImageAndFileInputFieldProps {
    label: string;
    type: 'file';
    onFileRemoved?: () => void;
    enableAIImageGeneration?: boolean;
    defaultImageGenerationPrompt?: string;
}
interface ILocationInputFieldProps {
    label: string;
    type: 'location';
}
interface IFormCheckboxFieldProps {
    label: string;
    icon: string;
    type: 'checkbox';
}
type IFieldProps<T> = (ITextInputFieldProps | ITextAreaInputFieldProps | IDateInputFieldProps | IListboxInputFieldProps | IColorInputFieldProps | IIconInputFieldProps | IImageAndFileInputFieldProps | ILocationInputFieldProps | IFormCheckboxFieldProps) & {
    id: keyof T;
    hidden?: boolean;
    required?: boolean;
    disabled?: boolean;
};
type IFormState = Record<string, any>;

declare function FormModal<T extends IFormState, U extends RecordModel>({ fields, additionalFields, data, setData, title, icon, openType, onClose, loading, onSubmit, id, endpoint, queryKey, getFinalData, sortBy, sortMode, submitButtonProps, customUpdateDataList, actionButtonIcon, actionButtonIsRed, onActionButtonClick, namespace }: {
    modalRef?: React.RefObject<HTMLDivElement | null>;
    fields: IFieldProps<T>[];
    additionalFields?: React.ReactNode;
    data: T;
    setData: React.Dispatch<React.SetStateAction<T>>;
    title: string;
    icon: string;
    openType?: 'create' | 'update' | null;
    onClose: () => void;
    submitButtonProps?: React.ComponentProps<typeof _default$4>;
    onSubmit?: () => Promise<void>;
    queryKey?: unknown[];
    endpoint?: string;
    id?: string;
    loading?: boolean;
    actionButtonIcon?: string;
    actionButtonIsRed?: boolean;
    onActionButtonClick?: () => void;
    namespace: string;
    getFinalData?: (originalData: T) => Promise<Record<string, unknown>>;
    sortBy?: keyof U;
    sortMode?: 'asc' | 'desc';
    customUpdateDataList?: {
        create?: (newData: U) => void;
        update?: (newData: U) => void;
    };
}): react_jsx_runtime.JSX.Element;

declare function DeleteConfirmationModal<T extends RecordModel>({ onClose, data: { itemName, data, updateDataList, apiEndpoint, customTitle, customText, nameKey, customCallback, customConfirmButtonIcon, customConfirmButtonText, customOnClick, queryKey, queryUpdateType, multiQueryKey, confirmationText } }: {
    onClose: () => void;
    data: {
        itemName?: string;
        data?: T | T[];
        updateDataList?: () => void;
        apiEndpoint?: string;
        customTitle?: string;
        customText?: string;
        nameKey?: keyof T;
        customCallback?: () => Promise<void>;
        customConfirmButtonIcon?: string;
        customConfirmButtonText?: string;
        customOnClick?: (close: () => void) => Promise<void>;
        queryKey?: unknown[] | unknown[][];
        queryUpdateType?: 'mutate' | 'invalidate';
        multiQueryKey?: boolean;
        confirmationText?: string;
    };
}): react_jsx_runtime.JSX.Element;

declare function ModalHeader({ title, needTranslate, icon, hasAI, onClose, actionButtonIcon, actionButtonIsRed, onActionButtonClick, className, appendTitle, namespace }: {
    title: string;
    needTranslate?: boolean;
    icon: string;
    hasAI?: boolean;
    onClose: () => void;
    actionButtonIcon?: string;
    actionButtonIsRed?: boolean;
    onActionButtonClick?: () => void;
    className?: string;
    appendTitle?: React.ReactElement;
    namespace?: string;
}): React.ReactElement;
declare const _default: react.MemoExoticComponent<typeof ModalHeader>;

declare function ModalWrapper({ isOpen, children, minWidth, minHeight, maxWidth, className, modalRef, zIndex, onExited }: {
    isOpen: boolean;
    children: React.ReactNode;
    minWidth?: string;
    minHeight?: string;
    maxWidth?: string;
    className?: string;
    modalRef?: React.RefObject<HTMLDivElement | null>;
    zIndex?: number;
    onExited?: () => void;
}): react.ReactPortal;

declare function ModalManager(): react_jsx_runtime.JSX.Element;

type ModalComponent<P = any> = react__default.FC<{
    data: P;
    onClose: () => void;
}>;
type ModalInstance<P = any> = {
    component: ModalComponent<P>;
    data: P;
    isClosing: boolean;
};
interface ModalState {
    stack: ModalInstance[];
    open: <P>(component: ModalComponent<P>, data: P) => void;
    close: () => void;
    remove: (index: number) => void;
}
declare const useModalStore: zustand.UseBoundStore<zustand.StoreApi<ModalState>>;

declare function SidebarWrapper({ isOpen, setOpen, customHeight, children }: {
    isOpen: boolean;
    setOpen: (value: boolean) => void;
    customHeight?: string;
    children: React.ReactNode;
}): react_jsx_runtime.JSX.Element;

type SidebarItemAutoActiveProps = {
    autoActive: true;
    active?: never;
} | {
    autoActive?: false;
    active: boolean;
};
interface MainSidebarItemProps {
    isMainSidebarItem: true;
    showAIIcon: boolean;
    subsection?: {
        name: string;
        icon: string | React.ReactElement;
        path: string;
    }[];
    prefix?: string;
    sidebarExpanded: boolean;
    toggleSidebar: () => void;
    sideStripColor?: never;
    onClick?: never;
    number?: never;
    onCancelButtonClick?: never;
    hamburgerMenuItems?: never;
    isCollapsed?: never;
    onCollapseButtonClick?: never;
    showCollapseSpacer?: never;
    namespace?: never;
    needTranslate?: never;
}
interface SubSidebarItemProps {
    isMainSidebarItem?: false;
    showAIIcon?: never;
    subsection?: never;
    prefix?: never;
    sidebarExpanded?: never;
    toggleSidebar?: never;
    onClick: () => void;
    sideStripColor?: string;
    number?: number;
    onCancelButtonClick?: () => void;
    hamburgerMenuItems?: React.ReactElement;
    isCollapsed?: boolean;
    onCollapseButtonClick?: () => void;
    showCollapseSpacer?: boolean;
    namespace?: string;
    needTranslate?: boolean;
}
interface SidebarItemBaseProps {
    name: string;
    icon?: string | React.ReactElement;
}
type SidebarItemProps$1 = SidebarItemAutoActiveProps & (MainSidebarItemProps | SubSidebarItemProps) & SidebarItemBaseProps;
declare function SidebarItem({ name, icon, sideStripColor, showAIIcon, subsection, isMainSidebarItem, sidebarExpanded, toggleSidebar, onClick, autoActive, active, prefix, number, onCancelButtonClick, hamburgerMenuItems, isCollapsed, onCollapseButtonClick, showCollapseSpacer, namespace, needTranslate }: SidebarItemProps$1): React.ReactElement;

interface PropsWithActionButton {
    actionButtonIcon: string | undefined;
    actionButtonOnClick: (() => void) | undefined;
}
interface PropsWithoutActionButton {
    actionButtonIcon?: never;
    actionButtonOnClick?: never;
}
type SidebarItemProps = {
    name: string;
    namespace?: string;
    customActionButton?: React.ReactElement;
} & (PropsWithActionButton | PropsWithoutActionButton);
declare function SidebarTitle({ name, actionButtonIcon, actionButtonOnClick, customActionButton, namespace }: SidebarItemProps): React.ReactElement;

declare function SidebarDivider({ noMargin }: {
    noMargin?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ContentWrapperWithSidebar({ children }: {
    children: React.ReactNode;
}): react_jsx_runtime.JSX.Element;

declare function LayoutWithSidebar({ children }: {
    children: React.ReactNode;
}): react_jsx_runtime.JSX.Element;

declare function ErrorScreen({ message }: {
    message: string;
}): react_jsx_runtime.JSX.Element;

declare function LoadingScreen({ customMessage }: {
    customMessage?: string;
}): react_jsx_runtime.JSX.Element;

declare function EmptyStateScreen({ onCTAClick, name, title, description, icon, ctaContent, ctaTProps, ctaIcon, customCTAButton, smaller, namespace, tKey }: {
    onCTAClick?: React.Dispatch<React.SetStateAction<'create' | 'update' | null>>;
    name: string | false;
    title?: string;
    description?: string;
    icon?: string | React.ReactElement;
    ctaContent?: string;
    ctaTProps?: Record<string, unknown>;
    ctaIcon?: string;
    customCTAButton?: React.ReactElement;
    smaller?: boolean;
    namespace: string | false;
    tKey?: string;
}): React.ReactElement;

declare function NotFoundScreen(): react_jsx_runtime.JSX.Element;

declare function QueryWrapper<T>({ query, children, showLoading }: {
    query: UseQueryResult<T, Error>;
    children: (data: T) => React.ReactElement | false;
    showLoading?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function HeaderFilter({ items, values, setValues }: {
    items: Record<string, {
        data: Array<{
            id: string;
            icon?: string;
            name: string;
            color?: string;
        }> | 'loading' | 'error';
        isColored?: boolean;
    }>;
    values: Record<string, string | null>;
    setValues: Record<string, (value: string | null) => void>;
}): react_jsx_runtime.JSX.Element;

declare function ConfigColumn({ title, desc, icon, vertical, tooltip, hasDivider, children, wrapWhen, noDefaultBreakpoints, className }: {
    title: string | React.ReactNode;
    desc: string;
    icon: string;
    vertical?: boolean;
    tooltip?: React.ReactNode;
    hasDivider?: boolean;
    children: React.ReactNode;
    wrapWhen?: 'sm' | 'md' | 'lg' | 'xl';
    noDefaultBreakpoints?: boolean;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function Pagination({ currentPage, onPageChange, totalPages, className }: {
    totalPages: number;
    onPageChange: (page: number) => void;
    currentPage: number;
    className?: string;
}): React.ReactElement;

declare function Scrollbar({ children, ...props }: {
    children: React.ReactNode;
} & ScrollbarProps): react_jsx_runtime.JSX.Element;

declare function Tabs<T extends string>({ items, enabled, active, onNavClick, className }: {
    items: Array<{
        id: T;
        name: string;
        icon: string;
        amount?: number;
    }>;
    enabled: T[];
    active: T;
    onNavClick: (id: T) => void;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function ViewModeSelector<T extends string>({ viewMode, setViewMode, options, className }: {
    viewMode: T;
    setViewMode: (value: T) => void;
    options: Array<{
        value: T;
        icon: string;
    }>;
    className?: string;
}): react_jsx_runtime.JSX.Element;

declare function DashboardItem({ ref, className, icon, title, children, componentBesideTitle, namespace }: {
    ref?: React.Ref<HTMLDivElement>;
    className?: string;
    icon: string;
    title: string;
    children?: React.ReactNode;
    componentBesideTitle?: React.ReactNode;
    namespace?: string;
}): react_jsx_runtime.JSX.Element;

declare function Tooltip({ id, icon, children, tooltipProps }: {
    id: string;
    icon: string;
    children: React.ReactNode;
    tooltipProps?: Record<string, unknown>;
}): react_jsx_runtime.JSX.Element;

declare function ModuleWrapper({ children, className, innerContainerClassName }: {
    children: React.ReactNode;
    className?: string;
    innerContainerClassName?: string;
}): react_jsx_runtime.JSX.Element;

interface ModuleHeaderProps {
    icon?: string;
    title: string | React.ReactNode;
    totalItems?: number;
    tips?: string;
    hamburgerMenuItems?: React.ReactNode;
    hamburgerMenuClassName?: string;
    actionButton?: React.ReactNode;
    customElement?: React.ReactNode;
    namespace?: string;
    tKey?: string;
}
declare function ModuleHeader({ icon, title, totalItems, tips, hamburgerMenuItems, hamburgerMenuClassName, actionButton, customElement, namespace, tKey }: ModuleHeaderProps): react_jsx_runtime.JSX.Element;

interface IContextData {
    apiHost: string;
    theme: 'light' | 'dark' | 'system';
    themeColor: string;
    bgTemp: string;
    bgImage: string;
    setTheme: (theme: 'light' | 'dark' | 'system') => void;
    setThemeColor: (color: string) => void;
    setBgTemp: (color: string) => void;
    setBgImage: (image: string) => void;
    language: string;
    toggleSidebar?: () => void;
    sidebarExpanded?: boolean;
}
interface LifeforgeUIProviderProps {
    children: ReactNode;
    personalization?: Partial<IContextData>;
}
declare const LifeforgeUIProvider: React.FC<LifeforgeUIProviderProps>;
declare const useLifeforgeUIContext: () => IContextData;

export { _default$4 as Button, Checkbox, ColorInput, ColorPickerModal, ConfigColumn, ContentWrapperWithSidebar, CurrencyInputComponent as CurrencyInput, DashboardItem, DateInput, DeleteConfirmationModal, DnDContainer, EmptyStateScreen, ErrorScreen, FAB, FileAndImagePickerModal, FormModal, GoBackButton, HamburgerMenu, HamburgerSelectorWrapper as HamburgerMenuSelectorWrapper, HeaderFilter, type IFieldProps, type IFormState, type ILocationEntry, IconInput, IconPickerModal, ImageAndFileInput, _default$2 as InputIcon, _default$1 as InputLabel, InputWrapper, LayoutWithSidebar, LifeforgeUIProvider, ListboxNullOption, ListboxOrComboboxInput, ListboxOrComboboxOption, ListboxOrComboboxOptions, LoadingScreen, LocationInput, MenuItem, type ModalComponent, _default as ModalHeader, ModalManager, ModalWrapper, ModuleHeader, ModuleWrapper, NotFoundScreen, Pagination, PreviewContainer, QRCodeScanner, QueryWrapper, Scrollbar, SearchInput, SidebarDivider, SidebarItem, SidebarTitle, SidebarWrapper, Switch, Tabs, TagsInput, TextAreaInput, _default$3 as TextInput, Tooltip, ViewModeSelector, useLifeforgeUIContext, useModalStore };