mftsccs-node 0.2.4 → 0.2.6

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

@@ -1,100 +1,11 @@
 import { Connection } from "../DataStructures/Connection";
-/**
- * ## 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>;
+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[]>;
 /**
  * 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[]>;
-/**
- * ## 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>;
+export declare function GetConnectionDataPrefetch(connectionIds?: number[]): Promise<Connection[]>;
+export declare function GetCompositionFromConnectionsWithDataIdInObject(ids?: number[], connections?: number[]): Promise<any>;

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

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

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

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

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

@@ -1,2 +1,2 @@
-export declare function GetConnectionsFromIndexDb(): Promise<void>;
-export declare function GetConnectionsFromIndexDbLocal(): Promise<void>;
+export declare function GetDataFromIndexDb(): Promise<void>;
+export declare function GetDataFromIndexDbLocal(): 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,2 +1,5 @@
-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>;
+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[]>;

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

@@ -1,9 +1,2 @@
 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(enableAi?: boolean): Promise<boolean>;
+export default function InitializeSystem(): Promise<boolean>;
 export declare function PurgatoryDatabaseUpdated(): Promise<void>;

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

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

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

@@ -1,29 +1 @@
-/**
- * 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>;
+export default function CreateLocalBinaryTreeFromData(): Promise<void>;

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

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

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

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

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

@@ -1,16 +1,2 @@
-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>;
+import { LConnection } from "../../DataStructures/Local/LConnection";
+export declare function CreateTheConnectionLocal(ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId?: number): LConnection;

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

@@ -1,14 +1,2 @@
-/**
- * This function returns the list of composition which have the type @param compositionName
- * @param compositionName The type of the composition to pull
- * @param userId User Id of the user trying to pull the list
- * @returns list of compositions.
- */
 export declare function GetCompositionListLocal(compositionName: string, userId: number): Promise<any>;
-/**
- * This function returns the list of composition with data - id format which have the type @param compositionName
- * @param compositionName The type of the composition to pull
- * @param userId User Id of the user trying to pull the list
- * @returns list of compositions with data - id format.
- */
 export declare function GetCompositionListLocalWithId(compositionName: string, userId: number): Promise<any>;

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

@@ -1,10 +1 @@
-import { Concept } from "../../app";
-export default function GetConceptByCharacterLocal(characterValue: string): Promise<Concept>;
-/**
- *
- * @param character the character value of the concept we want to find in our local system.
- * @returns LConcept which will be the associated concept with the character Value.
- */
-export declare function GetConceptByCharacterAndCategoryLocal(character: string): Promise<any>;
-export declare function GetConceptByCategoryAndCharacterLocalMemory(value: string, categoryId: number): Promise<Concept>;
-export declare function GetConceptByCharacterLocalFull(characterValue: string): Promise<Concept>;
+export default function GetConceptByCharacterLocal(characterValue: string): Promise<import("../../app").LConcept>;

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

@@ -1,2 +1,2 @@
-import { InnerActions } from "../../app";
-export default function MakeTheConceptLocal(referent: string, typeCharacter: string, userId: number, categoryId: number, typeId: number, actions?: InnerActions): Promise<any>;
+import { LConcept } from "../../DataStructures/Local/LConcept";
+export default function MakeTheConceptLocal(referent: string, typeCharacter: string, userId: number, categoryId: number, typeId: number): Promise<LConcept>;

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

@@ -1,18 +1,2 @@
-import { InnerActions } from "../../Constants/general.const";
-/**
- * This is the basic function of the concept connection system. This function let's you create a concept within the constraints of the
- * concept connection system. This function is the building block of the concept connection system.
- * This function automatically passes the concept to be synced to the background. Next time you sync the data this concept will also be created in the backend.
- * @param type this is the type of the concept. You can also think of this as the key of concept. first_name, last_name etc.
- * @param referent the actual value of the concept. The actual name of value of the concept.
- * @param composition this is a boolean that defines if the concept is a composition or not. If this is a composition then other things are also
- * connected internally with this concept. If composition is true then always a new concept is created otherwise it checks if the concept already exists
- * and creates only in the case that the concept does not already exists with its type and value as its unique identifier.
- * @param userId the userId of the creator.
- * @param accessId this is the accessId of the creator. By default should be 4.
- * @param sessionInformationId this is the session that is created by the system.
- * @param referentId In case we need this concept to refer to any other concept.
- * @param actions InnerActions Array for capturing concepts and connection
- * @returns a concept which is either newly created or an older concept that already exists.
- */
-export declare function MakeTheInstanceConceptLocal(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number, actions?: InnerActions): Promise<any>;
+import { LConcept } from "../../DataStructures/Local/LConcept";
+export declare function MakeTheInstanceConceptLocal(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number): Promise<LConcept>;

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

