mftsccs-node 0.2.4 → 0.2.5

package/dist/types/DataStructures/Local/LocalConnectionData.d.ts

@@ -1,20 +1,16 @@
-import { Connection } from "../Connection";
+import { LConnection } from "./LConnection";
 export declare class LocalConnectionData {
     name: string;
     constructor();
-    static connectionArray: Connection[];
-    static connectionDictionary: Connection[];
-    static CheckContains(connection: Connection): boolean;
-    static AddConnection(connection: Connection): void;
-    static AddConnectionToMemory(connection: Connection): void;
-    static AddToDictionary(connection: Connection): void;
-    static RemoveConnection(connection: Connection): void;
-    static RemoveConnectionById(connectionId: number): void;
-    static AddPermanentConnection(connection: Connection): void;
-    static GetConnection(id: number): Connection | null;
+    static connectionArray: LConnection[];
+    static connectionDictionary: LConnection[];
+    static CheckContains(connection: LConnection): boolean;
+    static AddConnection(connection: LConnection): void;
+    static AddToDictionary(connection: LConnection): void;
+    static RemoveConnection(connection: LConnection): void;
+    static GetConnection(id: number): LConnection | null;
     static waitForDataToLoad(): Promise<unknown>;
     static checkFlag(resolve: any): any;
-    static GetConnectionsOfCompositionLocal(id: number): Promise<Connection[]>;
-    static GetConnectionOfCompositionAndTypeLocal(typeId: number, ofTheConceptId: number): Promise<Connection[]>;
+    static GetConnectionsOfCompositionLocal(id: number): Promise<LConnection[]>;
     getName(): string;
 }

package/dist/types/DataStructures/Local/LocalSyncData.d.ts

@@ -1,33 +1,14 @@
-import { Concept } from "./../Concept";
-import { Connection } from "../Connection";
-import { InnerActions } from "../../app";
-type syncContainer = {
-    id: string;
-    data: InnerActions;
-    createdDate: string;
-};
+import { LConcept } from "./LConcept";
+import { LConnection } from "./LConnection";
 export declare class LocalSyncData {
-    static conceptsSyncArray: Concept[];
-    static connectionSyncArray: Connection[];
-    static ghostIdMap: Map<any, any>;
-    static transactionCollections: syncContainer[];
-    static CheckContains(concept: Concept): boolean;
+    static conceptsSyncArray: LConcept[];
+    static connectionSyncArray: LConnection[];
+    static CheckContains(concept: LConcept): boolean;
     static SyncDataDelete(id: number): void;
-    static CheckContainsConnection(connection: Connection): boolean;
-    static AddConcept(concept: Concept): void;
-    static RemoveConcept(concept: Concept): void;
-    static SyncDataOnlineWithoutAuth(transactionId?: string, actions?: InnerActions, withAuth?: boolean): Promise<any>;
-    static SyncDataOnline(transactionId?: string, actions?: InnerActions, withAuth?: boolean): Promise<any>;
-    static ConvertGhostIdsInConnections(connectionArray: Connection[]): void;
-    static UpdateConceptListToIncludeRelatedConcepts(connectionArray: Connection[], conceptsArray: Concept[]): Promise<void>;
-    static AddConceptIfDoesNotExist(concept: Concept, conceptList?: Concept[]): void;
-    static CheckIfTheConceptIdExists(id: number, conceptList?: Concept[]): Concept;
-    static AddConnection(connection: Connection): void;
-    static RemoveConnection(connection: Connection): void;
-    static RemoveConnectionById(connectionId: number): void;
+    static CheckContainsConnection(connection: LConnection): boolean;
+    static AddConcept(concept: LConcept): void;
+    static RemoveConcept(concept: LConcept): void;
+    static AddConnection(connection: LConnection): void;
+    static RemoveConnection(connection: LConnection): void;
     static syncDataLocalDb(): Promise<string>;
-    static initializeTransaction(transactionId: string): Promise<any>;
-    static markTransactionActions(transactionId: string, actions: InnerActions): Promise<any>;
-    static rollbackTransaction(transactionId: string, actions: InnerActions): Promise<any>;
 }
-export {};

package/dist/types/DataStructures/Node.d.ts

