@aristid/leav-types 0.0.7 → 1.0.0-78735ccf

package/apps/core/src/domain/library/libraryDomain.d.ts

@@ -0,0 +1,49 @@
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { GetCoreEntityByIdFunc } from 'domain/helpers/getCoreEntityById';
+import { IValidateHelper } from 'domain/helpers/validate';
+import { IAdminPermissionDomain } from 'domain/permission/adminPermissionDomain';
+import { i18n } from 'i18next';
+import { IAttributeRepo } from 'infra/attribute/attributeRepo';
+import { ILibraryRepo } from 'infra/library/libraryRepo';
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { IUtils } from 'utils/utils';
+import { IConfig } from '_types/config';
+import { IQueryInfos } from '_types/queryInfos';
+import { IGetCoreEntitiesParams } from '_types/shared';
+import { ICachesService } from '../../infra/cache/cacheService';
+import { ILibrary } from '../../_types/library';
+import { IList } from '../../_types/list';
+import { IAttributeDomain } from '../attribute/attributeDomain';
+import { IRecordDomain } from '../record/recordDomain';
+import { IDeleteAssociatedValuesHelper } from './helpers/deleteAssociatedValues';
+import { RunPreDeleteFunc } from './helpers/runPreDelete';
+import { IUpdateAssociatedFormsHelper } from './helpers/updateAssociatedForms';
+export interface ILibraryDomain {
+    getLibraries({ params, ctx }: {
+        params?: IGetCoreEntitiesParams;
+        ctx: IQueryInfos;
+    }): Promise<IList<ILibrary>>;
+    saveLibrary(library: ILibrary, ctx: IQueryInfos): Promise<ILibrary>;
+    deleteLibrary(id: string, ctx: IQueryInfos): Promise<ILibrary>;
+    getLibraryProperties(id: string, ctx: IQueryInfos): Promise<ILibrary>;
+    getLibrariesUsingAttribute(attributeId: string, ctx: IQueryInfos): Promise<string[]>;
+}
+export interface ILibraryDomainDeps {
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.domain.helpers.getCoreEntityById': GetCoreEntityByIdFunc;
+    'core.domain.helpers.validate': IValidateHelper;
+    'core.domain.library.helpers.deleteAssociatedValues': IDeleteAssociatedValuesHelper;
+    'core.domain.library.helpers.runPreDelete': RunPreDeleteFunc;
+    'core.domain.library.helpers.updateAssociatedForms': IUpdateAssociatedFormsHelper;
+    'core.domain.permission.admin': IAdminPermissionDomain;
+    'core.domain.record': IRecordDomain;
+    'core.infra.attribute': IAttributeRepo;
+    'core.infra.cache.cacheService': ICachesService;
+    'core.infra.library': ILibraryRepo;
+    'core.infra.tree': ITreeRepo;
+    'core.utils': IUtils;
+    config: IConfig;
+    translator: i18n;
+}
+export default function ({ 'core.domain.attribute': attributeDomain, 'core.domain.eventsManager': eventsManager, 'core.domain.helpers.getCoreEntityById': getCoreEntityById, 'core.domain.helpers.validate': validateHelper, 'core.domain.library.helpers.deleteAssociatedValues': deleteAssociatedValues, 'core.domain.library.helpers.runPreDelete': runPreDelete, 'core.domain.library.helpers.updateAssociatedForms': updateAssociatedForms, 'core.domain.permission.admin': adminPermissionDomain, 'core.domain.record': recordDomain, 'core.infra.attribute': attributeRepo, 'core.infra.cache.cacheService': cacheService, 'core.infra.library': libraryRepo, 'core.infra.tree': treeRepo, 'core.utils': utils, config, translator: translator }: ILibraryDomainDeps): ILibraryDomain;

package/apps/core/src/domain/library/libraryDomain.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/log/index.d.ts

@@ -0,0 +1 @@
+export { default } from './logDomain';

package/apps/core/src/domain/log/logDomain.d.ts

