@imtf/dms-core 1.0.0-beta.1

package/core/providers/Search/utils/createQuery.d.ts

@@ -0,0 +1,26 @@
+import { QueryParams } from "../types";
+export default function createQuery({ searchContextName, searchParams, queryResource, limit, offset, rootOid, highlight, }: QueryParams): {
+    kind: string;
+    searchContextName: string;
+    statistics: boolean;
+    queryResource: {
+        query?: string | undefined;
+        kind: string;
+        startNodeOid: string | undefined;
+    };
+    ordering: {
+        kind: string;
+        field: string;
+        direction: string;
+    }[] | undefined;
+    pagination: {
+        kind: string;
+        offset: number;
+        limit: number;
+    };
+    highlight: {
+        kind: string;
+        snippets: number;
+        field: string;
+    } | undefined;
+};

package/core/providers/Search/utils/sanitizeUrlSearchParams.d.ts

@@ -0,0 +1 @@
+export declare function sanitizeUrlSearchParams(searchParams: URLSearchParams): URLSearchParams;

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

@@ -0,0 +1,3 @@
+export declare const NOTIFICATION_DURATION = 4;
+export declare const SYS_NOTIFICATION_CONTAINER_ID = "system.notifications";
+export declare const SYS_NOTIFICATION_CONTAINER_ID_BANNER = "system.notifications.banner";

package/core/providers/SystemNotification/slice.d.ts

@@ -0,0 +1,9 @@
+import { SystemNotification } from "./type";
+export type SystemNotificationState = {
+    snackBar: SystemNotification | undefined;
+};
+export declare const notify: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[message: import("react").ReactNode, type?: "error" | "warning" | "info" | "success" | undefined, params?: Omit<SystemNotification, "oid" | "type" | "message"> | undefined], {
+    notification: SystemNotification;
+}, "systemNotification/notify", never, never>;
+declare const _default: import("redux").Reducer<SystemNotificationState>;
+export default _default;

package/core/providers/SystemNotification/useSystemNotification.d.ts

@@ -0,0 +1,6 @@
+import { Id, ToastContent, ToastOptions, UpdateOptions } from "react-toastify";
+declare const useSystemNotification: () => {
+    notify: (message: ToastContent, options: ToastOptions) => Id;
+    updateNotification: (tastId: Id, options: UpdateOptions) => void;
+};
+export default useSystemNotification;

package/core/providers/Tasks/Context.d.ts

@@ -0,0 +1,10 @@
+import { UpdateHighlightMode } from "./types";
+export type TasksContext = {
+    taskDataHistoryFrom: {
+        mode: UpdateHighlightMode;
+        fromDate: string | null;
+    } | undefined;
+    setTaskDataHistoryFrom: (mode: UpdateHighlightMode, fromDate: string | null) => void;
+};
+declare const TasksContext: import("react").Context<TasksContext>;
+export default TasksContext;

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

