@aristid/leav-types 0.0.2 → 0.0.4-b0a5cfe

package/apps/core/src/domain/import/importDomain.d.ts

@@ -0,0 +1,72 @@
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { UpdateTaskProgress } from 'domain/helpers/updateTaskProgress';
+import { ILibraryDomain } from 'domain/library/libraryDomain';
+import { IRecordDomain } from 'domain/record/recordDomain';
+import { ITasksManagerDomain } from 'domain/tasksManager/tasksManagerDomain';
+import { ITreeDomain } from 'domain/tree/treeDomain';
+import { IValueDomain } from 'domain/value/valueDomain';
+import { i18n } from 'i18next';
+import { IUtils } from 'utils/utils';
+import * as Config from '_types/config';
+import { ICachesService } from '../../infra/cache/cacheService';
+import { ImportMode, ImportType } from '../../_types/import';
+import { IQueryInfos } from '../../_types/queryInfos';
+import { ITaskFuncParams } from '../../_types/tasksManager';
+import { IValidateHelper } from '../helpers/validate';
+import { IVersionProfileDomain } from '../versionProfile/versionProfileDomain';
+export declare const IMPORT_DATA_SCHEMA_PATH: string;
+export declare const IMPORT_CONFIG_SCHEMA_PATH: string;
+export interface IImportExcelParams {
+    filename: string;
+    sheets?: Array<{
+        type: ImportType;
+        library: string;
+        mode: ImportMode;
+        mapping: Array<string | null>;
+        keyIndex?: number;
+        keyToIndex?: number;
+        linkAttribute?: string;
+        treeLinkLibrary?: string;
+    } | null>;
+    startAt?: number;
+}
+interface IImportDataParams {
+    filename: string;
+    ctx: IQueryInfos;
+    excelMapping?: IExcelMapping;
+}
+interface IImportConfigParams {
+    filepath: string;
+    ctx: IQueryInfos;
+    forceNoTask?: boolean;
+}
+export interface IImportDomain {
+    importConfig(params: IImportConfigParams, task?: ITaskFuncParams): Promise<string>;
+    importData(params: IImportDataParams, task?: ITaskFuncParams): Promise<string>;
+    importExcel({ filename, sheets, startAt }: IImportExcelParams, ctx: IQueryInfos): Promise<string>;
+}
+interface IExcelMapping {
+    [elementIndex: number]: {
+        sheet: number;
+        line: number;
+    };
+}
+export interface IImportDomainDeps {
+    'core.domain.library': ILibraryDomain;
+    'core.domain.record': IRecordDomain;
+    'core.domain.helpers.validate': IValidateHelper;
+    'core.domain.attribute': IAttributeDomain;
+    'core.domain.value': IValueDomain;
+    'core.domain.tree': ITreeDomain;
+    'core.domain.versionProfile': IVersionProfileDomain;
+    'core.domain.tasksManager': ITasksManagerDomain;
+    'core.domain.helpers.updateTaskProgress': UpdateTaskProgress;
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.infra.cache.cacheService': ICachesService;
+    config: Config.IConfig;
+    translator: i18n;
+    'core.utils': IUtils;
+}
+export default function ({ 'core.domain.library': libraryDomain, 'core.domain.record': recordDomain, 'core.domain.helpers.validate': validateHelper, 'core.domain.attribute': attributeDomain, 'core.domain.value': valueDomain, 'core.domain.tree': treeDomain, 'core.domain.versionProfile': versionProfileDomain, 'core.domain.tasksManager': tasksManagerDomain, 'core.domain.helpers.updateTaskProgress': updateTaskProgress, 'core.domain.eventsManager': eventsManagerDomain, 'core.infra.cache.cacheService': cacheService, 'core.utils': utils, config, translator }: IImportDomainDeps): IImportDomain;
+export {};

package/apps/core/src/domain/import/importDomain.spec.d.ts

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

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

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

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

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

package/apps/core/src/domain/indexationManager/indexationManagerDomain.d.ts

