@abidibo/react-cam-roi 0.2.2 → 0.2.4

package/dist/types/Components/BoolField/index.d.ts

@@ -0,0 +1,5 @@
+import { FieldProps } from "../../Types";
+declare const BoolField: React.FC<Omit<FieldProps<boolean>, 'onChange'> & {
+    onChange: (value: boolean) => void;
+}>;
+export default BoolField;

package/dist/types/Components/Button/index.d.ts

@@ -0,0 +1,8 @@
+import { PropsWithChildren } from 'react';
+export type ButtonProps = {
+    onClick: (event: React.MouseEvent) => void;
+    primary?: boolean;
+    disabled?: boolean;
+};
+declare const Button: ({ onClick, primary, disabled, children }: PropsWithChildren<ButtonProps>) => import("react/jsx-runtime").JSX.Element;
+export default Button;

package/dist/types/Components/EnumField/index.d.ts

@@ -0,0 +1,10 @@
+import { FieldProps } from '../../Types';
+export type EnumOption<T> = {
+    value: T;
+    label: string;
+};
+declare const EnumField: <T extends string | number>({ onChange, value, label, helperText, error, options, disabled, required, multiple }: Omit<FieldProps<T | T[]>, "readOnly"> & {
+    options: EnumOption<T>[];
+    multiple?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;
+export default EnumField;

package/dist/types/Components/IconButton/index.d.ts

@@ -0,0 +1,7 @@
+export type IconButtonProps = {
+    children?: React.ReactNode;
+    disabled?: boolean;
+    onClick?: (event: React.MouseEvent) => void;
+};
+declare const IconButton: React.FC<IconButtonProps>;
+export default IconButton;

package/dist/types/Components/Loader/index.d.ts

@@ -0,0 +1 @@
+export declare const Loader: React.FC;

package/dist/types/Components/Modal/index.d.ts

@@ -0,0 +1,10 @@
+import { PropsWithChildren } from 'react';
+export type ModalProps = {
+    isOpen: boolean;
+    onClose: () => void;
+    title: string;
+    maxWidth: 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+    onSubmit?: () => void;
+};
+declare const Modal: React.FC<PropsWithChildren<ModalProps>>;
+export default Modal;

package/dist/types/Components/NumberField/index.d.ts

@@ -0,0 +1,3 @@
+import { FieldProps } from '../../Types';
+declare const NumberField: React.FC<FieldProps<number | null>>;
+export default NumberField;

package/dist/types/Components/RoiEditor/Canvas.d.ts

@@ -0,0 +1,14 @@
+import { Output } from './Types';
+type CanvasProps = {
+    canvasSize: {
+        width: number;
+        height: number;
+    };
+    imageSize: {
+        width: number;
+        height: number;
+    };
+    initialData?: Output;
+};
+declare const Canvas: React.FC<CanvasProps>;
+export default Canvas;

package/dist/types/Components/RoiEditor/ColorPicker.d.ts

@@ -0,0 +1,5 @@
+type ColorPickerProps = {
+    style?: React.CSSProperties;
+};
+declare const ColorPicker: React.FC<ColorPickerProps>;
+export default ColorPicker;

package/dist/types/Components/RoiEditor/Header.d.ts

@@ -0,0 +1,2 @@
+declare const Header: () => import("react/jsx-runtime").JSX.Element;
+export default Header;

package/dist/types/Components/RoiEditor/Hooks.d.ts

@@ -0,0 +1,38 @@
+import * as fabric from 'fabric';
+import { Metadata, Output, OutputParameter, Shape, ShapeType } from './Types';
+export declare const useImageSize: (imageUrl: string) => {
+    imageSize: {
+        width: number;
+        height: number;
+    };
+    isReady: boolean;
+};
+export declare const useCanvasSize: (imageUrl: string) => {
+    imageSize: {
+        width: number;
+        height: number;
+    };
+    canvasSize: {
+        width: number;
+        height: number;
+    };
+    wrapperRef: import("react").RefObject<HTMLDivElement>;
+    isReady: boolean;
+};
+export declare const initCanvasData: (canvasRef: React.MutableRefObject<fabric.Canvas | null>, imageSize: {
+    width: number;
+    height: number;
+}, addShapes: (shapes: {
+    id: string;
+    type: ShapeType;
+    shape: Shape;
+}[]) => void, metadata: Metadata, setMetadata: (v: Metadata) => void, initialData?: Output, enableLogs?: boolean) => void;
+export declare const useTool: (canvas: fabric.Canvas | null) => void;
+export declare const useDispatcherEvents: (canvas: fabric.Canvas | null) => void;
+export declare const useParametersForm: (parameters: OutputParameter[]) => {
+    fields: Record<string, unknown>;
+    setField: <T>(key: string) => (value: T) => void;
+    setFields: import("react").Dispatch<import("react").SetStateAction<Record<string, unknown>>>;
+    errors: Record<string, string>;
+    setErrors: import("react").Dispatch<import("react").SetStateAction<Record<string, string>>>;
+};

package/dist/types/Components/RoiEditor/ParameterField.d.ts

@@ -0,0 +1,9 @@
+import { ConfigurationParameter } from './Types';
+export type ParameterFieldProps<T> = {
+    value: T;
+    onChange: (value: T) => void;
+    parameter: ConfigurationParameter;
+    errors: Record<string, string>;
+};
+declare const ParameterField: <T>({ value, onChange, parameter, errors }: ParameterFieldProps<T>) => import("react/jsx-runtime").JSX.Element | null;
+export default ParameterField;

package/dist/types/Components/RoiEditor/ParametersModalForm/index.d.ts

@@ -0,0 +1,17 @@
+import { ConfigurationParameter, OutputParameter, ShapeType } from '../Types';
+export type ParametersModalFormProps = {
+    onClose: () => void;
+    title: string;
+    parameters: ConfigurationParameter[];
+    data: OutputParameter[];
+    onSubmit: (data: OutputParameter[], properties?: {
+        name: string;
+        role: string;
+    }) => void;
+    shapeType?: ShapeType;
+    shapeName?: string;
+    shapeRole?: string;
+    shapeId?: string;
+};
+declare const ParametersModalForm: React.FC<ParametersModalFormProps>;
+export default ParametersModalForm;

package/dist/types/Components/RoiEditor/Polygon.d.ts

@@ -0,0 +1,18 @@
+import * as fabric from 'fabric';
+import { FabricEvent } from './Types';
+export declare const handleMouseDownPolygon: (event: FabricEvent, canvas: fabric.Canvas, activeColor: string, setIsDrawing: (v: boolean) => void, points: {
+    x: number;
+    y: number;
+}[], setPoints: (v: {
+    x: number;
+    y: number;
+}[]) => void, lines: fabric.Line[], setLines: (v: fabric.Line[]) => void) => void;
+export declare const handleMouseMovePolygon: (event: FabricEvent, canvas: fabric.Canvas, isDrawing: boolean, lines: fabric.Line[]) => void;
+export declare const handleDoubleClickPolygon: (editorId: string, canvas: fabric.Canvas, activeColor: string, setIsDrawing: (v: boolean) => void, points: {
+    x: number;
+    y: number;
+}[], setPoints: (v: {
+    x: number;
+    y: number;
+}[]) => void, lines: fabric.Line[], setLines: (v: fabric.Line[]) => void) => void;
+export declare const copyPolygon: (editorId: string, canvas: fabric.Canvas, polygon: fabric.Polygon) => fabric.Polygon;

package/dist/types/Components/RoiEditor/Polyline.d.ts

@@ -0,0 +1,28 @@
+import * as fabric from 'fabric';
+import { FabricEvent } from './Types';
+export declare const handleMouseDownPolyline: (event: FabricEvent, canvas: fabric.Canvas, activeColor: string, setIsDrawing: (v: boolean) => void, points: {
+    x: number;
+    y: number;
+}[], setPoints: (v: {
+    x: number;
+    y: number;
+}[]) => void, lines: fabric.Line[], setLines: (v: fabric.Line[]) => void) => void;
+export declare const handleMouseMovePolyline: (event: FabricEvent, canvas: fabric.Canvas, isDrawing: boolean, lines: fabric.Line[]) => void;
+export declare const handleDoubleClickPolyline: (editorId: string, canvas: fabric.Canvas, activeColor: string, setIsDrawing: (v: boolean) => void, points: {
+    x: number;
+    y: number;
+}[], setPoints: (v: {
+    x: number;
+    y: number;
+}[]) => void, lines: fabric.Line[], setLines: (v: fabric.Line[]) => void) => void;
+export declare const copyPolyline: (editorId: string, canvas: fabric.Canvas, polyline: fabric.Polyline) => fabric.Polyline<{
+    top: number;
+    left: number;
+    fill: string;
+    stroke: string | fabric.TFiller | null;
+    strokeWidth: number;
+    selectable: false;
+    hasControls: true;
+    hoverCursor: string;
+    id: string;
+}, fabric.SerializedPolylineProps, fabric.ObjectEvents>;

package/dist/types/Components/RoiEditor/Rectangle.d.ts

@@ -0,0 +1,21 @@
+import * as fabric from 'fabric';
+import { FabricEvent, Shape } from './Types';
+export declare const handleMouseDownRect: (event: FabricEvent, canvas: fabric.Canvas, activeColor: string, setOriginX: (v: number) => void, setOriginY: (v: number) => void, setShape: (v: Shape) => void, setIsDrawing: (v: boolean) => void) => void;
+export declare const handleMouseMoveRect: (event: FabricEvent, canvas: fabric.Canvas, originX: number, originY: number, shape: Shape, isDrawing: boolean) => void;
+export declare const handleMouseUpRect: (editorId: string, canvas: fabric.Canvas, setIsDrawing: (v: boolean) => void, shape: Shape, setShape: (v: Shape | null) => void) => void;
+export declare const copyRectangle: (editorId: string, canvas: fabric.Canvas, rectangle: fabric.Rect) => fabric.Rect<{
+    left: number;
+    top: number;
+    originX: "left";
+    originY: "top";
+    width: number;
+    height: number;
+    fill: string;
+    stroke: string | fabric.TFiller | null;
+    strokeWidth: number;
+    strokeUniform: true;
+    selectable: false;
+    hasControls: true;
+    hoverCursor: string;
+    id: string;
+}, fabric.SerializedRectProps, fabric.ObjectEvents>;

package/dist/types/Components/RoiEditor/RoisInfo.d.ts

@@ -0,0 +1,2 @@
+declare const RoisInfo: () => import("react/jsx-runtime").JSX.Element | null;
+export default RoisInfo;

package/dist/types/Components/RoiEditor/ShapesList.d.ts

@@ -0,0 +1,2 @@
+declare const ShapesList: React.FC;
+export default ShapesList;

package/dist/types/Components/RoiEditor/Toolbar.d.ts

@@ -0,0 +1,2 @@
+declare const Toolbar: () => import("react/jsx-runtime").JSX.Element;
+export default Toolbar;

package/dist/types/Components/RoiEditor/TopBar.d.ts

@@ -0,0 +1,2 @@
+declare const TopBar: () => import("react/jsx-runtime").JSX.Element;
+export default TopBar;

package/dist/types/Components/RoiEditor/Types.d.ts

@@ -0,0 +1,128 @@
+import * as fabric from 'fabric';
+export declare const enum ToolEnum {
+    Pointer = "pointer",
+    Polyline = "polyline",
+    Polygon = "polygon",
+    Rectangle = "rect"
+}
+export type ShapeType = ToolEnum.Polyline | ToolEnum.Polygon | ToolEnum.Rectangle;
+export type Shape = (fabric.Rect | fabric.Polygon | fabric.Polyline) & {
+    id?: string;
+};
+export type Shapes = Record<string, {
+    type: ShapeType;
+    shape: Shape;
+}>;
+export type FabricEvent = fabric.TPointerEventInfo<fabric.TPointerEvent>;
+export type FabricSelectionEvent = Partial<fabric.TEvent> & {
+    selected: fabric.Object[];
+};
+export type IAddShape = (id: string, type: ShapeType, shape: Shape) => void;
+export declare enum DataTypeEnum {
+    Integer = "int",
+    Float = "float",
+    String = "string",
+    Boolean = "bool"
+}
+export declare enum OperatorEnum {
+    Lt = "lt",
+    Lte = "lte",
+    Gt = "gt",
+    Gte = "gte",
+    Eq = "eq"
+}
+export type ConfigurationParameter = {
+    codename: string;
+    label: string;
+    description: string;
+    unit: string;
+    type: DataTypeEnum;
+    options: {
+        value: number | string;
+        label: string;
+    }[];
+    multiple?: boolean;
+    required: boolean;
+    value: number | string | boolean | string[] | number[] | null;
+};
+export type RoiConfiguration = {
+    role: string;
+    label: string;
+    type: Omit<ShapeType, 'pointer'>;
+    multiplicity: {
+        operator: OperatorEnum;
+        threshold: number;
+    };
+    parameters: ConfigurationParameter[];
+};
+export type Configuration = {
+    parameters: ConfigurationParameter[];
+    rois: RoiConfiguration[];
+    options?: {
+        hideForbiddenTools?: boolean;
+        description?: string;
+    };
+};
+export interface INotify {
+    info: (message: string) => void;
+    warn: (message: string) => void;
+    error: (message: string) => void;
+    success: (message: string) => void;
+}
+export type Metadata = {
+    parameters: OutputParameter[];
+    rois: {
+        id: string;
+        parameters: OutputParameter[];
+        name: string;
+        role: string;
+    }[];
+};
+export type OutputShapeRect = {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    color: string;
+};
+export type OutputShapePolyline = {
+    points: {
+        x: number;
+        y: number;
+    }[];
+    top: number;
+    left: number;
+    color: string;
+};
+export type OutputShapePolygon = {
+    points: {
+        x: number;
+        y: number;
+    }[];
+    top: number;
+    left: number;
+    color: string;
+};
+export interface OutputParameter {
+    codename: string;
+    value: number | string | boolean | string[] | number[] | null;
+}
+export interface OutputRoi {
+    parameters: OutputParameter[];
+    type: ShapeType;
+    name: string;
+    role: string;
+    id: string;
+    shape: OutputShapeRect | OutputShapePolyline | OutputShapePolygon;
+}
+export interface Output {
+    parameters: OutputParameter[];
+    rois: OutputRoi[];
+}
+export declare enum UpdateEventType {
+    AddRoi = "AddRoi",
+    RemoveRoi = "RemoveRoi",
+    UpdateRoi = "UpdateRoi",
+    UpdateRoiParameters = "UpdateRoiParameters",
+    UpdateMainParameters = "UpdateMainParameters"
+}

package/dist/types/Components/RoiEditor/Utils.d.ts

@@ -0,0 +1,25 @@
+import { Configuration, ConfigurationParameter, INotify, Metadata, Shape, Shapes, ShapeType, ToolEnum } from './Types';
+export declare const notify: INotify;
+export declare const enableRois: (configuration: Configuration) => boolean;
+export declare const enableMainMetadata: (configuration: Configuration) => boolean;
+export declare const canDrawShape: (configuration: Configuration, shapeType: Omit<ToolEnum, ToolEnum.Pointer>, shapes: Shapes, notify?: INotify, message?: string) => boolean;
+export declare const validateParametersForm: (parameters: ConfigurationParameter[], fields: Record<string, unknown>, setErrors: (errors: Record<string, string>) => void) => boolean;
+export declare const validate: (configuration: Configuration, shapes: Shapes, metadata: Metadata, strings: Record<string, string>) => [boolean, string[]];
+export declare const fabricShapeToOutputShape: (shape: Shape, type: ShapeType, imageSize: {
+    width: number;
+    height: number;
+}) => {
+    top: number;
+    left: number;
+    width: number;
+    height: number;
+    color: string;
+    points?: undefined;
+} | {
+    points: any;
+    top: number;
+    left: number;
+    color: string;
+    width?: undefined;
+    height?: undefined;
+};

package/dist/types/Components/RoiEditor/index.d.ts

@@ -0,0 +1,12 @@
+import React from 'react';
+import { Configuration, Output } from './Types';
+export type RoiEditorProps = {
+    imageUrl: string;
+    configuration: Configuration;
+    onSubmit: (data: Output) => void;
+    onUpdate?: (data: Output) => void;
+    initialData?: Output;
+    editorId: string;
+};
+declare const RoiEditor: React.FC<RoiEditorProps>;
+export default RoiEditor;

package/dist/types/Components/RoleField.d.ts

@@ -0,0 +1,7 @@
+import { FieldProps } from '../Types';
+import { ShapeType } from './RoiEditor/Types';
+type RoleFieldProps = Omit<FieldProps<string>, 'readonly' | 'label'> & {
+    shapeType: ShapeType;
+};
+declare const RoleField: React.FC<RoleFieldProps>;
+export default RoleField;

package/dist/types/Components/TextField/index.d.ts

@@ -0,0 +1,6 @@
+import { FieldProps } from '../../Types';
+export interface TextFieldProps extends FieldProps<string> {
+    type?: 'text' | 'email' | 'password';
+}
+declare const TextField: React.FC<TextFieldProps>;
+export default TextField;

package/dist/types/Components/Typography/index.d.ts

@@ -0,0 +1,9 @@
+export type TypographyProps = {
+    children?: React.ReactNode;
+    className?: string;
+    variant?: any;
+    component?: any;
+    style?: React.CSSProperties;
+};
+declare const Typography: React.FC<TypographyProps>;
+export default Typography;

package/dist/types/Icons/AnnotateIcon.d.ts

@@ -0,0 +1,6 @@
+type AnnotateIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const AnnotateIcon: React.FC<AnnotateIconProps>;
+export default AnnotateIcon;

package/dist/types/Icons/CloseIcon.d.ts

@@ -0,0 +1,6 @@
+type CloseIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const CloseIcon: React.FC<CloseIconProps>;
+export default CloseIcon;

package/dist/types/Icons/CopyIcon.d.ts

@@ -0,0 +1,6 @@
+type CopyIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const CopyIcon: React.FC<CopyIconProps>;
+export default CopyIcon;

package/dist/types/Icons/DeleteIcon.d.ts

@@ -0,0 +1,6 @@
+export type DeleteIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const DeleteIcon: React.FC<DeleteIconProps>;
+export default DeleteIcon;

package/dist/types/Icons/EditIcon.d.ts

@@ -0,0 +1,6 @@
+type EditIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const EditIcon: React.FC<EditIconProps>;
+export default EditIcon;

package/dist/types/Icons/PointerIcon.d.ts

@@ -0,0 +1,6 @@
+type PointerIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const PointerIcon: React.FC<PointerIconProps>;
+export default PointerIcon;

package/dist/types/Icons/PolygonIcon.d.ts

@@ -0,0 +1,6 @@
+type PolygonIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const PolygonIcon: React.FC<PolygonIconProps>;
+export default PolygonIcon;

package/dist/types/Icons/PolylineIcon.d.ts

@@ -0,0 +1,6 @@
+type PolylineIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const PolylineIcon: React.FC<PolylineIconProps>;
+export default PolylineIcon;

package/dist/types/Icons/RectangleIcon.d.ts

@@ -0,0 +1,6 @@
+type RectangleIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const RectangleIcon: React.FC<RectangleIconProps>;
+export default RectangleIcon;

package/dist/types/Icons/SaveIcon.d.ts

@@ -0,0 +1,6 @@
+type SaveIconProps = {
+    color?: string;
+    style?: React.CSSProperties;
+};
+declare const SaveIcon: React.FC<SaveIconProps>;
+export default SaveIcon;

package/dist/types/Providers/EditorProvider.d.ts

@@ -0,0 +1,26 @@
+import { PropsWithChildren } from 'react';
+import { Configuration, Metadata, Shape, Shapes, ShapeType, ToolEnum } from '../Components/RoiEditor/Types';
+type EditorContextType = {
+    hideForbiddenTools: boolean;
+    activeTool: ToolEnum;
+    setActiveTool: (tool: ToolEnum) => void;
+    activeColor: string;
+    setActiveColor: (color: string) => void;
+    shapes: Shapes;
+    addShape: (id: string, type: ShapeType, shape: Shape) => void;
+    addShapes: (shapes: {
+        id: string;
+        type: ShapeType;
+        shape: Shape;
+    }[]) => void;
+    removeShape: (id: string) => void;
+    configuration: Configuration;
+    metadata: Metadata;
+    setMetadata: (data: Metadata) => void;
+    onSubmit: () => void;
+    editorId: string;
+};
+export declare const EditorContext: import("react").Context<EditorContextType | undefined>;
+export declare function useEditorContext(): EditorContextType;
+declare const EditorProvider: ({ children, editorId, hideForbiddenTools, activeTool, setActiveTool, activeColor, setActiveColor, shapes, addShape, addShapes, removeShape, configuration, metadata, setMetadata, onSubmit, }: PropsWithChildren<EditorContextType>) => import("react/jsx-runtime").JSX.Element;
+export default EditorProvider;

package/dist/types/Providers/UiProvider.d.ts

@@ -0,0 +1,82 @@
+import { PropsWithChildren } from 'react';
+import Typography from '../Components/Typography';
+import IconButton from '../Components/IconButton';
+import DeleteIcon from '../Icons/DeleteIcon';
+import EditIcon from '../Icons/EditIcon';
+import { INotify } from '../Components/RoiEditor/Types';
+import CopyIcon from '../Icons/CopyIcon';
+import AnnotateIcon from '../Icons/AnnotateIcon';
+import Modal from '../Components/Modal';
+import CloseIcon from '../Icons/CloseIcon';
+import TextField from '../Components/TextField';
+import NumberField from '../Components/NumberField';
+import BoolField from '../Components/BoolField';
+import EnumField from '../Components/EnumField';
+import Button from '../Components/Button';
+import SaveIcon from '../Icons/SaveIcon';
+type UiContextType = {
+    children?: React.ReactNode;
+    enableLogs: boolean;
+    themeMode: 'light' | 'dark';
+    primaryColor: string;
+    primaryFgColor: string;
+    Typography: typeof Typography;
+    IconButton: typeof IconButton;
+    Modal: typeof Modal;
+    DeleteIcon: typeof DeleteIcon;
+    EditIcon: typeof EditIcon;
+    CopyIcon: typeof CopyIcon;
+    AnnotateIcon: typeof AnnotateIcon;
+    SaveIcon: typeof SaveIcon;
+    CloseIcon: typeof CloseIcon;
+    TextField: typeof TextField;
+    NumberField: typeof NumberField;
+    BoolField: typeof BoolField;
+    EnumField: typeof EnumField;
+    Button: typeof Button;
+    pickerColors: string[];
+    notify: INotify;
+    strings: {
+        cancel: string;
+        cannotDrawMorePolygons: string;
+        cannotDrawMorePolylines: string;
+        cannotDrawMoreRectangles: string;
+        id: string;
+        invalidSubmission: string;
+        mainParametersMetadata: string;
+        missingRequiredValuesInMainParameters: string;
+        missingRequiredValuesInShapeParameters: string;
+        roiMultiplicityEqRule: string;
+        roiMultiplicityGtRule: string;
+        roiMultiplicityGteRule: string;
+        roiMultiplicityLtRule: string;
+        roiMultiplicityLteRule: string;
+        roiMultiplicityNoRule: string;
+        name: string;
+        polygon: string;
+        polygonHelpText: string;
+        polyline: string;
+        polylineHelpText: string;
+        rect: string;
+        rectHelpText: string;
+        pointer: string;
+        pointerHelpText: string;
+        roisToBeDrawn: string;
+        role: string;
+        requiredField: string;
+        save: string;
+        shapeParametersMetadata: string;
+        shapesOfRoleShouldBeEqualToThreshold: string;
+        shapesOfRoleShouldBeGreaterThanThreshold: string;
+        shapesOfRoleShouldBeGreaterThanOrEqualToThreshold: string;
+        shapesOfRoleShouldBeLessThanThreshold: string;
+        shapesOfRoleShouldBeLessThanOrEqualToThreshold: string;
+        type: string;
+    };
+};
+export declare const DefaultUiContext: UiContextType;
+export declare const UiContext: import("react").Context<UiContextType>;
+declare const UiProvider: ({ children, enableLogs, themeMode, primaryColor, primaryFgColor, Typography, Modal, IconButton, DeleteIcon, EditIcon, CopyIcon, AnnotateIcon, SaveIcon, CloseIcon, TextField, NumberField, BoolField, EnumField, Button, pickerColors, notify, strings, }: PropsWithChildren<Partial<Omit<UiContextType, "strings">> & {
+    strings?: Partial<UiContextType["strings"]>;
+}>) => import("react/jsx-runtime").JSX.Element;
+export default UiProvider;

package/dist/types/Types.d.ts

@@ -0,0 +1,10 @@
+export interface FieldProps<T> {
+    onChange: (value: T) => void;
+    value: T;
+    label: string;
+    helperText?: string;
+    error?: boolean;
+    required?: boolean;
+    readOnly?: boolean;
+    disabled?: boolean;
+}

package/dist/types/Utils/Dispatcher.d.ts

@@ -0,0 +1,16 @@
+type DispatcherType = {
+    _prefix: string;
+    _listeners: Record<string, Array<unknown>>;
+    evtName: (evtName: string) => string;
+    register: <T>(evtName: string, callback: (evtName: string, params: T) => void, bind?: unknown) => void;
+    unregister: <T>(evtName: string, callback: (evtName: string, params: T) => void) => void;
+    emit: (evtName: string, ...params: unknown[]) => void;
+};
+/**
+ * Event Dispatcher
+ *
+ * Implementation of an event dispatcher following the Mediator pattern
+ * @namespace
+ */
+declare const Dispatcher: DispatcherType;
+export default Dispatcher;