@llmnative/react 0.1.0

package/dist/types/src/components/Component.d.ts

@@ -0,0 +1,55 @@
+import React from "react";
+type Primitive = string | number | boolean | undefined;
+interface FieldRenderProps {
+    name: string;
+    defaultValue?: any;
+    label?: string;
+    onChange?: (value: any) => void;
+}
+interface FieldAdapter<TProps = any> {
+    getDefaults: (name: string) => Record<string, any>;
+    render: (props?: FieldRenderProps & TProps) => React.ReactNode;
+    __props: TProps;
+}
+export type FieldFactory<TProps = {}> = (props?: TProps) => FieldAdapter;
+interface ComponentProps {
+    [key: string]: any;
+}
+type Defaults = {
+    [key: string]: Primitive | Primitive[];
+};
+export type ModelProps = {
+    [key: string]: FieldAdapter | React.ReactNode | ModelProps;
+};
+export type FormTree = {
+    [key: string]: React.ReactNode | FormTree;
+};
+export declare const Component: {
+    layout: import("../types/Layout").ComponentLayoutMap;
+    input: import("../types/FormFields").ComponentFormFieldsMap;
+    block: import("../types/Block").ComponentBlockMap;
+    section: import("../types/Section").ComponentSectionMap;
+};
+export declare abstract class ComponentBlock {
+    abstract model: ModelProps;
+    abstract html(props?: ComponentProps): React.ReactNode;
+    abstract form(props?: ComponentProps): React.ReactNode;
+    protected verifyRequiredMethods(): void;
+    static default(this: new () => ComponentBlock, options?: {
+        dataStoragePath?: string;
+    }): React.FC;
+}
+export declare function buildFormFields(model: ModelProps): [FormTree, Defaults];
+export declare function ComponentBlockSave(blockClass: new () => ComponentBlock, dbStoragePath: string): Promise<void>;
+export declare class ComponentTemplate {
+    private template?;
+    constructor(path: string);
+    loadTemplate(path: string): Promise<void>;
+    render(dataPath: string): Promise<{
+        html: () => React.ReactNode;
+        form: () => React.ReactNode;
+    }>;
+    private renderTemplate;
+    private parseTemplate;
+}
+export default Component;

package/dist/types/src/components/FormEnhancer.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import { RecordProps } from "../providers/data/DataProvider";
+import { FormRef, ChangeHandler } from './widgets/Form';
+type FormProps = {
+    name?: string;
+    value?: any;
+    onChange?: (event: ChangeHandler) => void;
+    dataStoragePath?: string;
+};
+interface EnhancerProps {
+    record?: RecordProps;
+    handleChange?: (event: ChangeHandler) => void;
+    parentName?: string;
+    dataStoragePath?: string;
+    formRef?: React.Ref<FormRef>;
+    wrapClass?: string;
+}
+interface FormEnhancerProps extends EnhancerProps {
+    components: React.ReactNode;
+}
+declare const FormEnhancer: ({ components, record, handleChange, parentName, dataStoragePath, formRef, wrapClass }: FormEnhancerProps) => React.JSX.Element;
+export declare function extractComponentProps<T>(components: React.ReactNode | React.ReactNode[], onEnhance: (props: {
+    [key: string]: any;
+}) => T): T[];
+export declare function asForm<P extends FormProps>(Component: React.ComponentType<P>): React.ComponentType<P>;
+export default FormEnhancer;

package/dist/types/src/components/Template.d.ts

@@ -0,0 +1,18 @@
+import React from 'react';
+import { ComponentFormFieldsMap } from '../types/FormFields';
+type ComponentSpec = {
+    tag: keyof ComponentFormFieldsMap;
+    props?: Record<string, any>;
+};
+type FormFieldsMap = Record<string, ComponentSpec>;
+export declare function FormTemplate({ htmlString, components, dataStoragePath }: {
+    htmlString: string;
+    components: FormFieldsMap;
+    dataStoragePath: string;
+}): React.JSX.Element;
+export declare function FormTemplate2({ template, fieldBucketKey, dataSource, }: {
+    template: string;
+    fieldBucketKey: string;
+    dataSource?: string;
+}): React.JSX.Element;
+export {};

