mftsccs-node 0.2.2 → 0.2.4

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

@@ -1,2 +1,10 @@
 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;

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

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param array1 The array you want to merge into
+ * @param array2 The array you want to merge
+ * @returns array1 with the elements of array 2
+ */
+export declare function MergeTwoArrays(array1: any, array2: any): any;

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

@@ -0,0 +1 @@
+export declare function removeAllChildren(parent: HTMLElement): void;

package/dist/types/Services/ConceptFinding/GetConceptByCharacterAndCategory.d.ts

@@ -1,5 +1,4 @@
 import { Concept } from "../../app";
 export declare function GetConceptByCharacterAndCategory(character: string): Promise<Concept>;
 export declare function GetConceptByCharacter(characterValue: string): Promise<Concept>;
-export declare function GetConceptByCharacterSingle(characterValue: string): Promise<Concept>;
 export declare function GetConceptByCharacterAndCategoryFromMemory(character: string, category: number): Promise<Concept>;

package/dist/types/Services/Conversion/ConvertConcepts.d.ts

@@ -1,7 +1,5 @@
 import { Concept } from "../../DataStructures/Concept";
 import { Connection } from "../../DataStructures/Connection";
-import { LConcept } from "../../DataStructures/Local/LConcept";
-import { LConnection } from "../../DataStructures/Local/LConnection";
-export declare function convertFromConceptToLConcept(concept: Concept): LConcept;
-export declare function convertFromLConceptToConcept(lconcept: LConcept): Concept;
-export declare function convertFromConnectionToLConnection(connection: Connection): LConnection;
+export declare function convertFromConceptToLConcept(concept: Concept): Concept;
+export declare function convertFromLConceptToConcept(lconcept: Concept): Concept;
+export declare function convertFromConnectionToLConnection(connection: Connection): Connection;

package/dist/types/Services/CreateBinaryTreeFromData.d.ts

@@ -1 +1,4 @@
-export default function CreateBinaryTreeFromData(): Promise<void>;
+/**
+ * This function builds up the binary tree on startup from the indexdb
+ */
+export default function CreateConceptBinaryTreeFromIndexDb(): Promise<void>;

package/dist/types/Services/CreateCharacterBinaryTreeFromData.d.ts

@@ -1 +1,5 @@
+/**
+ * This function creates a binary character tree in the memory from which we can search for concepts using character key
+ * This helps us in searching concept by character faster.
+ */
 export declare function CreateCharacterBinaryTreeFromData(): Promise<void>;

package/dist/types/Services/CreateConnection/CreateConnectionEntity.d.ts

@@ -0,0 +1,2 @@
+import { Concept, InnerActions } from "../../app";
+export declare function CreateConnectionBetweenEntityLocal(concept1Data: Concept, concept2Data: Concept, linker: string, actions?: InnerActions): Promise<any>;

package/dist/types/Services/CreateConnectionBetweenTwoConcepts.d.ts

@@ -1,5 +1,5 @@
 import { Concept } from "../DataStructures/Concept";
 import { Connection } from "../DataStructures/Connection";
-export declare function CreateConnectionBetweenTwoConcepts(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean, count?: boolean): Promise<Connection>;
+export declare function CreateConnectionBetweenTwoConcepts(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean, count?: boolean): Promise<any>;
 export declare function CountRelationship(linker: string, concept: Concept, passedUserId?: number | null): Promise<void>;
 export declare function CreateConnectionBetweenTwoConceptsGeneral(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean, count?: boolean): Promise<Connection>;

package/dist/types/Services/CreateTheComposition.d.ts

@@ -1,2 +1 @@
-import { Concept } from "../DataStructures/Concept";
-export default function CreateTheComposition(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null): Promise<Concept>;
+export default function CreateTheComposition(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null): Promise<any>;

package/dist/types/Services/CreateTheConcept.d.ts

@@ -1,4 +1,4 @@
 import { Concept } from "../DataStructures/Concept";