@@ -0,0 +1,40 @@
+import { IAmqpService } from '@leav/message-broker';
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { IEventsManagerDomain } from 'domain/eventsManager/eventsManagerDomain';
+import { ILibraryDomain } from 'domain/library/libraryDomain';
+import { IRecordDomain } from 'domain/record/recordDomain';
+import { IFindRecordParams } from 'domain/record/_types';
+import { ITasksManagerDomain } from 'domain/tasksManager/tasksManagerDomain';
+import { i18n } from 'i18next';
+import winston from 'winston';
+import * as Config from '_types/config';
+import { IQueryInfos } from '_types/queryInfos';
+import { IIndexationService } from '../../infra/indexation/indexationService';
+import { ITaskFuncParams } from '../../_types/tasksManager';
+interface IIndexDatabaseParams {
+    findRecordParams: IFindRecordParams | IFindRecordParams[];
+    attributes?: {
+        up?: string[];
+        del?: string[];
+    };
+    ctx: IQueryInfos;
+    forceNoTask?: boolean;
+}
+export interface IIndexationManagerDomain {
+    init(): Promise<void>;
+    indexDatabase(params: IIndexDatabaseParams, task?: ITaskFuncParams): Promise<string>;
+}
+export interface IIndexationManagerDomainDeps {
+    config: Config.IConfig;
+    'core.infra.amqpService': IAmqpService;
+    'core.domain.record': IRecordDomain;
+    'core.domain.library': ILibraryDomain;
+    'core.domain.attribute': IAttributeDomain;
+    'core.infra.indexation.indexationService': IIndexationService;
+    'core.domain.tasksManager': ITasksManagerDomain;
+    'core.domain.eventsManager': IEventsManagerDomain;
+    'core.utils.logger': winston.Winston;
+    translator: i18n;
+}
+export default function ({ config, 'core.infra.amqpService': amqpService, 'core.domain.record': recordDomain, 'core.domain.library': libraryDomain, 'core.domain.attribute': attributeDomain, 'core.domain.tasksManager': tasksManagerDomain, 'core.infra.indexation.indexationService': indexationService, 'core.domain.eventsManager': eventsManager, 'core.utils.logger': logger, translator }: IIndexationManagerDomainDeps): IIndexationManagerDomain;
+export {};

package/apps/core/src/domain/indexationManager/indexationManagerDomain.spec.d.ts

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

package/apps/core/src/domain/library/helpers/checkSavePermission.d.ts

@@ -0,0 +1,10 @@
+import { IAdminPermissionDomain } from 'domain/permission/adminPermissionDomain';
+import { IQueryInfos } from '_types/queryInfos';
+import { AdminPermissionsActions } from '../../../_types/permissions';
+declare const _default: (existingLib: boolean, userId: string, deps: {
+    adminPermissionDomain: IAdminPermissionDomain;
+}, ctx: IQueryInfos) => Promise<{
+    canSave: boolean;
+    action: AdminPermissionsActions;
+}>;
+export default _default;

package/apps/core/src/domain/library/helpers/deleteAssociatedValues.d.ts

@@ -0,0 +1,16 @@
+import { IRecordDomain } from 'domain/record/recordDomain';
+import { IValueDomain } from 'domain/value/valueDomain';
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { IQueryInfos } from '_types/queryInfos';
+import { IValueRepo } from 'infra/value/valueRepo';
+interface IDeps {
+    'core.domain.record'?: IRecordDomain;
+    'core.domain.value'?: IValueDomain;
+    'core.domain.attribute'?: IAttributeDomain;
+    'core.infra.value'?: IValueRepo;
+}
+export interface IDeleteAssociatedValuesHelper {
+    deleteAssociatedValues: (attributes: string[], libraryId: string, ctx: IQueryInfos) => Promise<void>;
+}
+export default function ({ 'core.domain.record': recordDomain, 'core.domain.value': valueDomain, 'core.infra.value': valueRepo, 'core.domain.attribute': attributeDomain }: IDeps): IDeleteAssociatedValuesHelper;
+export {};

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

@@ -0,0 +1,4 @@
+export { default as deleteAssociatedValues } from './deleteAssociatedValues';
+export { default as runBehaviorPostSave } from './runBehaviorPostSave';
+export { default as runPreDelete } from './runPreDelete';
+export { default as updateAssociatedForms } from './updateAssociatedForms';

package/apps/core/src/domain/library/helpers/runBehaviorPostSave.d.ts

@@ -0,0 +1,18 @@
+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 { ILibrary } from '../../../_types/library';
+interface IDeps {
+    treeRepo: ITreeRepo;
+    libraryRepo: ILibraryRepo;
+    attributeRepo: IAttributeRepo;
+    utils: IUtils;
+    translator: i18n;
+    config: IConfig;
+}
+declare const _default: (library: ILibrary, isNewLib: boolean, deps: IDeps, ctx: IQueryInfos) => Promise<void>;
+export default _default;

package/apps/core/src/domain/library/helpers/runPreDelete.d.ts

@@ -0,0 +1,13 @@
+import { ITreeDomain } from 'domain/tree/treeDomain';
+import { ITreeRepo } from 'infra/tree/treeRepo';
+import { IUtils } from 'utils/utils';
+import { IQueryInfos } from '_types/queryInfos';
+import { ILibrary } from '../../../_types/library';
+interface IDeps {
+    'core.domain.tree'?: ITreeDomain;
+    'core.infra.tree'?: ITreeRepo;
+    'core.utils'?: IUtils;
+}
+export type RunPreDeleteFunc = (library: ILibrary, ctx: IQueryInfos) => Promise<void>;
+declare const _default: ({ "core.domain.tree": treeDomain, "core.infra.tree": treeRepo, "core.utils": utils }: IDeps) => RunPreDeleteFunc;
+export default _default;