package/dist/types/src/components/blocks/Brand.d.ts

@@ -0,0 +1,14 @@
+import React from 'react';
+type BrandProps = {
+    url?: string;
+    label?: string;
+    logo?: string;
+    width?: number;
+    height?: number;
+    wrapClass?: string;
+    className?: string;
+    logoClass?: string;
+    labelClass?: string;
+};
+declare const Brand: ({ url, label, logo, width, height, wrapClass, className, logoClass, labelClass }: BrandProps) => React.JSX.Element;
+export default Brand;

package/dist/types/src/components/blocks/Breadcrumbs.d.ts

@@ -0,0 +1,8 @@
+import React from 'react';
+type BreadcrumbsProps = {
+    path?: string;
+    pre?: React.ReactNode;
+    className?: string;
+};
+export declare const Breadcrumbs: ({ path, pre, className }: BreadcrumbsProps) => React.JSX.Element;
+export default Breadcrumbs;

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

@@ -0,0 +1,19 @@
+import React from 'react';
+type AutoPlayOptions = {
+    interval: number;
+    pause: "hover" | "false" | "true";
+    wrap: boolean;
+};
+type CarouselProps = {
+    children: React.ReactElement[];
+    showIndicators?: boolean;
+    showControls?: boolean;
+    showCaption?: boolean;
+    layoutDark?: boolean;
+    autoPlay?: AutoPlayOptions;
+    startSlide?: number;
+    onParseCaption?: (image: React.ReactElement) => React.ReactElement;
+    onClick?: (event: React.MouseEvent<HTMLDivElement, MouseEvent>) => void;
+};
+declare const Carousel: ({ children, showIndicators, showControls, showCaption, layoutDark, autoPlay, startSlide, onParseCaption, onClick, }: CarouselProps) => React.JSX.Element;
+export default Carousel;

package/dist/types/src/components/blocks/Dropdown.d.ts

@@ -0,0 +1,64 @@
+import React from 'react';
+import { BadgeProps } from "../ui/Badge";
+import type { MotionUIProps } from '../types';
+interface DropdownTogglerProps {
+    icon?: string;
+    text?: string;
+}
+interface DropdownProps extends Pick<MotionUIProps, 'motion'> {
+    children: React.ReactNode;
+    toggleButton?: string | React.ReactNode | DropdownTogglerProps;
+    badge?: BadgeProps;
+    header?: React.ReactNode;
+    footer?: React.ReactNode;
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+    alwaysOpen?: boolean;
+    position?: "start" | "end";
+    wrapClass?: string;
+    className?: string;
+    buttonClass?: string;
+    badgeClass?: string;
+    menuClass?: string;
+    headerClass?: string;
+    footerClass?: string;
+}
+interface DropdownButtonProps extends Pick<MotionUIProps, 'motion'> {
+    children: React.ReactNode;
+    badge?: BadgeProps;
+    display?: "static" | "dynamic";
+    className?: string;
+    badgeClass?: string;
+    onToggle?: () => void;
+    open?: boolean;
+    menuId?: string;
+}
+interface DropdownItemProps {
+    url?: string;
+    onClick?: React.MouseEventHandler<HTMLAnchorElement | HTMLButtonElement>;
+    className?: string;
+    children: React.ReactNode;
+    icon?: string;
+}
+interface DropdownHeaderProps {
+    children: React.ReactNode;
+    className?: string;
+}
+interface DropdownDividerProps {
+    className?: string;
+}
+export declare const Dropdown: ({ children, toggleButton, badge, header, footer, defaultOpen, open: controlledOpen, onOpenChange, alwaysOpen, position, wrapClass, className, buttonClass, menuClass, badgeClass, headerClass, footerClass, motion: motionConfig, }: DropdownProps) => React.JSX.Element;
+export declare const DropdownButton: ({ children, badge, display, className, badgeClass, motion: motionConfig, onToggle, open, menuId }: DropdownButtonProps) => React.JSX.Element;
+export declare const DropdownItem: ({ children, url, onClick, icon, className }: DropdownItemProps) => React.JSX.Element;
+export declare const DropdownHeader: ({ children, className }: DropdownHeaderProps) => React.JSX.Element;
+export declare const DropdownDivider: ({ className }: DropdownDividerProps) => React.JSX.Element;
+interface DropdownMenuProps {
+    context: string;
+    Type?: 'ul' | 'ol';
+    badges?: Record<string, any>;
+    pre?: React.ReactNode;
+    post?: React.ReactNode;
+}
+export declare const DropdownMenu: ({ context, Type, badges, pre, post }: DropdownMenuProps) => React.JSX.Element;
+export {};

