mftsccs-browser 2.1.238-beta → 2.1.239-dev

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

@@ -1,63 +0,0 @@
-/**
- * Retrieves a concept by ID with support for both local (virtual) and server concepts.
- *
- * This is the primary function for fetching concepts in offline/local mode. It intelligently
- * handles three types of concept IDs and retrieves from appropriate sources:
- *
- * **ID Types Handled:**
- * 1. **Negative IDs (Virtual/Local)**: Concepts created locally not yet synced
- *    - Stored in LocalConceptsData (IndexedDB)
- *    - Return negative IDs
- *
- * 2. **Synced Virtual IDs**: Originally local concepts now synced to backend
- *    - Looked up via LocalGhostIdTree (maps negative to positive IDs)
- *    - Returns positive (real) ID with ghostId reference
- *
- * 3. **Positive IDs (Server)**: Real backend concepts
- *    - Fetched via GetTheConcept from backend
- *    - Converted to LConcept format
- *    - May have undefined ghostId
- *
- * **Retrieval Strategy:**
- * - If id < 0: Check LocalConceptsData → Check LocalGhostIdTree
- * - If id >= 0: Fetch from backend → Convert to LConcept
- * - Routes through service worker if enabled
- * - Returns default empty concept if not found
- *
- * **Ghost ID System:**
- * - ghostId: Original negative ID (preserved after sync)
- * - id: Current ID (negative if local, positive if synced)
- * - LocalGhostIdTree maintains the mapping
- *
- * @param id - The concept ID to retrieve. Can be:
- *            - Negative (e.g., -12345) for local-only concepts
- *            - Positive (e.g., 789) for server concepts
- *
- * @returns Promise resolving to a Concept object in LConcept format.
- *         Returns default concept (id=0) if not found.
- *
- * @example
- * // Get a local concept (negative ID)
- * const localConcept = await GetTheConceptLocal(-12345);
- * console.log(localConcept.id); // -12345
- * console.log(localConcept.characterValue); // "Draft Note"
- *
- * @example
- * // Get a synced concept (originally local, now on server)
- * const syncedConcept = await GetTheConceptLocal(-12345);
- * console.log(syncedConcept.id); // 789 (now positive, synced)
- * console.log(syncedConcept.ghostId); // -12345 (original ID preserved)
- *
- * @example
- * // Get a server concept
- * const serverConcept = await GetTheConceptLocal(456);
- * console.log(serverConcept.id); // 456
- * // Converted to LConcept format for consistency
- *
- * @throws Logs errors but returns default concept instead of throwing
- *
- * @see {@link CreateTheConceptLocal} for creating local concepts
- * @see {@link GetTheConcept} for fetching server concepts only
- * @see {@link convertFromConceptToLConcept} for format conversion
- */
-export declare function GetTheConceptLocal(id: number): Promise<any>;

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

@@ -1,22 +0,0 @@
-import { InnerActions } from "../../app";
-/**
- * Gets or creates a local concept - implements get-or-create pattern.
- *
- * Checks LocalConceptsData for existing concept matching referent and typeId.
- * If found, returns existing concept. If not found, creates new local concept.
- *
- * **Special Case**: If typeCharacter is "the", sets categoryId to 1 (system category).
- *
- * @param referent - The character value/name of the concept
- * @param typeCharacter - Type name string (e.g., "the_name")
- * @param userId - User ID creating the concept
- * @param categoryId - Category classification ID
- * @param typeId - Type classification ID
- * @param actions - Action tracking for batch operations
- * @returns Existing or newly created Concept
- *
- * @example
- * const concept = await MakeTheConceptLocal("Active", "the_status", 101, 1, 5);
- * // Returns existing "Active" status or creates new one
- */
-export default function MakeTheConceptLocal(referent: string, typeCharacter: string, userId: number, categoryId: number, typeId: number, actions?: InnerActions): Promise<any>;

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

