mftsccs-node 0.0.57 → 0.0.58

package/dist/types/Api/Create/CreateTheCharacter.d.ts

@@ -1,3 +1,45 @@
+/**
+ * Character creation API module for the Concept Connection System.
+ * This module handles the creation and persistence of character data in the CCS database,
+ * managing both local repository caching and remote server synchronization.
+ *
+ * @module Api/Create/CreateTheCharacter
+ * @see https://documentation.freeschema.com for CCS API reference
+ */
 import { Returner } from "../../DataStructures/Returner";
 import { TheCharacter } from "../../DataStructures/TheCharacter";
+/**
+ * Creates a new character in the Concept Connection System database.
+ * This function checks if the character already exists in the local repository
+ * before making an API call. If the character doesn't exist (id == 0), it sends
+ * a POST request to create the character on the server and caches it locally.
+ * If the character already exists, it returns the existing character data without
+ * making a network request.
+ *
+ * @param characterData - The character object containing the data to be created
+ * @returns A promise that resolves to a Returner object containing the character ID,
+ *          user ID, and creation status information
+ *
+ * @example
+ * ```typescript
+ * const newCharacter = new TheCharacter(userId, "A", 0, 0, 4, 4, 999, 999, "", false);
+ * const result = await CreateTheCharacter(newCharacter);
+ * console.log(`Created character with ID: ${result.id}`);
+ * ```
+ *
+ * @remarks
+ * This function implements a dual-write pattern:
+ * 1. First checks the local CharacterRepository for existing character
+ * 2. If not found (id == 0), creates the character on the server via API
+ * 3. Caches the newly created character in the local repository
+ * 4. Returns either the new character data or existing character reference
+ *
+ * The function uses GetRequestHeader() for authentication and authorization.
+ * Network errors are logged and handled through the HandleHttpError utility.
+ *
+ * @throws Will throw an error if the HTTP request fails or returns a non-OK status
+ * @see CharacterRepository for local character caching
+ * @see GetRequestHeader for authentication details
+ * @see https://documentation.freeschema.com for character data structure
+ */
 export declare function CreateTheCharacter(characterData: TheCharacter): Promise<Returner>;

package/dist/types/Api/Create/CreateTheConceptApi.d.ts

@@ -1,2 +1,52 @@
+/**
+ * Concept creation API module for the Concept Connection System.
+ * This module provides functionality to create new concepts in the CCS database,
+ * which are the fundamental building blocks of the knowledge graph system.
+ * Concepts represent individual ideas, entities, or nodes in the connection network.
+ *
+ * @module Api/Create/CreateTheConceptApi
+ * @see https://documentation.freeschema.com for concept structure and API reference
+ */
 import { Concept } from "../../DataStructures/Concept";
+/**
+ * Creates a new concept in the Concept Connection System database.
+ * This function sends a POST request to the CCS API to persist a new concept.
+ * Concepts are the core data entities in CCS, representing nodes in the knowledge
+ * graph that can be connected to other concepts through relationships.
+ *
+ * @param conceptData - The concept data object to be created. Can be any valid concept
+ *                      structure that conforms to the API requirements
+ * @returns A promise that resolves to a Concept object containing the created concept
+ *          with its assigned ID and all properties. Returns a default concept if
+ *          the operation fails.
+ *
+ * @example
+ * ```typescript
+ * const newConcept = {
+ *   userId: 123,
+ *   characterId: 456,
+ *   typeId: 1,
+ *   composition: [],
+ *   // ... other concept properties
+ * };
+ * const createdConcept = await CreateTheConceptApi(newConcept);
+ * console.log(`Concept created with ID: ${createdConcept.id}`);
+ * ```
+ *
+ * @remarks
+ * This function follows a fail-safe pattern by initializing the result with a
+ * default concept using CreateDefaultConcept(). This ensures that a valid concept
+ * structure is always returned, even if the API call fails.
+ *
+ * The function uses GetRequestHeader() to include necessary authentication tokens
+ * and headers in the request. All HTTP errors are handled through the HandleHttpError
+ * utility and logged to the console with descriptive messages.
+ *
+ * @throws Will throw an error if the HTTP request fails or returns a non-OK status,
+ *         after logging the error details
+ * @see CreateDefaultConcept for the default concept initialization
+ * @see GetRequestHeader for authentication details
+ * @see HandleHttpError for error handling
+ * @see https://documentation.freeschema.com for concept data model
+ */
 export declare function CreateTheConceptApi(conceptData: any): Promise<Concept>;

