mftsccs-node 0.2.23 → 0.2.25

package/dist/types/Api/Search/Search.d.ts

@@ -18,7 +18,8 @@
  * @param token - Authentication token for authorized access
  * @param inpage - Number of results per page (defaults to 10)
  * @param page - Page number for pagination, starting from 1 (defaults to 1)
- * @returns Promise resolving to an array of matching concepts, or empty array on error
+ * @returns Promise resolving to an array of matching concepts. A valid empty result is returned as an empty array.
+ * @throws Will throw if the request fails or the backend returns a non-OK response.
  *
  * @example
  * ```typescript
@@ -51,9 +52,9 @@
  * simple search operations. For more complex queries, consider using FreeschemaQueryApi.
  *
  * Error handling:
- * - HTTP errors are handled via HandleHttpError and logged
+ * - HTTP errors are handled via HandleHttpError and thrown
  * - Network errors are caught, logged, and re-thrown
- * - Returns empty array on HTTP errors, throws exception on network errors
+ * - Empty arrays represent valid empty results, not failed requests
  *
  * Pagination:
  * - Results are paginated server-side

package/dist/types/Api/Search/SearchInternalApi.d.ts

@@ -7,7 +7,7 @@
  * @module Api/Search/SearchInternalApi
  * @see https://documentation.freeschema.com for internal composition structure and search patterns
  */
-import { SearchStructure } from "../../app";
+import { SearchStructure } from "../../DataStructures/Search/SearchStructure";
 /**
  * Searches for concepts within internal (nested) compositions with authentication.
  * This function enables searching for concepts that are part of internal compositions,
@@ -16,7 +16,8 @@ import { SearchStructure } from "../../app";
  *
  * @param search - SearchStructure object containing all search parameters including composition, internal composition, type, search text, and pagination
  * @param token - Optional authentication token for authorized access (defaults to empty string for public queries)
- * @returns Promise resolving to an array of matching concepts from the internal composition, or empty array on error
+ * @returns Promise resolving to an array of matching concepts from the internal composition. A valid empty result is returned as an empty array.
+ * @throws Will throw if the request fails or the backend returns a non-OK response.
  *
  * @example
  * ```typescript
@@ -56,9 +57,9 @@ import { SearchStructure } from "../../app";
  * - Filtering results within specific composition contexts
  *
  * Error handling:
- * - HTTP errors are logged with status and handled via HandleHttpError
+ * - HTTP errors are handled via HandleHttpError and thrown
  * - Network errors are caught, logged, and re-thrown
- * - Returns empty array on HTTP errors to prevent null reference issues
+ * - Empty arrays represent valid empty results, not failed requests
  *
  * Query construction:
  * - All parameters are URL-encoded as query strings

package/dist/types/Api/Search/SearchLinkMultipleApi.d.ts

@@ -17,7 +17,8 @@ import { SearchQuery } from '../../DataStructures/SearchQuery';
  *
  * @param searchQuery - Array of SearchQuery objects, each containing search parameters for a specific query
  * @param token - Optional authentication token for authorized access (defaults to empty string for public queries)
- * @returns Promise resolving to an array of search results (one result set per query), or empty array on error
+ * @returns Promise resolving to an array of search results, one result set per query. A valid empty result is returned as an empty array.
+ * @throws Will throw if the request fails or the backend returns a non-OK response.
  *
  * @example
  * ```typescript
@@ -74,10 +75,9 @@ import { SearchQuery } from '../../DataStructures/SearchQuery';
  * - Atomic execution of all queries
  *
  * Error handling:
- * - HTTP errors are logged with status and handled via HandleHttpError
+ * - HTTP errors are handled via HandleHttpError and thrown
  * - Network errors are caught, logged, and re-thrown
- * - Returns empty array on HTTP errors to prevent null reference issues
- * - If any query fails, the entire operation returns an empty array
+ * - Empty arrays represent valid empty results, not failed requests
  *
  * Query execution:
  * - All queries are executed server-side

package/dist/types/Api/Search/SearchWithLinker.d.ts

@@ -17,7 +17,8 @@ import { SearchQuery } from '../../DataStructures/SearchQuery';
  *
  * @param searchQuery - Array of SearchQuery objects defining search criteria and relationship paths to follow
  * @param token - Optional authentication token for authorized access (defaults to empty string for public queries)
- * @returns Promise resolving to an array of search results with linked concepts resolved, or empty array on error
+ * @returns Promise resolving to an array of search results with linked concepts resolved. A valid empty result is returned as an empty array.
+ * @throws Will throw if the request fails or the backend returns a non-OK response.
  *
  * @example
  * ```typescript