@@ -1,164 +0,0 @@
-import { InnerActions } from "../../Constants/general.const";
-/**
- * Creates or retrieves an instance concept locally - the core building block of the concept-connection system.
- *
- * This is THE fundamental function for creating concepts in local storage. It implements an intelligent
- * get-or-create pattern that checks for existing concepts before creating new ones, preventing duplicates
- * while supporting both unique instances and composition concepts.
- *
- * **Core Behaviors:**
- * 1. **Composition Mode (composition=true)**: Always creates a new concept
- *    - Used for containers/objects that need unique instances
- *    - Marks concept with isComposition flag
- *    - Example: Each "Project" is unique, even with same name
- *
- * 2. **Instance Mode (composition=false)**: Get-or-create pattern
- *    - Checks if concept with same type and value exists
- *    - Returns existing if found (deduplication)
- *    - Creates new only if not found
- *    - Example: "Published" status concept reused across items
- *
- * 3. **Long Text Handling**: Values >255 characters always create new
- *    - Prevents expensive lookups on large text
- *    - Each long text gets unique concept
- *
- * **Type String Processing:**
- * - **Best Practice**: Always pass type with "the_" prefix (e.g., "the_name", "the_email")
- * - Auto-correction: If missing, "the_" is automatically added internally
- *   - "name" → "the_name" (auto-corrected)
- *   - "email" → "the_email" (auto-corrected)
- *   - "the_status" → "the_status" (already correct)
- * - Creates type concept if it doesn't exist
- * - **Recommendation**: Use explicit "the_" prefix for code clarity and consistency
- *
- * **Sync and Storage:**
- * - Adds concept to LocalSyncData queue for backend sync
- * - Stores in LocalConceptsData (IndexedDB)
- * - Tracks in actions parameter for batch operations
- * - Assigns negative ID (virtual/local)
- *
- * **Process Flow:**
- * 1. Normalizes type string (adds "the_" prefix)
- * 2. Creates/retrieves type concept via MakeTheTypeConceptLocal
- * 3. If composition=true: Creates new concept immediately
- * 4. If referent length >255: Creates new concept
- * 5. If regular instance: Checks for existing by type+value
- * 6. Returns existing or creates new
- * 7. Attaches type information
- * 8. Adds to sync queue
- *
- * @param type - The type/key of the concept. **Should follow the format "the_xyz"**.
- *              Represents what kind of data this is.
- *              Examples: "the_name", "the_email", "the_status", "the_first_name"
- *
- *              **Note**: If you pass without "the_" prefix (e.g., "name"), the code will
- *              automatically add it internally (becomes "the_name"). However, best practice
- *              is to always include the "the_" prefix for clarity and consistency.
- *
- * @param referent - The actual value/content of the concept.
- *                  The human-readable data (e.g., "Alice", "alice@example.com", "Active").
- *                  Can be empty string for composition concepts.
- *
- * @param composition - Boolean flag determining creation behavior.
- *                     - true: Always creates new concept (unique instances)
- *                     - false: Get-or-create pattern (reuses existing)
- *                     Defaults to false.
- *
- * @param userId - The ID of the user creating this concept. Used for ownership and permissions.
- *
- * @param accessId - Access control level. Typically 4 (default internal access).
- *                  Controls who can view/modify this concept.
- *
- * @param sessionInformationId - Session identifier for tracking. Defaults to 999 (system).
- *                              Used for audit logging and session management.
- *
- * @param referentId - Optional reference to another concept ID.
- *                    Used when this concept is an instance of or refers to another concept.
- *                    Defaults to 0 (no reference).
- *
- * @param actions - Action tracking object that accumulates all created concepts and connections.
- *                 Used for batch operations, rollback, and sync management.
- *                 Structure: { concepts: Concept[], connections: Connection[] }
- *
- * @returns Promise resolving to the created or retrieved Concept object with:
- *         - Negative ID if newly created locally
- *         - Attached type information (concept.type)
- *         - All standard concept properties
- *
- * @example
- * // Create a reusable status concept (get-or-create)
- * const status = await MakeTheInstanceConceptLocal(
- *   "the_status",       // type (with "the_" prefix - best practice)
- *   "Active",           // value
- *   false,              // not composition - will reuse if exists
- *   101,                // userId
- *   4,                  // accessId
- *   999,                // sessionId
- *   0                   // no referent
- * );
- * // First call creates, subsequent calls return same concept
- *
- * @example
- * // Create a composition concept (always new)
- * const project = await MakeTheInstanceConceptLocal(
- *   "the_project",      // type (with "the_" prefix)
- *   "Project Alpha",    // value
- *   true,               // composition - always creates new
- *   101,
- *   4,
- *   999,
- *   0
- * );
- * // Each project is unique, even with same name
- * console.log(project.isComposition); // true
- *
- * @example
- * // Type prefix is added automatically if missing (but prefer explicit)
- * const email = await MakeTheInstanceConceptLocal(
- *   "email",            // Missing "the_" - will become "the_email" internally
- *   "alice@example.com",
- *   false,
- *   101, 4
- * );
- * console.log(email.typeCharacter); // "the_email" (auto-prefixed)
- *
- * // RECOMMENDED: Always include "the_" prefix explicitly
- * const emailBetter = await MakeTheInstanceConceptLocal(
- *   "the_email",        // Explicit prefix - clearer and more consistent
- *   "bob@example.com",
- *   false,
- *   101, 4
- * );
- *
- * @example
- * // Long text always creates new concept
- * const longDescription = "Lorem ipsum...".repeat(100); // >255 chars
- * const concept = await MakeTheInstanceConceptLocal(
- *   "the_description",  // type with "the_" prefix
- *   longDescription,
- *   false,              // Even with false, creates new due to length
- *   101, 4
- * );
- *
- * @example
- * // Track actions for batch operations
- * const actions = { concepts: [], connections: [] };
- * await MakeTheInstanceConceptLocal("the_name", "Alice", false, 101, 4, 999, 0, actions);
- * await MakeTheInstanceConceptLocal("the_email", "alice@ex.com", false, 101, 4, 999, 0, actions);
- * console.log(actions.concepts.length); // 2 (plus any type concepts created)
- *
- * @example
- * // Deduplication in action
- * const status1 = await MakeTheInstanceConceptLocal("the_status", "Published", false, 101, 4);
- * const status2 = await MakeTheInstanceConceptLocal("the_status", "Published", false, 101, 4);
- * console.log(status1.id === status2.id); // true - same concept reused
- *
- * @throws Logs errors and re-throws for handling by caller.
- *        Common issues: Type concept creation failures, IndexedDB errors.
- *
- * @see {@link CreateTheConceptLocal} for the underlying creation function
- * @see {@link MakeTheTypeConceptLocal} for type concept creation/retrieval
- * @see {@link LocalConceptsData.GetConceptByCharacterAndTypeLocal} for existence check
- * @see {@link LocalSyncData.AddConcept} for sync queue management
- */
-export declare function MakeTheInstanceConceptLocal(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number, actions?: InnerActions): Promise<any>;

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