@@ -0,0 +1,70 @@
+import type { EventFilter } from "../App/types";
+export declare const COMPLETE = "imtf/Tasks/COMPLETE";
+export declare const COMPLETE_SUCCESS = "imtf/Tasks/COMPLETE_SUCCESS";
+export declare const COMPLETE_ERROR = "imtf/Tasks/COMPLETE_ERROR";
+export declare const REVIEW = "imtf/Tasks/REVIEW";
+export declare const REVIEW_SUCCESS = "imtf/Tasks/REVIEW_SUCCESS";
+export declare const REVIEW_ERROR = "imtf/Tasks/REVIEW_ERROR";
+export declare const GET_TASK_ENTITIES_HISTORY = "imtf/Tasks/GET_TASK_ENTITIES_HISTORY";
+export declare const CLAIM_TASK = "imtf/Tasks/CLAIM_TASK";
+export declare const CLAIM_TASK_SUCCESS = "imtf/Tasks/CLAIM_TASK_SUCCESS";
+export declare const CLAIM_TASK_ERROR = "imtf/Tasks/CLAIM_TASK_ERROR";
+export declare const RELEASE_TASK = "imtf/Tasks/RELEASE_TASK";
+export declare const RELEASE_TASK_SUCCESS = "imtf/Tasks/RELEASE_TASK_SUCCESS";
+export declare const RELEASE_TASK_ERROR = "imtf/Tasks/RELEASE_TASK_ERROR";
+export declare const CLEAN = "imtf/Tasks/CLEAN";
+export declare const SEARCH_CONTEXT_NAME = "tasks";
+export declare const TASK_TYPES: {
+    readonly QUESTIONNAIRE: "questionnaire";
+    readonly AML_QUALIFICATION: "aml_qualification";
+    readonly TODO: "todo";
+    readonly DOCUMENTS: "documents";
+    readonly DOCUMENTS_FILING: "documents_filing";
+    readonly DOCUMENTS_APPROVAL: "documents_approval";
+};
+export declare const FORM_TYPES: {
+    readonly MDM_EDITOR: "mdmEditor";
+    readonly CONTEXT_MDM_EDITOR: "contextEntityEditor";
+    readonly DOCUMENT_UPLOAD: "documentUpload";
+    readonly AML_QUALIFICATION: "aml_qualification";
+    readonly DISPLAY_TEXT: "displayText";
+    readonly PLUGIN: "plugin";
+    readonly ADVERSE_MEDIA: "adverseMedia";
+    readonly RISK_ASSESSMENT: "riskAssessment";
+};
+export declare const MODAL_TYPES: {
+    readonly DELEGATE_TASK: "imtf/Tasks/modal/DELEGATE_TASK";
+    readonly ASSIGN_TASK: "imtf/Tasks/modal/ASSIGN_TASK";
+    readonly TIMELINE: "imtf/Tasks/modal/TIMELINE";
+};
+export declare const INSPECTORS: {
+    TASK_DETAILS: string;
+    TASK_TIMELINE: string;
+    TASK_DATA: string;
+    TASK_DATAVISUALIZER: string;
+    TASK_COMMENTS: string;
+};
+export declare const ACTIONS: {
+    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";
+};
+export declare const OUTCOME_TYPES: {
+    readonly OK: "ok";
+    readonly NOK: "nok";
+};
+export declare const STATE_TYPES: {
+    readonly COMPLETED: "completed";
+    readonly OPEN: "open";
+    readonly ACTIVE: "active";
+    readonly CANCELED: "canceled";
+    readonly SUSPENDED: "suspended";
+    readonly REVIEW: "review";
+    readonly DELETED: "deleted";
+    readonly UNKNOW: "unknow";
+    readonly REVIEWED: "reviewed";
+};
+export declare const DOCUMENT_TASK_TYPES: ("documents" | "documents_filing" | "documents_approval")[];
+export declare const EVENT_FILTERS: Readonly<EventFilter[]>;

package/core/providers/Tasks/hooks/useEntitiesMutate.d.ts

@@ -0,0 +1,15 @@
+import { AxiosError } from "axios";
+import { Key } from "swr";
+import { Entity } from "../../MdmGraph/types";
+export type Params = {
+    triggerQuestionnaireReload?: boolean;
+    triggerTaskDataReload?: boolean;
+};
+declare const useEntitiesMutate: (taskOid: string) => import("swr/mutation").SWRMutationResponse<{
+    entities?: Entity[];
+    params?: Params;
+}, AxiosError<unknown, any>, Key, {
+    entities: Entity[];
+    params?: Params;
+}>;
+export default useEntitiesMutate;

package/core/providers/Tasks/hooks/useEntityDelete.d.ts

@@ -0,0 +1,17 @@
+import { AxiosError } from "axios";
+import { Key } from "swr";
+type Params = {
+    triggerTaskDataReload?: boolean;
+    triggerQuestionnaireReload?: boolean;
+} & {
+    entityOid: string;
+};
+declare const useEntityDelete: (taskOid: string) => {
+    deleteEntity: (entityOid: string, params: Omit<Params, "entityOid">) => Promise<unknown>;
+    isMutating: boolean;
+    trigger: import("swr/mutation").TriggerWithArgs<string, AxiosError<unknown, any>, Key, Params>;
+    reset: () => void;
+    error: AxiosError<unknown, any> | undefined;
+    data: string | undefined;
+};
+export default useEntityDelete;

package/core/providers/Tasks/hooks/useEntityMutate.d.ts