@@ -1,16 +1,2 @@
-import { Concept } from "../../DataStructures/Concept";
-import { InnerActions } from "../../Constants/general.const";
-/**
- * There are two types of concepts. One type of concept is a type concept. These concepts have no actual value and do not mean
- * anything unless they are associated with other values. These are placeholders like first_name, last_name, age etc that are required in the system.
- * These types need to be created seperately.
- *
- *
- * @param typeString type of the concept that needs to be created.
- * @param sessionId SessionId of the user
- * @param sessionUserId Not required pass 999
- * @param userId UserId of the user creating this concept
- * @param actions InnerActions|undefined actions to collect
- * @returns
- */
-export declare function MakeTheTypeConceptLocal(typeString: string, sessionId: number, sessionUserId: number, userId: number, actions?: InnerActions): Promise<Concept>;
+import { LConcept } from "../../DataStructures/Local/LConcept";
+export default function MakeTheTypeConceptLocal(typeString: string, sessionId: number, sessionUserId: number, userId: number): Promise<LConcept>;

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

@@ -1,3 +1,2 @@
-import { PatcherStructure } from "../../DataStructures/PatcherStructure";
-import { InnerActions } from "../../app";
-export declare function UpdateCompositionLocal(patcherStructure: PatcherStructure, actions?: InnerActions): Promise<any>;
+import { PatcherStructure } from '../../DataStructures/PatcherStructure';
+export declare function UpdateCompositionLocal(patcherStructure: PatcherStructure): Promise<void>;

package/dist/types/Services/Logs/LogEvent.d.ts

@@ -0,0 +1 @@
+export declare function LogEvent(EventName: string, EventDescription: string, event: any): void;

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

@@ -1,2 +1,2 @@
 import { Concept } from "../DataStructures/Concept";
