mftsccs-node 0.0.56 → 0.0.58

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,82 @@
+/**
+ * API module for retrieving connections associated with a specific composition.
+ * This module handles both local caching and remote fetching of composition connections,
+ * with automatic synchronization and deletion detection.
+ *
+ * @module Api/GetAllConnectionsOfComposition
+ * @see https://documentation.freeschema.com for more information on the Concept Connection System
+ */
+import { Connection } from '../DataStructures/Connection';
+/**
+ * Retrieves all connections associated with a specific composition, using local cache when available.
+ * This function implements a smart caching strategy: it first checks for locally stored connections,
+ * and if found, fetches fresh data from the server to detect any deletions or changes. If no local
+ * data exists, it directly fetches from the server.
+ *
+ * A composition represents a group or collection of related concepts and their connections.
+ * This function ensures that all connections within a composition are available and synchronized
+ * with the remote server.
+ *
+ * @param composition_id - The unique identifier of the composition whose connections should be retrieved
+ *
+ * @returns A promise that resolves to an array of Connection objects belonging to the composition
+ *
+ * @example
+ * ```typescript
+ * // Fetch all connections for composition 456
+ * const connections = await GetAllConnectionsOfComposition(456);
+ *
+ * // Process the connections
+ * connections.forEach(conn => {
+ *   console.log(`Connection: ${conn.id} links concepts`);
+ * });
+ * ```
+ *
+ * @remarks
+ * This function implements a two-step synchronization process:
+ * 1. First fetch: Retrieves from local cache if available
+ * 2. Online fetch: Always fetches fresh data from server
+ * 3. Deletion check: Compares old and new data to detect removed connections
+ *
+ * This approach ensures data consistency while maintaining local performance benefits.
+ *
+ * @see GetAllConnectionsOfCompositionOnline for the underlying server fetch operation
+ * @see CheckForConnectionDeletion for how deleted connections are detected
+ * @see ConnectionData.GetConnectionsOfCompositionLocal for local cache access
+ */
+export declare function GetAllConnectionsOfComposition(composition_id: number): Promise<Connection[]>;
+/**
+ * Fetches connections for a specific composition directly from the remote server.
+ * This function bypasses local caching and always retrieves fresh data from the backend,
+ * making it suitable for ensuring data accuracy and detecting server-side changes.
+ *
+ * All retrieved connections are automatically added to the local ConnectionData store
+ * for subsequent use throughout the application.
+ *
+ * @param composition_id - The unique identifier of the composition whose connections should be fetched
+ *
+ * @returns A promise that resolves to an array of Connection objects retrieved from the server
+ *
+ * @example
+ * ```typescript
+ * // Fetch fresh connections directly from server
+ * const connections = await GetAllConnectionsOfCompositionOnline(456);
+ *
+ * // Compare with cached data
+ * const cachedConnections = await ConnectionData.GetConnectionsOfCompositionLocal(456);
+ * ```
+ *
+ * @remarks
+ * This is the underlying server communication function used by GetAllConnectionsOfComposition.
+ * It should generally not be called directly unless you specifically need to bypass caching
+ * and force a fresh server fetch.
+ *
+ * Each retrieved connection is added to ConnectionData, making it available for local queries
+ * and reducing the need for subsequent server requests.
+ *
+ * @throws Will throw an error if the network request fails or if the server returns an error response
+ *
+ * @see GetAllConnectionsOfComposition for the recommended high-level function with caching
+ * @see ConnectionData.AddConnection for how connections are stored locally
+ */
+export declare function GetAllConnectionsOfCompositionOnline(composition_id: number): Promise<Connection[]>;

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

