mftsccs-node 0.0.56 → 0.0.58

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

@@ -0,0 +1,179 @@
+/**
+ * @fileoverview Static repository for managing concepts to be drawn/rendered in the CCS-JS system.
+ * @module DataStructures/ConceptsToDraw
+ */
+import { Concept } from "./Concept";
+/**
+ * Manages a static collection of concepts that need to be drawn or rendered.
+ *
+ * @remarks
+ * ConceptsToDraw acts as a singleton-like repository using static methods and properties
+ * to manage a collection of Concept instances. It provides functionality to add, remove,
+ * check existence, and retrieve concepts by ID. This is typically used for maintaining
+ * a render queue or active concept list in visualization components.
+ *
+ * The class uses static methods for all operations, meaning the concept array is shared
+ * across all instances of the class. The instance method `getName()` is provided for
+ * identification purposes.
+ *
+ * @example
+ * ```typescript
+ * // Add concepts to the collection
+ * const concept1 = new Concept(...);
+ * ConceptsToDraw.AddConcept(concept1);
+ *
+ * // Check if a concept exists
+ * if (ConceptsToDraw.CheckContains(concept1)) {
+ *   console.log('Concept is in the draw queue');
+ * }
+ *
+ * // Retrieve a concept by ID
+ * const retrieved = ConceptsToDraw.GetConcept(concept1.id);
+ *
+ * // Remove when done
+ * ConceptsToDraw.RemoveConcept(concept1);
+ * ```
+ */
+export declare class ConceptsToDraw {
+    /**
+     * Descriptive name for this concepts collection.
+     * @defaultValue "concepts To Draw"
+     */
+    name: string;
+    /**
+     * Creates a new ConceptsToDraw instance.
+     *
+     * @remarks
+     * While the class can be instantiated, the primary functionality is accessed
+     * through static methods. Instances are mainly useful for accessing the `name`
+     * property via the `getName()` method.
+     *
+     * @example
+     * ```typescript
+     * const conceptsToDraw = new ConceptsToDraw();
+     * console.log(conceptsToDraw.getName()); // "concepts To Draw"
+     * ```
+     */
+    constructor();
+    /**
+     * Static array holding all concepts that are queued to be drawn.
+     *
+     * @remarks
+     * This array is shared across all instances and should be managed through
+     * the static methods provided by the class. Direct manipulation is not recommended.
+     */
+    static conceptsArray: Concept[];
+    /**
+     * Checks whether a concept already exists in the collection.
+     *
+     * @param concept - The concept to check for existence
+     * @returns `true` if the concept exists (matched by ID), `false` otherwise
+     *
+     * @remarks
+     * Performs a linear search through the conceptsArray comparing concept IDs.
+     * This method is used internally by `AddConcept` to prevent duplicates.
+     *
+     * @example
+     * ```typescript
+     * const concept = new Concept(...);
+     * ConceptsToDraw.AddConcept(concept);
+     *
+     * if (ConceptsToDraw.CheckContains(concept)) {
+     *   console.log('Concept already exists');
+     * }
+     * ```
+     */
+    static CheckContains(concept: Concept): boolean;
+    /**
+     * Adds a concept to the collection if it doesn't already exist.
+     *
+     * @param concept - The concept to add to the collection
+     *
+     * @remarks
+     * This method ensures no duplicate concepts are added by first checking
+     * existence via `CheckContains`. Only concepts with unique IDs will be added.
+     * If a concept with the same ID already exists, the method silently returns
+     * without adding the duplicate.
+     *
+     * @example
+     * ```typescript
+     * const concept1 = new Concept(...);
+     * const concept2 = new Concept(...);
+     *
+     * ConceptsToDraw.AddConcept(concept1);
+     * ConceptsToDraw.AddConcept(concept2);
+     * ConceptsToDraw.AddConcept(concept1); // Won't add duplicate
+     *
+     * console.log(ConceptsToDraw.conceptsArray.length); // 2
+     * ```
+     */
+    static AddConcept(concept: Concept): void;
+    /**
+     * Removes a concept from the collection by matching its ID.
+     *
+     * @param concept - The concept to remove from the collection
+     *
+     * @remarks
+     * Performs a linear search to find and remove the concept with a matching ID.
+     * Uses `Array.splice()` to remove the element. If multiple concepts with the
+     * same ID exist (which shouldn't happen with proper usage of AddConcept), only
+     * the first match is removed.
+     *
+     * If the concept doesn't exist in the array, the method completes without error.
+     *
+     * @example
+     * ```typescript
+     * const concept = new Concept(...);
+     * ConceptsToDraw.AddConcept(concept);
+     *
+     * // Later, when no longer needed
+     * ConceptsToDraw.RemoveConcept(concept);
+     *
+     * // Verify removal
+     * console.log(ConceptsToDraw.CheckContains(concept)); // false
+     * ```
+     */
+    static RemoveConcept(concept: Concept): void;
+    /**
+     * Retrieves a concept from the collection by its ID.
+     *
+     * @param id - The unique identifier of the concept to retrieve
+     * @returns The Concept object if found, or `null` if no matching concept exists
+     *
+     * @remarks
+     * Performs a linear search through the conceptsArray to find a concept with
+     * the matching ID. Returns the first match found. If no concept with the
+     * specified ID exists, returns `null`.
+     *
+     * @example
+     * ```typescript
+     * const concept = new Concept(...);
+     * ConceptsToDraw.AddConcept(concept);
+     *
+     * // Retrieve by ID
+     * const retrieved = ConceptsToDraw.GetConcept(concept.id);
+     * if (retrieved) {
+     *   console.log('Found concept:', retrieved.id);
+     * } else {
+     *   console.log('Concept not found');
+     * }
+     * ```
+     */
+    static GetConcept(id: number): Concept | null;
+    /**
+     * Gets the descriptive name of this concepts collection.
+     *
+     * @returns The name string "concepts To Draw"
+     *
+     * @remarks
+     * This is an instance method (unlike the other methods which are static),
+     * so it requires an instance of ConceptsToDraw to call.
+     *
+     * @example
+     * ```typescript
+     * const conceptsToDraw = new ConceptsToDraw();
+     * console.log(conceptsToDraw.getName()); // "concepts To Draw"
+     * ```
+     */
+    getName(): string;
+}

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

