mftsccs-browser 2.1.239-dev → 2.1.240-dev

package/dist/types/ServiceWorker/actions/getActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const getActions: Actions;

package/dist/types/ServiceWorker/actions/index.d.ts

@@ -0,0 +1,15 @@
+import { InnerActions } from "../../app";
+export { getActions } from '../actions/getActions';
+export { searchActions } from '../actions/searchActions';
+export { createActions } from '../actions/createActions';
+export { updateActions } from '../actions/updateActions';
+export { connectionActions } from '../actions/connectionActions';
+export { deleteActions } from '../actions/deleteActions';
+export { syncActions } from '../actions/syncActions';
+export interface Actions {
+    [key: string]: (payload: any) => Promise<{
+        success: boolean;
+        data?: any;
+        actions?: InnerActions;
+    }>;
+}

package/dist/types/ServiceWorker/actions/searchActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const searchActions: Actions;

package/dist/types/ServiceWorker/actions/syncActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const syncActions: Actions;

package/dist/types/ServiceWorker/actions/updateActions.d.ts

@@ -0,0 +1,2 @@
+import { Actions } from ".";
+export declare const updateActions: Actions;

package/dist/types/ServiceWorker/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Method to handle message event in service worker
+ * @param event any
+ * @returns Promise<void>
+ */
+export declare function handleMessageEvent(event: any): Promise<void>;
+/**
+ * Method to check and inform main thread if sw is not initialized
+ * @returns boolean
+ */
+export declare const checkSWInitialization: () => boolean;

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

@@ -0,0 +1,7 @@
+/**
+ * Clears all application caches (both in-memory and IndexedDB).
+ *
+ * Call this on user logout or when you need to force-refresh all cached data.
+ * Clears widget caches (standard, latest, recent) and query caches.
+ */
+export declare function clearAllCaches(): void;

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

@@ -0,0 +1,3 @@
+import { Connection } from "../DataStructures/Connection";
+export declare function CheckForConnectionDeletion(newConnections?: Connection[], oldConnections?: Connection[]): void;
+export declare function CheckForConnectionDeletionWithIds(newConnectionIds?: number[], oldConnections?: Connection[]): void;

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

@@ -0,0 +1,3 @@
+import { CountInfo } from "../../DataStructures/Count/CountInfo";
+export declare function DecodeCountInfo(countStrings?: string[]): CountInfo[];
+export declare function GetConnectionTypeForCount(countInfos: CountInfo[]): Promise<any>;

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

@@ -0,0 +1,7 @@
+/**
+ *
+ * @param ms The time required to wait before executing this function
+ * @param callback This is the function that needs to be executed
+ * @returns returns a promise for the resolve
+ */
+export declare function DelayFunctionExecution(ms: number, callback: any): Promise<unknown>;

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

@@ -0,0 +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/RegexFunction.d.ts

@@ -0,0 +1 @@
+export declare function removeThePrefix(inputString: string): string;

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

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

package/dist/types/Services/Composition/BuildComposition.d.ts

@@ -0,0 +1,3 @@
+import { Connection } from '../../DataStructures/Connection';
+import { Concept } from '../../DataStructures/Concept';
+export declare function recursiveFetchNew(id: number, connectionList: Connection[], conceptList: Concept[], compositionList: number[], visitedConcepts?: number[]): Promise<any>;

package/dist/types/Services/Composition/CompositionCache.d.ts

@@ -0,0 +1,4 @@
+import { Connection } from '../../DataStructures/Connection';
+export declare function GetCompositionWithCache(id: number, connectionListPassed?: Connection[]): Promise<any>;
+export declare function GetCompositionWithDataIdWithCache(id: number, connectionListPassed?: Connection[]): Promise<any>;
+export declare function GetCompositionWithDataIdBulk(ids: number[], connections: number[]): Promise<any[]>;

package/dist/types/Services/Composition/CreateCompositionCache.d.ts

@@ -0,0 +1,3 @@
+import { Concept } from '../../DataStructures/Concept';
+import { Composition } from '../../DataStructures/Composition/Composition';
+export declare function CreateTheCompositionWithCache(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null, composition?: Composition | null): Promise<Concept>;

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

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

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