-export default function CreateTheConcept(referent: string, userId: number, categoryId: number, categoryUserId: number, typeId: number, typeUserId: number, referentId: number, referentUserId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number): Promise<Concept>;
-export declare function CreateTheConceptTemporary(referent: string, userId: number, categoryId: number, categoryUserId: number, typeId: number, typeUserId: number, referentId: number, referentUserId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number): Promise<Concept>;
-export declare function CreateTheConceptImmediate(referent: string, userId: number, categoryId: number, categoryUserId: number, typeId: number, typeUserId: number, referentId: number, referentUserId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number): Promise<Concept>;
+export default function CreateTheConcept(referent: string, userId: number, categoryId: number, typeId: number, referentId: number, accessId: number, typeCharacter: string): Promise<Concept>;
+export declare function CreateTheConceptTemporary(referent: string, userId: number, categoryId: number, typeId: number, referentId: number, accessId: number, typeCharacter: string): Promise<Concept>;
+export declare function CreateTheConceptImmediate(referent: string, userId: number, categoryId: number, typeId: number, referentId: number | null, accessId: number, typeCharacter: string): Promise<Concept>;

package/dist/types/Services/CreateTheConnection.d.ts

@@ -1,2 +1,10 @@
 import { Connection } from "../DataStructures/Connection";
-export declare function createTheConnection(ofTheConceptId: number, ofTheConceptUserId: number, toTheConceptId: number, toTheConceptUserId: number, typeId: number, sessionInformationId: number, sessionInformationUserId: number): Connection;
+/**
+ * This function is used to create a connection that is internal(inside of a composition)
+ * @param ofTheConceptId Start of the connection
+ * @param userId user id fo the user creating the connection
+ * @param toTheConceptId the end of the connection
+ * @param typeId this is the type of the connection
+ * @returns
+ */
+export declare function createTheConnection(ofTheConceptId: number, userId: number, toTheConceptId: number, typeId: number): Connection;

package/dist/types/Services/CreateTheConnectionGeneral.d.ts

@@ -1,4 +1,2 @@
-import { Concept } from "../app";
 import { Connection } from "../DataStructures/Connection";
-export declare function CreateTheConnectionGeneral(ofTheConceptId: number, ofTheConceptUserId: number, toTheConceptId: number, toTheConceptUserId: number, typeId: number, sessionInformationId: number, sessionInformationUserId: number, orderId?: number, accessId?: number, passedUserId?: number): Promise<Connection>;
-export declare function CreateConnection(ofTheConcept: Concept, toTheConcept: Concept, connectionTypeString: string): Promise<Connection>;
+export declare function CreateTheConnectionGeneral(ofTheConceptId: number, ofTheConceptUserId: number, toTheConceptId: number, typeId: number, orderId?: number, accessId?: number): Promise<Connection>;

package/dist/types/Services/DeleteConcept.d.ts

@@ -1 +1,2 @@
-export declare function DeleteConceptById(id: number, token?: string): Promise<void>;
+export declare function DeleteConceptById(id: number): Promise<any>;
+export declare function DeleteUser(id: number): Promise<any>;

package/dist/types/Services/DeleteConnection.d.ts

@@ -1 +1,2 @@
-export declare function DeleteConnectionById(id: number, token?: string): Promise<boolean>;
+export declare function DeleteConnectionById(id: number): Promise<any>;
+export declare function DeleteConnectionByIdBulk(ids: number[]): Promise<any>;

package/dist/types/Services/DeleteConnectionByType.d.ts

@@ -0,0 +1,22 @@
+/**
+ *
+ * @param id
+ * @param linker
+ * @returns
+ */
+export declare function DeleteConnectionByType(id: number, linker: string): Promise<any>;
+export declare function DeleteConnectionByTypeBulk(id: number, linkers: string[]): Promise<any>;
+/**
+ * This function returns all the connections from the ofTheConceptId and connection type
+ * @param id ofTheConceptId
+ * @param linker the connection type
+ * @returns Array of connections
+ */
+export declare function GetAllTheConnectionsByTypeAndOfTheConcept(id: number, linker: string, reverse?: boolean): Promise<any>;
+/**
+ *
+ * @param id
+ * @param linker
+ * @returns
+ */
+export declare function DeleteConnectionsByTypeLocal(id: number, linkerStrings: string[]): Promise<any>;

package/dist/types/Services/FindConeceptsFromConnection.d.ts

@@ -1,2 +1,6 @@
 import { Connection } from "../DataStructures/Connection";
+/**
+ * This function takes in a list of connections and in bulk gets the concepts that are related with these connections.
+ * @param connectionList list of connections whose concepts need to be found out.
+ */
 export declare function FindConceptsFromConnections(connectionList?: Connection[]): Promise<void>;

package/dist/types/Services/FindConnectionsOfCompositionBulkInMemory.d.ts