@@ -11,7 +11,6 @@ export declare class Node {
     addCurrentNode(passedNode: Node, node: Node | null): Node;
     addCurrentNodeType(passedNode: Node, node: Node | null): Node;
     addNode(passedNode: Node, node: Node | null, height: number): Node | null;
-    checkIfIdsInNode(node: Node | null, ids: number[], connectionArray: Concept[], remainingIds: any): void;
     addCharacterNode(passedNode: Node, node: Node | null, height: number): Node | null;
     addTypeNode(passedNode: Node, node: Node | null, height: number): Node | null;
     rightRotate(y: Node | null): Node | null;

package/dist/types/DataStructures/Search/FreeschemaQuery.d.ts

@@ -14,10 +14,9 @@ export declare class FreeschemaQuery {
     order: string;
     outputFormat: number;
     name: string;
-    filterAncestor: string;
     reverse: boolean;
     limit: boolean;
-    isSecure: boolean;
+    filterAncestor: string;
     includeInFilter: boolean;
     isOldConnectionType: boolean;
 }

package/dist/types/DataStructures/Search/SearchStructure.d.ts

@@ -6,5 +6,4 @@ export declare class SearchStructure {
     userId: number;
     inpage: number;
     page: number;
-    auth: boolean;
 }

package/dist/types/DataStructures/SearchQuery.d.ts

@@ -13,5 +13,4 @@ export declare class SearchQuery {
     doFilter: boolean;
     filterSearches: FilterSearch[];
     selectors: string[];
-    ofCompositions: number[];
 }

package/dist/types/DataStructures/Security/TokenStorage.d.ts

@@ -1,5 +1,4 @@
 export declare class TokenStorage {
     static BearerAccessToken: string;
-    static sessionId: number;
-    static setSession(sessionId: any): void;
+    static JwtSecret: string;
 }

package/dist/types/DataStructures/SyncData.d.ts

@@ -1,8 +1,15 @@
 import { Concept } from "./Concept";
 import { Connection } from "./Connection";
+import { InnerActions } from "./Transaction/Transaction";
+type syncContainer = {
+    id: string;
+    data: InnerActions;
+    createdDate: string;
+};
 export declare class SyncData {
     static conceptsSyncArray: Concept[];
     static connectionSyncArray: Connection[];
+    static transactionCollections: syncContainer[];
     static CheckContains(concept: Concept): boolean;
     static SyncDataDelete(id: number): void;
     static CheckContainsConnection(connection: Connection): boolean;
@@ -10,5 +17,10 @@ export declare class SyncData {
     static RemoveConcept(concept: Concept): void;
     static AddConnection(connection: Connection): void;
     static RemoveConnection(connection: Connection): void;
-    static SyncDataOnline(): Promise<any>;
+    static SyncDataOnline(transactionId?: string): Promise<"done" | undefined>;
+    static initializeTransaction(transactionId: string): Promise<void>;
+    static markTransactionActions(transactionId: string, actions: InnerActions): Promise<void>;
+    static rollbackTransaction(transactionId: string, actions: InnerActions): Promise<void>;
+    static syncDataLocalDb(): Promise<string>;
 }
+export {};

package/dist/types/DataStructures/Transaction/Transaction.d.ts

@@ -0,0 +1,30 @@
+import { Concept } from "../Concept";
+import { Connection } from "../Connection";
+export declare class Transaction {
+    protected transactionId: string;
+    actions: InnerActions;
+    protected success: boolean;
+    constructor();
+    initialize(): Promise<void>;
+    /**
+   * Method to move concepts and connection to transaction collection
+   * @param concept Concept
+   */
+    protected markAction(): Promise<void>;
+    /**
+   * Method to rollback all the tranctions occured
+   */
+    rollbackTransaction(): Promise<void>;
+    commitTransaction(): Promise<void>;
+    /**
+   * Concepts
+   */
+    MakeTheInstanceConcept(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number): Promise<Concept>;
+    CreateConnection(ofTheConcept: Concept, toTheConcept: Concept, typeConnection: string): Promise<Connection>;
+    MakeTheTypeConcept(typeString: string, sessionId: number, sessionUserId: number, userId: number): Promise<Concept>;
+    CreateTheConnectionGeneral(ofTheConceptId: number, ofTheConceptUserId: number, toTheConceptId: number, toTheConceptUserId: number, typeId: number, sessionInformationId: number, sessionInformationUserId: number, orderId?: number, accessId?: number, passedUserId?: number): Promise<Connection>;
+}
+export interface InnerActions {
+    concepts: Concept[];
+    connections: Connection[];
+}

package/dist/types/DataStructures/User/UserBinaryTree.d.ts

@@ -1,13 +1,15 @@
-import { Concept } from "../../DataStructures/Concept";
+import { LConcept } from "../../DataStructures/Local/LConcept";
 import { UserNode } from "./UserNode";
+import { LConnection } from "../Local/LConnection";
 export declare class UserBinaryTree {
     static root: UserNode | null;
-    static compositeKey(userId: number, sessionId: number): string;
+    static compositeKey(userId: number, sessionId: number, randomizer?: number): string;
     static addNodeToTree(node: UserNode): UserNode | undefined;
     static waitForDataToLoad(): Promise<unknown>;
     static checkFlag(resolve: any): any;
-    static addConceptToTree(concept: Concept, userId: number, sessionId?: number): void;
-    static getNodeFromTree(userId: number, sessionId: number): Promise<UserNode | null>;
-    static removeNodeFromTree(userId: number, sessionId?: number): Promise<void>;
+    static addConceptToTree(concept: LConcept, userId: number, sessionId?: number): void;
+    static addConnectionToTree(connection: LConnection, userId: number, sessionId?: number): void;
+    static getNodeFromTree(userId: number, sessionId: number, randomizer?: number): Promise<UserNode | null>;
+    static removeNodeFromTree(userId: number, sessionId?: number, randomizer?: number): Promise<void>;
     static countNumberOfNodes(): number;
 }

package/dist/types/DataStructures/User/UserNode.d.ts

@@ -1,11 +1,13 @@
-import { Concept } from "../Concept";
+import { LConcept } from "../Local/LConcept";
+import { LConnection } from "../Local/LConnection";
 export declare class UserNode {
     key: any;
-    value: Concept[];
+    connectionValue: LConnection[];
+    value: LConcept[];
     leftNode: UserNode | null;
     rightNode: UserNode | null;
     height: number;
-    constructor(key: any, value: Concept, leftNode: UserNode | null, rightNode: UserNode | null);
+    constructor(key: any, value: LConcept, connectionValue: LConnection, leftNode: UserNode | null, rightNode: UserNode | null);
     addNode(passedNode: UserNode, node: UserNode | null, height: number): UserNode | null;
     rightRotate(y: UserNode | null): UserNode | null;
     leftRotate(x: UserNode | null): UserNode | null;

package/dist/types/Database/NoIndexDb.d.ts

@@ -4,6 +4,6 @@ export declare function storeToDatabase(databaseName: string, object: any): void
 export declare function GetStatsFromDatabase(): SettingData;
 export declare function AiUpdateFlag(object: SettingData): void;
 export declare function getFromDatabaseWithType(databaseName: string, type: string, id: number): Promise<void>;
-export declare function getObjectsFromIndexDb(databaseName: string): Promise<void>;
+export declare function getFromDatabaseWithTypeOld(databaseName: string): Promise<void>;
 export declare function removeFromDatabase(databaseName: string, id: number): void;
 export declare function getAllFromLocalDb(databaseName: string): Promise<void>;

package/dist/types/Database/indexdblocal.d.ts

@@ -1,43 +1,3 @@
-/**
- * This class will help us store the indexdb  reference in memory and not go back to index db.
- */
 export declare class LocalIndexDb {
     static db: IDBDatabase;
 }
-/**
- *
- * @param databaseName not required actually. This is not used you can pass anything.
- * @returns a promise that either resolves or rejects opening the database.
- */
-export declare function openDatabase(databaseName: string): Promise<IDBDatabase>;
-export declare function LockTheDatabase(databaseName: string): Promise<void>;
-export declare function UnlockDatabase(databaseName: string): Promise<void>;
-export declare function GetLockStatus(databaseName: string): Promise<any>;
-/**
-*  this function will return all the objects that are in the database
-* @param databaseName name of the database
-* @returns all the objects that are in the database
-*/
-export declare function getObjectsFromLocalIndexDb(databaseName: string): Promise<unknown>;
-/**
- *
- * @param databaseName name of the database that you want to store data to.
- * @param object any object that can be stored but keep in mind it must follow the convention that we created
- * while creating the datbase.
- * @returns a promise that if a store is successful then the obejct is returned else rejects with the event.
- */
-export declare function storeToDatabase(databaseName: string, object: any): Promise<unknown>;
-/**
- *
- * @param databaseName name of the database
- * @param object this is the object that you want to update
- * @returns returns the object if it is updated successfully.
- */
-export declare function UpdateToDatabase(databaseName: string, object: any): Promise<unknown>;
-/**
- *
- * @param databaseName name of the database
- * @param id the id that we need to remove from the database (this is the index)
- * @returns an id if the deletion is successful and error with even in case it cannot.
- */
-export declare function removeFromDatabase(databaseName: string, id: number): Promise<unknown>;

package/dist/types/Database/indexeddb.d.ts

@@ -1,53 +1,3 @@
-import { SettingData } from "../DataStructures/SettingData";
-/**
- * This class will help us store the indexdb  reference in memory and not go back to index db.
- */
 export declare class IndexDb {
     static db: IDBDatabase;
 }
-/**
- *
- * @param databaseName not required actually. This is not used you can pass anything.
- * @returns a promise that either resolves or rejects opening the database.
- */
-export declare function openDatabase(databaseName: string): Promise<IDBDatabase>;
-/**
- *
- * @param databaseName name of the database that you want to store data to.
- * @param object any object that can be stored but keep in mind it must follow the convention that we created
- * while creating the datbase.
- * @returns a promise that if a store is successful then the obejct is returned else rejects with the event.
- */
-export declare function storeToDatabase(databaseName: string, object: any): Promise<any>;
-/**
-  *
-  * @param databaseName name of the database
-  * @param object this is the object that you want to update
-  * @returns returns the object if it is updated successfully.
-  */
-export declare function UpdateToDatabase(databaseName: string, object: any): Promise<unknown>;
-/**
- *
- * @returns This returns the last object from the database.
- */
-export declare function GetLastSettingsFromDatabase(): Promise<unknown>;
-/**
- *
- * @param object SettingData
- * @returns this will update the indexdb with the ai flag so that another time we do not have to pull
- *  ai data from the api.
- */
-export declare function AiUpdateFlag(object: SettingData): Promise<unknown>;
-/**
- *  this function will return all the objects that are in the database
- * @param databaseName name of the database
- * @returns all the objects that are in the database
- */
-export declare function getObjectsFromIndexDb(databaseName: string): Promise<unknown>;
-/**
- *
- * @param databaseName name of the database
- * @param id the id that we need to remove from the database (this is the index)
- * @returns an id if the deletion is successful and error with even in case it cannot.
- */
-export declare function removeFromDatabase(databaseName: string, id: number): Promise<unknown>;

package/dist/types/Helpers/CheckIfExists.d.ts

@@ -1,9 +1,10 @@
 import { Concept } from "../DataStructures/Concept";
 import { Connection } from "../DataStructures/Connection";
+import { LConcept, LConnection } from "../app";
 export declare function CheckIfConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept;
 export declare function CheckIfTypeConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept[];
-export declare function CheckIfTypeLConceptsExistsInArray(conceptList: Concept[] | undefined, concept: Concept): Concept[];
+export declare function CheckIfTypeLConceptsExistsInArray(conceptList: LConcept[] | undefined, concept: LConcept): LConcept[];
 export declare function CheckIfConnectionExistsInArray(connectionList: Connection[] | undefined, connection: Connection): Connection;
 export declare function CheckIfToTheConceptExistsInConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection;
 export declare function CheckAllConnectionsConnectedInConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection[];
-export declare function CheckAllConnectionsConnectedInLConnectionArray(connectionList: Connection[] | undefined, conceptId: number): Connection[];
+export declare function CheckAllConnectionsConnectedInLConnectionArray(connectionList: LConnection[] | undefined, conceptId: number): LConnection[];

package/dist/types/Helpers/RemoveFromArray.d.ts

@@ -1,5 +1,6 @@
 import { Concept } from "../DataStructures/Concept";
 import { Connection } from "../DataStructures/Connection";
+import { LConnection } from "../app";
 export declare function RemoveConceptFromList(conceptList: Concept[] | undefined, concept: Concept): void;
 export declare function RemoveConnectionFromList(connectionList: Connection[] | undefined, connection: Connection): void;
-export declare function RemoveLConnectionFromList(connectionList: Connection[] | undefined, connection: Connection): void;
+export declare function RemoveLConnectionFromList(connectionList: LConnection[] | undefined, connection: LConnection): void;

package/dist/types/Services/AccessControl/AccessControlCacheService.d.ts

@@ -0,0 +1,19 @@
+import { PermissionSet } from './PermissionSet';
+export declare class AccessControlCacheService {
+    private readonly userAccessCache;
+    private readonly publicAccessCache;
+    private readonly baseUrl;
+    constructor();
+    loadCacheFromApi(entityId?: number): Promise<void>;
+    loadCacheFromJson(jsonData: any): void;
+    hasAccess(entityId: number, conceptId: number, required: PermissionSet): Promise<boolean>;
+    getAccessibleConcepts(entityId: number, conceptIds: number[], required: PermissionSet): Promise<number[]>;
+    getAccessByUser(entityId: number): Promise<Map<number, PermissionSet>>;
+    getAccessByConcept(conceptId: number): Promise<Map<number, PermissionSet>>;
+    deleteRecordByUserId(entityId: number): void;
+    deletePublicAccessRecordById(conceptId: number): void;
+    clearCache(): void;
+    getConceptsByPublicAccess(): Promise<Record<number, string[]>>;
+    hasPublicAccess(conceptId: number, required: PermissionSet): Promise<boolean>;
+    getConceptsWithPublicAccess(conceptIds: number[], required: PermissionSet): Promise<number[]>;
+}

package/dist/types/Services/AccessControl/AccessControlService.d.ts

@@ -0,0 +1,267 @@
+import { PermissionSet } from "./PermissionSet";
+export declare class AccessControlService {
+    private static accessCache;
+    private static baseUrl;
+    private static initialize;
+    /**
+     * Checks if a user or entity has the specified access for a single concept.
+     * @param userId - The user's ID.
+     * @param access - The required PermissionSet.
+     * @param conceptId - The concept ID to check.
+     * @param entityId - Optional entity ID (defaults to userId).
+     * @returns Promise<boolean> - True if access is granted, false otherwise.
+     */
+    static checkAccessOfConcept(userId: number, access: PermissionSet, conceptId: number, entityId?: number): Promise<boolean>;
+    /**
+     * Checks if a user or entity has the specified access for all concepts in a list.
+     * @param userId - The user's ID.
+     * @param access - The required PermissionSet.
+     * @param conceptIdList - Array of concept IDs to check.
+     * @param entityId - Optional entity ID (defaults to userId).
+     * @returns Promise<boolean> - True if access is granted for all, false otherwise.
+     */
+    static checkAccessOfConceptList(userId: number, access: PermissionSet, conceptIdList: number[], entityId?: number): Promise<boolean>;
+    /**
+     * Filters a list of concept IDs, returning only those for which the user or entity has the specified access.
+     * @param userId - The user's ID.
+     * @param access - The required PermissionSet.
+     * @param conceptIdList - Array of concept IDs to filter.
+     * @param entityId - Optional entity ID (defaults to userId).
+     * @returns Promise<number[]> - Array of concept IDs with access.
+     */
+    static filterConceptListByAccess(userId: number, access: PermissionSet, conceptIdList: number[], entityId?: number): Promise<number[]>;
+    /**
+     * Gets the entity ID for a given user ID.
+     * @param userId - The user's ID.
+     * @returns number - The entity ID (default: userId).
+     */
+    private static getEntityIdConceptByUserId;
+    /**
+     * Assigns access to a specific entity for a concept.
+     * @param request - Object containing conceptId, access, entityId, makePublic.
+     * @returns Promise<any> - API response.
+     */
+    static assignAccessToEntity(request: {
+        conceptId: number;
+        access: string;
+        entityId: number;
+        makePublic: boolean;
+    }): Promise<any>;
+    /**
+     * Assigns public access to a concept or list of concepts.
+     * @param request - Object containing conceptId, accessList, connectionTypeList, nestedAccessLevel, conceptIdList.
+     * @returns Promise<any> - API response.
+     */
+    static assignPublicAccess(request: {
+        conceptId: number;
+        accessList: string[];
+        connectionTypeList?: string[];
+        nestedAccessLevel?: number;
+        conceptIdList?: number[];
+    }): Promise<any>;
+    /**
+     * Assigns public access to multiple concepts in bulk.
+     * @param request - Object containing conceptIdList, accessList, connectionTypeList, nestedAccessLevel, conceptId.
+     * @returns Promise<any> - API response.
+     */
+    static assignPublicAccessBlukConcept(request: {
+        conceptIdList: number[];
+        accessList: string[];
+        connectionTypeList?: string[];
+        nestedAccessLevel?: number;
+        conceptId?: number;
+    }): Promise<any>;
+    /**
+     * Assigns access to multiple entities and concepts in bulk.
+     * @param request - Object containing conceptId, conceptIdList, entityIdList, accessList, connectionTypeList, nestedAccessLevel.
+     * @returns Promise<any> - API response.
+     */
+    static assignAccessToEntityBulk(request: {
+        conceptId: number;
+        conceptIdList?: number[];
+        entityIdList: number[];
+        accessList: string[];
+        connectionTypeList?: string[];
+        nestedAccessLevel?: number;
+    }): Promise<any>;
+    /**
+     * Assigns access to a user for a concept.
+     * @param request - Object containing conceptId, access, userId, makePublic.
+     * @returns Promise<any> - API response.
+     */
+    static assignAccessByUser(request: {
+        conceptId: number;
+        access: string;
+        userId: number;
+        makePublic: boolean;
+    }): Promise<any>;
+    /**
+     * Revokes access for an entity from a concept.
+     * @param params - Object containing conceptId, access, entityId.
+     * @returns Promise<any> - API response.
+     */
+    static revokeAccess(params: {
+        conceptId: number;
+        access: string;
+        entityId: number;
+    }): Promise<any>;
+    /**
+     * Revokes access for multiple entities in bulk.
+     * @param request - Object containing conceptId, entityIdList, accessList.
+     * @returns Promise<any> - API response.
+     */
+    static revokeAccessBulk(request: {
+        conceptId: number;
+        entityIdList: number[];
+        accessList: string[];
+    }): Promise<any>;
+    /**
+     * Gets the access list for a concept and user.
+     * @param conceptId - The concept ID.
+     * @param userId - The user ID.
+     * @returns Promise<any> - API response.
+     */
+    static getAccessList(conceptId: number, userId: number): Promise<any>;
+    /**
+     * Gets the public access list for a list of concept IDs.
+     * @param conceptIdList - Array of concept IDs.
+     * @returns Promise<any> - API response.
+     */
+    static getPublicAccessList(conceptIdList: number[]): Promise<any>;
+    /**
+     * Revokes public access for a concept.
+     * @param request - Object containing conceptId, accessList.
+     * @returns Promise<any> - API response.
+     */
+    static revokePublicAccess(request: {
+        conceptId: number;
+        accessList: string[];
+    }): Promise<any>;
+    /**
+     * Checks if an entity has a specific permission for a concept.
+     * @param params - Object containing conceptId, permission, entityId.
+     * @returns Promise<any> - API response.
+     */
+    static checkAccess(params: {
+        conceptId: number;
+        permission: string;
+        entityId: number;
+    }): Promise<any>;
+    /**
+     * Checks if a user has a specific access for a concept.
+     * @param request - Object containing conceptId, access, userId.
+     * @returns Promise<any> - API response.
+     */
+    static checkAccessByUser(request: {
+        conceptId: number;
+        access: string;
+        userId: number;
+    }): Promise<any>;
+    /**
+     * Filters concepts by access for a user.
+     * @param request - Object containing userId, access, conceptIdList, connectionIdList.
+     * @returns Promise<any> - API response.
+     */
+    static filterConceptsByAccess(request: {
+        userId: number;
+        access: string;
+        conceptIdList?: number[];
+        connectionIdList?: number[];
+    }): Promise<any>;
+    /**
+     * Checks access for a user on multiple concepts in bulk.
+     * @param request - Object containing userId, access, conceptIdList.
+     * @returns Promise<any> - API response.
+     */
+    static checkAccessOfConceptBulk(request: {
+        userId: number;
+        access: string;
+        conceptIdList: number[];
+    }): Promise<any>;
+    /**
+     * Gets entities with a specific access for a concept.
+     * @param conceptId - The concept ID.
+     * @param access - The access type.
+     * @returns Promise<any> - API response.
+     */
+    static getEntitiesByAccess(conceptId: number, access: string): Promise<any>;
+    /**
+     * Gets all entities with any access for a concept.
+     * @param conceptId - The concept ID.
+     * @returns Promise<any> - API response.
+     */
+    static getEntitiesWithAccess(conceptId: number): Promise<any>;
+    /**
+     * Gets access groups by entity.
+     * @param entityId - Optional entity ID.
+     * @returns Promise<any> - API response.
+     */
+    static getAccessGroupByEntity(entityId?: number): Promise<any>;
+    /**
+     * Gets access groups by user.
+     * @param userId - Optional user ID.
+     * @returns Promise<any> - API response.
+     */
+    static getAccessGroupByUser(userId?: number): Promise<any>;
+    /**
+     * Gets public access by access IDs.
+     * @param accessIdList - Array of access IDs.
+     * @returns Promise<any> - API response.
+     */
+    static getPublicAccessByAccessIds(accessIdList: number[]): Promise<any>;
+    /**
+     * Gets the full access mapping for public users.
+     * @returns Promise<any> - API response.
+     */
+    static getFullAccessMappingForPublic(): Promise<any>;
+    /**
+     * Assigns public access for all users.
+     * @returns Promise<any> - API response.
+     */
+    static assignPublicAccessForAllUser(): Promise<any>;
+    /**
+     * Assigns access by connection type for users.
+     * @returns Promise<any> - API response.
+     */
+    static assignAccessByConncetionTypeOfUser(): Promise<any>;
+    /**
+     * Sets access inheritance for a concept.
+     * @param request - Object containing mainConceptId, enable, connectionTypeId.
+     * @returns Promise<any> - API response.
+     */
+    static setAccessInheritance(request: {
+        mainConceptId: number;
+        enable: boolean;
+        connectionTypeId?: number;
+    }): Promise<any>;
+    /**
+     * Gets the status of access inheritance for a concept.
+     * @param mainConceptId - The main concept ID.
+     * @param connectionTypeId - The connection type ID (default: 999).
+     * @returns Promise<any> - API response.
+     */
+    static getAccessInheritanceStatus(mainConceptId: number, connectionTypeId?: number): Promise<any>;
+    /**
+     * Performs a GET request to the backend API.
+     * @param path - The API path.
+     * @param errorMsg - Error message to throw if request fails.
+     * @returns Promise<any> - API response.
+     */
+    private static _get;
+    /**
+     * Performs a POST request to the backend API.
+     * @param path - The API path.
+     * @param body - Request body.
+     * @param errorMsg - Error message to throw if request fails.
+     * @returns Promise<any> - API response.
+     */
+    private static _post;
+    /**
+     * Performs a DELETE request to the backend API.
+     * @param path - The API path.
+     * @param body - Optional request body.
+     * @param errorMsg - Error message to throw if request fails.
+     * @returns Promise<any> - API response.
+     */
+    private static _delete;
+}

package/dist/types/Services/AccessControl/PermissionSet.d.ts

@@ -0,0 +1,8 @@
+export declare enum PermissionSet {
+    None = 0,
+    Read = 1,
+    Write = 2,
+    Execute = 4,
+    Delete = 8
+}
+export declare function getPermissionSetFromStrings(permissions: string[]): PermissionSet;

package/dist/types/Services/Common/ErrorPosting.d.ts

@@ -1,10 +1,2 @@
 export declare function HandleHttpError(response: Response): void;
-export declare function HandleHttpErrorObject(response: Response, output?: any): void;
 export declare function HandleInternalError(error: any, url?: string): void;
-/**
- * Handle errors inside package functions
- * @updateLog existing function log at start
- * @param functionName name of the function that encountered the error
- * @param error error appeared
- */
-export declare function UpdatePackageLogWithError(logData: any, functionName: string, error: any): void;