@@ -0,0 +1,5 @@
+import { Concept } from "../../DataStructures/Concept";
+import { Connection } from "../../DataStructures/Connection";
+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

@@ -0,0 +1,5 @@
+/**
+ * This function builds up the binary tree on startup from the indexdb.
+ * Processes records in chunks to avoid blocking the main thread.
+ */
+export default function CreateConceptBinaryTreeFromIndexDb(): 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

@@ -0,0 +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<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/CreateDefaultConcept.d.ts

@@ -0,0 +1,3 @@
+import { Concept } from "../DataStructures/Concept";
+export declare function CreateDefaultConcept(): Concept;
+export declare function formatDate(date: Date): string;

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

@@ -0,0 +1 @@
+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

@@ -0,0 +1,122 @@
+import { Concept } from "../DataStructures/Concept";
+/**
+ * Creates a new concept and adds it to the sync queue for backend synchronization.
+ *
+ * This is the primary function for creating concepts in the system. The concept is:
+ * - Assigned a unique ID from the reserved ID pool
+ * - Marked as non-temporary (persisted)
+ * - Added to the SyncData queue for automatic backend synchronization
+ * - Cached locally in IndexedDB for offline access
+ *
+ * @param {string} referent - The character value (text/name) of the concept. This is the human-readable
+ *                           representation of the concept (e.g., "John Doe", "Project Alpha")
+ * @param {number} userId - The ID of the user creating this concept. Used for ownership and access control.
+ * @param {number} categoryId - The category classification ID. Used for further classification within a type
+ *                             (e.g., for TYPE_PERSON: 1=Employee, 2=Contractor, 3=Customer)
+ * @param {number} typeId - The type classification ID. Defines what kind of concept this is
+ *                         (e.g., 1=Person, 2=Organization, 3=Document)
+ * @param {number} referentId - Optional reference to another concept ID. Used for creating instances
+ *                             that reference a type concept. Can be 0 or null if not applicable.
+ * @param {number} accessId - Access control level for the concept. Determines who can view/edit
+ *                           (e.g., 1=Public, 2=Private, 3=Shared, 4=Admin)
+ * @param {string} typeCharacter - The string representation of the type name (e.g., "Person", "Document").
+ *                                Used for display and filtering purposes.
+ *
+ * @returns {Promise<Concept>} A promise that resolves to the newly created Concept object with all properties set.
+ *
+ * @example
+ * // Create a person concept
+ * const person = await CreateTheConcept(
+ *   "Alice Smith",  // name
+ *   101,           // userId
+ *   1,             // categoryId (Employee)
+ *   1,             // typeId (Person)
+ *   0,             // referentId (none)
+ *   2,             // accessId (Private)
+ *   "Person"       // typeCharacter
+ * );
+ * console.log(person.id); // 12345
+ *
+ * @see {@link CreateTheConceptTemporary} for creating non-persisted temporary concepts
+ * @see {@link CreateTheConceptImmediate} for creating concepts with immediate backend sync
+ */
+export default function CreateTheConcept(referent: string, userId: number, categoryId: number, typeId: number, referentId: number, accessId: number, typeCharacter: string): Promise<Concept>;
+/**
+ * Creates a temporary concept that is NOT persisted to the database or synced to the backend.
+ *
+ * Use this function when you need a transient concept that exists only in memory during the
+ * current session. Temporary concepts are useful for:
+ * - UI state management
+ * - Draft content before finalization
+ * - Calculations or intermediate results
+ * - Testing without affecting the database
+ *
+ * Temporary concepts are marked with `isTemp = true` and will not be saved when the application
+ * closes or refreshes. They are NOT added to the SyncData queue.
+ *
+ * @param referent - The character value (text/name) of the concept
+ * @param userId - The ID of the user creating this concept
+ * @param categoryId - The category classification ID
+ * @param typeId - The type classification ID
+ * @param referentId - Optional reference to another concept ID
+ * @param accessId - Access control level for the concept
+ * @param typeCharacter - The string representation of the type name
+ *
+ * @returns Promise resolving to the temporary Concept object
+ *
+ * @example
+ * // Create a temporary draft note
+ * const draftNote = await CreateTheConceptTemporary(
+ *   "Draft: Meeting Notes",
+ *   101,
+ *   1,
+ *   3,  // Document type
+ *   0,
+ *   2,
+ *   "Document"
+ * );
+ * console.log(draftNote.isTemp); // true
+ *
+ * @see {@link CreateTheConcept} for creating persistent concepts
+ */
+export declare function CreateTheConceptTemporary(referent: string, userId: number, categoryId: number, typeId: number, referentId: number, accessId: number, typeCharacter: string): Promise<Concept>;
+/**
+ * Creates a concept and immediately sends it to the backend API, bypassing the sync queue.
+ *
+ * This function is useful when you need guaranteed immediate synchronization to the backend,
+ * such as for critical operations that must be persisted right away. Unlike the standard
+ * CreateTheConcept, this function:
+ * - Calls the backend API directly (CreateTheConceptApi)
+ * - Does NOT use the SyncData queue (bypasses batch synchronization)
+ * - Adds the concept to local ConceptsData immediately
+ * - Marks the concept as NOT new (isNew = false)
+ *
+ * Use this for time-sensitive operations where you cannot wait for the next sync cycle.
+ *
+ * @param referent - The character value (text/name) of the concept
+ * @param userId - The ID of the user creating this concept
+ * @param categoryId - The category classification ID
+ * @param typeId - The type classification ID
+ * @param referentId - Optional reference to another concept ID (can be null)
+ * @param accessId - Access control level for the concept
+ * @param typeCharacter - The string representation of the type name
+ *
+ * @returns Promise resolving to the created Concept object
+ *
+ * @example
+ * // Create a critical log entry that must be saved immediately
+ * const logEntry = await CreateTheConceptImmediate(
+ *   "Critical Error: System Failure",
+ *   101,
+ *   5,  // Log category
+ *   7,  // Log type
+ *   null,
+ *   1,  // Public access
+ *   "LogEntry"
+ * );
+ * // Concept is immediately sent to backend
+ *
+ * @see {@link CreateTheConcept} for standard queued creation
+ * @see {@link CreateTheConceptApi} for the backend API call
+ */
+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