@@ -1,2 +1 @@
-import { Connection } from "../DataStructures/Connection";
-export declare function FindConnectionsOfCompositionsBulkInMemory(composition_ids?: number[]): Promise<Connection[]>;
+export declare function FindConnectionsOfCompositionsBulkInMemory(composition_ids?: number[]): Promise<any>;

package/dist/types/Services/GetComposition.d.ts

@@ -1,10 +1,148 @@
+import { Concept } from "../DataStructures/Concept";
 import { Connection } from "../DataStructures/Connection";
+export declare function GetCompositionById(id: number): Promise<{
+    connectionList: Connection[];
+    compositionList: number[];
+}>;
+/**
+ * ## format JUSTDATA ##
+ * this function builds the composition with the main id as the point of building.
+ * @param id id of the main composition that you want to build
+ * @param connectionList  list of connections
+ * @param compositionList list of of_the_concept_ids for all the connections.
+ * @returns
+ */
+export declare function RecursiveFetchBuildLayer(id: number, connectionList: Connection[], compositionList: number[]): Promise<any>;
+/**
+ * ## format DATAID ##
+ * this function builds the composition with the main id as the point of building.
+ * @param id id of the main composition that you want to build
+ * @param connectionList  list of connections
+ * @param compositionList list of of_the_concept_ids for all the connections.
+ * @returns
+ */
+export declare function RecursiveFetchBuildLayerDataId(id: number, connectionList: Connection[], compositionList: number[]): Promise<any>;
+/**
+ * ## format Normal ##
+ * this function builds the composition with the main id as the point of building.
+ * @param id id of the main composition that you want to build
+ * @param connectionList  list of connections
+ * @param compositionList list of of_the_concept_ids for all the connections.
+ * @returns
+ */
+export declare function RecursiveFetchBuildLayerNormal(id: number, connectionList: Connection[], compositionList: number[]): Promise<any>;
+/**
+ * ## format JUSTDATA ##
+ * this function builds the composition with the main id as the point of building.
+ * This just requires the id
+ * @param id id of the main composition that you want to build
+ * @param connectionList  list of connections
+ * @param compositionList list of of_the_concept_ids for all the connections.
+ * @returns
+ */
 export declare function GetComposition(id: number): Promise<any>;
 export declare function GetCompositionWithAllIds(id: number): Promise<any>;
+/**
+ * ### Format JUSTDATA ###
+ * This function just builds data from the memory.
+ * This is a function that takes on all the concepts and connections of the concept (as a composition ) and builds
+ * it into a json data.
+ * @param id this id is just used to get all the composition data from the concepts and connections in memory
+ * @returns
+ */
 export declare function GetCompositionFromMemory(id: number): Promise<any>;
+/**
+ * ### Format Normal ###
+ * This function just builds data from the memory.
+ * This is a function that takes on all the concepts and connections of the concept (as a composition ) and builds
+ * it into a json data.
+ * @param id this id is just used to get all the composition data from the concepts and connections in memory
+ * @returns
+ */
+export declare function GetCompositionFromMemoryNormal(id: number): Promise<any>;
+/**
+ * ### Format DATAIDDATE ####
+ * Gets data just from memory
+ * @param id
+ * @returns
+ */
 export declare function GetCompositionWithIdFromMemory(id: number): Promise<any>;
+/**
+ * ### Format Normal ####
+ * Gets data just from memory
+ * @param id
+ * @returns
+ */
+export declare function GetCompositionFromMemoryWithConnections(id: number, connectionList: Connection[]): Promise<any>;
+/**
+ * ### Format DATAIDDATE ####
+ * Gets data just from memory
+ * @param id
+ * @returns
+ */
+export declare function GetCompositionWithIdFromMemoryFromConnection(id: number, connectionList: Connection[]): Promise<any>;
+/**
+ * ### Format DATAIDDATE ####
+ * ### experimental ####
+ * This is the new format that needs to work with a single or max two loops
+ * @param id the id whose composition needs to be created
+ * @returns
+ */
+export declare function GetCompositionWithIdFromMemoryNew(id: number): Promise<any>;
+/**
+ * ### Format DATAIDDATE #####
+ * ### This just returns composition from memory and not from anywhere else.
+ * @param id
+ * @returns
+ */
 export declare function GetCompositionWithIdAndDateFromMemory(id: number): Promise<any>;
