@imtf/dms-core 1.0.0-beta.1

package/core/providers/Cases/selectors.d.ts

@@ -0,0 +1,64 @@
+import { CaseState } from "./reducer";
+export declare const createFilesSelector: (caseOid: string) => ((state: any) => (import("../Inodes/types").Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode"> | undefined)[] | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: CaseState | undefined, resultFuncArgs_1: import("../Inodes/types").InodeState) => (import("../Inodes/types").Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode"> | undefined)[] | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: CaseState | undefined, resultFuncArgs_1: import("../Inodes/types").InodeState) => (import("../Inodes/types").Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode"> | undefined)[] | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => (import("../Inodes/types").Inode<"dms-core.Folder" | "dms-core.File" | "dms-core.Template" | "dms-core.Dossier" | "dms-core.DeniedInode"> | undefined)[] | undefined;
+    dependencies: [(state: any) => CaseState | undefined, (state: any) => import("../Inodes/types").InodeState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const allCasesInodeOidsSelector: ((state: any) => string[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: Record<string, CaseState>) => string[];
+    memoizedResultFunc: ((resultFuncArgs_0: Record<string, CaseState>) => string[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => string[];
+    dependencies: [(state: any) => Record<string, CaseState>];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const reloadCountSelector: (caseOid: string) => ((state: any) => number | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: CaseState | undefined) => number | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: CaseState | undefined) => number | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => number | undefined;
+    dependencies: [(state: any) => CaseState | undefined];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};

package/core/providers/Cases/service.d.ts

@@ -0,0 +1,92 @@
+import { AxiosRequestConfig } from "axios";
+import { FileInode } from "../Inodes/types";
+import { CaseProcess } from "./types";
+type Data = Record<string, unknown>;
+export declare const paths: Readonly<{
+    readonly case: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly relatedCases: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly create: (params?: {} | undefined) => string;
+    readonly suspend: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly complete: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly reactivate: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly restart: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly cancel: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly reopen: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly activityFlow: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly icosReports: (params?: {} | undefined) => string;
+    readonly process: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly comments: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly comment: (params?: {} | undefined) => string;
+    readonly documentGenerator: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly documentGeneratorList: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly classifications: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly createClassification: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly payload: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly adhocProcesses: (params?: {} | undefined) => string;
+    readonly documentGuidance: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly files: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly entityFiles: (params?: {
+        caseOid: string | null;
+        entityOid: string | null;
+    } | undefined) => string;
+    readonly attachFile: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly documentTypes: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly timeline: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly relatedBusinessDossiers: (params?: {
+        caseOid: string | null;
+    } | undefined) => string;
+    readonly downloadTimeline: (params?: {} | undefined) => string;
+    readonly downloadReport: (params?: {} | undefined) => string;
+    readonly milestones: (params?: {} | undefined) => string;
+}>;
+export declare function create(data: Data, config?: AxiosRequestConfig): Promise<any>;
+export declare function createProcess(caseOid: string, caseProcess: CaseProcess): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function addClassification(caseOid: string, data: Data): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function getAdHocProcesses(caseKey: string): Promise<any>;
+export declare function getFiles(caseOid: string): Promise<any[]>;
+export declare function uploadFiles(caseOid: string, files: File[], inodes: FileInode[], config?: AxiosRequestConfig): Promise<any[]>;
+export declare function createFiles(caseOid: string, entityOid: string, inodes: FileInode[]): Promise<any>;
+export declare function attachFiles(caseOid: string, inodes: FileInode[], config?: AxiosRequestConfig): Promise<any[]>;
+export {};

package/core/providers/Cases/types.d.ts

@@ -0,0 +1,143 @@
+import { List, MapOf } from "immutable";
+import { CASE, CASE_PROCESS, CASE_REF } from "../../../core/constants/kinds";
+import type { Capabilities } from "../App/types";
+import type { DossierRef, Inode } from "../Inodes/types";
+import type { Entity, Relation } from "../MdmGraph/types";
+export type ImmutableCase = MapOf<Omit<Case, "capabilities" | "classifications" | "dossierRefs"> & {
+    capabilities: MapOf<Capabilities>;
+    classifications: MapOf<{
+        kind: "acm.ClassificationList";
+        items: List<MapOf<CaseClassification>>;
+    }>;
+    dossierRefs: MapOf<{
+        kind: "acm.DossierRefList";
+        items: List<MapOf<DossierRef>>;
+    }>;
+}>;
+export type CaseClassification = {
+    kind: "acm.CaseClassification";
+    name: string;
+    label: string;
+};
+/**
+ * Kind can be either 'acm.Case' or 'acm.CaseRef'
+ * so we can easely recast Case to CaseRef
+ */
+export type CaseRef = {
+    kind: typeof CASE_REF | typeof CASE;
+    oid: Case["oid"];
+    uri: Case["uri"];
+    presentableId: Case["presentableId"];
+    definitionName: Case["definitionName"];
+    creationDate: Case["creationDate"];
+    status: Case["status"];
+    definitionLabel: string;
+    label: string;
+};
+export type ReportsList = {
+    contentType: "ReportConfig";
+    kind: null;
+    items: {
+        caseType: string;
+        contentType: "ReportConfig";
+        kind: null;
+        reportName: string;
+        templateFilename: string;
+    }[];
+};
+export type Case = {
+    kind: typeof CASE;
+    oid: string;
+    uri: string;
+    creationDate: string;
+    definitionLabel: string;
+    definitionName: string;
+    label: string;
+    businessUnit: string;
+    modificationDate: string;
+    dueDate: string | null;
+    dossierRefs: {
+        kind: "acm.DossierRefList";
+        items: DossierRef[];
+    };
+    classifications: {
+        kind: "acm.ClassificationList";
+        items: CaseClassification[];
+    };
+    presentableId: string;
+    status: "active" | "suspended" | "completed" | "canceled";
+    scope: string;
+    capabilities: Capabilities<{
+        canSuspendCase: boolean;
+        canCompleteCase: boolean;
+        canReactivateCase: boolean;
+        canRestartCase: boolean;
+        canCancelCase: boolean;
+        canReopenCase: boolean;
+        canEditPayload: boolean;
+        canCreateADHocProcess: boolean;
+        canGenerateReport: boolean;
+        canViewPanels: string[];
+        canSendLinkByEmail: boolean;
+    }>;
+    milestones: {
+        color: string;
+        createdBy: string;
+        creationDate: string;
+        label: string;
+        milestone: string;
+    }[];
+    outcome: {
+        kind: "acm.CaseOutcome";
+        label: string;
+        name: string;
+    } | null;
+};
+/**
+ * Case object returned by useCase hook
+ */
+export interface CaseObject {
+    item: Case | undefined;
+    status: "loading" | "idle" | "error";
+    activityFlow?: any;
+    documents: {
+        status: string;
+        error?: any;
+        guidance?: any;
+        items?: any[];
+    };
+    error?: any;
+    graphData?: CaseData;
+    payload?: {
+        [key: string]: any;
+    };
+    reloadCount: number;
+    timeline: any;
+    [key: string]: any;
+}
+export type CaseProcess = {
+    kind: typeof CASE_PROCESS;
+    key: string;
+    formName?: string;
+    comment: string;
+    parameters: Record<string, unknown>;
+};
+export type CaseData = {
+    contextObjectOid: string | null;
+    entities: {
+        [oid: string]: Entity;
+    };
+    inode?: Inode;
+    inodeOid?: string;
+    relations: {
+        [oid: string]: Relation;
+    };
+};
+export type CasePayload = Record<string, any>;
+export type MilestonesList = {
+    milestones: {
+        color: string;
+        label: string;
+        milestone: string;
+    }[];
+};

package/core/providers/Cases/utils/can.d.ts

@@ -0,0 +1,14 @@
+declare const can: Readonly<{
+    suspend(caze: unknown): boolean;
+    complete(caze: unknown): boolean;
+    reactivate(caze: unknown): boolean;
+    restart(caze: unknown): boolean;
+    cancel(caze: unknown): boolean;
+    reopen(caze: unknown): boolean;
+    editPayload(caze: unknown): boolean;
+    createAdHocProcess(caze: unknown): boolean;
+    generateReport(caze: unknown): boolean;
+    exportTimeline(caze: unknown): caze is import("../types").Case | import("../types").ImmutableCase;
+    viewPanels<K extends string | undefined = undefined>(caze: unknown, panelKey?: K): K extends string ? boolean : string[];
+}>;
+export default can;

package/core/providers/Cases/utils/common.d.ts

@@ -0,0 +1,10 @@
+export function getDossierRefUrl(caze: any): string;
+export function getReportUrl({ templateName, caseId, encryptedToken, language, }: {
+    templateName: any;
+    caseId: any;
+    encryptedToken: any;
+    language: any;
+}): string;
+export function getCaseOidFromItem(item: unknown): string | undefined;
+export function getCasePayloadEditorActions(caze: any): Promise<any>;
+export function getDownloadCaseTimelineUrl(caseId: any, encryptedToken: any): string;

package/core/providers/Cases/utils/isCase.d.ts

@@ -0,0 +1,5 @@
+import { BusinessProcessCaseRef } from "../../Inodes/types";
+import { Case, ImmutableCase } from "../types";
+export default function isCase(item: unknown): item is Case;
+export declare function isBusinessProcessCaseRef(item: unknown): item is BusinessProcessCaseRef;
+export declare function isImmutableCase(item: unknown): item is ImmutableCase;

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

@@ -0,0 +1,50 @@
+export declare const FILTERS: {
+    readonly ALL: "ALL";
+    readonly LAST_30_DAYS: "LAST_30_DAYS";
+    readonly LAST_60_DAYS: "LAST_60_DAYS";
+    readonly DATE_RANGE: "DATE_RANGE";
+};
+export declare const MODAL_TYPES: {
+    readonly FIND_IT: "imtf/CCM/modal/FIND_IT";
+    readonly AML_ALERTS: "imtf/CCM/modal/AML_ALERTS";
+    readonly ADHOC_SCREENING: "imtf/CCM/modal/ADHOC_SCREENING";
+    readonly EDIT_CLIENT_GROUP: "imtf/CCM/modal/EDIT_CLIENT_GROUP";
+    readonly ADD_MEMBER_TO_CLIENT_GROUP: "imtf/CCM/modal/ADD_MEMBER_TO_CLIENT_GROUP";
+    readonly ENTITY_RISK_HISTORY: "imtf/CCM/modal/ENTITY_RISK_HISTORY";
+    readonly DATAVISUALIZER: "imtf/CCM/modal/DATAVISUALIZER";
+};
+export declare const INSPECTORS: {
+    CASE_FIND_IT: string;
+    CASE_AML_ALERTS: string;
+    CASE_IMATCH_ALERTS: string;
+    CASE_CLIENTS: string;
+    CLIENT_GROUP_TIMELINE: string;
+    HOUSEHOLD_TIMELINE: string;
+};
+export type CCMRelationType = "NATURAL_PERSON_HAS_CCM_RISK" | "LEGAL_ENTITY_HAS_CCM_RISK" | "SCENARIO_HAS_TRANSACTION" | "ACCOUNT_HAS_TRANSACTION" | "AMLALERT_HAS_SCENARIO" | "NATURAL_PERSON_HAS_AMLALERT" | "LEGAL_ENTITY_HAS_AML_ALERT";
+export declare const ENTITY_TYPES: {
+    readonly ACCOUNT: "Account";
+    readonly AML_ALERT: "AmlAlert";
+    readonly HOUSEHOLD: "Household";
+    readonly SCENARIO: "Scenario";
+    readonly LEGAL_ENTITY: "LegalEntity";
+    readonly NATURAL_PERSON: "NaturalPerson";
+    readonly CLIENT_GROUP: "ClientGroup";
+    readonly PROSPECT_ENTITY: "Prospect";
+    readonly TRANSACTION: "Transaction";
+    readonly CCM_RISK: "CcmRisk";
+    readonly NATURAL_PERSON_RISK_FACTORS: "NaturalPersonRiskFactors";
+    readonly NATURAL_PERSON_RISK_PARAMETERS: "NaturalPersonRiskParameters";
+    readonly IMATCH_ALERT: "IMatchAlert";
+    readonly IMATCH_WATCHLIST_DOCUMENT: "IMatchWatchlistDocument";
+    readonly IMATCH_WATCHLIST_DOCUMENT_TRANSLATION: "IMatchWatchlistDocumentTranslation";
+    readonly IMATCH_WATCHLIST_ENTRY: "IMatchWatchlistEntry";
+    readonly IMATCH_WATCHLIST_DOCUMENT_ASSOCIATED_ENTITY: "IMatchWatchlistDocumentAssociatedEntity";
+    readonly IMATCH_CASE: "IMatchCase";
+    readonly ACCOUNT_RISK_FACTORS: "AccountRiskFactors";
+    readonly ACCOUNT_RISK_PARAMETERS: "AccountRiskParameters";
+    readonly LEGAL_ENTITY_RISK_FACTORS: "LegalEntityRiskFactors";
+    readonly LEGAL_ENTITY_RISK_PARAMETERS: "LegalEntityRiskParameters";
+};
+export declare const EXTERNAL_TRANSACTIONS_API_TIMEOUT_MS = 15000;
+export declare const EXTERNAL_TRANSACTIONS_LINES_TO_DISPLAY = 200;

package/core/providers/Ccm/types.d.ts

@@ -0,0 +1,137 @@
+import { Entity, EntityData, Relation } from "../MdmGraph/types";
+import { ENTITY_TYPES } from "./constants";
+export type EntityType = (typeof ENTITY_TYPES)[keyof typeof ENTITY_TYPES];
+export type AlertEntity = Entity<typeof ENTITY_TYPES.AML_ALERT, {
+    amlAlertDate: string;
+    amlAlertScore: number;
+    amlAlertUnderMonitoring: boolean;
+}>;
+export type ScenarioEntity = Entity<typeof ENTITY_TYPES.SCENARIO, {
+    scenarioScore: number;
+    scenarioDescription: string;
+}>;
+export type TransactionEntity = Entity<typeof ENTITY_TYPES.TRANSACTION, {
+    transactionEntryDate: string;
+    transactionAmountOrigin: number;
+    transactionAmount: number;
+    transactionCurrency: string;
+    transactionGlobalCurrency: string;
+    transactionContraAccountNumber: string;
+    transactionIsInbound: boolean;
+}>;
+/** Export an  */
+export type CcmEntity<Type extends string = string, Data extends EntityData = EntityData> = Entity<Type, Data> & {
+    data: {
+        businessId: string;
+        tenantId: string;
+    } & Data;
+    displayData: {
+        businessId: string;
+        tenantId: string;
+    } & Data;
+};
+export interface CcmGroupEntity extends CcmEntity<typeof ENTITY_TYPES.CLIENT_GROUP, {
+    name: string;
+    description?: string;
+    riskLevel: string;
+}> {
+    capabilities: {
+        canAddClient: boolean;
+        canRemoveClient: boolean;
+    } & Entity["capabilities"];
+}
+export type CcmClientEntity = CcmEntity<typeof ENTITY_TYPES.LEGAL_ENTITY | typeof ENTITY_TYPES.NATURAL_PERSON>;
+export type CcmAccountEntity = CcmEntity<typeof ENTITY_TYPES.ACCOUNT>;
+export type CcmHouseholdEntity = CcmEntity<typeof ENTITY_TYPES.HOUSEHOLD, {
+    name: string;
+    description: string;
+    riskLevel: string;
+}> & {
+    capabilities: {
+        canAddClient: boolean;
+        canRemoveClient: boolean;
+    } & Entity["capabilities"];
+};
+export type CcmRiskEntity = CcmEntity<typeof ENTITY_TYPES.CCM_RISK, {
+    manualRiskLevel?: string;
+    manualRiskLevelUpdatedBy?: string;
+    manualRiskLevelUpdatedAt?: string;
+    lastCalculationDate?: string;
+    riskLevel?: string;
+    riskScore: number;
+}>;
+export type RelatedPersonsData = {
+    extras: {
+        risk: CcmRiskEntity;
+    };
+    person: CcmClientEntity;
+    relationship: Relation;
+};
+export type IMatchCaseEntity = CcmEntity<typeof ENTITY_TYPES.IMATCH_CASE, {
+    birthLocation: string[];
+    customerCategory: string;
+    firstName: string;
+    lastSuccessfulScreeningDate: string;
+    listOriginIds: string[];
+    name: string;
+    originId: string;
+    screeningSource: string;
+    yearOfBirth: string;
+}>;
+export type IMatchAlertEntity = CcmEntity<typeof ENTITY_TYPES.IMATCH_ALERT, {
+    aliasOriginId: string;
+    aliases: string[];
+    birthDate: string[];
+    birthLocation: string[];
+    categories: string[];
+    externalLinks: string[];
+    firstName: string;
+    furtherInformation: string;
+    gender: string;
+    hitName: string;
+    idNumbers: string[];
+    isAlive: boolean;
+    keywords: string[];
+    linkedTo: string[];
+    listName: string;
+    locations: string[];
+    name: string;
+    nationalities: string[];
+    originId: string;
+    personType: string;
+    positions: string[];
+    recordCreatedAt: string;
+    recordLastModifiedAt: string;
+    recordStoredAt: string;
+    score: string;
+    screenedDate: string;
+    watchListType: string;
+    isProcessed: boolean;
+    isAdhoc: boolean;
+}>;
+export type IMatchWatchlistEntryEntity = CcmEntity<typeof ENTITY_TYPES.IMATCH_WATCHLIST_ENTRY, {
+    identification: string;
+}>;
+export type IMatchWatchlistDocumentEntity = CcmEntity<typeof ENTITY_TYPES.IMATCH_WATCHLIST_DOCUMENT, {
+    associatedEntities: string[];
+    categories: string[];
+    creationDate: string;
+    documentEntryId: string;
+    evaluation: string;
+    evaluationAction: string;
+    evaluationComments: string;
+    language: string;
+    providerSource: string;
+    publicationDate: string;
+    text: string;
+    title: string;
+    url: string;
+    watchListOriginId: string;
+}>;
+export type IMatchWatchlistDocumentTranslationEntity = CcmEntity<typeof ENTITY_TYPES.IMATCH_WATCHLIST_DOCUMENT_TRANSLATION, Pick<IMatchWatchlistDocumentEntity["data"], "language" | "text" | "title">>;
+export type IMatchWatchlistDocumentAssociatedEntity = CcmEntity<typeof ENTITY_TYPES.IMATCH_WATCHLIST_DOCUMENT_ASSOCIATED_ENTITY, {
+    name: string;
+    legalStatus: string;
+    legalState: string;
+    originId: string;
+}>;

package/core/providers/Ccm/utils/isAccount.d.ts

@@ -0,0 +1,4 @@
+import { ImmutableEntity } from "../../MdmGraph/types";
+import { CcmAccountEntity } from "../types";
+export declare function isImmutableAccount(entity: unknown): entity is ImmutableEntity;
+export declare function isCcmAccountEntity(entity: unknown): entity is CcmAccountEntity;

package/core/providers/Ccm/utils/isClient.d.ts

@@ -0,0 +1,4 @@
+import { ImmutableEntity } from "../../MdmGraph/types";
+import { CcmClientEntity } from "../types";
+export declare function isImmutableClient(entity: unknown): entity is ImmutableEntity;
+export declare function isCcmClientEntity(entity: unknown): entity is CcmClientEntity;

package/core/providers/Ccm/utils/isClientGroup.d.ts

@@ -0,0 +1,4 @@
+import { ImmutableEntity } from "../../MdmGraph/types";
+import { CcmGroupEntity } from "../types";
+export declare function isImmutableClientGroup(entity: unknown): entity is ImmutableEntity;
+export default function isClientGroup(entity: unknown): entity is CcmGroupEntity;

package/core/providers/Ccm/utils/isHouseholdEntity.d.ts

@@ -0,0 +1,4 @@
+import { ImmutableEntity } from "../../MdmGraph/types";
+import { CcmHouseholdEntity } from "../types";
+export declare function isImmutableHousehold(entity: unknown): entity is ImmutableEntity;
+export declare function isHouseholdEntity(entity: unknown): entity is CcmHouseholdEntity;

package/core/providers/Definitions/service.d.ts

@@ -0,0 +1,30 @@
+export declare const paths: Readonly<{
+    readonly inodeTypes: (params?: {} | undefined) => string;
+    readonly formDefinitions: (params?: {} | undefined) => string;
+    readonly formDefinition: (params?: {
+        formName: string | null;
+    } | undefined) => string;
+    readonly questionnaireDefinitions: (params?: {} | undefined) => string;
+    readonly mdmEditorDefinitions: (params?: {} | undefined) => string;
+    readonly caseDefinitions: (params?: {} | undefined) => string;
+    readonly taskDefinitions: (params?: {} | undefined) => string;
+    readonly inspectorDefinitions: (params?: {} | undefined) => string;
+    readonly documentUploadDefinitions: (params?: {} | undefined) => string;
+    readonly processDefinitions: (params?: {} | undefined) => string;
+    readonly searchMaskDefinitions: (params?: {} | undefined) => string;
+    readonly searchContextDefinitions: (params?: {} | undefined) => string;
+    readonly codetype: (params?: {
+        key: string | null;
+    } | undefined) => string;
+    readonly formText: (params?: {
+        key: string | null;
+    } | undefined) => string;
+    readonly datasourceData: (params?: {
+        value: string | null;
+        datasourceName: string | null;
+    } | undefined) => string;
+    readonly datasourceSearch: (params?: {
+        datasourceName: string | null;
+    } | undefined) => string;
+    readonly propertyGroupByType: (params?: {} | undefined) => string;
+}>;