mftsccs-browser 2.1.238-beta → 2.1.239-dev

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

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

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

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

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

@@ -1,7 +0,0 @@
-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 +0,0 @@
-export default function GetConceptByCharacter(characterValue: string): Promise<any>;
-export declare function GetConceptByCharacterUpdated(characterValue: string): Promise<any>;

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

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

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

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

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

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

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

@@ -1,3 +0,0 @@
-import { Concept } from "./../DataStructures/Concept";
-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/GetLinkerConnectionFromConcept.d.ts

@@ -1,3 +0,0 @@
-import { Connection } from "../DataStructures/Connection";
-export declare function GetLinkerConnectionFromConcepts(id: number): Promise<Connection[]>;
-export declare function GetLinkerConnectionToConcepts(id: number): Promise<Connection[]>;

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

@@ -1,3 +0,0 @@
-export declare function GetRelation(id: number, relation: string, inpage?: number, page?: number, reverse?: boolean): Promise<any>;
-export declare function GetRelationNew(id: number, relation: string, inpage?: number, page?: number, reverse?: boolean): Promise<void>;
-export declare function GetRelationRaw(id: number, relation: string, inpage?: number, page?: number, reverse?: boolean): Promise<any>;

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

@@ -1,96 +0,0 @@
-import { Concept } from "../DataStructures/Concept";
-/**
- * Retrieves a concept by its ID with intelligent caching and multi-source lookup.
- *
- * This is the primary function for fetching concepts in the system. It implements a sophisticated
- * multi-level retrieval strategy:
- *
- * **Retrieval Strategy:**
- * 1. Checks in-memory promise cache to prevent duplicate requests
- * 2. For negative IDs: Fetches from local IndexedDB (LocalConceptsData)
- * 3. For positive IDs: Checks local ConceptsData cache first
- * 4. If not in cache: Fetches from backend API
- * 5. Automatically resolves and attaches the concept's type information
- * 6. Routes through service worker if enabled for better performance
- *
- * **Features:**
- * - Promise caching prevents duplicate concurrent requests for the same concept
- * - Automatic type resolution (fetches and attaches type concept)
- * - Access tracking integration (increments access counter if enabled)
- * - Service worker support for background processing
- * - Error logging and performance monitoring
- * - Supports both server concepts (positive IDs) and local concepts (negative IDs)
- *
- * @param id - The unique identifier of the concept to retrieve.
- *            Positive IDs = server concepts, Negative IDs = local-only concepts
- * @param userId - The ID of the user requesting the concept. Used for access tracking
- *                and audit logging. Defaults to 999 (system/anonymous user)
- *
- * @returns Promise resolving to the Concept object if found, or a default empty Concept if not found
- *
- * @example
- * // Get a server concept
- * const concept = await GetTheConcept(12345, 101);
- * console.log(concept.characterValue); // "Alice Smith"
- * console.log(concept.type?.characterValue); // "Person" (auto-resolved)
- *
- * @example
- * // Get a local concept (negative ID)
- * const localConcept = await GetTheConcept(-5, 101);
- * console.log(localConcept.characterValue); // "Local Draft"
- *
- * @example
- * // Multiple concurrent calls use the same promise (efficient)
- * const [c1, c2, c3] = await Promise.all([
- *   GetTheConcept(123),
- *   GetTheConcept(123),  // Same ID - uses cached promise
- *   GetTheConcept(123)   // Same ID - uses cached promise
- * ]);
- * // Only one actual fetch is performed
- *
- * @throws Will log errors but returns a default empty concept instead of throwing
- *
- * @see {@link CreateTheConcept} for creating new concepts
- * @see {@link GetConceptBulk} for fetching multiple concepts efficiently
- * @see {@link AddTypeConcept} for manually adding type information to a concept
- */
-export default function GetTheConcept(id: number, userId?: number): Promise<Concept>;
-/**
- * Fetches and attaches type information to a concept if not already present.
- *
- * This utility function ensures that a concept has its type information loaded and attached.
- * Every concept has a `typeId` that references another concept representing its type
- * (e.g., a person concept might have typeId=1 which points to a "Person" type concept).
- *
- * **Process:**
- * 1. Checks if concept.type is already set (if yes, does nothing)
- * 2. Attempts to fetch type concept from local cache (ConceptsData)
- * 3. If not in cache and typeId is valid: fetches from backend API
- * 4. Attaches the type concept to concept.type property
- * 5. Routes through service worker if enabled
- *
- * **Type Concept:**
- * A type concept is a special concept that represents a classification or category.
- * For example: "Person", "Document", "Organization" are type concepts.
- *
- * @param concept - The concept object to which type information should be added.
- *                 The concept must have a valid `typeId` property.
- *
- * @returns Promise that resolves when type information has been attached (or confirmed present)
- *
- * @example
- * const concept = await GetTheConcept(12345);
- * console.log(concept.type); // might be null
- *
- * await AddTypeConcept(concept);
- * console.log(concept.type?.characterValue); // "Person"
- *
- * @example
- * // Ensure multiple concepts have their types loaded
- * const concepts = await GetConceptBulk([1, 2, 3, 4, 5]);
- * await Promise.all(concepts.map(c => AddTypeConcept(c)));
- * // All concepts now have their type information
- *
- * @see {@link GetTheConcept} which automatically calls this function
- */
-export declare function AddTypeConcept(concept: Concept): Promise<Concept | undefined>;

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

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

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