package/dist/types/Api/Create/CreateTheConnectionApi.d.ts

@@ -1,2 +1,53 @@
+/**
+ * Connection creation API module for the Concept Connection System.
+ * This module handles the creation of connections (edges) between concepts in the CCS
+ * knowledge graph. Connections define relationships and associations between concepts,
+ * forming the network structure that enables knowledge mapping and traversal.
+ *
+ * @module Api/Create/CreateTheConnectionApi
+ * @see https://documentation.freeschema.com for connection structure and relationship types
+ */
 import { Connection } from "../../DataStructures/Connection";
+/**
+ * Creates one or more connections between concepts in the Concept Connection System.
+ * This function sends a batch of connection data to the CCS API to establish
+ * relationships between concepts. Connections are the edges in the knowledge graph
+ * that link concepts together, enabling navigation and semantic relationships.
+ *
+ * @param connectionData - An array of Connection objects to be created. Each connection
+ *                         defines a relationship between two concepts with directional
+ *                         and metadata properties
+ * @returns A promise that resolves to a Connection object. Note that the function
+ *          returns a default connection instance initialized at the start, and the
+ *          actual API response is processed but not returned in success cases
+ *
+ * @example
+ * ```typescript
+ * const connections = [
+ *   new Connection(userId, ofTheConceptId, toTheConceptId, typeId, ...),
+ *   new Connection(userId, anotherConceptId, targetConceptId, typeId, ...)
+ * ];
+ * await CreateTheConnectionApi(connections);
+ * ```
+ *
+ * @remarks
+ * This function supports batch connection creation by accepting an array of
+ * Connection objects. The API processes all connections in a single request,
+ * which is more efficient than creating connections individually.
+ *
+ * The function has an asymmetric return pattern:
+ * - On success: Returns the default connection instance created at function start
+ * - On error: Logs the error and handles it through HandleHttpError
+ *
+ * The connection data is serialized to JSON and sent with authentication headers
+ * obtained from GetRequestHeader(). All network and HTTP errors are logged to
+ * the console with descriptive prefixes for debugging.
+ *
+ * @throws Will throw an error if the HTTP request fails, after logging error details
+ *         and processing through HandleHttpError
+ * @see Connection for the connection data structure
+ * @see GetRequestHeader for authentication details
+ * @see HandleHttpError for error handling
+ * @see https://documentation.freeschema.com for connection types and semantics
+ */
 export declare function CreateTheConnectionApi(connectionData: Connection[]): Promise<Connection>;

package/dist/types/Api/Create/CreateTheTextData.d.ts

@@ -1,2 +1,58 @@
+/**
+ * Text data creation API module for the Concept Connection System.
+ * This module provides functionality to create and persist text data entries in the
+ * CCS database. Text data represents the textual content associated with concepts,
+ * enabling rich descriptions, annotations, and semantic information storage.
+ *
+ * @module Api/Create/CreateTheTextData
+ * @see https://documentation.freeschema.com for text data structure and usage
+ */
 import { TheTexts } from "../../DataStructures/TheTexts";
+/**
+ * Creates a new text data entry in the Concept Connection System database.
+ * This function sends a POST request to persist text content that can be associated
+ * with concepts, providing descriptive or explanatory information. Text data is a
+ * fundamental component for enriching concepts with human-readable content.
+ *
+ * @param textData - The TheTexts object containing the text content and metadata
+ *                   to be persisted in the database
+ * @returns A promise that resolves to a TheTexts object containing the created
+ *          text data with its assigned ID and all associated properties
+ *
+ * @example
+ * ```typescript
+ * const newText = new TheTexts(
+ *   userId,
+ *   characterId,
+ *   conceptId,
+ *   "Sample text content",
+ *   languageId,
+ *   typeId
+ * );
+ * const createdText = await CreateTextData(newText);
+ * console.log(`Text data created with ID: ${createdText.id}`);
+ * ```
+ *
+ * @remarks
+ * This function is essential for adding textual descriptions to concepts in the
+ * knowledge graph. Text data can include:
+ * - Concept descriptions and definitions
+ * - Annotations and notes
+ * - Multi-language translations
+ * - Rich content and documentation
+ *
+ * The function uses GetRequestHeader() to include authentication credentials
+ * and necessary headers for the API request. The created text data is returned
+ * with its server-assigned ID, enabling immediate reference and updates.
+ *
+ * All HTTP errors are processed through HandleHttpError and logged with
+ * descriptive error messages. Errors are propagated to the caller after logging.
+ *
+ * @throws Will throw an error if the HTTP request fails or returns a non-OK status,
+ *         after logging the error details to the console
+ * @see TheTexts for the text data structure
+ * @see GetRequestHeader for authentication details
+ * @see HandleHttpError for error handling
+ * @see https://documentation.freeschema.com for text data model and language support
+ */
 export declare function CreateTextData(textData: TheTexts): Promise<TheTexts>;