@@ -0,0 +1,93 @@
+/**
+ * API module for retrieving connections for multiple compositions in a single bulk operation.
+ * This module optimizes performance by fetching connections for multiple compositions at once,
+ * with automatic synchronization, deletion detection, and concept resolution.
+ *
+ * @module Api/GetAllConnectionsOfCompositionBulk
+ * @see https://documentation.freeschema.com for more information on the Concept Connection System
+ */
+import { Connection } from '../DataStructures/Connection';
+/**
+ * Retrieves connections for multiple compositions in a single bulk operation for improved performance.
+ * This function fetches connections for multiple composition IDs at once, checks for deletions by
+ * comparing with in-memory data, and automatically resolves all referenced concepts.
+ *
+ * Bulk operations are significantly more efficient than individual requests when working with
+ * multiple compositions, reducing network overhead and improving application responsiveness.
+ *
+ * @param composition_ids - Array of composition IDs whose connections should be retrieved. Defaults to empty array.
+ *
+ * @returns A promise that resolves to an array of Connection objects from all specified compositions
+ *
+ * @example
+ * ```typescript
+ * // Fetch connections for multiple compositions at once
+ * const compositionIds = [100, 200, 300];
+ * const connections = await GetAllConnectionsOfCompositionBulk(compositionIds);
+ *
+ * console.log(`Retrieved ${connections.length} connections`);
+ *
+ * // All referenced concepts are automatically fetched
+ * connections.forEach(conn => {
+ *   console.log(`Connection ${conn.id} is ready with its concepts`);
+ * });
+ *
+ * // Handle empty array case
+ * const noConnections = await GetAllConnectionsOfCompositionBulk([]);
+ * console.log(noConnections); // Returns empty array
+ * ```
+ *
+ * @remarks
+ * This function performs several important operations:
+ * 1. Early return if composition_ids array is empty
+ * 2. Retrieves old connections from in-memory storage for comparison
+ * 3. Fetches fresh connections from server via bulk endpoint
+ * 4. Detects and handles deleted connections via CheckForConnectionDeletion
+ * 5. Automatically resolves all concepts referenced by the connections
+ *
+ * The automatic concept resolution ensures that all concepts referenced in the connections
+ * are available locally, preventing the need for additional lookups.
+ *
+ * @see GetAllConnectionsOfCompositionOnline for the underlying bulk server fetch
+ * @see FindConnectionsOfCompositionsBulkInMemory for in-memory lookup
+ * @see FindConceptsFromConnections for automatic concept resolution
+ * @see CheckForConnectionDeletion for deletion detection logic
+ */
+export declare function GetAllConnectionsOfCompositionBulk(composition_ids?: number[]): Promise<Connection[]>;
+/**
+ * Fetches connections for multiple compositions directly from the remote server in a single request.
+ * This function bypasses local caching and retrieves fresh data from the bulk endpoint,
+ * which is optimized for handling multiple composition IDs efficiently.
+ *
+ * All retrieved connections are automatically added to the local ConnectionData store
+ * for subsequent use throughout the application.
+ *
+ * @param composition_ids - Array of composition IDs to fetch connections for. Defaults to empty array.
+ *
+ * @returns A promise that resolves to an array of Connection objects retrieved from the server
+ *
+ * @example
+ * ```typescript
+ * // Fetch connections for multiple compositions from server
+ * const connections = await GetAllConnectionsOfCompositionOnline([100, 200, 300]);
+ *
+ * // Process the bulk results
+ * console.log(`Fetched ${connections.length} connections from server`);
+ * ```
+ *
+ * @remarks
+ * This is the underlying server communication function for bulk composition queries.
+ * It uses JSON serialization for the request body to send the array of composition IDs,
+ * and the server returns all connections for those compositions in a single response.
+ *
+ * The function handles both successful and error responses gracefully, logging appropriate
+ * error messages with the prefix 'Get all connections of composition bulk error message'.
+ *
+ * Each retrieved connection is added to ConnectionData, making it available for local queries.
+ *
+ * @throws Will throw an error if the network request fails or if the server returns an error response
+ *
+ * @see GetAllConnectionsOfCompositionBulk for the recommended high-level function
+ * @see ConnectionData.AddConnection for how connections are stored locally
+ */
+export declare function GetAllConnectionsOfCompositionOnline(composition_ids?: number[]): Promise<Connection[]>;

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

@@ -0,0 +1,54 @@
+/**
+ * API module for retrieving all linker connections originating from a specific concept.
+ * This module fetches outbound linker connections where the specified concept acts as the source,
+ * enabling navigation and analysis of concept relationships in the forward direction.
+ *
+ * @module Api/GetAllLinkerConnectionsFromTheConcept
+ * @see https://documentation.freeschema.com for more information on the Concept Connection System
+ */
+import { Connection } from "../DataStructures/Connection";
+/**
+ * Retrieves all linker connections that originate from a specific concept.
+ * This function fetches connections where the specified concept is the source (from-concept),
+ * allowing you to discover all concepts that this concept links to or relates with.
+ *
+ * Linker connections represent directed relationships in the concept graph, and this function
+ * specifically returns outbound connections where the given concept acts as the origin point.
+ * This is essential for graph traversal, relationship discovery, and understanding how a
+ * concept connects to other parts of the knowledge graph.
+ *
+ * @param conceptId - The unique identifier of the concept whose outbound linker connections should be retrieved
+ *
+ * @returns A promise that resolves to an array of Connection objects originating from the specified concept
+ *
+ * @example
+ * ```typescript
+ * // Get all connections from concept 789
+ * const outboundConnections = await GetAllLinkerConnectionsFromTheConcept(789);
+ *
+ * // Discover what this concept links to
+ * outboundConnections.forEach(connection => {
+ *   console.log(`Concept 789 links to concept ${connection.toConceptId}`);
+ * });
+ *
+ * // Use for graph navigation
+ * async function traverseFromConcept(conceptId: number) {
+ *   const connections = await GetAllLinkerConnectionsFromTheConcept(conceptId);
+ *   return connections.map(conn => conn.toConceptId);
+ * }
+ * ```
+ *
+ * @remarks
+ * This function uses a GET request with the concept ID as a query parameter.
+ * Unlike some other API functions, it does not automatically add connections to ConnectionData,
+ * allowing the caller to decide how to handle the returned connections.
+ *
+ * The function returns an empty array if the request fails or if no connections are found.
+ * Errors are logged with the prefix 'Get all linker connection from the concepts error'.
+ *
+ * @throws Will throw an error if the network request fails or if the server returns an error response
+ *
+ * @see GetAllLinkerConnectionsToTheConcept for retrieving inbound connections to a concept
+ * @see Connection for the connection data structure
+ */
+export declare function GetAllLinkerConnectionsFromTheConcept(conceptId: number): Promise<Connection[]>;