@@ -1,41 +0,0 @@
-import { Concept } from "../../DataStructures/Concept";
-/**
- * Converts a local concept (LConcept) to a standard Concept format.
- *
- * This function is part of the local/server concept conversion system. Currently, it
- * performs a passthrough as LConcept and Concept share the same structure. This function
- * exists for:
- * - API consistency and symmetry with convertFromConceptToLConcept
- * - Future extensibility if conversion logic is needed
- * - Type clarity in code (explicit conversion intent)
- *
- * **LConcept vs Concept:**
- * - LConcept: Local-only concepts stored in IndexedDB (negative IDs)
- * - Concept: Server-synced concepts (positive IDs)
- * - Both use the same Concept class structure
- *
- * **When to Use:**
- * - Preparing local concepts for backend sync
- * - Converting local concepts to server format
- * - Type-safe conversion in TypeScript
- * - Maintaining code clarity and intent
- *
- * @param lconcept - The local concept to convert
- *
- * @returns The concept in standard Concept format (currently identical to input)
- *
- * @example
- * // Convert local concept before syncing
- * const localConcept = await CreateTheConceptLocal('Draft', 'the_note', 101, 1, 3, 2);
- * const serverConcept = ConvertFromLConceptToConcept(localConcept);
- * // Now ready for backend sync
- *
- * @example
- * // Type-safe conversion
- * const lconcepts = await GetAllLocalConcepts();
- * const concepts = lconcepts.map(lc => ConvertFromLConceptToConcept(lc));
- *
- * @see {@link convertFromConceptToLConcept} for the reverse conversion
- * @see {@link CreateTheConceptLocal} for creating local concepts
- */
-export declare function ConvertFromLConceptToConcept(lconcept: Concept): Concept;

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

@@ -1,47 +0,0 @@
-import { Connection } from "../../DataStructures/Connection";
-/**
- * Converts a local connection (LConnection) to a standard Connection format.
- *
- * This function extracts the essential properties from a local connection and creates
- * a new Connection object. It's part of the local/server conversion system used when
- * preparing local connections for backend sync.
- *
- * **Properties Transferred:**
- * - id: Connection identifier
- * - ofTheConceptId: Source concept ID
- * - toTheConceptId: Target concept ID
- * - typeId: Connection type ID
- * - orderId: Order for sorting connections
- *
- * **LConnection vs Connection:**
- * - LConnection: Local-only connections stored in IndexedDB (negative IDs)
- * - Connection: Server-synced connections (positive IDs)
- * - Both use the same Connection class structure
- *
- * **Use Cases:**
- * - Preparing local connections for backend sync
- * - Converting local data to server format
- * - Data export and serialization
- * - Maintaining consistency across local and server data
- *
- * @param lconnection - The local connection to convert
- *
- * @returns A new Connection object with properties copied from the local connection
- *
- * @example
- * // Convert local connection before syncing
- * const localConn = await CreateTheConnectionLocal(fromId, toId, typeId, 1);
- * const serverConn = ConvertFromLConnectionToConnection(localConn);
- * // Now ready for backend sync
- *
- * @example
- * // Batch conversion
- * const localConnections = await GetAllLocalConnections();
- * const serverConnections = localConnections.map(lc =>
- *   ConvertFromLConnectionToConnection(lc)
- * );
- *
- * @see {@link CreateTheConnectionLocal} for creating local connections
- * @see {@link ConvertFromLConceptToConcept} for concept conversion
- */
-export declare function ConvertFromLConnectionToConnection(lconnection: Connection): Connection;

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