-export declare function GetCompositionWithIdFromMemoryFromConnections(id: number, connectionList: Connection[]): Promise<any>;
+export declare function GetCompositionWithIdFromMemoryFromConnections(id: number, connectionList?: Connection[]): Promise<any>;
+/**
+ * #### Format DATAID ####
+ * ## This will return the composition even if it is not in the local memory ##
+ * @param id
+ * @returns
+ */
 export declare function GetCompositionWithId(id: number): Promise<any>;
+/**
+ * ## Format justdata ###
+ * ## This contains a concept in the parameter so that you dont have to again find the concept ##
+ * This function takes concepts and connections and then builds a json.
+ * @param concept The concept that needs to get other concepts that are inside of it.
+ * @param connectionList List of connections that are available in the composition. We have to loop over it.
+ * @param compositionList Composition list is the list of concepts that have connections inside of them.
+ * @param visitedConcepts This is a checking mechanism to not go in loops. So preferably pass an empty array.
+ * @returns
+ */
+export declare function recursiveFetchConcept(concept: Concept, connectionList: Connection[], compositionList: number[], visitedConcepts?: number[]): Promise<any>;
+/**
+* ## Format Normal ###
+* ## This contains a concept in the parameter so that you dont have to again find the concept ##
+* This function takes concepts and connections and then builds a json.
+* @param concept The concept that needs to get other concepts that are inside of it.
+* @param connectionList List of connections that are available in the composition. We have to loop over it.
+* @param compositionList Composition list is the list of concepts that have connections inside of them.
+* @param visitedConcepts This is a checking mechanism to not go in loops. So preferably pass an empty array.
+* @returns
+*/
+export declare function recursiveFetchConceptNormal(concept: Concept, connectionList: Connection[], compositionList: number[], visitedConcepts?: number[]): Promise<any>;
+/**
+ * ## experimental ##
+* This function takes concepts and connections and then builds a json.
+* @param concept The concept that needs to get other concepts that are inside of it.
+* @param connectionList List of connections that are available in the composition. We have to loop over it.
+* @param compositionList Composition list is the list of concepts that have connections inside of them.
+* @param visitedConcepts This is a checking mechanism to not go in loops. So preferably pass an empty array.
+* @returns
+*/
+export declare function recursiveFetchConceptSingleLoop(concept: Concept, connectionList: Connection[], compositionList: number[], visitedConcepts?: number[]): Promise<any>;
+/**
+ * ## Format justdata ##
+ * @param id
+ * @param connectionList
+ * @param compositionList
+ * @param visitedConcepts
+ * @returns
+ */
 export declare function recursiveFetch(id: number, connectionList: Connection[], compositionList: number[], visitedConcepts?: number[]): Promise<any>;
 export declare function recursiveFetchWithSubCompositions(id: number, connectionList: Connection[], compositionList: number[], visitedConcepts?: number[]): Promise<any>;

package/dist/types/Services/GetCompositionBulk.d.ts

@@ -1,11 +1,100 @@
 import { Connection } from "../DataStructures/Connection";