package/dist/types/Api/Delete/DeleteConceptInBackend.d.ts

@@ -1 +1,44 @@
+/**
+ * Backend concept deletion API module for the Concept Connection System.
+ *
+ * This module provides functionality to permanently delete concepts from the backend database.
+ * It handles authenticated API requests to remove concept records using the trash/delete endpoint.
+ *
+ * @module Api/Delete/DeleteConceptInBackend
+ * @see https://documentation.freeschema.com for API reference
+ */
+/**
+ * Permanently deletes a concept from the backend database using the trash endpoint.
+ *
+ * This function sends an authenticated POST request to remove a concept by its ID. It's used
+ * when a concept needs to be completely removed from the system rather than just marked as deleted.
+ * The operation requires authentication and will throw errors if the deletion fails.
+ *
+ * @param id - The unique identifier of the concept to delete
+ * @param token - Bearer authentication token for authorizing the deletion request
+ *
+ * @returns A promise that resolves when the concept is successfully deleted, or rejects with an error
+ *
+ * @throws Will throw an error if the HTTP request fails or returns a non-OK status
+ * @throws Will re-throw any caught errors after logging them to the console
+ *
+ * @example
+ * ```typescript
+ * // Delete a concept with authentication
+ * try {
+ *   await TrashTheConcept(12345, 'your-auth-token-here');
+ *   console.log('Concept deleted successfully');
+ * } catch (error) {
+ *   console.error('Failed to delete concept:', error);
+ * }
+ * ```
+ *
+ * @remarks
+ * This function uses FormData to send the concept ID in the request body. The deletion is permanent
+ * and cannot be undone. All errors are logged to the console before being re-thrown to allow
+ * proper error handling by the caller.
+ *
+ * @see DeleteTheConcept for an alternative deletion method
+ * @see BaseUrl.DeleteConceptUrl for the API endpoint configuration
+ */
 export declare function TrashTheConcept(id: number, token: string): Promise<void>;

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

@@ -1 +1,56 @@
+/**
+ * Bulk connection deletion API module for the Concept Connection System.
+ *
+ * This module provides functionality to delete multiple connections between concepts in a single API call.
+ * It optimizes performance by allowing batch deletion operations rather than individual deletions,
+ * making it ideal for cleanup operations and managing multiple relationships at once.
+ *
+ * @module Api/DeleteConnectionApiBulk
+ * @see https://documentation.freeschema.com for API reference
+ */
+/**
+ * Deletes multiple connections between concepts in a single bulk operation.
+ *
+ * This function sends an authenticated POST request to delete multiple connection records
+ * identified by their IDs. It's particularly useful for cleanup operations, removing outdated
+ * relationships, or managing connections in bulk rather than one at a time. The function
+ * returns a boolean indicating success or failure of the bulk deletion.
+ *
+ * @param ids - Array of connection IDs to delete in bulk
+ *
+ * @returns A promise that resolves to `true` if all connections were successfully deleted,
+ *          `false` if the deletion failed or encountered errors
+ *
+ * @example
+ * ```typescript
+ * // Delete multiple connections at once
+ * const connectionIds = [101, 102, 103, 104];
+ * const success = await DeleteTheConnectionBulkApi(connectionIds);
+ *
+ * if (success) {
+ *   console.log('All connections deleted successfully');
+ * } else {
+ *   console.log('Bulk deletion failed');
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Clean up all connections for a specific concept
+ * const obsoleteConnections = [45, 67, 89];
+ * const result = await DeleteTheConnectionBulkApi(obsoleteConnections);
+ * ```
+ *
+ * @remarks
+ * This function uses authenticated headers retrieved from GetRequestHeaderWithAuthorization().
+ * The connection IDs are sent as a JSON array in the request body. Unlike individual deletion
+ * methods, this function does not throw errors but returns false on failure, making it safer
+ * for batch operations where partial failures should be handled gracefully.
+ *
+ * The function logs all errors to the console for debugging purposes but does not re-throw them,
+ * allowing the calling code to continue execution even if the bulk deletion fails.
+ *
+ * @see DeleteTheConnection for single connection deletion
+ * @see BaseUrl.DeleteTheConnectionBulkUrl for the API endpoint configuration
+ */
 export default function DeleteTheConnectionBulkApi(ids: number[]): Promise<boolean>;

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