@@ -1,44 +0,0 @@
-import { Concept } from "../../app";
-import { InnerActions } from "../../Constants/general.const";
-/**
- * Creates a named connection between two concepts with optional bidirectional linking.
- *
- * **Complex Naming Logic**:
- * - Forward connection type: "{ofType}_s_{linker}_s" (e.g., "person_s_knows_s")
- * - Backward connection type: "{toType}_s_{linker}_by" (e.g., "person_s_knows_by")
- * - Uses type.characterValue from concepts to build meaningful connection names
- *
- * **Bidirectional Mode (both=true)**:
- * - Creates two connections: A→B and B→A
- * - Forward: ofTheConcept → toTheConcept with "{ofType}_s_{linker}_s"
- * - Backward: toTheConcept → ofTheConcept with "{toType}_s_{linker}_by"
- *
- * @param ofTheConcept - Source concept (connection starts here)
- * @param toTheConcept - Target concept (connection points here)
- * @param linker - Relationship name (e.g., "knows", "works_at", "has")
- * @param both - If true, creates bidirectional connection (both A→B and B→A)
- * @param actions - Action tracking for batch operations
- * @returns The forward connection object
- * @throws Error if connection creation fails
- *
- * @example
- * // Create unidirectional "Alice knows Bob"
- * const conn = await CreateConnectionBetweenTwoConceptsLocal(
- *   aliceConcept,
- *   bobConcept,
- *   "knows",
- *   false
- * );
- * // Creates: person_s_knows_s connection from Alice to Bob
- *
- * @example
- * // Create bidirectional "Alice friends Bob" (both directions)
- * await CreateConnectionBetweenTwoConceptsLocal(
- *   aliceConcept,
- *   bobConcept,
- *   "friends",
- *   true
- * );
- * // Creates: person_s_friends_s (Alice→Bob) AND person_s_friends_by (Bob→Alice)
- */
-export declare function CreateConnectionBetweenTwoConceptsLocal(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean, actions?: InnerActions): Promise<any>;

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

@@ -1,46 +0,0 @@
-import { Concept } from "../../DataStructures/Concept";
-/**
- * Creates a default empty local concept with all properties set to zero/default values.
- *
- * This utility function generates a blank Concept object that can be used as a placeholder
- * or default return value when a concept is not found. All IDs and values are set to 0
- * or empty defaults.
- *
- * **Default Values:**
- * - id: 0 (indicates empty/not found)
- * - userId: 0
- * - typeId: 0
- * - categoryId: 0
- * - referentId: 0
- * - characterValue: "0"
- * - accessId: 0
- * - isNew: false
- * - entryTimeStamp: current date
- * - updatedTimeStamp: current date
- * - typeCharacter: "0"
- *
- * **Use Cases:**
- * - Default return value when concept not found
- * - Placeholder for conditional logic
- * - Initial state before loading data
- * - Template for creating new concepts
- *
- * @returns A Concept object with all properties set to default/zero values
- *
- * @example
- * // Use as default return
- * let concept = await GetTheConceptLocal(id);
- * if (concept.id === 0) {
- *   concept = CreateDefaultLConcept();
- * }
- *
- * @example
- * // Check if concept is valid
- * const concept = CreateDefaultLConcept();
- * console.log(concept.id); // 0
- * console.log(concept.characterValue); // "0"
- *
- * @see {@link CreateTheConceptLocal} for creating actual local concepts
- * @see {@link GetTheConceptLocal} for retrieving local concepts
- */
-export declare function CreateDefaultLConcept(): Concept;