package/dist/types/src/components/blocks/Menu.d.ts

@@ -0,0 +1,24 @@
+import React from 'react';
+import { BadgeType } from '../ui/Badge';
+interface MenuProps {
+    context: string;
+    Type?: 'ul' | 'ol';
+    badges?: Record<string, {
+        type?: BadgeType;
+        children: string;
+    }>;
+    pre?: React.ReactNode;
+    post?: React.ReactNode;
+    wrapClass?: string;
+    className?: string;
+    headerClass?: string;
+    itemClass?: string;
+    linkClass?: string;
+    iconClass?: string;
+    textClass?: string;
+    badgeClass?: string;
+    arrowClass?: string;
+    submenuClass?: string;
+}
+declare const Menu: ({ context, Type, badges, pre, post, wrapClass, className, headerClass, itemClass, linkClass, iconClass, textClass, badgeClass, arrowClass, submenuClass, }: MenuProps) => React.JSX.Element;
+export default Menu;

package/dist/types/src/components/blocks/Notifications.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import type { BadgeProps } from "../ui/Badge";
+interface NotificationItem {
+    title: string;
+    url: string;
+    time: string;
+    icon: string;
+}
+interface NotificationsProps {
+    children?: NotificationItem[];
+    badge?: BadgeProps;
+    wrapClass?: string;
+}
+declare function Notifications({ children, badge, wrapClass }: NotificationsProps): React.JSX.Element;
+export default Notifications;

package/dist/types/src/components/blocks/Search.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+interface SearchProps {
+    handleSearch?: (event: React.ChangeEvent<HTMLInputElement>) => void;
+}
+export declare const SearchButton: () => React.JSX.Element;
+declare function Search({ handleSearch }: SearchProps): React.JSX.Element;
+export default Search;

package/dist/types/src/components/index.d.ts