@@ -0,0 +1,63 @@
+import { Connection } from "../DataStructures/Connection";
+/**
+ * Creates a connection (relationship) between two concepts and adds it to the sync queue.
+ *
+ * This is the primary function for establishing relationships in the knowledge graph.
+ * Connections are directed edges that link two concepts together, representing relationships
+ * like "works at", "belongs to", "authored by", etc.
+ *
+ * **Connection Structure:**
+ * - FROM concept (ofTheConceptId) → TO concept (toTheConceptId)
+ * - The relationship is directional
+ * - Type ID classifies what kind of relationship it is
+ * - Order ID allows sorting when multiple connections of the same type exist
+ *
+ * **Important Behaviors:**
+ * - Connections are marked as temporary (isTemp = true) for internal compositions
+ * - Added to SyncData queue for backend synchronization
+ * - Assigned a random temporary ID until persisted
+ * - Self-connections (same from/to) are prevented (returns invalid connection)
+ * - Default access level is 4 (typically means "admin" or "restricted")
+ *
+ * @param ofTheConceptId - The source concept ID (start of the relationship).
+ *                        This is where the connection originates FROM.
+ * @param userId - The ID of the user creating this connection. Used for ownership and permissions.
+ * @param toTheConceptId - The target concept ID (end of the relationship).
+ *                        This is where the connection points TO.
+ * @param typeId - The type classification for this connection. Defines the nature of the relationship.
+ *                (e.g., 5="works_at", 6="manages", 7="member_of")
+ *
+ * @returns The created Connection object with all properties set, including a temporary ID
+ *
+ * @example
+ * // Create a "works at" relationship
+ * const connection = createTheConnection(
+ *   aliceId,      // Alice (person)
+ *   101,          // user creating this
+ *   companyId,    // Tech Corp (organization)
+ *   5             // "works at" connection type
+ * );
+ * // Result: Alice → works_at → Tech Corp
+ *
+ * @example
+ * // Create a hierarchical relationship
+ * const managerConnection = createTheConnection(
+ *   managerId,    // Manager concept
+ *   101,          // user
+ *   employeeId,   // Employee concept
+ *   6             // "manages" connection type
+ * );
+ * // Result: Manager → manages → Employee
+ *
+ * @example
+ * // Attempting self-connection (will return invalid connection)
+ * const selfConn = createTheConnection(123, 101, 123, 5);
+ * console.log(selfConn.ofTheConceptId); // 0 (invalid)
+ * console.log(selfConn.toTheConceptId); // 1 (invalid)
+ *
+ * @throws Errors are caught and logged via HandleInternalError but don't prevent return
+ *
+ * @see {@link CreateTheConnectionGeneral} for alternative connection creation
+ * @see {@link CreateTheConnectionApi} for direct backend API connection creation
+ */
+export declare function createTheConnection(ofTheConceptId: number, userId: number, toTheConceptId: number, typeId: number): Connection;

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