-export declare function GetCompositionBulk(ids?: number[]): Promise<any[]>;
-export declare function GetCompositionBulkWithDataId(ids?: number[]): Promise<any[]>;
-export declare function GetCompositionFromConnectionsWithDataId(ids?: number[], connections?: number[]): Promise<any[]>;
+/**
+ * ## Format JUSTDATA ##
+ * Function converts the conceptIds to json (compositions)
+ * This function takes in the conceptIds and returns a list of compositions related to those concepts.
+ * @param conceptIds  list of concept ids that are compositions.
+ * @returns compositions
+ */
+export declare function GetCompositionBulk(conceptIds?: number[]): Promise<any[]>;
+/**
+ * ## FORMAT DATAIDDATE ##
+ * Function converts the conceptIds to json (compositions)
+ * @param conceptIds this is the list of concept ids that should be converted to compostions in data - id format.
+ * @returns list of compositions in the data - id format.
+ */
+export declare function GetCompositionBulkWithDataId(conceptIds?: number[]): Promise<any[]>;
+/**
+ * ## FORMAT DATAIDDATE ##
+ * This function converts the conceptIds and internal connectionIds to compositions in data-Id format.
+ * @param conceptIds This is the list of concept ids that need to be converted to compositions.
+ * @param connectionIds These are the internal connectionIds that need to be passed to create the compositions.
+ * @returns list of compositions created from the passed conceptIds and connectionIds.
+ */
+export declare function GetCompositionFromConnectionsWithDataId(conceptIds?: number[], connectionIds?: number[]): Promise<any>;
+/**
+ * ## FORMAT DATAIDDATE ##
+ * This is just a different version of GetCompositionFromConnectionsWithDataId, This has the added functionality that
+ * it also prints out internal connections.
+ * This function converts the conceptIds and internal connectionIds to compositions in data-Id format.
+ * @param conceptIds This is the list of concept ids that need to be converted to compositions.
+ * @param connectionIds These are the internal connectionIds that need to be passed to create the compositions.
+ * @returns list of compositions created from the passed conceptIds and connectionIds.
+ */
+export declare function GetCompositionFromConnectionsWithDataIdFromConnections(conceptIds?: number[], connectionIds?: number[]): Promise<any>;
+/**
+ * ## Format DATAIDDATE ##
+ * This function converts the conceptIds and internal connectionIds to compositions in data-Id format with index(conceptId).
+ * @param conceptIds This is the list of concept ids that need to be converted to compositions.
+ * @param connectionIds These are the internal connectionIds that need to be passed to create the compositions.
+ * @returns dictionary of compositions created from the passed conceptIds and connectionIds with conceptId as its index .
+ */
+export declare function GetCompositionFromConnectionsWithDataIdIndex(conceptIds?: number[], connectionIds?: number[]): Promise<any>;
+/**
+ * ## Format is dictionary with key as concept id and value as data (json) ##
+ * This function converts the conceptIds and internal connectionIds to compositions format with index(conceptId).
+ * @param conceptIds This is the list of concept ids that need to be converted to compositions.
+ * @param connectionIds These are the internal connectionIds that need to be passed to create the compositions.
+ * @returns dictionary of compositions created from the passed conceptIds and connectionIds with conceptId as its index .
+ */
+export declare function GetCompositionFromConnectionsWithIndex(conceptIds?: number[], connectionIds?: number[]): Promise<any>;
+/**
+ * ## FORMAT DATAIDDATE ##
+ * This is just a different version of GetCompositionFromConnectionsWithDataId, This has the added functionality that
+ * it also prints out internal connections.
+ * This function converts the conceptIds and internal connectionIds to compositions in data-Id format.
+ * @param conceptIds This is the list of concept ids that need to be converted to compositions.
+ * @param connectionIds These are the internal connectionIds that need to be passed to create the compositions.
+ * @returns list of compositions created from the passed conceptIds and connectionIds.
+ */
+export declare function GetCompositionFromConnectionsWithIndexFromConnections(conceptIds?: number[], connectionIds?: number[]): Promise<any>;
 /**
  * Used to prefetch all the connections and their related concepts.
  * @param connectionIds these are the connection ids that are used to fetch all the connections and also their related concepts.
  * @returns all the connections that are passed as ids.
  */
-export declare function GetConnectionDataPrefetch(connectionIds?: number[]): Promise<Connection[]>;
-export declare function GetCompositionFromConnectionsWithDataIdInObject(ids?: number[], connections?: number[]): Promise<any>;
+export declare function GetConnectionDataPrefetch(connectionIds: number[]): Promise<Connection[]>;
+/**
+ * ## Format DATAIDDATE ##
+ * This function converts the conceptIds and internal connections to create compositions.
+ * Format is of a dictionary with ids as the key and value is the composition data.
+ * @param conceptIds these are the concept ids that need to be fetched to create their compositions
+ * @param connections these are the connections that are used to create the structure.
+ * @returns a dictionary / object that has key as their conceptId and the value as their composition object.
+ */
+export declare function GetCompositionFromConnectionsWithDataIdInObject(conceptIds?: number[], connections?: number[]): Promise<any>;
+/**
+ * ## Format DATAIDDATE ##
+ * ## duplicate ##
+ * This function converts the conceptIds and internal connections to create compositions.
+ * @param conceptIds these are the concept ids that need to be fetched to create their compositions
+ * @param connections these are the connections that are used to create the structure.
+ * @returns a dictionary / object that has key as their conceptId and the value as their composition object.
+ */
+export declare function GetCompositionFromConnectionsWithDataIdInObjectNew(conceptIds?: number[], connections?: number[]): Promise<any>;
+/**
+ * ## Format justdata ##
+ * This function converts the conceptIds and internal connections to create compositions.
+ * @param conceptIds these are the concept ids that need to be fetched to create their compositions
+ * @param connections these are the connections that are used to create the structure.
+ * @returns a dictionary / object that has key as their conceptId and the value as their composition object.
+ */
+export declare function GetCompositionFromConnectionsInObject(conceptIds?: number[], connections?: number[]): Promise<any>;
+/**
+ * ## Format Normal ##
+ * This function converts the conceptIds and internal connections to create compositions.
+ * @param conceptIds these are the concept ids that need to be fetched to create their compositions
+ * @param connections these are the connections that are used to create the structure.
+ * @returns a dictionary / object that has key as their conceptId and the value as their composition object.
+ */
+export declare function GetCompositionFromConnectionsInObjectNormal(conceptIds?: number[], connections?: number[]): Promise<any>;