@@ -0,0 +1,19 @@
+import { ILogRepo } from 'infra/log/logRepo';
+import { ILogFilters, ILogPagination, ILogResponse, ILogSort } from '_types/log';
+import { IQueryInfos } from '_types/queryInfos';
+import { IPermissionDomain } from 'domain/permission/permissionDomain';
+import { IRecordPermissionDomain } from 'domain/permission/recordPermissionDomain';
+export interface ILogDomain {
+    getLogs: (params: {
+        filters?: ILogFilters;
+        sort?: ILogSort;
+        pagination?: ILogPagination;
+    }, ctx: IQueryInfos) => Promise<ILogResponse>;
+}
+interface IDeps {
+    'core.infra.log': ILogRepo;
+    'core.domain.permission': IPermissionDomain;
+    'core.domain.permission.record': IRecordPermissionDomain;
+}
+export default function ({ 'core.infra.log': logRepo, 'core.domain.permission': permissionDomain, 'core.domain.permission.record': recordPermissionDomain }: IDeps): ILogDomain;
+export {};

package/apps/core/src/domain/log/logDomain.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/_types.d.ts

@@ -0,0 +1,209 @@
+import { AdminPermissionsActions, ApplicationPermissionsActions, AttributePermissionsActions, IPermissionsTreeTarget, ITreePermissionsConf, LibraryPermissionsActions, PermissionsActions, PermissionTypes, RecordAttributePermissionsActions, RecordPermissionsActions, TreeNodePermissionsActions, TreePermissionsActions } from '_types/permissions';
+import { IQueryInfos } from '_types/queryInfos';
+import { TreePath } from '_types/tree';
+export declare const PERMISSIONS_CACHE_HEADER = "permissions";
+export declare const PERMISSIONS_NULL_PLACEHOLDER = "__null__";
+export interface IPermissionTarget {
+    attributeId?: string;
+    recordId?: string;
+    libraryId?: string;
+    nodeId?: string;
+}
+export interface IGetSimplePermissionsParams {
+    type: PermissionTypes;
+    applyTo: string | null;
+    action: PermissionsActions;
+    usersGroupNodeId: string;
+    permissionTreeTarget?: IPermissionsTreeTarget;
+    ctx: IQueryInfos;
+}
+export interface IGetPermissionsByActionsParams {
+    type: PermissionTypes;
+    applyTo: string | null;
+    actions: PermissionsActions[];
+    usersGroupNodeId: string;
+    permissionTreeTarget?: IPermissionsTreeTarget;
+    ctx: IQueryInfos;
+}
+export type PermByActionsRes = {
+    [name: string]: boolean | null;
+} | null;
+export interface IGetAdminPermissionParams {
+    action: AdminPermissionsActions;
+    userId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetInheritedAdminPermissionParams {
+    action: AdminPermissionsActions;
+    userGroupId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetLibraryPermissionParams {
+    action: LibraryPermissionsActions;
+    libraryId: string;
+    userId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetTreePermissionParams {
+    action: TreePermissionsActions;
+    treeId: string;
+    userId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetTreeLibraryPermissionParams {
+    action: TreeNodePermissionsActions;
+    treeId: string;
+    libraryId: string;
+    userId: string;
+    getDefaultPermission?: (params?: IGetDefaultTreeLibraryPermissionParams) => Promise<boolean> | boolean;
+    ctx: IQueryInfos;
+}
+export interface IGetApplicationPermissionParams {
+    action: ApplicationPermissionsActions;
+    applicationId: string;
+    userId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetDefaultTreeLibraryPermissionParams {
+    type?: PermissionTypes;
+    applyTo?: string;
+    userId?: string;
+    action?: PermissionsActions;
+    ctx: IQueryInfos;
+}
+export interface IGetTreeNodePermissionParams {
+    action: TreeNodePermissionsActions;
+    userId: string;
+    nodeId: string;
+    treeId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetInheritedTreeNodePermissionParams {
+    action: TreeNodePermissionsActions;
+    userGroupId: string;
+    treeId: string;
+    libraryId: string;
+    permTree: string;
+    permTreeNode: string;
+    ctx: IQueryInfos;
+}
+export interface IGetInheritedLibraryPermissionParams {
+    action: LibraryPermissionsActions;
+    libraryId: string;
+    userGroupId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetInheritedTreePermissionParams {
+    action: TreePermissionsActions;
+    treeId: string;
+    userGroupId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetInheritedApplicationPermissionParams {
+    action: ApplicationPermissionsActions;
+    applicationId: string;
+    userGroupId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetDefaultInheritedTreeLibraryPermissionParams {
+    type?: PermissionTypes;
+    applyTo?: string;
+    userId?: string;
+    action?: PermissionsActions;
+    ctx: IQueryInfos;
+}
+export interface IGetInheritedTreeLibraryPermissionParams {
+    action: TreeNodePermissionsActions;
+    treeId: string;
+    libraryId: string;
+    userGroupId: string;
+    getDefaultPermission?: (params?: IGetDefaultInheritedTreeLibraryPermissionParams) => boolean | null;
+    ctx: IQueryInfos;
+}
+export interface IGetAttributePermissionParams {
+    action: AttributePermissionsActions;
+    attributeId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetInheritedAttributePermissionParams {
+    action: AttributePermissionsActions;
+    attributeId: string;
+    userGroupId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetInheritedPermissionsParams {
+    type: PermissionTypes;
+    applyTo: string;
+    action: PermissionsActions;
+    userGroupId: string;
+    permissionTreeTarget?: IPermissionsTreeTarget;
+    ctx: IQueryInfos;
+}
+export interface IIsAllowedParams {
+    type: PermissionTypes;
+    action: PermissionsActions;
+    userId: string;
+    applyTo?: string;
+    target?: IPermissionTarget;
+    ctx: IQueryInfos;
+}
+export interface IGetActionsByTypeParams {
+    type: PermissionTypes;
+    applyOn?: string;
+    skipApplyOn?: boolean;
+}
+export interface IGetRecordAttributeHeritedPermissionsParams {
+    action: RecordAttributePermissionsActions;
+    attributeId: string;
+    userGroupId: string;
+    permTree: string;
+    permTreeNode: string;
+}
+export interface IGetDefaultPermissionParams {
+    action?: any;
+    applyTo?: string;
+    userId?: string;
+    userGroups?: TreePath[];
+}
+export interface IGetTreeBasedPermissionParams {
+    type: PermissionTypes;
+    action: PermissionsActions;
+    userId: string;
+    applyTo: string;
+    treeValues: {
+        [treeAttributeId: string]: string[];
+    };
+    permissions_conf: ITreePermissionsConf;
+    getDefaultPermission: (params: IGetDefaultPermissionParams) => Promise<boolean> | boolean;
+}
+export interface IGetInheritedTreeBasedPermissionParams {
+    type: PermissionTypes;
+    action: PermissionsActions;
+    userGroupId: string;
+    applyTo: string;
+    permissionTreeTarget: IPermissionsTreeTarget;
+    getDefaultPermission: (params: IGetDefaultPermissionParams) => Promise<boolean> | boolean;
+}
+export interface IGetRecordPermissionParams {
+    action: RecordPermissionsActions;
+    userId: string;
+    library: string;
+    recordId: string;
+    ctx: IQueryInfos;
+}
+export interface IGetInheritedRecordPermissionParams {
+    action: RecordPermissionsActions;
+    userGroupId: string;
+    library: string;
+    permTree: string;
+    permTreeNode: string;
+    ctx: IQueryInfos;
+}
+export interface IEstimateTreeValueRecordPermissionParams {
+    action: RecordPermissionsActions;
+    userId: string;
+    libraryId: string;
+    attributeId: string;
+    nodeId: string;
+    ctx: IQueryInfos;
+}

package/apps/core/src/domain/permission/adminPermissionDomain.d.ts

@@ -0,0 +1,11 @@
+import { IGlobalPermissionHelper } from './helpers/globalPermission';
+import { IGetAdminPermissionParams, IGetInheritedAdminPermissionParams } from './_types';
+export interface IAdminPermissionDomain {
+    getAdminPermission({ action, userId, ctx }: IGetAdminPermissionParams): Promise<boolean>;
+    getInheritedAdminPermission({ action, userGroupId, ctx }: IGetInheritedAdminPermissionParams): Promise<boolean>;
+}
+interface IDeps {
+    'core.domain.permission.helpers.globalPermission': IGlobalPermissionHelper;
+}
+export default function ({ 'core.domain.permission.helpers.globalPermission': globalPermHelper }: IDeps): IAdminPermissionDomain;
+export {};

package/apps/core/src/domain/permission/adminPermissionDomain.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/applicationPermissionDomain.d.ts

@@ -0,0 +1,11 @@
+import { IGlobalPermissionHelper } from './helpers/globalPermission';
+import { IGetApplicationPermissionParams, IGetInheritedApplicationPermissionParams } from './_types';
+export interface IApplicationPermissionDomain {
+    getApplicationPermission(params: IGetApplicationPermissionParams): Promise<boolean>;
+    getInheritedApplicationPermission(params: IGetInheritedApplicationPermissionParams): Promise<boolean>;
+}
+interface IDeps {
+    'core.domain.permission.helpers.globalPermission': IGlobalPermissionHelper;
+}
+export default function ({ 'core.domain.permission.helpers.globalPermission': globalPermHelper }: IDeps): IApplicationPermissionDomain;
+export {};

package/apps/core/src/domain/permission/applicationPermissionDomain.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/attributePermissionDomain.d.ts

@@ -0,0 +1,11 @@
+import { IGlobalPermissionHelper } from './helpers/globalPermission';
+import { IGetAttributePermissionParams, IGetInheritedAttributePermissionParams } from './_types';
+export interface IAttributePermissionDomain {
+    getAttributePermission(params: IGetAttributePermissionParams): Promise<boolean>;
+    getInheritedAttributePermission(params: IGetInheritedAttributePermissionParams): Promise<boolean>;
+}
+interface IDeps {
+    'core.domain.permission.helpers.globalPermission': IGlobalPermissionHelper;
+}
+export default function (deps: IDeps): IAttributePermissionDomain;
+export {};

package/apps/core/src/domain/permission/attributePermissionDomain.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/helpers/defaultPermission.d.ts

@@ -0,0 +1,9 @@
+import { IConfig } from '_types/config';
+interface IDeps {
+    config: IConfig;
+}
+export interface IDefaultPermissionHelper {
+    getDefaultPermission: () => boolean;
+}
+export default function ({ config }: IDeps): IDefaultPermissionHelper;
+export {};

package/apps/core/src/domain/permission/helpers/defaultPermission.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/helpers/getPermissionCacheKey.d.ts

@@ -0,0 +1,2 @@
+import { PermissionsActions, PermissionTypes } from '_types/permissions';
+export default function (groupsId?: string[] | null, permissionType?: PermissionTypes | null, applyTo?: string | null, permissionAction?: PermissionsActions | null, key?: string | null): string;

package/apps/core/src/domain/permission/helpers/getPermissionCacheKey.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/helpers/getPermissionCachePatternKey.d.ts

@@ -0,0 +1,8 @@
+import { PermissionsActions, PermissionTypes } from '_types/permissions';
+export default function ({ groupsId, permissionType, applyTo, permissionAction, key }: {
+    groupsId?: string[];
+    permissionType?: PermissionTypes;
+    applyTo?: string;
+    permissionAction?: PermissionsActions;
+    key?: string;
+}): string;

package/apps/core/src/domain/permission/helpers/getPermissionCachePatternKey.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/helpers/globalPermission.d.ts

@@ -0,0 +1,36 @@
+import { IQueryInfos } from '_types/queryInfos';
+import { PermissionsActions, PermissionTypes } from '../../../_types/permissions';
+import { IDefaultPermissionHelper } from './defaultPermission';
+import { IPermissionByUserGroupsHelper } from './permissionByUserGroups';
+import { IElementAncestorsHelper } from 'domain/tree/helpers/elementAncestors';
+interface IGetGlobalPermissionParams {
+    type: PermissionTypes;
+    applyTo?: string;
+    action: PermissionsActions;
+    getDefaultPermission?: (params?: IGetDefaultGlobalPermissionParams) => Promise<boolean> | boolean;
+}
+interface IGetInheritedGlobalPermissionParams {
+    type: PermissionTypes;
+    applyTo?: string;
+    userGroupNodeId: string | null;
+    action: PermissionsActions;
+    getDefaultPermission?: (params?: IGetDefaultGlobalPermissionParams) => boolean;
+}
+interface IGetDefaultGlobalPermissionParams {
+    type?: PermissionTypes;
+    applyTo?: string;
+    userId?: string;
+    action?: PermissionsActions;
+    ctx: IQueryInfos;
+}
+export interface IGlobalPermissionHelper {
+    getGlobalPermission(params: IGetGlobalPermissionParams, ctx: IQueryInfos): Promise<boolean>;
+    getInheritedGlobalPermission(params: IGetInheritedGlobalPermissionParams, ctx: IQueryInfos): Promise<boolean>;
+}
+export interface IGlobalPermissionDeps {
+    'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
+    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
+    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
+}
+export default function ({ 'core.domain.permission.helpers.permissionByUserGroups': permByUserGroupsHelper, 'core.domain.permission.helpers.defaultPermission': defaultPermHelper, 'core.domain.tree.helpers.elementAncestors': elementAncestorsHelper }: IGlobalPermissionDeps): IGlobalPermissionHelper;
+export {};

package/apps/core/src/domain/permission/helpers/globalPermission.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/helpers/index.d.ts

@@ -0,0 +1,7 @@
+export { default as defaultPermission } from './defaultPermission';
+export { default as globalPermission } from './globalPermission';
+export { default as permissionByUserGroups } from './permissionByUserGroups';
+export { default as permissionsByActions } from './permissionsByActions';
+export { default as reducePermissionsArray } from './reducePermissionsArray';
+export { default as simplePermission } from './simplePermission';
+export { default as treeBasedPermissions } from './treeBasedPermissions';

package/apps/core/src/domain/permission/helpers/permissionByUserGroups.d.ts

@@ -0,0 +1,32 @@
+import { IReducePermissionsArrayHelper } from './reducePermissionsArray';
+import { ISimplePermissionHelper } from './simplePermission';
+import { IDefaultPermissionHelper } from './defaultPermission';
+import { TreePath } from '../../../_types/tree';
+import { PermissionsActions, PermissionTypes } from '../../../_types/permissions';
+import { IQueryInfos } from '../../../_types/queryInfos';
+import { ICachesService } from '../../../infra/cache/cacheService';
+import { IConfig } from '_types/config';
+export interface IPermissionByUserGroupsHelperDeps {
+    'core.domain.permission.helpers.simplePermission': ISimplePermissionHelper;
+    'core.domain.permission.helpers.reducePermissionsArray': IReducePermissionsArrayHelper;
+    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
+    'core.infra.cache.cacheService': ICachesService;
+    config: IConfig;
+}
+interface IGetPermissionByUserGroupsParams {
+    type: PermissionTypes;
+    action: PermissionsActions;
+    userGroupsPaths: TreePath[];
+    applyTo?: string;
+    treeTarget?: {
+        tree: string;
+        path: TreePath;
+    };
+    getDefaultPermission?: () => Promise<boolean> | boolean;
+    ctx: IQueryInfos;
+}
+export interface IPermissionByUserGroupsHelper {
+    getPermissionByUserGroups: (params: IGetPermissionByUserGroupsParams) => Promise<boolean>;
+}
+export default function (deps: IPermissionByUserGroupsHelperDeps): IPermissionByUserGroupsHelper;
+export {};

package/apps/core/src/domain/permission/helpers/permissionByUserGroups.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/helpers/permissionsByActions.d.ts

@@ -0,0 +1,12 @@
+import { IPermissionRepo } from 'infra/permission/permissionRepo';
+import { IGetPermissionsByActionsParams } from '../_types';
+interface IDeps {
+    'core.infra.permission': IPermissionRepo;
+}
+export interface IPermissionsByActionsHelper {
+    getPermissionsByActions: (params: IGetPermissionsByActionsParams) => Promise<{
+        [name: string]: boolean | null;
+    }>;
+}
+export default function ({ 'core.infra.permission': permissionRepo }: IDeps): IPermissionsByActionsHelper;
+export {};

package/apps/core/src/domain/permission/helpers/permissionsByActions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/helpers/reducePermissionsArray.d.ts

@@ -0,0 +1,4 @@
+export interface IReducePermissionsArrayHelper {
+    reducePermissionsArray: (permissions: boolean[]) => boolean;
+}
+export default function (): IReducePermissionsArrayHelper;

package/apps/core/src/domain/permission/helpers/reducePermissionsArray.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/helpers/simplePermission.d.ts

@@ -0,0 +1,10 @@
+import { IGetSimplePermissionsParams } from '../_types';
+import { IPermissionsByActionsHelper } from './permissionsByActions';
+interface IDeps {
+    'core.domain.permission.helpers.permissionsByActions': IPermissionsByActionsHelper;
+}
+export interface ISimplePermissionHelper {
+    getSimplePermission: (params: IGetSimplePermissionsParams) => Promise<boolean | null>;
+}
+export default function ({ 'core.domain.permission.helpers.permissionsByActions': permsByActionsHelper }: IDeps): ISimplePermissionHelper;
+export {};

package/apps/core/src/domain/permission/helpers/simplePermission.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/helpers/treeBasedPermissions.d.ts

@@ -0,0 +1,19 @@
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { IElementAncestorsHelper } from 'domain/tree/helpers/elementAncestors';
+import { IPermissionRepo } from 'infra/permission/permissionRepo';
+import { IQueryInfos } from '_types/queryInfos';
+import { IGetInheritedTreeBasedPermissionParams, IGetTreeBasedPermissionParams } from '../_types';
+import { IPermissionByUserGroupsHelper } from './permissionByUserGroups';
+import { IReducePermissionsArrayHelper } from './reducePermissionsArray';
+export interface ITreeBasedPermissionsDeps {
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
+    'core.domain.permission.helpers.reducePermissionsArray': IReducePermissionsArrayHelper;
+    'core.domain.tree.helpers.elementAncestors': IElementAncestorsHelper;
+    'core.infra.permission': IPermissionRepo;
+}
+export interface ITreeBasedPermissionHelper {
+    getTreeBasedPermission(params: IGetTreeBasedPermissionParams, ctx: IQueryInfos): Promise<boolean>;
+    getInheritedTreeBasedPermission(params: IGetInheritedTreeBasedPermissionParams, ctx: IQueryInfos): Promise<boolean>;
+}
+export default function (deps: ITreeBasedPermissionsDeps): ITreeBasedPermissionHelper;

package/apps/core/src/domain/permission/helpers/treeBasedPermissions.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/index.d.ts

@@ -0,0 +1,10 @@
+export { default as admin } from './adminPermissionDomain';
+export { default as application } from './applicationPermissionDomain';
+export { default as attribute } from './attributePermissionDomain';
+export { default as library } from './libraryPermissionDomain';
+export { default } from './permissionDomain';
+export { default as recordAttribute } from './recordAttributePermissionDomain';
+export { default as record } from './recordPermissionDomain';
+export { default as treeLibrary } from './treeLibraryPermissionDomain';
+export { default as treeNode } from './treeNodePermissionDomain';
+export { default as tree } from './treePermissionDomain';

package/apps/core/src/domain/permission/libraryPermissionDomain.d.ts

@@ -0,0 +1,11 @@
+import { IGlobalPermissionHelper } from './helpers/globalPermission';
+import { IGetInheritedLibraryPermissionParams, IGetLibraryPermissionParams } from './_types';
+export interface ILibraryPermissionDomain {
+    getLibraryPermission(params: IGetLibraryPermissionParams): Promise<boolean>;
+    getInheritedLibraryPermission({ action, userGroupId, ctx }: IGetInheritedLibraryPermissionParams): Promise<boolean>;
+}
+interface IDeps {
+    'core.domain.permission.helpers.globalPermission': IGlobalPermissionHelper;
+}
+export default function ({ 'core.domain.permission.helpers.globalPermission': globalPermHelper }: IDeps): ILibraryPermissionDomain;
+export {};

package/apps/core/src/domain/permission/libraryPermissionDomain.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/permissionDomain.d.ts

@@ -0,0 +1,46 @@
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { i18n } from 'i18next';
+import { IPermissionRepo } from 'infra/permission/permissionRepo';
+import { IConfig } from '_types/config';
+import { IQueryInfos } from '_types/queryInfos';
+import { ICachesService } from '../../infra/cache/cacheService';
+import { ILabeledPermissionsAction, IPermission, PermissionTypes } from '../../_types/permissions';
+import { IAdminPermissionDomain } from './adminPermissionDomain';
+import { IApplicationPermissionDomain } from './applicationPermissionDomain';
+import { IAttributePermissionDomain } from './attributePermissionDomain';
+import { ILibraryPermissionDomain } from './libraryPermissionDomain';
+import { IRecordAttributePermissionDomain } from './recordAttributePermissionDomain';
+import { IRecordPermissionDomain } from './recordPermissionDomain';
+import { ITreeLibraryPermissionDomain } from './treeLibraryPermissionDomain';
+import { ITreeNodePermissionDomain } from './treeNodePermissionDomain';
+import { ITreePermissionDomain } from './treePermissionDomain';
+import { IGetActionsByTypeParams, IGetInheritedPermissionsParams, IGetPermissionsByActionsParams, IIsAllowedParams, PermByActionsRes } from './_types';
+export interface IPermissionDomain {
+    savePermission(permData: IPermission, ctx: IQueryInfos): Promise<IPermission>;
+    getPermissionsByActions({ type, applyTo, actions, usersGroupNodeId, permissionTreeTarget, ctx }: IGetPermissionsByActionsParams): Promise<PermByActionsRes>;
+    /**
+     * Retrieve herited permission: ignore permission defined on given element, force retrieval of herited permission
+     */
+    getInheritedPermissions({ type, applyTo, action, userGroupId, permissionTreeTarget, ctx }: IGetInheritedPermissionsParams): Promise<boolean>;
+    isAllowed({ type, action, userId, applyTo, target, ctx }: IIsAllowedParams): Promise<boolean>;
+    getActionsByType(params: IGetActionsByTypeParams): ILabeledPermissionsAction[];
+    registerActions(type: PermissionTypes, actions: string[], applyOn?: string[]): void;
+    isAdminOrSystemUser(ctx: IQueryInfos): boolean;
+}
+export interface IPermissionDomainDeps {
+    'core.domain.permission.admin': IAdminPermissionDomain;
+    'core.domain.permission.library': ILibraryPermissionDomain;
+    'core.domain.permission.record': IRecordPermissionDomain;
+    'core.domain.permission.attribute': IAttributePermissionDomain;
+    'core.domain.permission.recordAttribute': IRecordAttributePermissionDomain;
+    'core.domain.permission.tree': ITreePermissionDomain;
+    'core.domain.permission.treeNode': ITreeNodePermissionDomain;
+    'core.domain.permission.treeLibrary': ITreeLibraryPermissionDomain;
+    'core.domain.permission.application': IApplicationPermissionDomain;
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.infra.permission': IPermissionRepo;
+    'core.infra.cache.cacheService': ICachesService;
+    translator: i18n;
+    config: IConfig;
+}
+export default function (deps: IPermissionDomainDeps): IPermissionDomain;

package/apps/core/src/domain/permission/permissionDomain.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/apps/core/src/domain/permission/recordAttributePermissionDomain.d.ts

@@ -0,0 +1,22 @@
+import { IValueRepo } from 'infra/value/valueRepo';
+import { IQueryInfos } from '_types/queryInfos';
+import { RecordAttributePermissionsActions } from '../../_types/permissions';
+import { IAttributeDomain } from '../attribute/attributeDomain';
+import { IAttributePermissionDomain } from './attributePermissionDomain';
+import { IDefaultPermissionHelper } from './helpers/defaultPermission';
+import { IPermissionByUserGroupsHelper } from './helpers/permissionByUserGroups';
+import { ITreeBasedPermissionHelper } from './helpers/treeBasedPermissions';
+import { IGetRecordAttributeHeritedPermissionsParams as IGetRecordAttributeInheritedPermissionsParams } from './_types';
+export interface IRecordAttributePermissionDomain {
+    getRecordAttributePermission(action: RecordAttributePermissionsActions, userGroupId: string, attributeId: string, recordLibrary: string, recordId: string, ctx: IQueryInfos): Promise<boolean>;
+    getInheritedRecordAttributePermission(params: IGetRecordAttributeInheritedPermissionsParams, ctx: IQueryInfos): Promise<boolean>;
+}
+export interface IRecordAttributePermissionDomainDeps {
+    'core.domain.permission.attribute': IAttributePermissionDomain;
+    'core.domain.permission.helpers.treeBasedPermissions': ITreeBasedPermissionHelper;
+    'core.domain.permission.helpers.permissionByUserGroups': IPermissionByUserGroupsHelper;
+    'core.domain.permission.helpers.defaultPermission': IDefaultPermissionHelper;
+    'core.domain.attribute': IAttributeDomain;
+    'core.infra.value': IValueRepo;
+}
+export default function (deps: IRecordAttributePermissionDomainDeps): IRecordAttributePermissionDomain;

package/apps/core/src/domain/permission/recordAttributePermissionDomain.spec.d.ts

@@ -0,0 +1 @@
+export {};