@@ -0,0 +1,52 @@
+export type { MotionUIProps, UIProps } from './types';
+export { default as Brand } from './blocks/Brand';
+export { default as Breadcrumbs } from './blocks/Breadcrumbs';
+export { default as Carousel } from './blocks/Carousel';
+export * from './blocks/Dropdown';
+export { default as Notifications } from './blocks/Notifications';
+export { default as Search } from './blocks/Search';
+export { default as Alert } from './ui/Alert';
+export { default as Badge } from './ui/Badge';
+export * from './ui/Badge';
+export * from './ui/Buttons';
+export { default as Card } from './ui/Card';
+export { default as Code } from './ui/Code';
+export { default as Gallery } from './ui/Gallery';
+export * from './ui/Gallery';
+export type { GallerySelectionChangeHandler, GallerySelectionState } from './ui/Gallery';
+export * from './ui/GridSystem';
+export { default as Image } from './ui/Image';
+export { default as ImageAvatar } from './ui/ImageAvatar';
+export { default as Loader } from './ui/Loader';
+export { default as Modal } from './ui/Modal';
+export * from './ui/Modal';
+export { default as Percentage } from './ui/Percentage';
+export { default as Repeat } from './ui/Repeat';
+export { default as Tab } from './ui/Tab';
+export * from './ui/Tab';
+export { default as Table } from './ui/Table';
+export type { TableHeaderProp, TableReorderHandler, TableReorderMeta, TableSelectionChangeHandler, TableSelectionState } from './ui/Table';
+export { default as Icon } from './ui/Icon';
+export { LayoutBuilder } from './ui/LayoutBuilder';
+export * from './ui/fields/Input';
+export * from './ui/fields/Select';
+export * from './ui/fields/Upload';
+export * from './ui/fields/Crop';
+export * from './ui/fields/UploadCSV';
+export * from './ui/fields/ImageUrl';
+export { default as AssistantAI } from './ui/fields/AssistantAI';
+export { default as Menu } from './blocks/Menu';
+export { default as Form } from './widgets/Form';
+export type { FormDeleteArgs, FormDeleteHandler, FormFinallyArgs, FormFinallyHandler, FormSaveArgs, FormSaveHandler, SavePathProps } from './widgets/Form';
+export { default as Grid } from './widgets/Grid';
+export { GridArray, GridCore, GridDB, GridGalleryView, GridTableView } from './widgets/grid-core';
+export type { GridAction, GridActions, GridAfterActionArgs, GridAfterActionHandler, GridArrayProps, GridColumn, GridCoreProps, GridDBQuery, GridDBProps, GridFooterContext, GridFormContext, GridGalleryViewProps, GridHeaderContext, GridLayout, GridMutationDeleteArgs, GridMutationDeleteHandler, GridMutationSaveArgs, GridMutationSaveHandler, GridReorderHandler, GridReorderMeta, GridRecordKey, GridProps, GridSelectionChangeHandler, GridSelectionMode, GridSelectionState, GridSticky, GridTableViewProps, } from './widgets/Grid';
+export { default as ImageEditor } from './widgets/ImageEditor';
+export { default as MarkdownReader } from './widgets/MarkdownReader';
+export type { MarkdownReaderProps } from './widgets/MarkdownReader';
+export * from './widgets/Prompt';
+export { default as TabDynamic } from './widgets/TabDynamic';
+export { default as Component } from './Component';
+export { ComponentBlock } from './Component';
+export * from './Template';
+export type { ModalDeleteHandler, ModalSaveHandler } from './ui/Modal';

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

@@ -0,0 +1,11 @@
+import type React from 'react';
+import type { MotionReference } from '../motion';
+export interface UIProps {
+    pre?: React.ReactNode;
+    post?: React.ReactNode;
+    wrapClass?: string;
+    className?: string;
+}
+export interface MotionUIProps extends UIProps {
+    motion?: MotionReference;
+}

package/dist/types/src/components/ui/Alert.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import { UIProps } from '../..';
+type AlertProps = {
+    children: string | React.ReactNode;
+    type?: "info" | "success" | "warning" | "danger" | "primary" | "secondary" | "light" | "dark";
+    isFixed?: "top" | "bottom";
+    timeout?: number;
+    onClose?: () => void;
+    icon?: string | boolean;
+    className?: string;
+} & UIProps;
+declare const Alert: ({ children, type, isFixed, timeout, onClose, icon, pre, post, wrapClass, className }: AlertProps) => React.JSX.Element;
+export default Alert;

package/dist/types/src/components/ui/Badge.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+import type { UIProps } from '../types';
+export type BadgeType = "info" | "success" | "warning" | "danger" | "primary" | "secondary" | "light" | "dark";
+export type BadgeDescriptor = {
+    content: React.ReactNode;
+    type?: BadgeType;
+    className?: string;
+};
+export type BadgeProps = React.ReactNode | BadgeDescriptor;
+export declare function isBadgeDescriptor(value: BadgeProps | undefined): value is BadgeDescriptor;
+export declare function normalizeBadgeProps(value: BadgeProps | undefined, fallbackType?: BadgeType, fallbackClassName?: string): BadgeDescriptor | undefined;
+export type BadgeOverlayProps = {
+    badge?: BadgeProps;
+    content?: React.ReactNode;
+    type?: BadgeType;
+    defaultType?: BadgeType;
+    className?: string;
+    descriptorOnly?: boolean;
+    children?: React.ReactNode;
+};
+export declare const BadgeOverlay: ({ badge, content, type, defaultType, className, descriptorOnly, children }: BadgeOverlayProps) => React.ReactNode;
+export type BadgeComponentProps = {
+    children: string | React.ReactNode;
+    type?: BadgeType;
+} & UIProps;
+declare const Badge: ({ children, type, pre, post, wrapClass, className }: BadgeComponentProps) => React.JSX.Element;
+export default Badge;