package/dist/types/Services/GetCompositionList.d.ts

@@ -1,2 +1,7 @@
+import { Concept } from "../app";
 export declare function GetCompositionList(compositionName: string, userId: number, inpage?: number, page?: number): Promise<any>;
+export declare function GetCompositionListAll(compositionName: string, userId: number, inpage?: number, page?: number): Promise<any[]>;
+export declare function GetCompositionListAllWithId(compositionName: string, userId: number, inpage?: number, page?: number): Promise<any>;
 export declare function GetCompositionListWithId(compositionName: string, userId: number, inpage?: number, page?: number): Promise<any>;
+export declare function GetCompositionListWithIdUpdated(compositionName: string, userId: number, inpage?: number, page?: number): Promise<any>;
+export declare function FormatTheConcepts(conceptList: Concept[], localConceptList: Concept[], inpage?: number, page?: number): Promise<any[]>;

package/dist/types/Services/GetConceptByCharacter.d.ts

@@ -1,3 +1,2 @@
-import { Concept } from "../DataStructures/Concept";
-export default function GetConceptByCharacter(characterValue: string): Promise<Concept>;
-export declare function GetConceptByCharacterUpdated(characterValue: string): Promise<Concept>;
+export default function GetConceptByCharacter(characterValue: string): Promise<any>;
+export declare function GetConceptByCharacterUpdated(characterValue: string): Promise<any>;

package/dist/types/Services/GetConnectionBetweenTwoConceptsLinker.d.ts

@@ -0,0 +1,11 @@
+import { Concept } from "../app";
+/**
+ * This function will give you all the connections between two concepts by their linker or fullLinker
+ * @param ofTheConcept start of the connecction
+ * @param toTheConcept end of the connection
+ * @param linker the primitive linkers with type connection (16) these are the old type of linkers (if you want full linker then put this as empty string)
+ * @param fullLinker fullLinker is the modern linker (if you want linker then put this as empty string)
+ * @param forward if you want to get the forward relation in the primitive linker put true else for backward linker false.
+ * @returns list of connections
+ */
+export declare function GetConnectionBetweenTwoConceptsLinker(ofTheConcept: Concept, toTheConcept: Concept, linker: string, fullLinker: string, forward?: boolean): Promise<any>;

package/dist/types/Services/GetConnections.d.ts

@@ -1,2 +1 @@
-import { Connection } from "../DataStructures/Connection";
-export declare function GetConnectionById(id: number): Promise<Connection>;
+export declare function GetConnectionById(id: number): Promise<any>;

package/dist/types/Services/GetDataFromIndexDb.d.ts

@@ -1,2 +1,2 @@
-export declare function GetDataFromIndexDb(): Promise<void>;
-export declare function GetDataFromIndexDbLocal(): Promise<void>;
+export declare function GetConnectionsFromIndexDb(): Promise<void>;
+export declare function GetConnectionsFromIndexDbLocal(): Promise<void>;

package/dist/types/Services/GetLink.d.ts

@@ -1,3 +1,3 @@
 import { Concept } from "./../DataStructures/Concept";
-export declare function GetLink(id: number, linker: string, inpage?: number, page?: number): Promise<any[]>;
+export declare function GetLink(id: number, linker: string, inpage?: number, page?: number): Promise<any>;
 export declare function GetLinkRaw(id: number, linker: string, inpage?: number, page?: number): Promise<Concept[]>;

package/dist/types/Services/GetRelation.d.ts