@@ -1,36 +0,0 @@
-import { Concept } from "../../DataStructures/Concept";
-import { InnerActions } from "../../Constants/general.const";
-/**
- * Creates or retrieves a type concept locally - handles hierarchical type system.
- *
- * Type concepts are placeholders/templates (e.g., "the_first_name", "the_email") that define
- * what kind of data a concept represents. They have no actual value themselves.
- *
- * **Hierarchical Processing (Complex Logic)**:
- * - Single word (e.g., "status"): Creates simple type concept with typeId=51
- * - Compound words (e.g., "the_person_email"): Splits into parts and creates hierarchy:
- *   1. Creates category concept from first part ("the_person")
- *   2. Creates type concept from second part ("email")
- *   3. Creates final concept with category and type linked
- *   **Uses recursion** to build multi-level type hierarchies
- *
- * Always checks for existing type concept before creating to prevent duplicates.
- *
- * @param typeString - The type name to create (e.g., "the_status", "the_person_email")
- * @param sessionId - Session identifier (typically 999)
- * @param sessionUserId - Session user ID (typically 999, not used)
- * @param userId - User creating the type concept
- * @param actions - Action tracking for batch operations
- * @returns Type Concept (existing or newly created)
- *
- * @example
- * // Simple type
- * const statusType = await MakeTheTypeConceptLocal("the_status", 999, 999, 101);
- * // Creates: "the_status" type concept
- *
- * @example
- * // Hierarchical type (recursive processing)
- * const emailType = await MakeTheTypeConceptLocal("the_person_email", 999, 999, 101);
- * // Creates: "the_person" (category) + "email" (type) + "the_person_email" (combined)
- */
-export declare function MakeTheTypeConceptLocal(typeString: string, sessionId: number, sessionUserId: number, userId: number, actions?: InnerActions): Promise<Concept>;

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