package/dist/types/src/components/ui/Buttons.d.ts

@@ -0,0 +1,57 @@
+import React from 'react';
+import type { MotionUIProps, UIProps } from '../types';
+import { BadgeProps } from './Badge';
+export interface IButton extends MotionUIProps {
+    onClick?: (e: any) => any;
+    icon?: string;
+    label?: string | React.ReactNode;
+    badge?: BadgeProps;
+    title?: string;
+    disabled?: boolean;
+    showLoader?: boolean;
+    iconClass?: string;
+    style?: React.CSSProperties;
+    variant?: "primary" | "secondary" | "danger" | "success" | "warning" | "info" | "light" | "dark" | "outline-primary" | "outline-secondary" | "outline-danger" | "outline-success" | "link";
+}
+export type SetMessagePayload = {
+    message: string;
+    chunkDone?: number;
+    totalChunks?: number;
+};
+export interface LoadingButtonProps extends Omit<IButton, "onClick"> {
+    onClick?: (e: any, setMessage?: (payload: SetMessagePayload) => any) => Promise<any>;
+    loadingLabel?: string | React.ReactNode;
+}
+export declare const buttonBaseClass = "btn";
+export declare const buttonPrimaryClass = "btn-primary";
+export declare const buttonSecondaryClass = "btn-secondary";
+export declare const buttonDangerClass = "btn-danger";
+export declare const buttonSuccessClass = "btn-success";
+export declare const buttonWarningClass = "btn-warning";
+export declare const buttonInfoClass = "btn-info";
+export declare const buttonLightClass = "btn-light";
+export declare const buttonDarkClass = "btn-dark";
+export declare const buttonOutlinePrimaryClass = "btn-outline-primary";
+export declare const buttonOutlineSecondaryClass = "btn-outline-secondary";
+export declare const buttonOutlineDangerClass = "btn-outline-danger";
+export declare const buttonOutlineSuccessClass = "btn-outline-success";
+export declare const buttonLinkClass = "btn-link";
+export declare const LoadingButton: ({ onClick, icon, label, badge, title, disabled, showLoader, pre, post, wrapClass, className, iconClass, style, loadingLabel, variant, motion: motionConfig }?: LoadingButtonProps) => React.JSX.Element;
+export declare const ActionButton: ({ onClick, icon, label, badge, title, disabled, pre, post, wrapClass, className, iconClass, style, variant, motion: motionConfig }?: IButton) => React.JSX.Element;
+interface BackLinkProps extends UIProps {
+    label?: string;
+}
+export declare const BackLink: ({ label, pre, post, wrapClass, className }: BackLinkProps) => React.JSX.Element;
+interface GoSiteProps extends UIProps {
+    label: string;
+    url: string;
+}
+export declare const GoSite: ({ label, url, pre, post, wrapClass, className }: GoSiteProps) => React.JSX.Element;
+interface ReferSiteProps extends UIProps {
+    title: string;
+    url: string;
+    imageUrl: string;
+    width?: number | string;
+}
+export declare const ReferSite: ({ title, url, imageUrl, width, pre, post, wrapClass, className }: ReferSiteProps) => React.JSX.Element;
+export {};

package/dist/types/src/components/ui/Card.d.ts

@@ -0,0 +1,15 @@
+import React from 'react';
+import { UIProps } from '../..';
+interface CardProps extends UIProps {
+    children: React.ReactNode;
+    title?: string;
+    header?: string | React.ReactNode;
+    footer?: string | React.ReactNode;
+    headerClass?: string;
+    bodyClass?: string;
+    footerClass?: string;
+    showLoader?: boolean;
+    showArrow?: boolean;
+}
+declare const Card: ({ children, title, header, footer, showLoader, showArrow, wrapClass, className, headerClass, bodyClass, footerClass }: CardProps) => React.JSX.Element;
+export default Card;

package/dist/types/src/components/ui/Code.d.ts