@@ -1,5 +1,2 @@
-import { Connection } from "../DataStructures/Connection";
-import { Concept } from "./../DataStructures/Concept";
-export declare function GetRelation(id: number, relation: string, inpage?: number, page?: number, reverse?: boolean): Promise<any[]>;
-export declare function GetRelationRaw(id: number, relation: string, inpage?: number, page?: number, reverse?: boolean): Promise<Concept[]>;
-export declare function GetRelationConnections(id: number, relation: string, inpage?: number, page?: number, reverse?: boolean): Promise<Connection[]>;
+export declare function GetRelation(id: number, relation: string, inpage?: number, page?: number, reverse?: boolean): Promise<any>;
+export declare function GetRelationRaw(id: number, relation: string, inpage?: number, page?: number, reverse?: boolean): Promise<any>;

package/dist/types/Services/GetTheConcept.d.ts

@@ -1,2 +1,9 @@
 import { Concept } from "../DataStructures/Concept";
+/**
+ * Get The Concept From Concept Id
+ * @param id this is the id that can be used to get the concept.
+ * @param userId This is the user that calls the concept
+ * @returns Concept if it exists
+ */
 export default function GetTheConcept(id: number, userId?: number): Promise<Concept>;
+export declare function AddTypeConcept(concept: Concept): Promise<Concept | undefined>;

package/dist/types/Services/InitializeSystem.d.ts

@@ -1,2 +1,2 @@
-export default function InitializeSystem(): Promise<boolean>;
+export default function InitializeSystem(enableAi?: boolean): Promise<boolean>;
 export declare function PurgatoryDatabaseUpdated(): Promise<void>;

package/dist/types/Services/Local/ConvertFromLConceptToConcept.d.ts

@@ -0,0 +1,2 @@
+import { Concept } from "../../DataStructures/Concept";
+export declare function ConvertFromLConceptToConcept(lconcept: Concept): Concept;

package/dist/types/Services/Local/ConvertFromLConnectionToConnection.d.ts

@@ -0,0 +1,2 @@
+import { Connection } from "../../DataStructures/Connection";
+export declare function ConvertFromLConnectionToConnection(lconnection: Connection): Connection;

package/dist/types/Services/Local/CreateConnectionBetweenTwoConceptsLocal.d.ts

@@ -0,0 +1,3 @@
+import { Concept } from "../../app";
+import { InnerActions } from "../../Constants/general.const";
+export declare function CreateConnectionBetweenTwoConceptsLocal(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean, actions?: InnerActions): Promise<any>;

package/dist/types/Services/Local/CreateDefaultLConcept.d.ts

@@ -1,2 +1,2 @@
-import { LConcept } from "../../DataStructures/Local/LConcept";
-export declare function CreateDefaultLConcept(): LConcept;
+import { Concept } from "../../DataStructures/Concept";
+export declare function CreateDefaultLConcept(): Concept;

package/dist/types/Services/Local/CreateLocalBinaryTreeFromData.d.ts

@@ -1 +1,29 @@
-export default function CreateLocalBinaryTreeFromData(): Promise<void>;
+/**
+ * This will create a binary tree of local concepts that is saved from the indexdb.
+ */
+export default function CreateLocalBinaryTreeFromIndexDb(): Promise<void>;
+/**
+ * We have designed our system to use local concepts and connections with its own local ids(negative ids) that
+ * is only valid for the browser that creates this. We have a translator in our node server.
+ * We cannot keep on using the indexdb to get the new data so we populate the data from indexdb to our memory
+ * then we use these ids from memory and update the indexdb with the latest id frequently.
+ * This function does this process in initlization from indexdb to memory.
+ *
+ * Here we have locked this function so that other processes cannot access this process in the case that this process is ongoing
+ *
+ *
+ */
+export declare function PopulateTheLocalConceptsToMemory(): Promise<void>;
+/**
+* We have designed our system to use local concepts and connections with its own local ids(negative ids) that
+* is only valid for the browser that creates this. We have a translator in our node server.
+* We cannot keep on using the indexdb to get the new data so we populate the data from indexdb to our memory
+* then we use these ids from memory and update the indexdb with the latest id frequently.
+* This function does this process in initlization from indexdb to memory.
+*
+* This function locked so that no two parallel process can access this functionality at the same time.
+* That might cause some ids to be repeated.
+*
+*
+*/
+export declare function PopulateTheLocalConnectionToMemory(): Promise<void>;