@@ -1,42 +0,0 @@
-import { PatcherStructure } from "../../DataStructures/PatcherStructure";
-import { InnerActions } from "../../app";
-/**
- * Updates/patches a composition in local storage with new or modified properties.
- *
- * **Complex Patching Logic** (197 lines):
- * 1. Fetches latest composition data from backend (all connections and concepts)
- * 2. Iterates through patchObject properties to add/update
- * 3. For each property:
- *    - If value is object/array: Creates composition concept and nested composition
- *    - If value is primitive: Creates instance concept with value
- *    - Checks if concept type already exists in composition
- *    - If exists: Marks old connections for deletion (replaces old value)
- *    - If new: Simply adds new connection
- * 4. Creates connections between parent composition and new/updated concepts
- * 5. Deletes old connections (cleanup)
- * 6. Syncs changes to backend
- *
- * **Use Case**: Updating fields in an existing composition without recreating it entirely.
- *
- * @param patcherStructure - Object containing:
- *   - compositionId: The composition to update
- *   - ofTheCompositionId: Optional parent composition for nested updates
- *   - patchObject: Object with key-value pairs to add/update
- *   - userId, sessionId, accessId: User context
- * @param actions - Action tracking for batch operations and rollback
- *
- * @example
- * // Update a person's email and phone
- * await UpdateCompositionLocal({
- *   compositionId: personId,
- *   patchObject: {
- *     the_email: "newemail@example.com",
- *     the_phone: "555-1234"
- *   },
- *   userId: 101,
- *   sessionId: 999,
- *   accessId: 4
- * });
- * // Old email connection deleted, new email connection created
- */
-export declare function UpdateCompositionLocal(patcherStructure: PatcherStructure, actions?: InnerActions): Promise<any>;

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

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

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

@@ -1,18 +0,0 @@
-export interface EmailBody {
-    toAddress: string;
-    heading: string;
-    body?: string;
-    attachments?: Array<string>;
-}
-export interface BulkEmailBody extends Omit<EmailBody, 'toAddress'> {
-    toAddress?: string;
-    ccAddresses: Array<string>;
-}
-/**
- * Method to send Email to user
- * @param body FormData | EmailBody
- * @param token string
- * @param bulk boolean
- * @returns JSON | string | null
- */
-export declare const sendEmail: (body: FormData | EmailBody | BulkEmailBody, token: string, bulk?: boolean) => Promise<any>;

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

@@ -1,2 +0,0 @@
-import { Concept } from "../DataStructures/Concept";
-export default function MakeTheCharacter(the_character_data: string, userId: number, securityId: number, accessId: number, accessUserId: number, sessionId: number): Promise<Concept>;

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

@@ -1,2 +0,0 @@
-import { Returner } from "../DataStructures/Returner";
-export default function MakeTheCharacterData(the_character_data: string, userId: number, securityId: number, accessId: number, sessionId: number): Promise<Returner>;

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

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

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

@@ -1,15 +0,0 @@
-/**
- * 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>;

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

@@ -1 +0,0 @@
-export declare function MakeTheTimestamp(type: string, referent: string, userId: number, accessId?: number, sessionInformationId?: number): Promise<any>;

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

@@ -1 +0,0 @@
-export declare function MakeTheTypeConcept(typeString: string, sessionId: number, sessionUserId: number, userId: number): Promise<any>;

package/dist/types/Services/Mqtt/publishMessage.d.ts

@@ -1 +0,0 @@
-export declare function publishMessage(topic: string, message: any): void;

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

@@ -1,32 +0,0 @@
-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 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 ##
- * 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[]>;

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

@@ -1,36 +0,0 @@
-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 ##
- * This function takes in the connections and then converts the connections to the single level objects for further processing
- * This function is the builder of the arrays/ objects from the connections.
- */
-export declare function formatFunction(connections: Connection[], compositionData: any, reverse: number[]): Promise<any>;
-/**
-*
-* ## Format Normal ##
-* This function takes in the connections and then converts the connections to the single level objects for further processing
-* This function is the builder of the arrays/ objects from the connections.
-*/
-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[]>;

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

