@imtf/dms-core 1.0.0-beta.1

package/core/providers/Plugins/hooks/cases/useCaseDocumentTypes.d.ts

@@ -0,0 +1,5 @@
+import { CaseDocumentType } from "../../../Cases/hooks/useCaseDocumentTypes";
+import { Case } from "../../../Cases/types";
+import { Task } from "../../../Tasks/types";
+declare const useCaseDocumentTypes: (item: string | Case | Task) => import("swr").SWRResponse<CaseDocumentType[], any, any>;
+export default useCaseDocumentTypes;

package/core/providers/Plugins/hooks/cases/useCaseDocuments.d.ts

@@ -0,0 +1,2 @@
+export default useCaseDocuments;
+declare function useCaseDocuments(item: any): (import("../../../Inodes/types").Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode"> | undefined)[] | undefined;

package/core/providers/Plugins/hooks/cases/useData.d.ts

@@ -0,0 +1,14 @@
+import { EntityType } from "../../../Ccm/types";
+import { MdmGraphData } from "../../../MdmGraph/types";
+type EntitiesSelector<E = EntityType> = {
+    entityType: E;
+    attachedEntities?: E[];
+    orderBy?: string;
+};
+declare const useCasePaginatedMdmGraphData: <E = EntityType>(params: {
+    caseOid: string | undefined;
+    entitiesSelector?: EntitiesSelector<E>;
+    offset?: number;
+    limit?: number;
+}) => import("swr").SWRResponse<MdmGraphData, any, any>;
+export default useCasePaginatedMdmGraphData;

package/core/providers/Plugins/hooks/cases/usePayload.d.ts

@@ -0,0 +1,6 @@
+import { CasePayload } from "../../../Cases/types";
+declare const useCasePayload: (item: unknown) => import("swr").SWRResponse<{
+    kind: "acm.CasePayload";
+    payload: CasePayload;
+}, any, any>;
+export default useCasePayload;

package/core/providers/Plugins/hooks/inodes/useActions.d.ts

@@ -0,0 +1,12 @@
+export default useInodeActions;
+declare function useInodeActions(): {
+    delete: (inodes: any, permanent: any, showNotification: any) => Promise<{
+        inodes: import("../../../Inodes/types").Inode[];
+        permanent?: boolean;
+        showNotification?: boolean;
+    }>;
+    update: (inodes: any) => void;
+    stateAction: (inodes: any, action: any) => void;
+    updateProperties: (newProperties: any, oid: any) => void;
+    checkAndGetWithType: (inodes: any, targetTypes: any, forceChildrenWithType: any, sort: any) => Promise<any>;
+};

package/core/providers/Plugins/hooks/inodes/useInodesByOids.d.ts

@@ -0,0 +1,6 @@
+import { Inode } from "../../../Inodes/types";
+/**
+ * Load inodes from server if not already
+ * and return inode's objects
+ */
+export default function useInodesByOid(oids: string[]): Inode[];

package/core/providers/Plugins/hooks/mdm/useEntity.d.ts

@@ -0,0 +1,6 @@
+export default useEntity;
+declare function useEntity(taskOid: any, entityOid: any): {
+    data: any;
+    error: any;
+    loading: boolean;
+};

package/core/providers/Plugins/hooks/tasks/useActions.d.ts

@@ -0,0 +1,17 @@
+export default useTaskActions;
+declare function useTaskActions(taskOid: any): {
+    createEntity: (entity: any, params: any) => Promise<void>;
+    patchEntity: (entity: any, patchData: any, params: any) => Promise<void>;
+    deleteEntity: (entity: any, params: any) => Promise<unknown>;
+    createFiles: (entityOid: any, inodes: any) => {
+        type: string;
+        payload: {
+            caseOid: any;
+            taskOid: any;
+            entityOid: any;
+            inodes: any;
+        };
+    };
+    reloadQuestionnaire: () => Promise<any>;
+    reloadData: () => Promise<any>;
+};

package/core/providers/Plugins/hooks/tasks/useData.d.ts

@@ -0,0 +1,2 @@
+import useTaskData from "../../../Tasks/hooks/useTaskData";
+export default useTaskData;

package/core/providers/Plugins/hooks/tasks/useEntitiesMutate.d.ts

@@ -0,0 +1 @@
+export { default } from "../../../Tasks/hooks/useEntitiesMutate";

package/core/providers/Plugins/hooks/tasks/useTask.d.ts

@@ -0,0 +1,2 @@
+export default useTask;
+import useTask from "../../../Tasks/hooks/useTask";

package/core/providers/Plugins/hooks/usePlugin.d.ts

@@ -0,0 +1,3 @@
+import { TYPES } from "../constants";
+declare const usePlugin: (TYPE: Exclude<(typeof TYPES)[keyof typeof TYPES], "INSPECTOR" | "CONTEXT_MENU_ACTION">, NAME: string, defaultValue?: any) => any;
+export default usePlugin;

package/core/providers/Plugins/pluginRegistry.d.ts

@@ -0,0 +1,323 @@
+import { useIntl } from "react-intl";
+import useReloader from "../Search/hooks/useReloader";
+import { api } from "../../../core/services/settings";
+import { TRIGGER_TARGET } from "../Actions/constants";
+import { Action, ActionDefinition } from "../Actions/types";
+import { SupportedItem } from "../App/types";
+import { Case } from "../Cases/types";
+import { Inode } from "../Inodes/types";
+import { InspectorProps } from "../Inspectors/types";
+import { Task } from "../Tasks/types";
+import { TYPES } from "./constants";
+import useInodesByOids from "./hooks/inodes/useInodesByOids";
+import { CategoryFilterProps, EntitiesWrapperProps, EntityDocumentsDocumentLabelProps, EntityDocumentsDocumentProps, EntityDocumentsTypeLabelProps, EntityEditModalEditForm, MdmEditorEntityRowActionsProps } from "./types/componentPlugins";
+type PLUGIN_TYPES = (typeof TYPES)[keyof typeof TYPES];
+declare const plugins: {
+    [key in Exclude<PLUGIN_TYPES, "INSPECTOR" | "CONTEXT_MENU_ACTION">]: Record<string, Record<string, any>>;
+};
+declare class PluginRegistry {
+    private getActions;
+    private triggerItems;
+    private uploadFiles;
+    TYPES: Readonly<{
+        QUESTIONNAIRE_PART: "QUESTIONNAIRE_PART";
+        FORM_WIDGET: "FORM_WIDGET";
+        FORM_FIELD: "FORM_FIELD";
+        FORM_ACTION: "FORM_ACTION";
+        FORM_OPERATOR: "FORM_OPERATOR";
+        FORMATTER: "FORMATTER";
+        RENDERER: "RENDERER";
+        INSPECTOR: "INSPECTOR";
+        UNSAFE_SAGA: "UNSAFE_SAGA";
+        CONTEXT_MENU_ACTION: "CONTEXT_MENU_ACTION";
+        EXTERNAL_MODULE: "EXTERNAL_MODULE";
+        PROVIDER: "PROVIDER";
+        COMPONENT: "COMPONENT";
+    }>;
+    ENVIRONNEMENT: string;
+    service: {
+        service: {
+            get: <T = any, R = import("axios").AxiosResponse<T, any>, D = any>(url: string, config?: import("axios").AxiosRequestConfig<D>) => Promise<R> & {
+                "@@redux-saga/CANCEL_PROMISE"?: import("axios").Canceler;
+            };
+            post: <T = any, Data = any>(url: string, data?: Data, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<T, any>>;
+            put: <T = any, Data = any>(url: string, data?: Data, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<T, any>>;
+            patch: <T = any, Data = any>(url: string, data: Data, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<T, any>>;
+            delete: <Data = any>(url: string, data?: Data, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+            head: (url: string, config?: import("axios").AxiosRequestConfig) => Promise<import("axios").AxiosResponse<any, any>>;
+        };
+        api: typeof api;
+        CancelToken: import("axios").CancelTokenStatic;
+    };
+    components: {
+        DocumentViewer: import("react").MemoExoticComponent<({ inode }: {
+            inode: Inode;
+        }) => import("react/jsx-runtime").JSX.Element>;
+        CountryFlag: any;
+    };
+    hooks: {
+        app: {
+            useActions: () => {
+                openValidationModal: (callback: any, title: any, text: any, extraParams?: {}) => void;
+            };
+            useCodetype: (codetype?: string, params?: Partial<{
+                formName: string;
+            }>) => import("swr").SWRResponse<import("../Definitions/types").Codetypes, any, any>;
+            useIntl: typeof useIntl;
+            useNotification: () => {
+                notify: (message: import("react-toastify").ToastContent, options: import("react-toastify").ToastOptions) => import("react-toastify").Id;
+                updateNotification: (tastId: import("react-toastify").Id, options: import("react-toastify").UpdateOptions) => void;
+            };
+            useParameter: <T>(key: "translations" | "language" | "contentType" | "locales" | "enableCaseCreation" | "shouldReloadResults" | "reloadResultsIntervals" | "userInactivitySessionTimeout" | "showDropzone" | "theme" | "productNameInSidebar" | "disableTaskAutoClaim" | "useRelativeDateWheneverPossible" | "customerRelatedEntitiesTemplates" | "documentTaskSearchContextName" | "canOpenRelatedAlertFromInspector" | "propertyPanelOverrides" | "additionalTransactionsColumns" | "millisecondsToHideUploadProgress" | "inodeTimelineExportLimit" | "searchExportLimit" | "customStamps" | "openEachInodeInNewTabOrWindowLimit" | "useSolrDocumentIcons" | "loadFirstFromQuickSearch" | "enableDossierCreation" | "enableBarcodeProcessing" | "enablePropertiesUpload" | "navigateOnCaseCreation" | "navigateOnTaskCompletion" | "authenticationWorkflow" | "hitListLimit" | "inodeListLimit" | "appBarColor" | "displayEnvironmentName" | "autosaveDebounce" | "displayFullnameInDocuments" | "enableDigitalSignatureVerification" | "certificateRevocationListProxyServerUrl" | "companionScanDPIResolution", defaultValue?: T) => T | undefined;
+            useReloader: typeof useReloader;
+            useSWR: import("swr").SWRHook;
+            useSWRImmutable: import("swr").SWRHook;
+            useSWRConfig: () => import("swr/_internal").FullConfiguration;
+            useUserDetails: () => import("../User/types").User | undefined;
+        };
+        case: {
+            useActions: (item: any) => {
+                createFiles: (entityOid: any, inodes: any) => void;
+            };
+            useCase: (item: Case) => import("swr").SWRResponse<Case, any, any>;
+            useData: <E = import("../Ccm/types").EntityType>(params: {
+                caseOid: string | undefined;
+                entitiesSelector?: {
+                    entityType: E;
+                    attachedEntities?: E[] | undefined;
+                    orderBy?: string;
+                };
+                offset?: number;
+                limit?: number;
+            }) => import("swr").SWRResponse<import("../MdmGraph/types").MdmGraphData, any, any>;
+            useDocuments: (item: any) => (Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode"> | undefined)[] | undefined;
+            useDocumentTypes: (item: string | Case | Task) => import("swr").SWRResponse<import("../Cases/hooks/useCaseDocumentTypes").CaseDocumentType[], any, any>;
+            usePayload: (item: unknown) => import("swr").SWRResponse<{
+                kind: "acm.CasePayload";
+                payload: import("../Cases/types").CasePayload;
+            }, any, any>;
+        };
+        task: {
+            useActions: (taskOid: any) => {
+                createEntity: (entity: any, params: any) => Promise<void>;
+                patchEntity: (entity: any, patchData: any, params: any) => Promise<void>;
+                deleteEntity: (entity: any, params: any) => Promise<unknown>;
+                createFiles: (entityOid: any, inodes: any) => {
+                    type: string;
+                    payload: {
+                        caseOid: any;
+                        taskOid: any;
+                        entityOid: any;
+                        inodes: any;
+                    };
+                };
+                reloadQuestionnaire: () => Promise<any>;
+                reloadData: () => Promise<any>;
+            };
+            useData: <EntityType extends import("../MdmGraph/types").Entity>(taskOid: string | undefined, config?: import("swr").SWRConfiguration) => import("swr").SWRResponse<import("../Tasks/types").TaskData<EntityType>, any, import("swr").SWRConfiguration<import("../Tasks/types").TaskData<EntityType>, any, import("swr").BareFetcher<import("../Tasks/types").TaskData<EntityType>>> | undefined>;
+            useEntitiesMutate: (taskOid: string) => import("swr/mutation").SWRMutationResponse<{
+                entities?: import("../MdmGraph/types").Entity[];
+                params?: import("../Tasks/hooks/useEntitiesMutate").Params;
+            }, import("axios").AxiosError<unknown, any>, import("swr").Key, {
+                entities: import("../MdmGraph/types").Entity[];
+                params?: import("../Tasks/hooks/useEntitiesMutate").Params;
+            }>;
+            useEntityMutate: (taskOid: string) => {
+                trigger: (entity: import("../MdmGraph/types").Entity, patchData?: import("../MdmGraph/types").EntityData, params?: import("../Tasks/hooks/useEntityMutate").Params) => Promise<void>;
+                isMutating: boolean;
+                reset: () => void;
+                error: import("axios").AxiosError<unknown, any> | undefined;
+                data: {
+                    entity?: import("../MdmGraph/types").Entity & {
+                        __creationOid?: string;
+                    };
+                    relation?: import("../MdmGraph/types").Relation;
+                    params?: import("../Tasks/hooks/useEntityMutate").Params | undefined;
+                } | undefined;
+            };
+            useEntityDelete: (taskOid: string) => {
+                deleteEntity: (entityOid: string, params: Omit<{
+                    triggerTaskDataReload?: boolean;
+                    triggerQuestionnaireReload?: boolean;
+                } & {
+                    entityOid: string;
+                }, "entityOid">) => Promise<unknown>;
+                isMutating: boolean;
+                trigger: import("swr/mutation").TriggerWithArgs<string, import("axios").AxiosError<unknown, any>, import("swr").Key, {
+                    triggerTaskDataReload?: boolean;
+                    triggerQuestionnaireReload?: boolean;
+                } & {
+                    entityOid: string;
+                }>;
+                reset: () => void;
+                error: import("axios").AxiosError<unknown, any> | undefined;
+                data: string | undefined;
+            };
+            useTask: (taskOid: string | undefined) => import("swr").SWRResponse<Task, any, any>;
+        };
+        mdm: {
+            useEntity: (taskOid: any, entityOid: any) => {
+                data: any;
+                error: any;
+                loading: boolean;
+            };
+        };
+        inode: {
+            useActions: () => {
+                delete: (inodes: any, permanent: any, showNotification: any) => Promise<{
+                    inodes: Inode[];
+                    permanent?: boolean;
+                    showNotification?: boolean;
+                }>;
+                update: (inodes: any) => void;
+                stateAction: (inodes: any, action: any) => void;
+                updateProperties: (newProperties: any, oid: any) => void;
+                checkAndGetWithType: (inodes: any, targetTypes: any, forceChildrenWithType: any, sort: any) => Promise<any>;
+            };
+            useInodesByOids: typeof useInodesByOids;
+        };
+    };
+    setDeps({ getActions, triggerItems, upload, }: {
+        getActions: typeof PluginRegistry.prototype.getActions;
+        triggerItems: typeof PluginRegistry.prototype.triggerItems;
+        upload: typeof PluginRegistry.prototype.uploadFiles;
+    }): void;
+    register(type: typeof TYPES.FORM_WIDGET | typeof TYPES.FORM_FIELD | typeof TYPES.RENDERER | typeof TYPES.CONTEXT_MENU_ACTION | typeof TYPES.EXTERNAL_MODULE | typeof TYPES.QUESTIONNAIRE_PART | typeof TYPES.PROVIDER, name: string, plugin: (...args: any[]) => React.ReactNode, options?: {
+        condition?: (item: unknown) => boolean;
+    }): void;
+    register(type: typeof TYPES.INSPECTOR, name: string, component: React.FC<InspectorProps>, options?: {
+        label?: string;
+        condition?: (item: Case | Task | Inode) => boolean;
+    }): void;
+    register(type: typeof TYPES.FORM_OPERATOR, name: string, plugin: (item: Record<string, any>) => React.ReactNode): void;
+    register(type: typeof TYPES.FORMATTER, name: string, plugin: (...args: any[]) => string, params?: unknown): void;
+    register(type: typeof TYPES.COMPONENT, name: "mdmEditor/EntitiesWrapper", plugin: React.FC<EntitiesWrapperProps>, params?: {
+        condition: (props: EntitiesWrapperProps) => boolean;
+    }): void;
+    register(type: typeof TYPES.COMPONENT, name: "mdmEditor/EntityRowActions", plugin: React.FC<MdmEditorEntityRowActionsProps>, params?: {
+        condition: (props: MdmEditorEntityRowActionsProps) => boolean;
+    }): void;
+    register(type: typeof TYPES.COMPONENT, name: "mdmEditor/EditModal/EditForm", plugin: React.FC<EntityEditModalEditForm>, params?: {
+        condition: (props: EntityEditModalEditForm) => boolean;
+    }): void;
+    register(type: typeof TYPES.COMPONENT, name: "documentUpload/Filters", plugin: React.FC<CategoryFilterProps>, params?: {
+        condition: (props: CategoryFilterProps) => boolean;
+    }): void;
+    register(type: typeof TYPES.COMPONENT, name: "entityDocuments/TypeLabel", plugin: React.FC<EntityDocumentsTypeLabelProps>, params?: {
+        condition: (props: EntityDocumentsTypeLabelProps) => boolean;
+    }): void;
+    register(type: typeof TYPES.COMPONENT, name: "entityDocuments/Document", plugin: React.FC<EntityDocumentsDocumentProps>, params?: {
+        condition: (props: EntityDocumentsDocumentProps) => boolean;
+    }): void;
+    register(type: typeof TYPES.COMPONENT, name: "entityDocuments/DocumentLabel", plugin: React.FC<EntityDocumentsDocumentLabelProps>, params?: {
+        condition: (props: EntityDocumentsDocumentLabelProps) => boolean;
+    }): void;
+    get(type: keyof typeof plugins, name?: string): Record<string, any> | undefined;
+    getAll(type: keyof typeof plugins): Record<string, Record<string, any>>;
+    upload: {
+        promptIcosUpload: (params: {
+            multiple?: boolean;
+            accept?: string;
+            caseOid?: string;
+            taskOid?: string;
+            entityOid?: string;
+            type?: import("../Inodes/types").InodeType;
+            properties?: any;
+            types?: import("../Inodes/types").InodeType[];
+        }) => Promise<null>;
+        uploadIcosFiles: (params: {
+            files: File[];
+            caseOid?: string;
+            taskOid?: string;
+            entityOid?: string;
+            fileProps?: Record<string, any>;
+            fileInodes?: Inode[];
+            types: import("../Inodes/types").InodeType[];
+        }) => Promise<null>;
+        updateBinary: (inodeOid: string, file: File, getUpdatedItem?: (file: File) => File) => Promise<null>;
+    };
+    actions: {
+        getActions: (items: SupportedItem[], extraActions?: ActionDefinition[], extraActionParams?: Record<string, any>) => Action[];
+        triggerItems: (items: SupportedItem[], target?: keyof typeof TRIGGER_TARGET) => void;
+        getAction: (actionId: string, itemArray: SupportedItem[]) => false | (() => void) | undefined;
+        TYPES: {
+            APP: {
+                readonly OPEN: "OPEN";
+                readonly OPEN_IN_NEW_TAB: "OPEN_IN_NEW_TAB";
+                readonly OPEN_IN_NEW_WINDOW: "OPEN_IN_NEW_WINDOW";
+                readonly OPEN_EACH_IN_NEW_WINDOW: "OPEN_EACH_IN_NEW_WINDOW";
+                readonly OPEN_EACH_IN_NEW_TAB: "OPEN_EACH_IN_NEW_TAB";
+                readonly DEV_DETAILS: "DETAILS";
+                readonly DETAILS: "DETAILS";
+                readonly SEND_LINK_BY_EMAIL: "SEND_LINK_BY_EMAIL";
+            };
+            CASE: {
+                readonly REOPEN: "CASE_REOPEN";
+                readonly CANCEL: "CASE_CANCEL";
+                readonly SUSPEND: "CASE_SUSPEND";
+                readonly COMPLETE: "CASE_COMPLETE";
+                readonly REACTIVATE: "CASE_REACTIVATE";
+                readonly RESTART: "CASE_RESTART";
+                readonly CREATE_AD_HOC_PROCESS: "CREATE_AD_HOC_PROCESS";
+                readonly OPEN_DOSSIER: "OPEN_DOSSIER";
+                readonly GENERATE_CASE_REPORT: "GENERATE_CASE_REPORT";
+                readonly SHOW_TIMELINE: "SHOW_TIMELINE";
+                readonly ADD_COMMENT: "CASE_ADD_COMMENT";
+            };
+            TASK: {
+                readonly CLAIM_TASK: "CLAIM_TASK";
+                readonly RELEASE_TASK: "RELEASE_TASK";
+                readonly DELEGATE_TASK: "DELEGATE_TASK";
+                readonly ASSIGN_TASK: "ASSIGN_TASK";
+                readonly ADD_COMMENT: "TASK_ADD_COMMENT";
+            };
+            INODE: {
+                readonly MARK_AS_FAVORITE: "INODE_MARK_AS_FAVORITE";
+                readonly MARK_AS_UNFAVORITE: "INODE_MARK_AS_UNFAVORITE";
+                readonly RENAME: "INODE_RENAME";
+                readonly OPEN_CASE: "OPEN_CASE";
+                readonly DUPLICATE: "INODE_DUPLICATE";
+                readonly CREATE_LINK: "INODE_CREATE_LINK";
+                readonly DOWNLOAD: "INODE_DOWNLOAD";
+                readonly EDIT: "INODE_EDIT";
+                readonly SCAN: "SCAN_FILE";
+                readonly PDFTRON_PRINT: "INODE_PDFTRON_PRINT";
+                readonly PDFTRON_PRINT_MERGE: "INODE_PDFTRON_PRINT_MERGE";
+                readonly UPDATE: "INODE_UPDATE";
+                readonly WATCH: "INODE_WATCH";
+                readonly UNWATCH: "INODE_UNWATCH";
+                readonly ADD_FILE: "INODE_ADD_FILE";
+                readonly ADD_FOLDER: "INODE_ADD_FOLDER";
+                readonly ADD_COMMENT: "INODE_ADD_COMMENT";
+                readonly RESTORE: "INODE_RESTORE";
+                readonly COMPOSE: "INODE_COMPOSE";
+                readonly QUICK_LOOK: "INODE_QUICK_LOOK";
+                readonly QUICK_LOOK_MERGE: "INODE_QUICK_LOOK_MERGE";
+                readonly CREATE_CASE: "INODE_CREATE_CASE";
+                readonly MERGE_PDF: "INODE_MERGE_PDF";
+                readonly CREATE_NEW_TASK: "INODE_CREATE_NEW_TASK";
+                readonly DELETE: "INODES_DELETE";
+                readonly ADD_TO_DROP_ZONE: "INODES_ADD_TO_DROP_ZONE";
+                readonly LINK_FROM_DROP_ZONE: "INODES_LINK_FROM_DROP_ZONE";
+                readonly COPY_FROM_DROP_ZONE: "INODES_COPY_FROM_DROP_ZONE";
+                readonly MOVE_FROM_DROP_ZONE: "INODES_MOVE_FROM_DROP_ZONE";
+                readonly REMOVE_FROM_DROP_ZONE: "INODES_REMOVE_FROM_DROP_ZONE";
+                readonly EXPAND_ALL_CHILDREN: "EXPAND_ALL_CHILDREN";
+                readonly DETAILS: "INODES_DETAILS";
+            };
+        };
+        GROUPS: {
+            readonly EDIT_ELEMENT: "EDIT_ELEMENT";
+            readonly EXTRA_ACTION: "EXTRA_ACTION";
+            readonly FOLDER_OPTIONS: "FOLDER_OPTIONS";
+            readonly LINK_TO_OTHER: "LINK_TO_OTHER";
+            readonly EDIT_GLOBAL: "EDIT_GLOBAL";
+            readonly ADMIN: "ADMIN";
+            readonly OTHER: "OTHER";
+            readonly DROPZONE: "DROPZONE";
+            readonly SEARCH: "SEARCH";
+        };
+    };
+}
+export { TYPES };
+export default PluginRegistry;

package/core/providers/Plugins/types/ccm.d.ts

@@ -0,0 +1,4 @@
+export type Definition = {
+    name: string;
+    [key: string]: unknown;
+};

package/core/providers/Plugins/types/componentPlugins.d.ts

@@ -0,0 +1,61 @@
+import { ReactNode } from "react";
+import { Inode } from "../../Inodes/types";
+import { Entity } from "../../MdmGraph/types";
+import { Definition } from "./ccm";
+export type ComponentPluginProps<P> = P & {
+    defaultRender: (props?: Partial<P>) => JSX.Element;
+};
+export type MdmEditorEntityRowActionsProps = ComponentPluginProps<{
+    isDisabled: boolean;
+    isEditable: boolean;
+    isDeletable: boolean;
+    entity: Entity;
+    taskOid: string;
+    definition: any;
+}>;
+export type EntityEditModalEditForm = ComponentPluginProps<{
+    definition: Definition;
+    entity: Entity;
+    children: ReactNode;
+}>;
+export type EntityDocumentsDocumentProps = ComponentPluginProps<{
+    document: Inode<"dms-core.File">;
+    disabled: boolean;
+    identifier?: string;
+    taskOid?: string;
+    caseOid?: string;
+    entityOid?: string;
+}>;
+export type EntityDocumentsDocumentLabelProps = ComponentPluginProps<{
+    document: Inode<"dms-core.File">;
+    canDrag: boolean;
+    disabled: boolean;
+    identifier?: string;
+    taskOid?: string;
+    caseOid?: string;
+    entityOid?: string;
+}>;
+export type CategoryFilterProps = ComponentPluginProps<{
+    documents: {
+        [entityOid: string]: Inode<"dms-core.File">[];
+    };
+    setDocuments: (documents: {
+        [entityOid: string]: Inode<"dms-core.File">[];
+    }) => void;
+}>;
+export type EntityDocumentsTypeLabelProps = ComponentPluginProps<{
+    label: string;
+    disabled: boolean;
+    isRequired: boolean;
+    identifier?: string;
+    taskOid?: string;
+    caseOid?: string;
+    entityOid?: string;
+    type: string;
+    documents: Inode<"dms-core.File">[];
+}>;
+export type EntitiesWrapperProps = ComponentPluginProps<{
+    definition: Definition;
+    entitiesLength: number;
+    disabled: boolean;
+}>;

package/core/providers/Search/actions.d.ts

@@ -0,0 +1,62 @@
+export function search(query: any, params?: {}): {
+    type: string;
+    payload: {
+        query: any;
+        params: {};
+    };
+};
+export function searchSuccess(results: any, query: any): {
+    type: string;
+    payload: {
+        results: any;
+        query: any;
+    };
+};
+export function searchError(error: any, query: any): {
+    type: string;
+    payload: {
+        query: any;
+    };
+    error: any;
+};
+export function clearResults(loading?: boolean): {
+    type: string;
+    payload: {
+        loading: boolean;
+    };
+};
+export function clearError(): {
+    type: string;
+};
+export function reset(): {
+    type: string;
+};
+export function setRowsStatus(itemOids: any, status: any): {
+    type: string;
+    payload: {
+        itemOids: any;
+        status: any;
+    };
+};
+export function deleteRows(itemOids: any): {
+    type: string;
+    payload: {
+        itemOids: any;
+    };
+};
+/**
+ * @param {{
+ *  caseOid: string,
+ *  taskOid?: string,
+ * }} props
+ */
+export function setDirty({ caseOid, taskOid }: {
+    caseOid: string;
+    taskOid?: string;
+}): {
+    type: string;
+    payload: {
+        caseOid: string;
+        taskOid: string | undefined;
+    };
+};

package/core/providers/Search/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const SEARCH = "imtf/Search/SEARCH";
+export declare const SEARCH_SUCCESS = "imtf/Search/SEARCH_SUCCESS";
+export declare const SEARCH_ERROR = "imtf/Search/SEARCH_ERROR";
+export declare const CLEAR_RESULTS = "imtf/Search/CLEAR_RESULTS";
+export declare const CLEAR_ERROR = "imtf/Search/CLEAR_ERROR";
+export declare const RESET = "imtf/Search/RESET";
+export declare const SET_ROWS_STATUS = "imtf/Search/SET_ROWS_STATUS";
+export declare const DELETE_ROWS = "imtf/Search/DELETE_ROWS";
+export declare const SET_DIRTY = "imtf/Search/SET_DIRTY";

package/core/providers/Search/hooks/useReloader.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Execute a function periodically
+ * @param {Function} fn Function to execute periodically
+ * @param {Array<Number>} [intervals] array of intervals (optional)
+ * @param {Boolean} infinite Should we repeat last interval
+ * @param {Boolean} autoStart Directly start intervalometer
+ * @param {Boolean} triggerOnBlurAndFocus Stop / restart when window is visible but blurred
+ * @param {Boolean} enabled Wether this hook should be enabled or not
+ * @returns an object containing restart and stop function
+ */
+export default function useReloader(fn: Function, intervals?: number[] | undefined, infinite?: boolean, enabled?: boolean, triggerOnBlurAndFocus?: boolean): {
+    restart: () => void;
+    stop: () => void;
+};

package/core/providers/Search/messages.d.ts

@@ -0,0 +1,7 @@
+declare const _default: {
+    singletonNavigation: {
+        id: string;
+        defaultMessage: string;
+    };
+};
+export default _default;

package/core/providers/Search/reducer.d.ts

@@ -0,0 +1,32 @@
+import { AnyAction } from "@reduxjs/toolkit";
+import { TableRow, TreeViewField } from "../../../core/containers/TreeView/types";
+import { SearchMask } from "../Definitions/types";
+import { SearchResultCapabilities } from "./types";
+export type SearchState = {
+    loading: boolean;
+    error: any;
+    results: {
+        contextName: string | undefined;
+        count: number | null;
+        head: TreeViewField[];
+        mask: SearchMask | null;
+        rows: TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: SearchResultCapabilities;
+    };
+};
+export default function searchReducer(state: SearchState | undefined, action: AnyAction): {
+    loading: any;
+    error: any;
+    results: {
+        contextName: string | undefined;
+        count: number | null;
+        head: TreeViewField[];
+        mask: SearchMask | null;
+        rows: TableRow[];
+        hasUnknowCount: boolean;
+        timestamp: number | undefined;
+        capabilities: SearchResultCapabilities;
+    };
+};

package/core/providers/Search/saga.d.ts

@@ -0,0 +1 @@
+export default function searchSaga(): Generator<import("redux-saga/effects").AllEffect<import("redux-saga/effects").ForkEffect<never>>, void, unknown>;