@@ -1 +1,65 @@
+/**
+ * Concept deletion API module for the Concept Connection System.
+ *
+ * This module provides the primary interface for deleting individual concept records from the system.
+ * It supports both authenticated and unauthenticated deletion requests, making it flexible for
+ * different security contexts. The module handles API communication, error management, and
+ * returns deletion status to the caller.
+ *
+ * @module Api/DeleteTheConcept
+ * @see https://documentation.freeschema.com for API reference
+ */
+/**
+ * Deletes a single concept from the system by its ID.
+ *
+ * This is the primary function for removing individual concepts from the CCS database. It supports
+ * optional authentication via a bearer token and handles both authenticated and unauthenticated
+ * deletion scenarios. The function returns a boolean indicating success or failure, and throws
+ * errors for critical failures that should halt execution.
+ *
+ * @param id - The unique identifier of the concept to delete
+ * @param token - Optional bearer authentication token. Defaults to empty string for unauthenticated requests
+ *
+ * @returns A promise that resolves to `true` if the concept was successfully deleted,
+ *          `false` if the deletion failed
+ *
+ * @throws Will throw an error if the HTTP request fails with a non-OK status
+ * @throws Will re-throw any caught errors after logging them to the console
+ *
+ * @example
+ * ```typescript
+ * // Delete a concept with authentication
+ * try {
+ *   const success = await DeleteTheConcept(12345, 'your-auth-token');
+ *   if (success) {
+ *     console.log('Concept deleted successfully');
+ *   }
+ * } catch (error) {
+ *   console.error('Critical deletion error:', error);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Delete a concept without authentication (using API key)
+ * const result = await DeleteTheConcept(67890);
+ * if (result) {
+ *   console.log('Public concept removed');
+ * }
+ * ```
+ *
+ * @remarks
+ * The function uses FormData to send the concept ID along with a hardcoded "nodeserver" API key.
+ * When a token is provided, it switches to authenticated headers using GetRequestHeaderWithAuthorization.
+ * Note that the headers parameter is currently commented out in the fetch call, which may affect
+ * authentication behavior.
+ *
+ * Error handling follows a dual approach: errors are logged to console for debugging and then
+ * re-thrown to allow the caller to handle critical failures. The function returns the success
+ * status from the API response JSON.
+ *
+ * @see TrashTheConcept for backend-specific concept deletion
+ * @see BaseUrl.DeleteConceptUrl for the API endpoint configuration
+ * @see GetRequestHeaderWithAuthorization for authentication header construction
+ */
 export default function DeleteTheConcept(id: number, token?: string): Promise<boolean>;

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

@@ -1 +1,77 @@
+/**
+ * Connection deletion API module for the Concept Connection System.
+ *
+ * This module provides the primary interface for deleting individual connection records between
+ * concepts in the system. Connections represent relationships, links, or associations between
+ * different concepts. This module supports both authenticated and unauthenticated deletion
+ * requests and handles all aspects of API communication and error management.
+ *
+ * @module Api/DeleteTheConnection
+ * @see https://documentation.freeschema.com for API reference
+ */
+/**
+ * Deletes a single connection between concepts by its ID.
+ *
+ * This is the primary function for removing individual connections (relationships) between concepts
+ * in the CCS database. Connections represent links, associations, or relationships between different
+ * concept nodes. The function supports optional authentication and returns a boolean indicating
+ * whether the deletion was successful.
+ *
+ * @param id - The unique identifier of the connection to delete
+ * @param token - Optional bearer authentication token. Defaults to empty string for unauthenticated requests
+ *
+ * @returns A promise that resolves to `true` if the connection was successfully deleted,
+ *          `false` if the deletion failed or encountered errors
+ *
+ * @throws Will re-throw any caught errors after logging them to the console
+ *
+ * @example
+ * ```typescript
+ * // Delete a connection with authentication
+ * try {
+ *   const success = await DeleteTheConnection(456, 'your-auth-token');
+ *   if (success) {
+ *     console.log('Connection removed successfully');
+ *   } else {
+ *     console.log('Failed to remove connection');
+ *   }
+ * } catch (error) {
+ *   console.error('Critical error during deletion:', error);
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Delete a connection without authentication
+ * const removed = await DeleteTheConnection(789);
+ * if (removed) {
+ *   console.log('Connection deleted');
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Remove multiple connections sequentially
+ * const connectionIds = [101, 102, 103];
+ * for (const connId of connectionIds) {
+ *   await DeleteTheConnection(connId, authToken);
+ * }
+ * ```
+ *
+ * @remarks
+ * The function uses FormData to send the connection ID along with a hardcoded "nodeserver" API key.
+ * When a token is provided, authenticated headers are prepared using GetRequestHeaderWithAuthorization,
+ * though the headers are currently commented out in the fetch call.
+ *
+ * The fetch request includes `redirect: "follow"` to handle any server-side redirects automatically.
+ * Error handling logs failures to the console before re-throwing, allowing both debugging and
+ * proper error propagation to calling code.
+ *
+ * Unlike concept deletion, connection deletion typically has fewer cascade effects since connections
+ * are edges in the concept graph rather than nodes themselves.
+ *
+ * @see DeleteTheConnectionBulkApi for bulk connection deletion
+ * @see BaseUrl.DeleteTheConnectionUrl for the API endpoint configuration
+ * @see GetRequestHeaderWithAuthorization for authentication header construction
+ */
 export default function DeleteTheConnection(id: number, token?: string): Promise<boolean>;

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