@@ -0,0 +1,103 @@
+/**
+ * @fileoverview Connection module for the Concept Connection System (CCS-JS).
+ * This module defines the Connection class which represents relationships between concepts.
+ * @module DataStructures/Connection
+ */
+import { Concept } from "./Concept";
+/**
+ * Represents a connection (relationship) between two concepts in the CCS system.
+ * Connections link concepts together and define semantic relationships with type, order, security, and access control.
+ *
+ * @class Connection
+ * @example
+ * ```typescript
+ * const connection = new Connection(
+ *   0, // id
+ *   123, // ofTheConceptId
+ *   456, // toTheConceptId
+ *   1, 1, // userIds
+ *   1, // userId
+ *   10, 1, // type
+ *   0, 0, // order
+ *   0, 0, // security
+ *   0, 0, // access
+ *   0, 0  // sessionInfo
+ * );
+ * ```
+ */
+export declare class Connection {
+    /** Unique identifier for this connection */
+    id: number;
+    /** User ID of the connection owner */
+    userId: number;
+    /** Ghost ID for tracking temporary connections before persistence */
+    ghostId: number;
+    /** ID of the source concept in this connection */
+    ofTheConceptId: number;
+    /** ID of the target concept in this connection */
+    toTheConceptId: number;
+    /** User ID of the source concept owner */
+    ofTheConceptUserId: number;
+    /** User ID of the target concept owner */
+    toTheConceptUserId: number;
+    /** Timestamp when the connection was created */
+    entryTimeStamp: Date | string;
+    /** Termination date for the connection (if applicable) */
+    terminationDateTime: Date;
+    /** Type ID defining the semantic meaning of this connection */
+    typeId: number;
+    /** User ID of the type concept owner */
+    typeUserId: number;
+    /** Order ID for sorting connections */
+    orderId: number;
+    /** User ID of the order concept owner */
+    orderUserId: number;
+    /** Security concept ID controlling access permissions */
+    securityId: number;
+    /** User ID of the security concept owner */
+    securityUserId: number;
+    /** Access control concept ID */
+    accessId: number;
+    /** User ID of the access concept owner */
+    accessUserId: number;
+    /** Session information concept ID for tracking connection context */
+    sessionInformationId: number;
+    /** User ID of the session information concept owner */
+    sessionInformationUserId: number;
+    /** Local synchronization timestamp for offline support */
+    localSyncTime: Date;
+    /** Flag indicating if this is a temporary connection not yet persisted */
+    isTemp: boolean;
+    /** Flag indicating if this connection needs to be updated */
+    toUpdate: boolean;
+    /** The type concept object providing semantic meaning to this connection */
+    type: Concept;
+    /**
+     * Creates a new Connection instance.
+     *
+     * @param {number} [id=0] - Unique identifier for the connection
+     * @param {number} ofTheConceptId - Source concept ID
+     * @param {number} toTheConceptId - Target concept ID
+     * @param {number} ofTheConceptUserId - User ID of source concept owner
+     * @param {number} toTheConceptUserId - User ID of target concept owner
+     * @param {number} userId - User ID of connection creator
+     * @param {number} typeId - Connection type ID
+     * @param {number} typeUserId - User ID of type concept owner
+     * @param {number} orderId - Order concept ID for sorting
+     * @param {number} orderUserId - User ID of order concept owner
+     * @param {number} securityId - Security concept ID
+     * @param {number} securityUserId - User ID of security concept owner
+     * @param {number} accessId - Access control concept ID
+     * @param {number} accessUserId - User ID of access concept owner
+     * @param {number} sessionInformationId - Session information concept ID
+     * @param {number} sessionInformationUserId - User ID of session information concept owner
+     *
+     * @example
+     * ```typescript
+     * const connection = new Connection(
+     *   1, 100, 200, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, 0, 0
+     * );
+     * ```
+     */
+    constructor(id: number | undefined, ofTheConceptId: number, toTheConceptId: number, ofTheConceptUserId: number, toTheConceptUserId: number, userId: number, typeId: number, typeUserId: number, orderId: number, orderUserId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number);
+}

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