-export default function MakeTheConcept(referent: string, userId: number, categoryId: number, typeId: number, referentId: number, accessId: number, typeCharacter: string): Promise<Concept>;
+export default function MakeTheConcept(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>;

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

@@ -1,15 +1,3 @@
-/**
- * This is the basic function of the concept connection system. This function let's you create a concept within the constraints of the
- * concept connection system. This function is the building block of the concept connection system.
- * @param type this is the type of the concept. You can also think of this as the key of concept. first_name, last_name etc.
- * @param referent the actual value of the concept. The actual name of value of the concept.
- * @param composition this is a boolean that defines if the concept is a composition or not. If this is a composition then other things are also
- * connected internally with this concept. If composition is true then always a new concept is created otherwise it checks if the concept already exists
- * and creates only in the case that the concept does not already exists with its type and value as its unique identifier.
- * @param userId the userId of the creator.
- * @param passedAccessId this is the accessId of the creator. By default should be 4.
- * @param passedSessionId this is the session that is created by the system.
- * @param referentId In case we need this concept to refer to any other concept.
- * @returns a concept which is either newly created or an older concept that already exists.
- */
-export default function MakeTheInstanceConcept(type: string, referent: string, composition: boolean | undefined, userId: number, passedAccessId?: number, passedSessionId?: number, referentId?: number): Promise<any>;
+import { Concept } from "../DataStructures/Concept";
+import { InnerActions } from "../DataStructures/Transaction/Transaction";
+export default function MakeTheInstanceConcept(type: string, referent: string, composition: boolean | undefined, userId: number, passedAccessId: number, passedSessionId?: number, referentId?: number, actions?: InnerActions): Promise<Concept>;

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

@@ -0,0 +1,2 @@
+import { Concept } from "../DataStructures/Concept";
+export declare function MakeTheName(theCharacterData: string, userId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number, typeId: number, typeUserId: number, existingConcept: Concept): Promise<Concept>;

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

@@ -1 +1,2 @@
-export declare function MakeTheTimestamp(type: string, referent: string, userId: number, accessId?: number, sessionInformationId?: number): Promise<any>;
+import { Concept } from "../DataStructures/Concept";
+export declare function MakeTheTimestamp(type: string, referent: string, userId: number, accessId: number, sessionInformationId?: number): Promise<Concept>;

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

@@ -1 +1,3 @@
-export declare function MakeTheTypeConcept(typeString: string, sessionId: number, sessionUserId: number, userId: number): Promise<any>;
+import { Concept } from "../DataStructures/Concept";
+import { InnerActions } from "../DataStructures/Transaction/Transaction";
+export declare function MakeTheTypeConcept(typeString: string, sessionId: number, sessionUserId: number, userId: number, actions?: InnerActions): Promise<Concept>;

package/dist/types/Services/Search/DataIdFormat.d.ts

@@ -1,24 +1,24 @@
 import { Connection } from "../../app";
 /**
- * ## Format DATA-ID ##
- * this function takes in connections and creates a single level objects so that all the data are added to its object/ array.
- * This is then passed on further for stiching.
- * @param connections
- * @param compositionData
- * @param reverse
- * @returns
- */
-export declare function FormatFunctionDataForData(connections: Connection[], compositionData?: any[], reverse?: number[]): Promise<any[]>;
+* ## Format DATA-ID ##
+* this function takes in connections and creates a single level objects so that all the data are added to its object/ array.
+* This is then passed on further for stiching.
+* @param connections
+* @param compositionData
+* @param reverse
+* @returns
+*/
+export declare function FormatFunctionDataForData(connections: Connection[], compositionData: any[], reverse?: number[]): Promise<any[]>;
 /**
- * ############ Format is data-id and is used for list. ############
- * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
- * The list format is helpful because you do not have to go over each individual query.
- * @param connections the type connections that need (external connections) to be passed
- * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
- * @param mainComposition this is list of  ids of the main composition that builds the tree
- * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
- * @returns
- */
+* ############ Format is data-id and is used for list. ############
+* This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
+* The list format is helpful because you do not have to go over each individual query.
+* @param connections the type connections that need (external connections) to be passed
+* @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
+* @param mainComposition this is list of  ids of the main composition that builds the tree
+* @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
+* @returns
+*/
 export declare function FormatFromConnectionsAlteredArrayExternal(connections: Connection[], compositionData: any[], newCompositionData: any, mainComposition: number[], reverse: number[] | undefined, CountDictionary: any[]): Promise<any[]>;
 /**
  * ## Format DATA-ID ##

package/dist/types/Services/Search/FormatData.d.ts

@@ -1,15 +1,4 @@
 import { Connection } from "../../app";
-/**
- * ######### Format is normal ######### used for listing. This only provides type connections.
- * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
- * The list format is helpful because you do not have to go over each individual query.
- * @param connections the type connections that need (external connections) to be passed
- * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
- * @param mainComposition this is list of  ids of the main composition that builds the tree
- * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
- * @returns
- */
-export declare function FormatConceptsAndConnectionsNormalList(connections: Connection[], compositionData: any[], mainComposition: number[], newCompositionData: any, reverse?: number[]): Promise<any[]>;
 /**
  *
  * ## Format Normal ##
@@ -25,12 +14,13 @@ export declare function formatFunction(connections: Connection[], compositionDat
 */
 export declare function formatFunctionForData(connections: Connection[], compositionData: any, reverse: number[]): Promise<any>;
 /**
- * ## Format DATA-ID ##
- * this function takes in connections and creates a single level objects so that all the data are added to its object/ array.
- * This is then passed on further for stiching.
- * @param connections
- * @param compositionData
- * @param reverse
- * @returns
- */
-export declare function FormatFunctionData(connections: Connection[], compositionData: any[], reverse?: number[]): Promise<any[]>;
+* ######### Format is normal ######### used for listing. This only provides type connections.
+* This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
+* The list format is helpful because you do not have to go over each individual query.
+* @param connections the type connections that need (external connections) to be passed
+* @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
+* @param mainComposition this is list of  ids of the main composition that builds the tree
+* @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
+* @returns
+*/
+export declare function FormatConceptsAndConnectionsNormalList(connections: Connection[] | undefined, compositionData: any[] | undefined, mainComposition: number[] | undefined, newCompositionData: any, reverse?: number[]): Promise<any[]>;

package/dist/types/Services/Search/SearchLinkInternal.d.ts

@@ -1,3 +1,2 @@
 import { SearchStructure } from "../../app";
 export declare function SearchLinkInternal(searchQuery: SearchStructure, token?: string): Promise<any[]>;
-export declare function SearchLinkInternalAll(searchQuery: SearchStructure, token?: string): Promise<any>;

package/dist/types/Services/Search/SearchLinkMultiple.d.ts

@@ -1,55 +1,3 @@
 import { SearchQuery } from "../../DataStructures/SearchQuery";
-import { Connection } from "../../app";
-export declare function SearchLinkMultipleAll(searchQuery: SearchQuery[], token?: string, caller?: any, format?: number): Promise<any>;
-/**
- * ######### This layer builds the data. Format is dataid ##########
- * @param linkers list of ids that help us
- * @param conceptIds this is all the concept ids that need  to be composited
- * @param connections these are the internal connections of the compositions that help in creating individual compositions
- * @param reverse this is the list of connection ids that need to show reverse connections(to->from)
- * @param mainCompositionId this is the main centre point of this data.
- * @returns
- */
-export declare function DataIdBuildLayer(linkers: number[], conceptIds: number[], connections: number[], reverse: number[], mainCompositionId: number, searchQuery: SearchQuery, format?: number): Promise<any>;
-/**
- * ## Format is DATAID ##
- * This  is altered format and is different from others because it passes all the connections prebuilt/prefetched
- * This will not let the connections to be again fetched from the memory.
- * @param connections the type connections that need (external connections) to be passed
- * @param compositionData this is a dictionary type of format that has all the build compositions {id: { actual data}}
- * @param mainComposition this is the id of the main composition that builds the tree
- * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
- * @returns
- */
-export declare function FormatFromConnectionsAltered(connections: Connection[], compositionData: any[], mainComposition: number, reverse?: number[]): Promise<any>;
-/**
- * ######### Format is normal ######### used for listing.
- * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
- * The list format is helpful because you do not have to go over each individual query.
- * @param connections the type connections that need (external connections) to be passed
- * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
- * @param mainComposition this is list of  ids of the main composition that builds the tree
- * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
- * @returns
- */
-export declare function FormatConceptsAndConnections(connections: Connection[], compositionData: any[], mainComposition: number[], reverse?: number[]): Promise<any[]>;
-/**
- * ############ Format is data-id and is used for list. ############
- * This is helpful in building a format that has multiple mainCompositions i.e. in the context of the list
- * The list format is helpful because you do not have to go over each individual query.
- * @param connections the type connections that need (external connections) to be passed
- * @param compositionData  this is a dictionary type of format that has all the build compositions {id: { actual data}}
- * @param mainComposition this is list of  ids of the main composition that builds the tree
- * @param reverse this is the list of connections ids that needs to go to the reverse direction (to---->from)
- * @returns
- */
-export declare function FormatFromConnectionsAlteredArray(connections: Connection[], compositionData: any[], conceptIds: number[], mainComposition: number[], reverse?: number[]): Promise<any[]>;
-/**
- * ########## Format works with JUSTDATA / NORMAL ########### used for single origin concept
- * @param linkers this is the list of linkers that
- * @param compositionData
- * @param mainComposition
- * @param reverse list of connection ids that need to show reverse conneciton.
- * @returns
- */
+export declare function SearchLinkMultipleAll(searchQuery: SearchQuery[], token?: string): Promise<any>;
 export declare function FormatFromConnections(linkers: number[], compositionData: any[], mainComposition: number, reverse?: number[]): Promise<any>;