@@ -0,0 +1,31 @@
+import { AxiosError } from "axios";
+import { Entity, EntityData, Relation } from "../../MdmGraph/types";
+export type Params = {
+    attach?: {
+        targetEntityOid: string;
+        relationName: string;
+        direction: "in" | "out";
+    };
+    triggerQuestionnaireReload?: boolean;
+    triggerTaskDataReload?: boolean;
+    immediate?: boolean;
+};
+type TriggerParams = {
+    entity: Entity & {
+        __creationOid?: string;
+    };
+    data?: EntityData;
+    params?: Params;
+};
+declare const useEntityMutate: (taskOid: string) => {
+    trigger: (entity: Entity, patchData?: EntityData, params?: Params) => Promise<void>;
+    isMutating: boolean;
+    reset: () => void;
+    error: AxiosError<unknown, any> | undefined;
+    data: {
+        entity?: TriggerParams["entity"];
+        relation?: Relation;
+        params?: TriggerParams["params"];
+    } | undefined;
+};
+export default useEntityMutate;

package/core/providers/Tasks/hooks/useQuestionnaire.d.ts

@@ -0,0 +1,4 @@
+import { SWRConfiguration } from "swr";
+import { QuestionnaireDefinition } from "../types";
+declare const useQuestionnaire: (taskOid: string | undefined, swrConfig?: SWRConfiguration) => import("swr").SWRResponse<QuestionnaireDefinition, any, SWRConfiguration<QuestionnaireDefinition, any, import("swr").BareFetcher<QuestionnaireDefinition>> | undefined>;
+export default useQuestionnaire;

package/core/providers/Tasks/hooks/useTask.d.ts

@@ -0,0 +1,3 @@
+import { Task } from "../types";
+declare const useTask: (taskOid: string | undefined) => import("swr").SWRResponse<Task, any, any>;
+export default useTask;

package/core/providers/Tasks/hooks/useTaskData.d.ts

@@ -0,0 +1,5 @@
+import { BareFetcher, SWRConfiguration } from "swr";
+import { Entity } from "../../MdmGraph/types";
+import { TaskData } from "../types";
+declare const useTaskData: <EntityType extends Entity>(taskOid: string | undefined, config?: SWRConfiguration) => import("swr").SWRResponse<TaskData<EntityType>, any, SWRConfiguration<TaskData<EntityType>, any, BareFetcher<TaskData<EntityType>>> | undefined>;
+export default useTaskData;

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