@@ -0,0 +1,126 @@
+/**
+ * @fileoverview Binary tree data structure for managing connections.
+ * This module provides an AVL tree implementation for efficient storage and retrieval of Connection objects.
+ * @module DataStructures/ConnectionBinaryTree/ConnectionBinaryTree
+ */
+import { Connection } from "../../DataStructures/Connection";
+import { ConnectionNode } from "./ConnectionNode";
+/**
+ * Binary tree data structure for managing connections with efficient ID-based lookup.
+ *
+ * @remarks
+ * This class implements a self-balancing AVL tree for storing Connection objects.
+ * It provides O(log n) search, insertion, and deletion operations. The tree supports
+ * asynchronous data loading with timeout capabilities and integrates with the
+ * IdentifierFlags system for data synchronization.
+ *
+ * @example
+ * ```typescript
+ * const connection = new Connection(123, ...);
+ * ConnectionBinaryTree.addConnectionToTree(connection);
+ * const node = await ConnectionBinaryTree.getNodeFromTree(123);
+ * ```
+ */
+export declare class ConnectionBinaryTree {
+    /**
+     * The root node of the connection binary tree.
+     * Null if the tree is empty.
+     */
+    static connectionroot: ConnectionNode | null;
+    /**
+     * Adds a connection node to the binary tree.
+     *
+     * @param node - The ConnectionNode to be added to the tree
+     * @returns The root node after insertion
+     *
+     * @remarks
+     * If the tree is empty, the provided node becomes the root.
+     * Otherwise, the node is inserted using the AVL tree balancing algorithm.
+     *
+     * @example
+     * ```typescript
+     * const node = new ConnectionNode(123, connection, null, null);
+     * ConnectionBinaryTree.addNodeToTree(node);
+     * ```
+     */
+    static addNodeToTree(node: ConnectionNode): ConnectionNode | undefined;
+    /**
+     * Creates a node from a connection and adds it to the tree.
+     *
+     * @param connection - The Connection object to be added to the tree
+     *
+     * @remarks
+     * This is a convenience method that wraps the connection in a ConnectionNode
+     * and adds it to the tree. The node is keyed by the connection's ID.
+     *
+     * @example
+     * ```typescript
+     * const connection = new Connection(123, 1, 2, 3, 4, 5);
+     * ConnectionBinaryTree.addConnectionToTree(connection);
+     * ```
+     */
+    static addConnectionToTree(connection: Connection): void;
+    /**
+     * Waits for connection 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
+     *
+     * @remarks
+     * This method polls the IdentifierFlags.isConnectionLoaded flag every second.
+     * Useful for ensuring data is ready before performing operations on the tree.
+     *
+     * @example
+     * ```typescript
+     * try {
+     *   await ConnectionBinaryTree.waitForDataToLoad();
+     *   console.log("Connection data loaded");
+     * } catch (error) {
+     *   console.log("Loading timed out");
+     * }
+     * ```
+     */
+    static waitForDataToLoad(): Promise<unknown>;
+    /**
+     * Periodically checks if connection data has been loaded.
+     *
+     * @param resolve - The promise resolve function to call when data is loaded
+     *
+     * @remarks
+     * This method recursively checks the IdentifierFlags.isConnectionLoaded flag every 1000ms.
+     */
+    static checkFlag(resolve: any): any;
+    /**
+     * Removes a connection node from the tree by its ID.
+     *
+     * @param id - The numeric ID of the connection to remove
+     *
+     * @remarks
+     * This method removes a node from the tree while maintaining AVL balance.
+     * The tree is automatically rebalanced after removal.
+     *
+     * @example
+     * ```typescript
+     * await ConnectionBinaryTree.removeNodeFromTree(123);
+     * ```
+     */
+    static removeNodeFromTree(id: number): Promise<void>;
+    /**
+     * Retrieves a connection node from the tree by its ID.
+     *
+     * @param id - The numeric ID of the connection to retrieve
+     * @returns The ConnectionNode if found, the root node otherwise
+     *
+     * @remarks
+     * This method performs a binary search through the tree using the connection ID as the key.
+     * The search has O(log n) time complexity in a balanced tree.
+     *
+     * @example
+     * ```typescript
+     * const node = await ConnectionBinaryTree.getNodeFromTree(123);
+     * if (node) {
+     *   console.log("Found connection:", node.value);
+     * }
+     * ```
+     */
+    static getNodeFromTree(id: number): Promise<ConnectionNode | null>;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionNode.d.ts

@@ -0,0 +1,193 @@
+/**
+ * @fileoverview Node implementation for the ConnectionBinaryTree.
+ * This module provides the ConnectionNode class with AVL tree operations and variant management.
+ * @module DataStructures/ConnectionBinaryTree/ConnectionNode
+ */
+import { Connection } from "./../Connection";
+/**
+ * Represents a node in the connection binary tree with support for variants.
+ *
+ * @remarks
+ * ConnectionNode implements an AVL tree node for Connection objects with special
+ * support for managing connection variants (multiple connections with the same key).
+ * Each node can store multiple connection variants in the variants array, allowing
+ * efficient grouping of related connections by type or other criteria.
+ *
+ * @example
+ * ```typescript
+ * const connection = new Connection(123, 1, 2, 3, 4, 5);
+ * const node = new ConnectionNode(123, connection, null, null);
+ * ```
+ */
+export declare class ConnectionNode {
+    /**
+     * The key used for tree ordering (typically connection ID or type ID).
+     */
+    key: any;
+    /**
+     * The Connection object stored in this node.
+     */
+    value: Connection;
+    /**
+     * Reference to the left child node.
+     */
+    leftNode: ConnectionNode | null;
+    /**
+     * Reference to the right child node.
+     */
+    rightNode: ConnectionNode | null;
+    /**
+     * Reference to current node for variant chaining.
+     */
+    currentNode: ConnectionNode | null;
+    /**
+     * Array of variant nodes that share the same key.
+     * Used for storing multiple connections with the same type or identifier.
+     */
+    variants: ConnectionNode[];
+    /**
+     * The height of this node in the tree.
+     * Used for AVL tree balancing calculations.
+     */
+    height: number;
+    /**
+     * Creates a new ConnectionNode.
+     *
+     * @param key - The key for tree ordering
+     * @param value - The Connection object to store
+     * @param leftNode - The left child node (or null)
+     * @param rightNode - The right child node (or null)
+     *
+     * @example
+     * ```typescript
+     * const node = new ConnectionNode(123, connection, null, null);
+     * ```
+     */
+    constructor(key: any, value: Connection, leftNode: ConnectionNode | null, rightNode: ConnectionNode | null);
+    /**
+     * Adds a node to the current node chain by type ID.
+     *
+     * @param passedNode - The node to add
+     * @param node - The current node in the chain
+     * @returns The updated node chain
+     *
+     * @remarks
+     * Used internally for managing connection variants with different type IDs.
+     */
+    addCurrentNode(passedNode: ConnectionNode, node: ConnectionNode | null): ConnectionNode;
+    /**
+     * Adds a connection variant to this node's variants array.
+     *
+     * @param passedNode - The variant node to add
+     * @param node - The current node
+     * @returns The updated node with the new variant
+     *
+     * @remarks
+     * This method ensures no duplicate connections are added by checking IDs.
+     * Variants are stored in the variants array for efficient retrieval.
+     */
+    addCurrentNodeType(passedNode: ConnectionNode, node: ConnectionNode | null): ConnectionNode;
+    /**
+     * 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 with automatic balancing through rotations.
+     */
+    addNode(passedNode: ConnectionNode, node: ConnectionNode | null, height: number): ConnectionNode | null;
+    /**
+     * Adds a node to the tree indexed by type ID with variant support.
+     *
+     * @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
+     * This method is similar to addNode but specifically handles type-based indexing
+     * and manages connection variants that share the same type ID.
+     */
+    addTypeNode(passedNode: ConnectionNode, node: ConnectionNode | null, height: number): ConnectionNode | 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: ConnectionNode | null): ConnectionNode | 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: ConnectionNode | null): ConnectionNode | 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: ConnectionNode | 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: ConnectionNode | null): number;
+    /**
+     * Retrieves a node from the tree by its numeric ID.
+     *
+     * @param id - The connection ID to search for
+     * @param node - The current node being evaluated
+     * @returns The matching ConnectionNode if found, null otherwise
+     */
+    getFromNode(id: number, node: ConnectionNode | null): ConnectionNode | null;
+    /**
+     * Retrieves a node from the tree by its character/string value.
+     *
+     * @param value - The character value to search for
+     * @param node - The current node being evaluated
+     * @returns The matching ConnectionNode if found, null otherwise
+     */
+    getCharacterFromNode(value: string, node: ConnectionNode | null): ConnectionNode | null;
+    /**
+     * Removes a node from the tree by its ID.
+     *
+     * @param passedNode - The current node being evaluated
+     * @param id - The connection ID to remove
+     * @returns The root node after removal
+     *
+     * @remarks
+     * Implements standard BST deletion with in-order successor replacement.
+     */
+    removeNode(passedNode: ConnectionNode | null, id: number): ConnectionNode | null;
+    /**
+     * Removes a specific variant from a node or the entire node if no variants remain.
+     *
+     * @param passedNode - The current node being evaluated
+     * @param typeIdentifier - The type identifier of the node
+     * @param conceptId - The specific connection ID to remove
+     * @returns The root node after removal
+     *
+     * @remarks
+     * This method handles removal of connection variants. If the main value matches,
+     * it's replaced by the first variant. If a variant matches, only that variant is removed.
+     */
+    removeNodeWithVariants(passedNode: ConnectionNode | null, typeIdentifier: any, conceptId: number): ConnectionNode | null;
+    /**
+     * 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: ConnectionNode): ConnectionNode;
+}

package/dist/types/DataStructures/ConnectionBinaryTree/ConnectionTypeTree.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @fileoverview Binary tree for managing connections indexed by type ID.
+ * This module provides a specialized tree for efficient type-based connection lookups and variant retrieval.
+ * @module DataStructures/ConnectionBinaryTree/ConnectionTypeTree
+ */
+import { Connection } from "../../DataStructures/Connection";
+import { ConnectionNode } from "./ConnectionNode";
+/**
+ * Binary tree data structure for managing connections indexed by type ID.
+ *
+ * @remarks
+ * This class implements an AVL tree optimized for type-based connection lookups.
+ * It enables efficient retrieval of all connections of a specific type and supports
+ * variant management for grouping related connections.
+ *
+ * @example
+ * ```typescript
+ * const connection = new Connection(123, 1, 2, 3, 4, 5);
+ * ConnectionTypeTree.addConnectionToTree(connection);
+ * const variants = await ConnectionTypeTree.getTypeVariantsFromTree(5);
+ * ```
+ */
+export declare class ConnectionTypeTree {
+    /**
+     * The root node of the type-indexed connection tree.
+     * Null if the tree is empty.
+     */
+    static connectionTypeRoot: ConnectionNode | null;
+    /**
+     * Adds a connection node to the type-indexed tree.
+     *
+     * @param node - The ConnectionNode to be added
+     * @returns The root node after insertion
+     *
+     * @remarks
+     * Uses the addTypeNode method for type-based insertion with variant support.
+     */
+    static addNodeToTree(node: ConnectionNode): Promise<ConnectionNode | null>;
+    /**
+     * Waits for connection type data to be loaded.
+     *
+     * @returns A promise that resolves when data is loaded, or rejects after 25 seconds
+     */
+    static waitForDataToLoad(): Promise<unknown>;
+    /**
+     * Periodically checks if connection type 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 connection and adds it to the type tree.
+     *
+     * @param connection - The Connection object to be added
+     *
+     * @remarks
+     * Only adds the connection if it has a non-zero typeId.
+     */
+    static addConnectionToTree(connection: Connection): void;
+    /**
+     * Removes a specific connection variant from the tree.
+     *
+     * @param typeId - The type ID identifying the node
+     * @param id - The connection ID to remove
+     */
+    static removeTypeConcept(typeId: number, id: number): void;
+    /**
+     * Retrieves a node from the tree by its type ID.
+     *
+     * @param id - The numeric type ID to search for
+     * @returns The ConnectionNode if found, the root node otherwise
+     */
+    static getNodeFromTree(id: number): ConnectionNode | null;
+    /**
+     * Retrieves all connection variants for a specific type ID.
+     *
+     * @param typeId - The type ID to search for
+     * @returns An array of Connection objects of the specified type
+     *
+     * @remarks
+     * Returns the primary connection and all its variants that share the same type ID.
+     */
+    static getTypeVariantsFromTree(typeId: number): Promise<Connection[] | undefined>;
+    /**
+     * Retrieves all connection variants for a specific type ID filtered by user ID.
+     *
+     * @param typeId - The type ID to search for
+     * @param userId - The user ID to filter by
+     * @returns An array of Connection objects of the specified type belonging to the specified user
+     *
+     * @remarks
+     * Useful for user-specific connection management and filtering.
+     */
+    static getTypeVariantsFromTreeWithUserId(typeId: number, userId: number): Promise<Connection[]>;
+}