@@ -81,10 +82,10 @@ import { SearchQuery } from '../../DataStructures/SearchQuery';
  * - Ideal for reducing client-side data fetching complexity
  *
  * Error handling:
- * - HTTP errors are logged with status and handled via HandleHttpError
+ * - HTTP errors are handled via HandleHttpError and thrown
  * - Network errors are caught, logged, and re-thrown
- * - Returns empty array on HTTP errors to maintain consistent error handling
- * - Link resolution errors are handled gracefully server-side
+ * - Empty arrays represent valid empty results, not failed requests
+ * - Link resolution errors are handled by the backend response contract
  *
  * Use cases:
  * - Building detailed profile views with all related data

package/dist/types/Api/SearchConcept/GetConceptByCharacterAndCategoryApi.d.ts

@@ -16,6 +16,7 @@ import { Concept } from "../../DataStructures/Concept";
  *
  * @param characterValue - The character string identifying the concept (e.g., "the_person", "john_doe")
  * @returns A promise that resolves to the matching Concept object, or a default concept if not found
+ * @throws Will throw if the request fails or the backend returns a non-OK response.
  *
  * @example
  * ```typescript
@@ -29,9 +30,9 @@ import { Concept } from "../../DataStructures/Concept";
  * ```
  *
  * @remarks
- * - Returns a default concept (id=0) if the concept is not found or an error occurs
+ * - Returns a default concept (id=0) if the concept is not found
  * - Automatically caches the retrieved concept in ConceptsData
- * - HTTP errors are handled through HandleHttpError but do not throw
+ * - HTTP errors are handled through HandleHttpError and thrown
  * - Errors are logged to console and re-thrown for caller handling
  *
  * @see GetConceptByCharacterAndCategoryDirectApi for searching with explicit category

package/dist/types/Api/SearchConcept/GetConceptByCharacterAndCategoryDirect.d.ts

@@ -18,6 +18,7 @@ import { Concept } from "./../../DataStructures/Concept";
  * @param characterValue - The character string identifying the concept (e.g., "john_doe", "building_a")
  * @param category_id - The specific category ID to search within
  * @returns A promise that resolves to the matching Concept object, or a default concept if not found
+ * @throws Will throw if the request fails or the backend returns a non-OK response.
  *
  * @example
  * ```typescript
@@ -36,10 +37,10 @@ import { Concept } from "./../../DataStructures/Concept";
  * @remarks
  * - Uses local caching (conceptCache) to prevent duplicate simultaneous requests
  * - Cache key is the concatenation of characterValue and category_id
- * - Returns a default concept (id=0) if the concept is not found or an error occurs
+ * - Returns a default concept (id=0) if the concept is not found
  * - Automatically caches the retrieved concept in ConceptsData for subsequent use
  * - Cache entries are cleaned up in the finally block after fetch completes
- * - HTTP errors are handled through HandleHttpError but do not throw
+ * - HTTP errors are handled through HandleHttpError and thrown
  * - Errors are logged with full diagnostic information including the endpoint URL
  *
  * @see GetConceptByCharacterAndCategoryApi for searching without explicit category

package/dist/types/Api/View/ViewInternalDataApi.d.ts

@@ -16,8 +16,8 @@
  * internal connection lists.
  *
  * @param ids - Array of concept IDs to retrieve internal data for
- * @returns A promise that resolves to a dictionary mapping concept IDs to their internal connections,
- *          or an empty connection list if the request fails
+ * @returns A promise that resolves to a dictionary mapping concept IDs to their internal connections.
+ * @throws Will throw if the request fails or the backend returns a non-OK response.
  *
  * @example
  * ```typescript
@@ -40,8 +40,7 @@
  * @remarks
  * - Returns an object where keys are concept IDs and values are arrays of Connection objects
  * - Automatically fetches and caches all sub-concepts via GetConceptBulk
- * - Returns an empty connection list on error
- * - HTTP errors are handled through HandleHttpError but do not throw
+ * - HTTP errors are handled through HandleHttpError and thrown
  * - Requires authentication via GetRequestHeader
  * - Errors are logged to console and re-thrown for caller handling
  *

package/dist/types/DataStructures/BaseUrl.d.ts