@@ -0,0 +1,71 @@
+import { HUMAN_TASK_OUTCOME } from "../../../core/constants/kinds";
+export declare const paths: Readonly<{
+    readonly get: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly complete: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly reviewApprove: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly reviewDisapprove: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly questionnaire: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly validate: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly claim: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly release: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly delegate: (params?: {
+        username: string | null;
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly bulkAssign: (params?: {} | undefined) => string;
+    readonly create: (params?: {} | undefined) => string;
+    readonly files: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly comments: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly comment: (params?: {} | undefined) => string;
+    readonly timeline: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+    readonly downloadTimeline: (params?: {
+        taskOid: string | null;
+    } | undefined) => string;
+}>;
+export declare function complete(taskOid: string, outcome: {
+    kind: typeof HUMAN_TASK_OUTCOME;
+    outcome: string;
+    data: Record<string, unknown>;
+}): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function reviewApprove(taskOid: string): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function reviewDisapprove(taskOid: string, data: {
+    comment: string;
+}): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function claim(taskOid: string): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function release(taskOid: string): Promise<import("axios").AxiosResponse<any, any>>;
+export declare function createTask(data: {
+    definitionKey: string;
+    comment: string;
+    owner: string;
+    parameters: Record<string, unknown>;
+    refs: {
+        kind: "acm.RefList";
+        items: {
+            kind: "acm.FileRef";
+            oid: string;
+            uri: string;
+        }[];
+    };
+}): Promise<any>;

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

@@ -0,0 +1,133 @@
+import { AxiosError } from "axios";
+import { FromJS } from "immutable";
+import { ACM_DATA, ERRORS, QUESTIONNAIRE_ERROR, TASK, TASK_DOCUMENT_ERRORS_LIST } from "../../../core/constants/kinds";
+import type { Capabilities, FormError } from "../App/types";
+import { CaseRef } from "../Cases/types";
+import { Inode } from "../Inodes/types";
+import { Entity, Relation } from "../MdmGraph/types";
+import { STATE_TYPES, TASK_TYPES } from "./constants";
+export type ImmutableTask = FromJS<Task>;
+export type ImmutableTaskObject = FromJS<TaskObject>;
+export type Task = {
+    kind: typeof TASK;
+    oid: string;
+    uri: string;
+    type: (typeof TASK_TYPES)[keyof typeof TASK_TYPES];
+    label: string;
+    creationDate: string;
+    modificationDate: string;
+    dueDate: string | null;
+    caseRef?: CaseRef;
+    priority: number;
+    fourEye: boolean;
+    assignee: string | null;
+    presentableId: string;
+    status: (typeof STATE_TYPES)[keyof typeof STATE_TYPES];
+    owner: string;
+    scope: string;
+    xEyesReviewers: any[];
+    capabilities: Capabilities;
+    completionOutcome: string | null;
+    completedDate: string | null;
+    followUpdate: any | null;
+    claim: string | null;
+    category: null;
+    definitionName: string;
+    definitionLabel: string;
+};
+/**
+ * Object returned by createTaskSelector
+ */
+export type TaskObject = {
+    item?: Task;
+    files?: Inode[];
+    processing: boolean;
+    validate: boolean;
+    error: AxiosError | QuestionnaireError | DocumentTaskListError | boolean;
+    graphData?: TaskData;
+};
+export type SectionError = {
+    kind: "acm.SectionError";
+    formErrors: FormError[];
+    sectionErrors: SectionError[];
+    sectionName: string;
+};
+export type QuestionnaireError = {
+    kind: typeof QUESTIONNAIRE_ERROR;
+    sectionErrors: SectionError[];
+};
+export type DocumentTask = Omit<Task, "type"> & {
+    type: "documents" | "documents_filing" | "documents_approval";
+};
+export type DocumentTaskListError = {
+    kind: typeof TASK_DOCUMENT_ERRORS_LIST;
+    errors: Array<{
+        kind: typeof ERRORS.DOCUMENT_ERROR;
+        errorDescription: string;
+        documentType: Inode["type"];
+        documentOid: Inode["oid"];
+    }>;
+};
+export type OutcomeAction = {
+    id: string;
+    label: string;
+    group: string;
+    orderingWeight: number;
+    action: () => void;
+};
+export type TaskData<EntityType = Entity> = {
+    kind: typeof ACM_DATA;
+    contextObjectOid: string | null;
+    entities: {
+        [oid: string]: EntityType;
+    };
+    relations: {
+        [oid: string]: Relation;
+    };
+    mdmScopeLock: {
+        lockedBy: string;
+    } | null;
+    inodeResource: Inode<"dms-core.File"> | null;
+};
+export type QuestionnaireForm = {
+    type: "mdmEditor" | "form" | "plugin" | "documentUpload" | "contextEntityEditor" | "aml_qualification" | "displayText" | "adverseMedia" | "riskAssessment";
+    name: string;
+    data?: any;
+    readOnly?: boolean;
+    validate?: boolean;
+};
+export type QuestionnaireFormHighlights = {
+    ancestorsOid: string[];
+    entityOid: string;
+    formName: string;
+    highlights: Array<{
+        propertyName: string;
+        type: "comments" | "updates";
+        value: number;
+    }>;
+};
+export type QuestionnaireSection = {
+    name: string;
+    entityType?: string | null;
+    entityOid?: string | null;
+    label: string;
+    forms: QuestionnaireForm[];
+    formHighlights?: QuestionnaireFormHighlights[];
+    sections?: QuestionnaireSection[];
+};
+export type UpdateHighlightMode = "NONE" | "ALL" | "FROM_DATE" | "FROM_LAST_TASK";
+export type QuestionnaireDefinition = {
+    kind: "acm.QuestionnaireDefinition";
+    name: string;
+    type: "statyc" | "dynamic";
+    sections: QuestionnaireSection[];
+    sectionFormHighlightContexts: {
+        updates?: {
+            mode: UpdateHighlightMode;
+            allowedModes: UpdateHighlightMode[];
+            currentTaskIncluded: boolean | null;
+            fromDate: string | null;
+            toDate: string | null;
+        };
+    };
+};

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

@@ -0,0 +1,21 @@
+export declare const immutableCan: Readonly<{
+    edit(task: Immutable.Map<string, any>): boolean;
+    process(task: Immutable.Map<string, any>): boolean;
+    claim(task: Immutable.Map<string, any>): boolean;
+    release(task: Immutable.Map<string, any>): boolean;
+    delegate(task: Immutable.Map<string, any>): boolean;
+    assign(task: Immutable.Map<string, any>): boolean;
+    processTaskFromActionMenu(task: Immutable.Map<string, any>): boolean;
+    viewPanels(task: Immutable.Map<string, any>, panelKey: string): boolean | unknown[];
+}>;
+declare const can: Readonly<{
+    edit(task: unknown): boolean;
+    process(task: unknown): boolean;
+    claim(task: unknown): boolean;
+    release(task: unknown): boolean;
+    delegate(task: unknown): boolean;
+    assign(task: unknown): boolean;
+    processTaskFromActionMenu(task: unknown): boolean;
+    viewPanels<K extends string | undefined = undefined>(task: unknown, panelKey?: K): K extends string ? boolean : string[];
+}>;
+export default can;

package/core/providers/Tasks/utils/isTask.d.ts

@@ -0,0 +1,5 @@
+import { BusinessProcessHumanTaskRef } from "../../Inodes/types";
+import { ImmutableTask, Task } from "../types";
+export declare function isImmutableTask(item: unknown): item is ImmutableTask;
+export declare function isBusinessProcessTaskRef(item: unknown): item is BusinessProcessHumanTaskRef;
+export default function isTask(item: unknown): item is Task;

package/core/providers/Uploader/Context.d.ts

@@ -0,0 +1,47 @@
+import { ComponentType } from "react";
+import { Inode, InodeType } from "../Inodes/types";
+export type UploadContextType = {
+    upload: (files: File[], targetInodeOid: string, fileProps: Record<string, any>) => Promise<null>;
+    icosUpload: (params: {
+        files: File[];
+        caseOid?: string;
+        taskOid?: string;
+        entityOid?: string;
+        fileProps?: Record<string, any>;
+        fileInodes?: Inode[];
+        types: InodeType[];
+    }) => Promise<null>;
+    updateBinary: (inodeOid: string, file: File, getUpdatedItem?: (file: File) => File) => Promise<null>;
+    promptGetFiles: (params: {
+        accept?: string;
+        multiple?: boolean;
+    }) => Promise<File>;
+    promptUpload: (params: {
+        multiple?: boolean;
+        accept?: string;
+        target: string;
+        expandItem?: boolean;
+        type?: InodeType;
+        properties?: any;
+    }) => Promise<null>;
+    promptUpdateBinary: (params: {
+        accept?: string;
+        target: string;
+        getUpdatedItem?: (file: File) => File;
+    }) => Promise<null>;
+    promptIcosUpload: (params: {
+        multiple?: boolean;
+        accept?: string;
+        caseOid?: string;
+        taskOid?: string;
+        entityOid?: string;
+        type?: InodeType;
+        properties?: any;
+        types?: InodeType[];
+    }) => Promise<null>;
+    processes: Record<string, any>;
+    clearCompletedProcesses: () => void;
+};
+declare const UploadContext: import("react").Context<UploadContextType>;
+export default UploadContext;
+export declare function withUploadContext<P extends Record<string, unknown>>(Comp: ComponentType<P>): (props: P) => import("react/jsx-runtime").JSX.Element;

package/core/providers/User/action.d.ts

@@ -0,0 +1,19 @@
+import { User, UserGroup } from "./types";
+export declare const getMeSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[user: User], {
+    user: User;
+}, "imtf/User/GET_ME_SUCCESS", never, never>;
+export declare const getMyGroupsSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[groups: UserGroup[]], {
+    groups: UserGroup[];
+}, "imtf/User/GET_MY_GROUPS_SUCCESS", never, never>;
+export declare const updateLocale: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[userOid: string, locale: string], {
+    userOid: string;
+    locale: string;
+}, "imtf/User/UPDATE_LOCALE", never, never>;
+export declare const updateLocaleSuccess: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[userOid: string, locale: string], {
+    userOid: string;
+    locale: string;
+}, "imtf/User/UPDATE_LOCALE_SUCCESS", never, never>;
+export declare const updateLocaleError: import("@reduxjs/toolkit").ActionCreatorWithPreparedPayload<[error: unknown, payload: object], {
+    error: unknown;
+    payload: object;
+}, "imtf/User/UPDATE_LOCALE_ERROR", never, never>;

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

@@ -0,0 +1,7 @@
+export declare const GET_ME_SUCCESS = "imtf/User/GET_ME_SUCCESS";
+export declare const GET_MY_GROUPS_SUCCESS = "imtf/User/GET_MY_GROUPS_SUCCESS";
+export declare const UPDATE_LOCALE = "imtf/User/UPDATE_LOCALE";
+export declare const UPDATE_LOCALE_SUCCESS = "imtf/User/UPDATE_LOCALE_SUCCESS";
+export declare const UPDATE_LOCALE_ERROR = "imtf/User/UPDATE_LOCALE_ERROR";
+export declare const INSPECTOR_WIDTH = 400;
+export declare const LOGIN_LOCALE = "login.locale";

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

@@ -0,0 +1,9 @@
+import { User, UserGroup } from "./types";
+export interface UserState {
+    details: User | undefined;
+    groups: UserGroup[];
+}
+declare const userReducer: import("redux").Reducer<UserState> & {
+    getInitialState: () => UserState;
+};
+export default userReducer;

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

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

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

@@ -0,0 +1,76 @@
+import { UserState } from "./reducer";
+export declare const userDetailsSelector: ((state: {
+    user: UserState;
+}) => import("./types").User | undefined) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UserState) => import("./types").User | undefined;
+    memoizedResultFunc: ((resultFuncArgs_0: UserState) => import("./types").User | undefined) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").User | undefined;
+    dependencies: [({ user }: {
+        user: UserState;
+    }) => UserState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const groupsSelector: ((state: {
+    user: UserState;
+}) => import("./types").UserGroup[]) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UserState) => import("./types").UserGroup[];
+    memoizedResultFunc: ((resultFuncArgs_0: UserState) => import("./types").UserGroup[]) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => import("./types").UserGroup[];
+    dependencies: [({ user }: {
+        user: UserState;
+    }) => UserState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};
+export declare const isAuthenticatedSelector: ((state: {
+    user: UserState;
+}) => boolean) & {
+    clearCache: () => void;
+    resultsCount: () => number;
+    resetResultsCount: () => void;
+} & {
+    resultFunc: (resultFuncArgs_0: UserState) => boolean;
+    memoizedResultFunc: ((resultFuncArgs_0: UserState) => boolean) & {
+        clearCache: () => void;
+        resultsCount: () => number;
+        resetResultsCount: () => void;
+    };
+    lastResult: () => boolean;
+    dependencies: [({ user }: {
+        user: UserState;
+    }) => UserState];
+    recomputations: () => number;
+    resetRecomputations: () => void;
+    dependencyRecomputations: () => number;
+    resetDependencyRecomputations: () => void;
+} & {
+    memoize: typeof import("reselect").lruMemoize;
+    argsMemoize: typeof import("reselect").weakMapMemoize;
+};

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

@@ -0,0 +1,11 @@
+import { Locale } from "../Localization/types";
+import { User, UserGroups } from "./types";
+/**
+ * Rest services
+ */
+export declare function getMe(): Promise<User>;
+export declare function getMyGroups(): Promise<UserGroups>;
+export declare function updateLocale(userOid: string, locale: Locale): Promise<{
+    kind: "dms-core.Language";
+    language: Locale;
+}>;

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

@@ -0,0 +1,31 @@
+import { Locale } from "../Localization/types";
+export type User = {
+    kind: "dms-core.User";
+    oid: string;
+    creationDate: string;
+    modificationDate: string;
+    firstname: string;
+    lastname: string;
+    username?: string;
+    name: string;
+    label: string;
+    language: Locale;
+    email: string | null;
+};
+export type UserList = {
+    kind: "dms-core.UserList";
+    users: User[];
+};
+export type UserGroup = {
+    kind: "dms-core.Group";
+    oid: string;
+    creationDate: string;
+    modificationDate: string;
+    name: string;
+    label: string;
+};
+export type UserGroups = {
+    kind: "dms-core.GroupList";
+    items: UserGroup[];
+};
+export type UserSettingValue = Immutable.ValueObject | Record<string, unknown> | string | number | boolean | undefined;