@@ -0,0 +1,2 @@
+import { Connection } from "../DataStructures/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

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

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

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

@@ -0,0 +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

@@ -0,0 +1 @@
+export declare function FindConnectionsOfCompositionsBulkInMemory(composition_ids?: number[]): Promise<any>;

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

@@ -0,0 +1,205 @@
+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>;
+/**
+ * Retrieves a complete composition structure for a given concept ID in JUSTDATA format.
+ *
+ * This is a primary composition retrieval function that builds a hierarchical structure
+ * containing the main concept, all its connections, and recursively fetched related concepts.
+ * The result is formatted as a nested object organized by concept types.
+ *
+ * **What is a Composition?**
+ * A composition represents a concept along with its connected relationships and sub-structures.
+ * Think of it as getting a "full profile" of a concept including everything connected to it.
+ *
+ * **Process:**
+ * 1. Fetches all connections associated with the concept
+ * 2. Identifies all related concept IDs from those connections
+ * 3. Recursively builds the composition tree
+ * 4. Fetches the main concept details
+ * 5. Organizes output by concept type (e.g., result["Person"] = {...})
+ * 6. Routes through service worker if enabled for better performance
+ *
+ * **Output Format (JUSTDATA):**
+ * Returns an object keyed by the main concept's type character value:
+ * ```
+ * {
+ *   "Person": {
+ *     id: 123,
+ *     characterValue: "Alice",
+ *     connections: [...],
+ *     relatedConcepts: {...}
+ *   }
+ * }
+ * ```
+ *
+ * @param id - The unique identifier of the concept for which to build the composition.
+ *            This becomes the root of the composition tree.
+ *
+ * @returns Promise resolving to an object containing the composition data organized by
+ *         the main concept's type. Returns empty object if concept not found or on error.
+ *
+ * @example
+ * // Get composition for a person concept
+ * const composition = await GetComposition(12345);
+ * console.log(composition["Person"]);
+ * // {
+ * //   id: 12345,
+ * //   characterValue: "Alice Smith",
+ * //   connections: [... all connections],
+ * //   Company: { ... related company data },
+ * //   Projects: { ... related projects }
+ * // }
+ *
+ * @example
+ * // Get composition for an organization
+ * const orgComposition = await GetComposition(456);
+ * console.log(orgComposition["Organization"]);
+ * // Contains the organization and all connected employees, departments, etc.
+ *
+ * @example
+ * // Use with service worker (automatic if enabled)
+ * // Service worker handles the heavy lifting in background
+ * const result = await GetComposition(789);
+ *
+ * @see {@link GetCompositionWithId} for composition with ID and timestamp (DATAID format)
+ * @see {@link GetCompositionBulk} for fetching multiple compositions efficiently
+ * @see {@link GetCompositionWithCache} for cached composition retrieval
+ * @see {@link recursiveFetch} for the recursive building logic
+ */
+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>;
+/**
+ * #### 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>;