@@ -0,0 +1,25 @@
+import React from 'react';
+import { UIProps } from '../..';
+declare const LANGUAGES: Record<string, () => Promise<unknown>>;
+declare const THEMES: {
+    prism: string;
+    dark: string;
+    coy: string;
+    funky: string;
+    okaidia: string;
+    solarizedlight: string;
+    tomorrow: string;
+    twilight: string;
+};
+type PrismLanguage = keyof typeof LANGUAGES;
+type PrismTheme = keyof typeof THEMES;
+export type PrismBackground = 'primary' | 'secondary' | 'success' | 'danger' | 'warning' | 'info' | 'light' | 'dark' | 'white' | 'black' | 'transparent' | 'default';
+interface CodeProps extends UIProps {
+    children: string;
+    language?: PrismLanguage;
+    showCopy?: boolean;
+    theme?: PrismTheme;
+    background?: PrismBackground;
+}
+declare const Code: ({ language, children, pre, post, wrapClass, className, showCopy, theme, background, }: CodeProps) => React.JSX.Element;
+export default Code;

package/dist/types/src/components/ui/Gallery.d.ts

@@ -0,0 +1,55 @@
+import React from 'react';
+import { RecordProps } from "../../providers/data/DataProvider";
+import { PaginationParams } from './Pagination';
+import { UIProps } from '../';
+import { BadgeProps } from './Badge';
+import { type OrderConfig } from '../../libs/order';
+import { RecordSelectionState } from './useRecordSelection';
+export type GalleryRecord = RecordProps & {
+    img?: React.ReactElement<{
+        className: string;
+        style?: React.CSSProperties;
+        onClick?: (e: React.MouseEvent<HTMLImageElement>) => void;
+    }>;
+    thumbnail?: string;
+    mimetype?: string;
+    width?: number;
+    height?: number;
+    name?: string;
+};
+export type GalleryOverlayPosition = "topLeft" | "topRight" | "bottomLeft" | "bottomRight" | "middleLeft" | "middleRight";
+export type GalleryOverlayFilter = Partial<Record<keyof GalleryRecord, unknown>> | ((item: GalleryRecord, index: number) => boolean);
+export type GalleryOverlayValue = BadgeProps | ((item: GalleryRecord, index: number) => BadgeProps | null | undefined);
+export type GalleryOverlay = {
+    position: GalleryOverlayPosition;
+    badge?: GalleryOverlayValue;
+    render?: (item: GalleryRecord, index: number) => React.ReactNode;
+    when?: GalleryOverlayFilter;
+    className?: string;
+};
+export type GallerySelectionState = RecordSelectionState<GalleryRecord>;
+export type GallerySelectionChangeHandler = (selection: GallerySelectionState) => void;
+interface GalleryProps extends UIProps {
+    body?: GalleryRecord[];
+    Header?: string | React.ReactNode;
+    Footer?: string | React.ReactNode;
+    overlays?: GalleryOverlay[];
+    onClick?: (record: GalleryRecord) => void;
+    onSelectionChange?: GallerySelectionChangeHandler;
+    sortable?: boolean | OrderConfig;
+    pagination?: PaginationParams;
+    scrollToTopOnChange?: boolean;
+    scrollBehavior?: ScrollBehavior;
+    gutterSize?: 0 | 1 | 2 | 3 | 4 | 5;
+    rowCols?: 1 | 2 | 3 | 4 | 6;
+    groupBy?: string | string[];
+    selectedKeys?: string[];
+    selectedRowKeys?: string[];
+    scrollClass?: string;
+    headerClass?: string;
+    bodyClass?: string;
+    footerClass?: string;
+    selectedClass?: string;
+}
+declare const Gallery: ({ body, Header, Footer, overlays, onClick, onSelectionChange, sortable, pagination, gutterSize, rowCols, groupBy, selectedKeys, selectedRowKeys, pre, post, wrapClass, className, headerClass, scrollClass, bodyClass, footerClass, selectedClass }: GalleryProps) => React.JSX.Element;
+export default Gallery;

package/dist/types/src/components/ui/GridSystem.d.ts