@@ -64,6 +64,11 @@ export declare class BaseUrl {
      * @returns {string} The user connections retrieval API endpoint
      */
     static GetAllConnectionsOfUserUrl(): string;
+    /**
+     * Returns the URL for retrieving connection IDs matching connection filters.
+     * @returns {string} The connection filtering API endpoint
+     */
+    static GetConnectionsBetweenUrl(): string;
     /**
      * Returns the URL for retrieving all connections of a composition.
      * @returns {string} The composition connections retrieval API endpoint

package/dist/types/DataStructures/ConceptData.d.ts

@@ -38,10 +38,19 @@ export declare class ConceptsData {
     /** Legacy array storage for concepts (deprecated in favor of tree structures) */
     static conceptsArray: Concept[];
     /**
-     * NPC (Non-Persistent Concepts) cache for temporarily tracking accessed concept IDs.
-     * Limited to 10 entries for memory management.
+     * NPC (Non-Persistent Concepts) cache for concept IDs that are currently in cooldown.
      */
     static NPC: number[];
+    /**
+     * Per-NPC cooldown state. Each failed backend lookup increases the cooldown by
+     * 30 seconds: first miss = 30s, second miss = 60s, third miss = 90s, etc.
+     */
+    static NPCMeta: Map<number, {
+        attempts: number;
+        expiresAt: number;
+    }>;
+    static NPC_BACKOFF_SECONDS: number;
+    static RemoveExpiredNpc(now?: number): void;
     /** Dictionary-style storage for quick concept lookups by ID */
     static conceptDictionary: Concept[];
     /**
@@ -61,7 +70,7 @@ export declare class ConceptsData {
     static CheckContains(concept: Concept): boolean;
     /**
      * Adds a concept ID to the Non-Persistent Concepts (NPC) cache.
-     * Used for tracking recently accessed concepts. Automatically clears when exceeding 10 entries.
+     * Used for tracking recently missed concepts with a growing retry cooldown.
      *
      * @param {number} id - The concept ID to add to NPC cache
      *
@@ -72,10 +81,10 @@ export declare class ConceptsData {
      */
     static AddNpc(id: number): void;
     /**
-     * Checks if a concept ID exists in the NPC cache.
+     * Checks if a concept ID exists in the NPC cache and is still inside its cooldown.
      *
      * @param {number} id - The concept ID to check
-     * @returns {boolean} True if the ID is in the NPC cache, false otherwise
+     * @returns {boolean} True if the ID is currently in NPC cooldown, false otherwise
      *
      * @example
      * ```typescript

package/dist/types/DataStructures/FetchConnection.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Request/response shape for POST /api/get-connection-between.
+ *
+ * Use only the fields relevant to the query and leave the rest at their
+ * zero/empty defaults. The backend resolves typeId from type when typeId is 0.
+ */
+export interface FetchConnection {
+    ofTheConceptId: number;
+    toTheConceptId: number;
+    typeId: number;
+    type: string;
+    oldType: string;
+    reverse: boolean;
+    isComposition: boolean;
+    connectionIds: number[];
+}
+export type FetchConnectionQuery = Omit<FetchConnection, 'connectionIds'>;
+/**
+ * Builds a complete FetchConnection request object from a partial query.
+ */
+export declare function buildFetchConnection(query: Partial<FetchConnectionQuery>): FetchConnection;

package/dist/types/DataStructures/ReservedIds.d.ts

@@ -24,6 +24,7 @@
 export declare class ReservedIds {
     /** Pool of reserved concept IDs */
     static ids: number[];
+    private static pendingFetch;
     /**
     * Gets the next available reserved ID from the pool.
     * Automatically refills the pool if it has fewer than 10 IDs.
@@ -77,21 +78,13 @@ export declare class ReservedIds {
 export declare class ReservedConnectionIds {
     /** Pool of reserved connection IDs */
     static connectionIds: number[];
+    private static pendingFetch;
     /**
      * Gets the next available reserved connection ID from the pool.
-     * Automatically refills the pool if it has fewer than 10 IDs.
+     * Triggers a background refill when the pool is low, and waits for a fetch
+     * if the pool is completely empty. Only one fetch is in-flight at a time.
      *
      * @returns {Promise<number>} A unique reserved connection ID
-     *
-     * @example
-     * ```typescript
-     * const id = await ReservedConnectionIds.getId();
-     * const connection = new Connection(id, ...);
-     * ```
-     *
-     * @remarks
-     * Uses FIFO (first in, first out) to retrieve IDs.
-     * Triggers a backend call to GetReservedConnectionIds when pool is low.
      */
     static getId(): Promise<number>;
     /**
@@ -99,13 +92,15 @@ export declare class ReservedConnectionIds {
      *
      * @param {number} id - The ID to add to the pool
      *
-     * @example
-     * ```typescript
-     * ReservedConnectionIds.AddId(456);
-     * ```
-     *
      * @remarks
      * Prevents duplicate IDs from being added to the pool.
      */
     static AddId(id: number): void;
+    /**
+     * Pre-fills the pool with at least `needed` IDs in a single API call.
+     * Call this before a parallel batch so getId() never has to wait mid-flight.
+     *
+     * @param {number} needed - Total IDs required for the upcoming batch
+     */
+    static warmUp(needed: number): Promise<void>;
 }

package/dist/types/DataStructures/Search/FreeschemaQuery.d.ts

@@ -184,4 +184,5 @@ export declare class FreeschemaQuery {
      * @default false
      */
     isOldConnectionType: boolean;
+    usePipelineQuery: boolean;
 }

package/dist/types/DataStructures/Transaction/Transaction.d.ts

@@ -4,6 +4,7 @@
  */
 import { Concept } from "../Concept";
 import { Connection } from "../Connection";
+import { FetchConnectionQuery } from "../FetchConnection";
 /**
  * Manages transactional operations for concepts and connections.
  * This class provides ACID-like transaction capabilities for creating and managing
@@ -69,6 +70,14 @@ export declare class Transaction {
      * @default true
      */
     protected success: boolean;
+    /**
+     * Connection IDs queued for deletion when the transaction commits.
+     * Rollback clears this list without touching the backend.
+     *
+     * @protected
+     * @type {number[]}
+     */
+    protected pendingConnectionDeletions: number[];
     /**
      * Creates a new Transaction instance.
      * Generates a unique transaction ID for tracking purposes.
@@ -154,6 +163,20 @@ export declare class Transaction {
      * ```
      */
     commitTransaction(): Promise<void>;
+    /**
+     * Queues connections matching one query for deletion on commit.
+     *
+     * Nothing is deleted until commitTransaction() is called. Calling
+     * rollbackTransaction() discards the queued IDs.
+     */
+    DeleteConnectionsBetween(query: Partial<FetchConnectionQuery>): Promise<number[]>;
+    /**
+     * Queues connections matching multiple queries for deletion on commit.
+     *
+     * The queries are resolved in one API call, then their connection IDs are
+     * merged into this transaction's pending deletion queue.
+     */
+    DeleteConnectionsBetweenBulk(queries: Partial<FetchConnectionQuery>[]): Promise<number[]>;
     /**
    * Creates a new instance concept within the transaction.
    * The concept represents a data instance of a specified type with associated metadata.

package/dist/types/DataStructures/User/UserBinaryTree.d.ts

@@ -1,132 +1,14 @@
-/**
- * @fileoverview Binary tree for managing user-specific concepts and connections.
- * This module provides a composite-key based tree for efficient user and session-based data storage.
- * @module DataStructures/User/UserBinaryTree
- */
 import { LConcept } from "../../DataStructures/Local/LConcept";
 import { UserNode } from "./UserNode";
 import { LConnection } from "../Local/LConnection";
-/**
- * Binary tree data structure for managing user-specific data with composite keys.
- *
- * @remarks
- * This class implements an AVL tree that uses composite keys (userId + sessionId + randomizer)
- * to organize user-specific concepts and connections. The composite key enables efficient
- * organization and retrieval of data by user, session, and application context.
- *
- * @example
- * ```typescript
- * const concept = new LConcept(123, "example", 5);
- * UserBinaryTree.addConceptToTree(concept, 42, 999);
- * const node = await UserBinaryTree.getNodeFromTree(42, 999, 123);
- * ```
- */
 export declare class UserBinaryTree {
-    /**
-     * The root node of the user data binary tree.
-     * Null if the tree is empty.
-     */
-    static root: UserNode | null;
-    /**
-     * Creates a composite key from user ID, session ID, and randomizer.
-     *
-     * @param userId - The user ID
-     * @param sessionId - The session ID
-     * @param randomizer - Additional identifier (defaults to 999)
-     * @returns A 12-character hexadecimal composite key
-     *
-     * @remarks
-     * The composite key is formed by concatenating three 4-digit hexadecimal values:
-     * userHex (4 chars) + sessionHex (4 chars) + randomizerHex (4 chars) = 12 chars total.
-     * This enables unique identification of data across users, sessions, and applications.
-     *
-     * @example
-     * ```typescript
-     * const key = UserBinaryTree.compositeKey(42, 999, 123);
-     * // Returns something like "002A03E7007B"
-     * ```
-     */
+    static nodeMap: Map<string, UserNode>;
     static compositeKey(userId: number, sessionId: number, randomizer?: number): string;
-    /**
-     * Adds a user node to the binary tree.
-     *
-     * @param node - The UserNode to be added to the tree
-     *
-     * @remarks
-     * If the tree is empty, the provided node becomes the root.
-     * Otherwise, the node is inserted using the AVL tree balancing algorithm.
-     */
-    static addNodeToTree(node: UserNode): UserNode | undefined;
-    /**
-     * Waits for user data to be loaded into the tree.
-     *
-     * @returns A promise that resolves with "done" when data is loaded, or rejects with "not" after 25 seconds
-     */
     static waitForDataToLoad(): Promise<unknown>;
-    /**
-     * Periodically checks if user data has been loaded.
-     *
-     * @param resolve - The promise resolve function to call when data is loaded
-     */
     static checkFlag(resolve: any): any;
-    /**
-     * Creates a node from a concept and adds it to the user tree.
-     *
-     * @param concept - The LConcept object to be added
-     * @param userId - The user ID
-     * @param sessionId - The session ID (defaults to 999)
-     *
-     * @remarks
-     * Uses the concept's applicationId as the randomizer in the composite key.
-     */
     static addConceptToTree(concept: LConcept, userId: number, sessionId?: number): void;
-    /**
-     * Creates a node from a connection and adds it to the user tree.
-     *
-     * @param connection - The LConnection object to be added
-     * @param userId - The user ID
-     * @param sessionId - The session ID (defaults to 999)
-     *
-     * @remarks
-     * Uses the connection's applicationId as the randomizer in the composite key.
-     */
     static addConnectionToTree(connection: LConnection, userId: number, sessionId?: number): void;
-    /**
-     * Retrieves a node from the tree using composite key components.
-     *
-     * @param userId - The user ID
-     * @param sessionId - The session ID
-     * @param randomizer - Additional identifier (defaults to 999)
-     * @returns The UserNode if found, null otherwise
-     *
-     * @remarks
-     * Constructs a composite key from the parameters and performs a binary search.
-     */
     static getNodeFromTree(userId: number, sessionId: number, randomizer?: number): Promise<UserNode | null>;
-    /**
-     * Removes a node from the tree using composite key components.
-     *
-     * @param userId - The user ID
-     * @param sessionId - The session ID (defaults to 999)
-     * @param randomizer - Additional identifier (defaults to 999)
-     *
-     * @remarks
-     * Constructs a composite key and removes the matching node while maintaining AVL balance.
-     */
     static removeNodeFromTree(userId: number, sessionId?: number, randomizer?: number): Promise<void>;
-    /**
-     * Counts the total number of nodes in the tree.
-     *
-     * @returns The total number of user nodes in the tree
-     *
-     * @remarks
-     * Recursively traverses the entire tree to count all nodes. Returns 0 if the tree is empty.
-     *
-     * @example
-     * ```typescript
-     * const count = UserBinaryTree.countNumberOfNodes();
-     * console.log(`Tree contains ${count} user data nodes`);
-     * ```
-     */
     static countNumberOfNodes(): number;
 }

package/dist/types/DataStructures/User/UserNode.d.ts

@@ -1,150 +1,8 @@
-/**
- * @fileoverview Node implementation for the UserBinaryTree.
- * This module provides the UserNode class for storing user-specific concepts and connections.
- * @module DataStructures/User/UserNode
- */
 import { LConcept } from "../Local/LConcept";
 import { LConnection } from "../Local/LConnection";
-/**
- * Represents a node in the user binary tree that stores both concepts and connections.
- *
- * @remarks
- * UserNode implements an AVL tree node that can store multiple concepts and connections
- * for a given composite key (userId + sessionId + randomizer). This allows efficient
- * storage and retrieval of all user data associated with a specific key combination.
- *
- * @example
- * ```typescript
- * const concept = new LConcept(123, "example", 5);
- * const connection = new LConnection(456, 1, 2, 3, 4, 5);
- * const node = new UserNode("compositeKey", concept, connection, null, null);
- * ```
- */
 export declare class UserNode {
-    /**
-     * The composite key used for tree ordering.
-     * Typically a hexadecimal string combining userId, sessionId, and randomizer.
-     */
-    key: any;
-    /**
-     * Array of connections stored in this node.
-     * Multiple connections can be associated with the same key.
-     */
-    connectionValue: LConnection[];
-    /**
-     * Array of concepts stored in this node.
-     * Multiple concepts can be associated with the same key.
-     */
-    value: LConcept[];
-    /**
-     * Reference to the left child node.
-     */
-    leftNode: UserNode | null;
-    /**
-     * Reference to the right child node.
-     */
-    rightNode: UserNode | null;
-    /**
-     * The height of this node in the tree.
-     * Used for AVL tree balancing calculations.
-     */
-    height: number;
-    /**
-     * Creates a new UserNode.
-     *
-     * @param key - The composite key for tree ordering
-     * @param value - The LConcept to store (added if ID > 0)
-     * @param connectionValue - The LConnection to store (added if ID > 0)
-     * @param leftNode - The left child node (or null)
-     * @param rightNode - The right child node (or null)
-     *
-     * @remarks
-     * Only adds concepts and connections with valid (> 0) IDs to their respective arrays.
-     *
-     * @example
-     * ```typescript
-     * const node = new UserNode("compositeKey", concept, connection, null, null);
-     * ```
-     */
-    constructor(key: any, value: LConcept, connectionValue: LConnection, leftNode: UserNode | null, rightNode: UserNode | null);
-    /**
-     * Adds a new node to the tree with AVL balancing.
-     *
-     * @param passedNode - The node to be added
-     * @param node - The current node being evaluated
-     * @param height - The height of the current node
-     * @returns The root node after insertion and balancing
-     *
-     * @remarks
-     * Implements AVL tree insertion. When a node with the same key exists,
-     * the new node's concepts and connections are added to the existing node's arrays.
-     */
-    addNode(passedNode: UserNode, node: UserNode | null, height: number): UserNode | null;
-    /**
-     * Performs a right rotation on the given node for AVL balancing.
-     *
-     * @param y - The node to rotate right
-     * @returns The new root node after rotation
-     */
-    rightRotate(y: UserNode | null): UserNode | null;
-    /**
-     * Performs a left rotation on the given node for AVL balancing.
-     *
-     * @param x - The node to rotate left
-     * @returns The new root node after rotation
-     */
-    leftRotate(x: UserNode | null): UserNode | null;
-    /**
-     * Gets the height of a node.
-     *
-     * @param node - The node to get the height from
-     * @returns The height of the node, or 0 if null
-     */
-    getHeight(node: UserNode | null): number;
-    /**
-     * Calculates the balance factor of a node.
-     *
-     * @param N - The node to calculate the balance factor for
-     * @returns The balance factor (difference between left and right heights)
-     */
-    getBalanceFactor(N: UserNode | null): number;
-    /**
-     * Retrieves a node from the tree by its composite key.
-     *
-     * @param id - The composite key string to search for
-     * @param node - The current node being evaluated
-     * @returns The matching UserNode if found, null otherwise
-     */
-    getFromNode(id: string, node: UserNode | null): UserNode | null;
-    /**
-     * Removes a node from the tree by its composite key.
-     *
-     * @param passedNode - The current node being evaluated
-     * @param id - The composite key string to remove
-     * @returns The root node after removal
-     *
-     * @remarks
-     * Implements standard BST deletion with in-order successor replacement.
-     */
-    removeNode(passedNode: UserNode | null, id: string): UserNode | null;
-    /**
-     * Counts all nodes below and including the given node.
-     *
-     * @param root - The root node to start counting from
-     * @returns The total number of nodes in the subtree
-     *
-     * @remarks
-     * Recursively traverses the entire subtree to count all nodes.
-     */
-    countNodeBelow(root: UserNode | null): number;
-    /**
-     * Finds the in-order successor of a node.
-     *
-     * @param root - The node to find the successor from
-     * @returns The in-order successor node (leftmost node in right subtree)
-     *
-     * @remarks
-     * Used during node deletion to find the replacement node.
-     */
-    inOrderSuccessor(root: UserNode): UserNode;
+    key: string;
+    value: Map<number, LConcept>;
+    connectionValue: Map<number, LConnection>;
+    constructor(key: string, value: LConcept, connectionValue: LConnection);
 }