@@ -1,23 +0,0 @@
-import { Connection } from "../../app";
-/**
-* ## Format Just-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 FormatFunctionDataForDataJustId(connections: Connection[], compositionData: any[], reverse?: number[]): Promise<any[]>;
-/**
- * ############ Format is Just 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 FormatFromConnectionsAlteredArrayExternalJustId(connections: Connection[], compositionData: any[], mainComposition: number[], reverse: number[] | undefined, CountDictionary: any[]): Promise<any[]>;
-export declare function AddCount(ofTheConceptId: number, CountDictionary: any, newData: any): void;

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

@@ -1,4 +0,0 @@
-import { Connection } from "../../app";
-export declare function FormatFunctionDataV2(connections: Connection[], compositionData?: Record<number, any>, reverse?: number[]): Promise<Record<number, any>>;
-export declare function FormatFunctionDataForDataV2(connections: Connection[], compositionData?: Record<number, any>, reverse?: number[]): Promise<Record<number, any>>;
-export declare function FormatFromConnectionsAlteredArrayExternalV2(connections: Connection[], compositionData: Record<number, any>, mainComposition: number[], reverse: number[] | undefined, CountDictionary: Record<number, any>): Promise<any[]>;

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

@@ -1,3 +0,0 @@
-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 +0,0 @@
-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 FormatFromConnections(linkers: number[], compositionData: any[], mainComposition: number, reverse?: number[]): Promise<any>;

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

@@ -1,82 +0,0 @@
-import { SearchStructure, SearchQuery } from '../../app';
-import { CountInfo } from '../../DataStructures/Count/CountInfo';
-/**
- * This function will help you search a concept by their type and also to query inside of it.
- * Put the number of compositions you want to get in the searchStructure which can be set by inpage and page
- * Then the type should be set in searchQuery for the compositionName.
- * Inside the searchQuery array this you can set the full linker / listLinker in the searchQuery.
- * This will give the id of the structures.
- */
-export declare function SearchWithTypeAndLinkerDataId(searchStructure: SearchStructure, searchQuery: SearchQuery[], token?: string): Promise<any>;
-/**
- * This function will help you search a concept by their type and also to query inside of it.
- * Put the number of compositions you want to get in the searchStructure which can be set by inpage and page
- * Then the type should be set in searchQuery for the compositionName.
- * Inside the searchQuery array this you can set the full linker / listLinker in the searchQuery.
- * This will not give the id of the structures.
- */
-export declare function SearchWithTypeAndLinker(searchStructure: SearchStructure, searchQuery: SearchQuery[], token?: string): Promise<any>;
-/**
- * ## Format dataid ##
- * @param linkers
- * @param conceptIds
- * @param connections
- * @param mainCompositionIds
- * @param reverse
- * @returns
- */
-export declare function formatDataArrayDataId(linkers: number[], conceptIds: number[], connections: number[], mainCompositionIds: number[], reverse: number[]): Promise<any>;
-/**
- * ## Format Normal ##
- * @param linkers
- * @param conceptIds
- * @param connections
- * @param mainCompositionIds
- * @param reverse
- * @returns
- */
-export declare function formatDataArrayNormal(linkers: number[], conceptIds: number[], connections: number[], mainCompositionIds: number[], reverse: number[]): Promise<any>;
-/**
- * ## Format Normal ##
- * @param linkers
- * @param conceptIds
- * @param connections
- * @param mainCompositionIds
- * @param reverse
- * @returns
- */
-export declare function formatLinkersNormal(linkers: number[], conceptIds: number[], connections: number[], mainCompositionIds: number[], reverse: number[]): Promise<any>;
-/**
- * ## Format Normal ##
- * This function fetches all the connections and then converts all the connections to the single level connections
- * Then those single level objects are then stiched together to create a complex json/ array.
- * @param linkers
- * @param conceptIds
- * @param mainCompositionIds
- * @param reverse
- * @returns
- */
-export declare function formatConnections(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[]): Promise<any>;
-/**
- * ## Format JustId ##
- * This function fetches all the connections and then converts all the connections to the single level connections
- * Then those single level objects are then stiched together to create a complex json/ array.
- * @param linkers
- * @param conceptIds
- * @param mainCompositionIds
- * @param reverse
- * @returns
- */
-export declare function formatConnectionsJustId(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;
-/**
- * ## Format DATA-ID ##
- * This function fetches all the connections and then converts all the connections to the single level connections
- * Then those single level objects are then stiched together to create a complex json/ array.
- * @param linkers
- * @param conceptIds
- * @param mainCompositionIds
- * @param reverse
- * @returns
- */
-export declare function formatConnectionsDataId(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;
-export declare function formatConnectionsV2(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;

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

@@ -1,2 +0,0 @@
-import { Connection } from "../../app";
-export declare function orderTheConnections(connections: Connection[], order?: string): Connection[];