@@ -0,0 +1,21 @@
+import React, { CSSProperties, ReactNode } from 'react';
+type ContainerProps = {
+    children?: ReactNode;
+    className?: string;
+    style?: CSSProperties;
+    onClick?: () => void;
+};
+type ColProps = ContainerProps & {
+    defaultSize?: number;
+    xxl?: number | 'auto';
+    xl?: number | 'auto';
+    lg?: number | 'auto';
+    md?: number | 'auto';
+    sm?: number | 'auto';
+    xs?: number | 'auto';
+};
+export declare const Wrapper: ({ children, className, style, onClick, }: ContainerProps) => React.JSX.Element;
+export declare const Container: ({ children, className, style }: ContainerProps) => React.JSX.Element;
+export declare const Row: ({ children, className, style }: ContainerProps) => React.JSX.Element;
+export declare const Col: ({ children, className, style, xxl, xl, lg, md, sm, xs }: ColProps) => React.JSX.Element;
+export {};

package/dist/types/src/components/ui/Icon.d.ts

@@ -0,0 +1,13 @@
+import React from 'react';
+import type { IconProviderAdapter } from '../../providers/icon/IconProvider';
+interface IconProps {
+    name?: string;
+    size?: number;
+    className?: string;
+    style?: React.CSSProperties;
+    /** Override the global icon provider for this instance only */
+    provider?: IconProviderAdapter;
+    label?: string;
+}
+declare const Icon: ({ name, size, className, style, provider: overrideProvider, label }: IconProps) => React.JSX.Element | null;
+export default Icon;

package/dist/types/src/components/ui/Image.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+import { UIProps } from '../..';
+export type ImageFit = 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
+export type ImagePosition = 'center' | 'top' | 'bottom' | 'left' | 'right' | 'top left' | 'top right' | 'bottom left' | 'bottom right';
+type ImageProps = {
+    src: string;
+    placeholder?: string;
+    label?: string;
+    title?: string;
+    fit?: ImageFit;
+    position?: ImagePosition;
+    feedback?: React.ReactNode;
+    width?: number;
+    height?: number;
+    srcset?: string;
+    sizes?: string;
+} & UIProps;
+declare const Image: ({ src, placeholder, label, title, fit, position, feedback, width, height, srcset, sizes, pre, post, wrapClass, className }: ImageProps) => React.JSX.Element;
+export default Image;

package/dist/types/src/components/ui/ImageAvatar.d.ts

@@ -0,0 +1,16 @@
+import React from "react";
+import type { UIProps } from '../types';
+import type { BadgeDescriptor } from './Badge';
+export type AvatarFit = 'cover' | 'contain' | 'fill' | 'scale-down' | 'none';
+interface ImageAvatarProps extends UIProps {
+    src: string;
+    width?: number;
+    height?: number;
+    title?: string;
+    alt?: string;
+    fit?: AvatarFit;
+    badge?: BadgeDescriptor;
+    feedback?: React.ReactNode;
+}
+declare const ImageAvatar: ({ src, width, height, title, alt, fit, badge, feedback, pre, post, wrapClass, className, }: ImageAvatarProps) => React.JSX.Element;
+export default ImageAvatar;

package/dist/types/src/components/ui/LayoutBuilder.d.ts

@@ -0,0 +1,19 @@
+import React from "react";
+type RowItem = {
+    id: string;
+    fieldName: string;
+    colStart: number;
+    colSpan: number;
+};
+export type LayoutBuilderHandle = {
+    getValue: () => RowItem[];
+    setValue: (items: RowItem[]) => void;
+    clear: () => void;
+};
+type Props = {
+    name: string;
+    defaultSpan?: number;
+    heightPx?: number;
+};
+export declare const LayoutBuilder: React.ForwardRefExoticComponent<Props & React.RefAttributes<LayoutBuilderHandle>>;
+export {};

package/dist/types/src/components/ui/Loader.d.ts

@@ -0,0 +1,11 @@
+import React from 'react';
+import { UIProps } from '../..';
+interface LoaderProps extends UIProps {
+    show?: boolean;
+    children: React.ReactNode;
+    icon?: string;
+    title?: string;
+    description?: string;
+}
+declare function Loader({ children, show, icon, title, description, pre, post, wrapClass, className }: LoaderProps): string | number | boolean | Iterable<React.ReactNode> | React.JSX.Element | null | undefined;
+export default Loader;