@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$1 from 'react';
import React__default, { ReactNode } from 'react';
import { DropzoneRootProps, DropzoneInputProps } from 'react-dropzone';
import { RecordModel } from 'pocketbase';
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$2: 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 }: {
    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;
}): 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, autoFocus, 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$1: React$1.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, setIconSelectorOpen, namespace, required }: {
    name: string;
    icon: string;
    disabled?: boolean;
    setIcon: (icon: string) => void;
    setIconSelectorOpen: React.Dispatch<React.SetStateAction<boolean>>;
    namespace: string;
    required?: boolean;
}): react_jsx_runtime.JSX.Element;

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

declare function ImageAndFileInput({ icon, name, reminderText, image, preview, setPreview, setImage, setImagePickerModalOpen, onImageRemoved, required, namespace, disabled }: {
    icon: string;
    name: string;
    reminderText?: string;
    image: string | File | null;
    preview: string | null;
    setPreview: (value: string | null) => void;
    setImage: (value: string | File | null) => void;
    setImagePickerModalOpen: React.Dispatch<React.SetStateAction<boolean>>;
    onImageRemoved?: () => void;
    required?: boolean;
    namespace: string;
    disabled?: boolean;
}): 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: string;
    setDate: (date: string) => void;
    name: string;
    icon: string;
    hasMargin?: boolean;
    className?: string;
    darker?: boolean;
    modalRef?: React.RefObject<HTMLElement | null>;
    index?: number;
    required?: boolean;
    hasTime?: boolean;
    namespace: string | false;
    disabled?: boolean;
}
declare function DateInput({ date, setDate, name, icon, hasMargin, className, darker, modalRef, index, 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({ searchQuery, setSearchQuery, stuffToSearch, onKeyUp, customIcon, hasTopMargin, onFilterIconClick, filterAmount, sideButtonIcon, sideButtonLoading, onSideButtonClick, className, namespace, tKey }: {
    searchQuery: string;
    setSearchQuery: (query: string) => void;
    stuffToSearch: string;
    onKeyUp?: (e: React.KeyboardEvent<HTMLInputElement>) => void;
    customIcon?: string;
    hasTopMargin?: boolean;
    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;

declare function LocationInput({ location, setLocation, namespace, label, required, disabled }: {
    location: string | null;
    setLocation: (value: string | null) => void;
    namespace: string;
    label?: string;
    required?: boolean;
    disabled?: boolean;
}): react_jsx_runtime.JSX.Element;

declare function ListboxOrComboboxOption({ value, text, icon, iconAtEnd, color, type, matchedSubstrings, noCheckmark }: {
    value: unknown;
    text: string;
    icon?: string | React.ReactElement;
    iconAtEnd?: boolean;
    color?: string;
    type?: 'listbox' | 'combobox';
    matchedSubstrings?: Array<{
        length: number;
        offset: number;
    }>;
    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 ImagePickerModal({ isOpen, onClose, enablePixabay, enableUrl, enableAI, defaultAIPrompt, acceptedMimeTypes, onSelect }: {
    isOpen: boolean;
    onClose: () => void;
    enablePixabay?: boolean;
    enableUrl?: boolean;
    enableAI?: boolean;
    defaultAIPrompt?: string;
    acceptedMimeTypes: Record<string, string[]>;
    onSelect: (file: string | File, preview: string | null) => Promise<void>;
}): react_jsx_runtime.JSX.Element;

declare function ColorPickerModal({ isOpen, setOpen, color, setColor }: {
    isOpen: boolean;
    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
    color: string;
    setColor: (color: string) => void;
}): react_jsx_runtime.JSX.Element;

declare function IconPickerModal({ isOpen, setOpen, setSelectedIcon }: {
    isOpen: boolean;
    setOpen: React.Dispatch<React.SetStateAction<boolean>>;
    setSelectedIcon: (icon: string) => 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, listboxOrCombobox, isCombobox, className }: {
    icon: string;
    active: boolean;
    listboxOrCombobox?: 'listbox' | 'combobox';
    isCombobox?: boolean;
    className?: string;
}): react_jsx_runtime.JSX.Element;
declare const _default: React$1.MemoExoticComponent<typeof InputIcon>;

interface InputLabelProps {
    label: string;
    active: boolean;
    isCombobox?: boolean;
    isListboxOrCombobox?: boolean;
    required?: boolean;
}
declare function InputLabel({ label, active, isListboxOrCombobox, isCombobox, required }: InputLabelProps): react_jsx_runtime.JSX.Element;

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';
    index: number;
    hasTime?: boolean;
    modalRef: React.RefObject<HTMLDivElement | null>;
}
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, string | string[] | {
    image: File | string | null;
    preview: string | null;
} | boolean>;

declare function FormModal<T extends IFormState, U extends RecordModel>({ fields, additionalFields, data, setData, title, icon, isOpen, openType, onClose, loading, onSubmit, id, endpoint, queryKey, getFinalData, sortBy, sortMode, submitButtonProps, customUpdateDataList, actionButtonIcon, actionButtonIsRed, onActionButtonClick, namespace, modalRef }: {
    modalRef?: React.RefObject<HTMLDivElement | null>;
    fields: IFieldProps<T>[];
    additionalFields?: React.ReactNode;
    data: T;
    setData: React.Dispatch<React.SetStateAction<T>>;
    title: string;
    icon: string;
    isOpen: boolean;
    openType?: 'create' | 'update' | null;
    onClose: () => void;
    submitButtonProps?: React.ComponentProps<typeof _default$2>;
    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>({ itemName, isOpen, onClose, data, updateDataList, apiEndpoint, customTitle, customText, nameKey, customCallback, customConfirmButtonIcon, customConfirmButtonText, customOnClick, queryKey, queryUpdateType, multiQueryKey, confirmationText }: {
    itemName?: string;
    isOpen: boolean;
    onClose: () => void;
    data?: T | T[];
    updateDataList?: () => void;
    apiEndpoint?: string;
    customTitle?: string;
    customText?: string;
    nameKey?: keyof T;
    customCallback?: () => Promise<void>;
    customConfirmButtonIcon?: string;
    customConfirmButtonText?: string;
    customOnClick?: () => 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 function ModalWrapper({ isOpen, children, minWidth, minHeight, maxWidth, className, modalRef }: {
    isOpen: boolean;
    children: React.ReactNode;
    minWidth?: string;
    minHeight?: string;
    maxWidth?: string;
    className?: string;
    modalRef?: React.RefObject<HTMLDivElement | null>;
}): react_jsx_runtime.JSX.Element;

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 }: {
    items: Record<string, {
        data: Array<{
            id: string;
            icon?: string;
            name: string;
            color?: string;
        }> | 'loading' | 'error';
        isColored?: boolean;
    }>;
}): 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$2 as Button, Checkbox, ColorInput, ColorPickerModal, ConfigColumn, ContentWrapperWithSidebar, CurrencyInputComponent as CurrencyInput, DashboardItem, DateInput, DeleteConfirmationModal, DnDContainer, EmptyStateScreen, ErrorScreen, FAB, FormModal, GoBackButton, HamburgerMenu, HamburgerSelectorWrapper as HamburgerMenuSelectorWrapper, HeaderFilter, type IFieldProps, type IFormState, IconInput, IconPickerModal, ImageAndFileInput, ImagePickerModal, _default as InputIcon, InputLabel, InputWrapper, LayoutWithSidebar, LifeforgeUIProvider, ListboxNullOption, ListboxOrComboboxInput, ListboxOrComboboxOption, ListboxOrComboboxOptions, LoadingScreen, LocationInput, MenuItem, ModalHeader, ModalWrapper, ModuleHeader, ModuleWrapper, NotFoundScreen, Pagination, PreviewContainer, QRCodeScanner, QueryWrapper, Scrollbar, SearchInput, SidebarDivider, SidebarItem, SidebarTitle, SidebarWrapper, Switch, Tabs, TagsInput, TextAreaInput, _default$1 as TextInput, Tooltip, ViewModeSelector, useLifeforgeUIContext };