@@ -1 +1,37 @@
+/**
+ * API module for fetching AI-related concept data from the remote server.
+ * This module retrieves AI-generated or AI-specific concepts and adds them to the local concept store.
+ *
+ * @module Api/GetAiData
+ * @see https://documentation.freeschema.com for more information on the Concept Connection System
+ */
+/**
+ * Fetches all AI-related concept data from the remote server and populates the local concept store.
+ * This function retrieves AI-generated concepts, AI metadata, or AI-specific data structures
+ * from the backend and adds them to the ConceptsData singleton for use throughout the application.
+ *
+ * The function uses authorized headers to ensure secure access to AI data endpoints.
+ * All retrieved concepts are automatically added to the local in-memory concept store.
+ *
+ * @returns A promise that resolves when all AI data has been fetched and stored locally
+ *
+ * @example
+ * ```typescript
+ * // Fetch and populate AI data
+ * await GetAiData();
+ *
+ * // AI concepts are now available in ConceptsData
+ * const aiConcepts = ConceptsData.GetAllConcepts();
+ * ```
+ *
+ * @remarks
+ * This function requires proper authentication headers via GetRequestHeaderWithAuthorization.
+ * Errors are logged to the console with the prefix 'Ai Error Message' and are re-thrown
+ * to allow calling code to handle failures appropriately.
+ *
+ * @throws Will throw an error if the network request fails or if the server returns an error response
+ *
+ * @see ConceptsData.AddConcept for how concepts are stored locally
+ * @see GetRequestHeaderWithAuthorization for authentication details
+ */
 export declare function GetAiData(): Promise<void>;

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

@@ -1 +1,43 @@
+/**
+ * API module for retrieving all concepts belonging to a specific user.
+ * This module fetches user-specific concept data from the remote server and populates the local concept store.
+ *
+ * @module Api/GetAllConcepts
+ * @see https://documentation.freeschema.com for more information on the Concept Connection System
+ */
+/**
+ * Retrieves all concepts created by or associated with a specific user from the remote server.
+ * This function fetches all concepts belonging to the specified user ID and adds them to the
+ * local ConceptsData store for use throughout the application.
+ *
+ * Concepts represent individual units of knowledge or data in the Concept Connection System.
+ * Each user can create and manage their own set of concepts, which can then be connected
+ * to form a knowledge graph.
+ *
+ * @param userId - The unique identifier of the user whose concepts should be retrieved
+ *
+ * @returns A promise that resolves when all user concepts have been fetched and stored locally
+ *
+ * @example
+ * ```typescript
+ * // Fetch all concepts for user with ID 123
+ * await GetAllUserConcepts(123);
+ *
+ * // User concepts are now available in ConceptsData
+ * const userConcepts = ConceptsData.GetAllConcepts();
+ * ```
+ *
+ * @remarks
+ * Note: The current implementation has an inverted logic check where it processes results
+ * when response.ok is false. This may be intentional for specific server configurations
+ * or may need review.
+ *
+ * Errors are logged with the prefix 'GetAllUserConcepts error' and are re-thrown to allow
+ * calling code to handle failures appropriately.
+ *
+ * @throws Will throw an error if the network request fails or if the server returns an error response
+ *
+ * @see ConceptsData.AddConcept for how concepts are stored locally
+ * @see GetRequestHeader for request header configuration
+ */
 export declare function GetAllUserConcepts(userId: number): Promise<void>;

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