package/apps/core/src/domain/library/helpers/runPreDelete.spec.d.ts

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

package/apps/core/src/domain/library/helpers/updateAssociatedForms.d.ts

@@ -0,0 +1,10 @@
+import { IQueryInfos } from '_types/queryInfos';
+import { IFormDomain } from 'domain/form/formDomain';
+interface IDeps {
+    'core.domain.form'?: IFormDomain;
+}
+export interface IUpdateAssociatedFormsHelper {
+    updateAssociatedForms: (deletedAttrs: string[], libraryId: string, ctx: IQueryInfos) => Promise<void>;
+}
+export default function ({ 'core.domain.form': formDomain }: IDeps): IUpdateAssociatedFormsHelper;
+export {};

package/apps/core/src/domain/library/helpers/validateLibAttributes.d.ts

@@ -0,0 +1,8 @@
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { ILibrary } from '_types/library';
+import { IQueryInfos } from '_types/queryInfos';
+import { ErrorFieldDetail } from '../../../_types/errors';
+declare const _default: (libraryData: ILibrary, attributes: string[], deps: {
+    attributeDomain: IAttributeDomain;
+}, ctx: IQueryInfos) => Promise<ErrorFieldDetail<ILibrary>>;
+export default _default;

package/apps/core/src/domain/library/helpers/validateLibFullTextAttributes.d.ts

@@ -0,0 +1,4 @@
+import { ILibrary } from '_types/library';
+import { ErrorFieldDetail } from '../../../_types/errors';
+declare const _default: (attributes: string[], fullTextAttributes: string[]) => ErrorFieldDetail<ILibrary>;
+export default _default;

package/apps/core/src/domain/library/helpers/validatePermConf.d.ts

@@ -0,0 +1,9 @@
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { ILibrary } from '_types/library';
+import { ITreePermissionsConf } from '_types/permissions';
+import { ErrorFieldDetail } from '../../../_types/errors';
+import { IQueryInfos } from '_types/queryInfos';
+declare const _default: (permissionsConf: ITreePermissionsConf, deps: {
+    attributeDomain: IAttributeDomain;
+}, ctx: IQueryInfos) => Promise<ErrorFieldDetail<ILibrary>>;
+export default _default;

package/apps/core/src/domain/library/helpers/validatePreviewsSettings.d.ts

@@ -0,0 +1,5 @@
+import { IQueryInfos } from '_types/queryInfos';
+import { ErrorFieldDetail } from '../../../_types/errors';
+import { ILibrary } from '../../../_types/library';
+declare const _default: (libData: ILibrary, ctx: IQueryInfos) => Promise<ErrorFieldDetail<ILibrary>>;
+export default _default;

package/apps/core/src/domain/library/helpers/validateRecordIdentityConf.d.ts

@@ -0,0 +1,8 @@
+import { IAttributeDomain } from 'domain/attribute/attributeDomain';
+import { ILibrary } from '_types/library';
+import { ErrorFieldDetail } from '../../../_types/errors';
+import { IQueryInfos } from '_types/queryInfos';
+declare const _default: (libData: ILibrary, libAttributes: string[], deps: {
+    attributeDomain: IAttributeDomain;
+}, ctx: IQueryInfos) => Promise<ErrorFieldDetail<ILibrary>>;
+export default _default;

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

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

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,16 @@
+import { Log } from '@leav/utils';
+import { ILogRepo } from 'infra/log/logRepo';
+import { ILogFilters, ILogPagination, ILogSort } from '_types/log';
+import { IQueryInfos } from '_types/queryInfos';
+export interface ILogDomain {
+    getLogs: (params: {
+        filters?: ILogFilters;
+        sort?: ILogSort;
+        pagination?: ILogPagination;
+    }, ctx: IQueryInfos) => Promise<Log[]>;
+}
+interface IDeps {
+    'core.infra.log': ILogRepo;
+}
+export default function ({ 'core.infra.log': logRepo }: 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 { TreePaths } 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 IGetPermissionByUserGroupsParams {
+    type: PermissionTypes;
+    action: PermissionsActions;
+    userGroupsPaths: TreePaths[];
+    applyTo?: string;
+    permissionTreeTarget?: IPermissionsTreeTarget;
+    ctx: IQueryInfos;
+}
+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) => boolean | null;
+    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?: TreePaths[];
+}
+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;
+}

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 {};