package/dist/types/Services/Local/CreateTheCompositionLocal.d.ts

@@ -1,2 +1,14 @@
-import { LConcept } from "../../DataStructures/Local/LConcept";
-export declare function CreateTheCompositionLocal(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null): Promise<LConcept>;
+import { InnerActions } from "../../app";
+/**
+ * This function converts a json data to concept connection and also preserves its relation.
+ * @param json The json data that needs to be converted to the concept connection system
+ * @param ofTheConceptId If in case that this composition is part of other composition then this must be the connecting concept.
+ * @param ofTheConceptUserId If in case that this composition is part of other composition then this must be the user Id of the  connecting concept.
+ * @param mainKey If in case that this composition is part of other composition then this must be the main composition
+ * @param userId The user Id of the user creating the composition.
+ * @param accessId The accessId of the user creating the composition.
+ * @param sessionInformationId Session of the user.
+ * @param automaticSync for future use.
+ * @returns the main concept of this composition.
+ */
+export declare function CreateTheCompositionLocal(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null, automaticSync?: boolean, actions?: InnerActions): Promise<any>;

package/dist/types/Services/Local/CreateTheConceptLocal.d.ts

@@ -1,2 +1,22 @@
-import { LConcept } from "../../DataStructures/Local/LConcept";
-export default function CreateTheConceptLocal(referent: string, typecharacter: string, userId: number, categoryId: number, typeId: number, accessId: number, referentId?: number): Promise<LConcept>;
+import { InnerActions } from "../../app";
+/**
+ * This function creates the concept in the local system (Local memory and IndexDb) but not in the backend database
+ * To create this concept in the backend database you need to sync the local data to the backend by LocalSyncData class.
+ *
+ * This function creates a id and ghost id which are equal to each other.
+ * These id and ghostId are negative which means that they are virtual concepts. After these concepts have been synced with the backend
+ * they are converted to real id. After returning from the backend the id changes to positive(+) and real id while the ghostId remains the same
+ *
+ * The system then saves this relation between -ve id and real id in the backend server and also in the local memory.
+ *
+ * @param referent This is the string that is the actual value of the concept.
+ * @param typecharacter The string that defines the type of the concept.
+ * @param userId This is the userId of the creator.
+ * @param categoryId This is the category Id of the concept.
+ * @param typeId This is the type Id of the concept that relates to the typecharacter passed above.
+ * @param accessId This is the accessId of the concept(most probably is the accessId of the user)
+ * @param isComposition This is set in the case that the composition needs to be created.
+ * @param referentId if this concept refers to any other concept then this needs to be passed.
+ * @returns
+ */
+export default function CreateTheConceptLocal(referent: string, typecharacter: string, userId: number, categoryId: number, typeId: number, accessId: number, isComposition?: boolean, referentId?: number | null, actions?: InnerActions): Promise<any>;

package/dist/types/Services/Local/CreateTheConnectionLocal.d.ts

@@ -1,2 +1,16 @@
-import { LConnection } from "../../DataStructures/Local/LConnection";
-export declare function CreateTheConnectionLocal(ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId?: number): LConnection;
+import { Concept, InnerActions } from "../../app";
+/**
+ * This function creates a connection for the concept connection system. This connection will only be created in real sense
+ * once the data is synced using LocalSyncData.SyncDataOnline()
+ * Here id and ghostId are created which are negative(these are virtual ids). After they are synced then they become real ids
+ * The real ids are then associated with these ghost ids in node server (backend) and also in the local memory.
+ * @param ofTheConceptId Of the concept Id for the connection
+ * @param toTheConceptId To the concept Id for the connection
+ * @param typeId Type of the connection, should be the composition id for internal connection and type concept in case
+ * of external connection.
+ * @param orderId current context is that for internal connections the order id is less than 3 and for external connections greater than 999
+ * @param typeString this is the typeString in the case of external connections.
+ * @returns a connection that is created and stored in the local system.
+ */
+export declare function CreateTheConnectionLocal(ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId?: number, typeString?: string, userId?: number, actions?: InnerActions): Promise<any>;
+export declare function CreateConnection(ofTheConcept: Concept, toTheConcept: Concept, connectionTypeString: string, actions?: InnerActions): Promise<any>;

package/dist/types/Services/Local/DeleteConceptLocal.d.ts

@@ -0,0 +1 @@
+export declare function DeleteConceptLocal(id: number): Promise<any>;