@@ -1 +1,46 @@
+/**
+ * API module for retrieving concepts filtered by type and user.
+ * This module fetches concepts of a specific type for a given user from the remote server
+ * and populates the local concept store.
+ *
+ * @module Api/GetAllConceptsByType
+ * @see https://documentation.freeschema.com for more information on the Concept Connection System
+ */
+/**
+ * Retrieves all concepts of a specific type belonging to a user from the remote server.
+ * This function allows filtering concepts by their type (e.g., "person", "place", "thing")
+ * and user ownership, enabling targeted retrieval of specific concept categories.
+ *
+ * In the Concept Connection System, concepts can be categorized by type to organize
+ * different kinds of knowledge. This function fetches only concepts matching the specified
+ * type for the given user, which is useful for displaying categorized views or performing
+ * type-specific operations.
+ *
+ * @param type - The type category of concepts to retrieve (e.g., "person", "organization", "idea")
+ * @param userId - The unique identifier of the user whose concepts should be retrieved
+ *
+ * @returns A promise that resolves when all matching concepts have been fetched and stored locally
+ *
+ * @example
+ * ```typescript
+ * // Fetch all "person" type concepts for user 123
+ * await GetAllConceptsByType("person", 123);
+ *
+ * // Fetch all "organization" type concepts for user 456
+ * await GetAllConceptsByType("organization", 456);
+ *
+ * // Retrieved concepts are now available in ConceptsData
+ * const concepts = ConceptsData.GetAllConcepts();
+ * ```
+ *
+ * @remarks
+ * The function uses URLSearchParams to properly encode the request body parameters.
+ * Errors are logged with the prefix 'GetAllConceptsByType error' and are re-thrown
+ * to allow calling code to handle failures appropriately.
+ *
+ * @throws Will throw an error if the network request fails or if the server returns an error response
+ *
+ * @see ConceptsData.AddConcept for how concepts are stored locally
+ * @see GetRequestHeader for request header configuration
+ */
 export declare function GetAllConceptsByType(type: string, userId: number): Promise<void>;

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

@@ -1 +1,49 @@
+/**
+ * API module for retrieving all connections belonging to a specific user.
+ * This module fetches user-specific connection data from the remote server and populates
+ * the local connection store, including both the main storage and the connection dictionary.
+ *
+ * @module Api/GetAllConnections
+ * @see https://documentation.freeschema.com for more information on the Concept Connection System
+ */
+/**
+ * Retrieves all connections created by or associated with a specific user from the remote server.
+ * This function fetches all connections belonging to the specified user ID and adds them to both
+ * the main ConnectionData store and the connection dictionary for efficient lookup.
+ *
+ * Connections represent relationships between concepts in the Concept Connection System.
+ * Each connection links two or more concepts together with specific relationship metadata.
+ * This function ensures that all user-created connections are available locally for
+ * graph traversal and relationship analysis.
+ *
+ * @param userId - The unique identifier of the user whose connections should be retrieved
+ *
+ * @returns A promise that resolves when all user connections have been fetched and stored locally
+ *
+ * @example
+ * ```typescript
+ * // Fetch all connections for user with ID 123
+ * await GetAllUserConnections(123);
+ *
+ * // User connections are now available in ConnectionData
+ * const userConnections = ConnectionData.GetAllConnections();
+ *
+ * // Connections are also indexed in the dictionary for fast lookup
+ * const connection = ConnectionData.GetConnectionFromDictionary(connectionId);
+ * ```
+ *
+ * @remarks
+ * This function performs dual storage operations for each connection:
+ * 1. AddConnection - Adds to the main connection collection
+ * 2. AddToDictionary - Indexes in a dictionary for O(1) lookup by connection ID
+ *
+ * Errors are logged with the prefix 'Get all user Connections error' and are re-thrown
+ * to allow calling code to handle failures appropriately.
+ *
+ * @throws Will throw an error if the network request fails or if the server returns an error response
+ *
+ * @see ConnectionData.AddConnection for how connections are stored
+ * @see ConnectionData.AddToDictionary for connection indexing details
+ * @see GetRequestHeader for request header configuration
+ */
 export declare function GetAllUserConnections(userId: number): Promise<void>;