mftsccs-node 0.0.57 → 0.0.59

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

@@ -1,2 +1,49 @@
+/**
+ * Module for retrieving concepts by their character value string.
+ * Provides lookup functionality for concepts using their character identifier without type restrictions.
+ *
+ * @module Api/GetConceptByCharacterValue
+ * @see https://documentation.freeschema.com for character value system details
+ */
 import { Concept } from "../DataStructures/Concept";
+/**
+ * Retrieves a concept by its character value string identifier.
+ * This function performs a type-agnostic lookup, returning the first concept matching the character value.
+ *
+ * @param characterValue - The character string identifier of the concept to retrieve
+ * @returns A promise that resolves to the Concept object, or a default concept if not found
+ *
+ * @example
+ * ```typescript
+ * // Fetch a concept by its character value
+ * const concept = await GetConceptByCharacterValue("username");
+ * if (concept.id > 0) {
+ *   console.log(`Found concept with ID: ${concept.id}`);
+ * } else {
+ *   console.log("Concept not found");
+ * }
+ * ```
+ *
+ * @remarks
+ * This function provides a simplified lookup mechanism:
+ *
+ * 1. Makes a direct API call with the character_value parameter
+ * 2. Does not check local cache before making the request
+ * 3. Automatically caches successful results in ConceptsData
+ * 4. Returns a default concept (id = 0) if not found or on error
+ *
+ * Key characteristics:
+ * - Uses form-urlencoded content type for the POST request
+ * - Only caches concepts with id > 0 (valid concepts)
+ * - Does not throw errors on HTTP failure, only logs them
+ * - Simpler than GetConceptByCharacterAndType as it doesn't consider type
+ *
+ * Use this when you know the character value uniquely identifies a concept,
+ * or when type information is not available or relevant.
+ *
+ * @see Concept for the structure of concept objects
+ * @see CreateDefaultConcept for default concept structure
+ * @see GetConceptByCharacterAndType for character+type lookup
+ * @see ConceptsData.AddConcept for caching mechanism
+ */
 export declare function GetConceptByCharacterValue(characterValue: string): Promise<Concept>;

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

@@ -1,2 +1,51 @@
+/**
+ * Module for retrieving individual connections from the CCS system.
+ * Provides caching and optimized retrieval of Connection objects by their unique identifiers.
+ *
+ * @module Api/GetConnection
+ * @see https://documentation.freeschema.com for connection details
+ */
 import { Connection } from "../DataStructures/Connection";
+/**
+ * Retrieves a connection by its unique ID with automatic caching.
+ * Connections represent relationships between concepts in the CCS system.
+ *
+ * @param id - The unique numeric identifier of the connection to retrieve
+ * @returns A promise that resolves to the Connection object
+ *
+ * @example
+ * ```typescript
+ * // Fetch a connection by ID
+ * const connection = await GetConnection(456);
+ * if (connection.id !== 0) {
+ *   console.log(`Connection from ${connection.ofTheConceptId} to ${connection.toTheConceptId}`);
+ * }
+ * ```
+ *
+ * @remarks
+ * This function implements a two-tier retrieval strategy:
+ *
+ * 1. Local Cache Check: First attempts to retrieve the connection from
+ *    ConnectionData cache using GetConnection().
+ *
+ * 2. API Fallback: If not found in cache (id = 0), makes an API request
+ *    to fetch the connection from the server.
+ *
+ * 3. Automatic Caching: Successfully retrieved connections are cached in
+ *    ConnectionData for future lookups.
+ *
+ * Key characteristics:
+ * - Uses form-urlencoded content type for POST request
+ * - Always returns a Connection object (default has id = 0 if not found)
+ * - Errors are logged but propagated to caller
+ * - Does not implement request deduplication (unlike GetConcept)
+ *
+ * Connections are fundamental to the CCS system, linking concepts together
+ * and forming the relationship graph that defines knowledge structure.
+ *
+ * @see Connection for the structure of connection objects
+ * @see ConnectionData.GetConnection for cache retrieval
+ * @see ConnectionData.AddConnection for caching mechanism
+ * @see GetConnectionBulk for retrieving multiple connections efficiently
+ */
 export declare function GetConnection(id: number): Promise<Connection>;

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

@@ -1,2 +1,48 @@
+/**
+ * Module for bulk retrieval of connections from the CCS system.
+ * Provides optimized batch fetching of multiple connections in a single API request.
+ *
+ * @module Api/GetConnectionBulk
+ * @see https://documentation.freeschema.com for bulk connection operations
+ */
 import { Connection } from "../DataStructures/Connection";
+/**
+ * Retrieves multiple connections in a single optimized API request.
+ * This function checks the local cache first and only fetches uncached connections from the API.
+ *
+ * @param connectionIds - Array of connection IDs to retrieve (defaults to empty array)
+ * @returns A promise that resolves to an array of Connection objects
+ *
+ * @example
+ * ```typescript
+ * // Fetch multiple connections at once
+ * const connections = await GetConnectionBulk([101, 102, 103, 104]);
+ * connections.forEach(conn => {
+ *   console.log(`Connection ${conn.id}: ${conn.ofTheConceptId} -> ${conn.toTheConceptId}`);
+ * });
+ * ```
+ *
+ * @remarks
+ * Performance optimization strategy:
+ * 1. Checks ConnectionData cache for each requested connection ID
+ * 2. Immediately includes cached connections in results
+ * 3. Batches all uncached IDs into a single bulk API request
+ * 4. Caches all newly fetched connections for future use
+ * 5. Automatically fetches related concepts via FindConceptsFromConnections
+ * 6. Returns empty array if all connections are cached or if none requested
+ *
+ * This function provides significant performance benefits:
+ * - Reduces network overhead by batching API requests
+ * - Avoids redundant fetches through cache checking
+ * - Proactively loads related concepts to prevent N+1 query problems
+ *
+ * The automatic concept fetching ensures that when you have connections,
+ * you also have the concepts they connect, enabling immediate relationship
+ * traversal without additional API calls.
+ *
+ * @see Connection for the structure of connection objects
+ * @see ConnectionData.AddConnection for caching mechanism
+ * @see GetConnection for single connection retrieval
+ * @see FindConceptsFromConnections for automatic concept loading
+ */
 export declare function GetConnectionBulk(connectionIds?: number[]): Promise<Connection[]>;

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

@@ -1,2 +1,52 @@
+/**
+ * Module for retrieving outgoing connections from a specific concept.
+ * Provides paginated access to connections where a concept is the source (ofTheConcept).
+ *
+ * @module Api/GetConnectionOfTheConcept
+ * @see https://documentation.freeschema.com for connection direction details
+ */
 import { Connection } from "../DataStructures/Connection";
+/**
+ * Retrieves all connections originating from a specific concept with pagination support.
+ * Returns connections where the specified concept is the source (ofTheConcept).
+ *
+ * @param typeId - The type ID to filter connections by connection type
+ * @param ofTheConceptId - The ID of the source concept whose outgoing connections to retrieve
+ * @param userId - The user ID for access control and filtering
+ * @param inpage - Number of connections per page (default: 10)
+ * @param page - Page number for pagination, 1-indexed (default: 1)
+ * @returns A promise that resolves to an array of Connection objects
+ *
+ * @example
+ * ```typescript
+ * // Get first 10 connections of type 5 from concept 100 for user 1
+ * const connections = await GetConnectionOfTheConcept(5, 100, 1);
+ * console.log(`Found ${connections.length} outgoing connections`);
+ *
+ * // Get second page with 20 connections per page
+ * const moreConnections = await GetConnectionOfTheConcept(5, 100, 1, 20, 2);
+ * ```
+ *
+ * @remarks
+ * Connection Direction:
+ * This function retrieves "outgoing" or "from" connections where the specified
+ * concept is the source. In the CCS graph model, these represent relationships
+ * initiated by or originating from the concept.
+ *
+ * Pagination:
+ * - Uses 1-based page numbering (page 1 is the first page)
+ * - Results are limited by the inpage parameter
+ * - Useful for large result sets to avoid loading all connections at once
+ *
+ * Filtering:
+ * - typeId filters connections by their type/relationship kind
+ * - userId enables user-specific visibility and access control
+ *
+ * The function does NOT automatically cache results in ConnectionData,
+ * unlike GetConnection or GetConnectionBulk. It returns the raw API response.
+ *
+ * @see Connection for the structure of connection objects
+ * @see GetConnectionToTheConcept for retrieving incoming connections
+ * @see GetConnectionBulk for bulk connection retrieval with caching
+ */
 export declare function GetConnectionOfTheConcept(typeId: number, ofTheConceptId: number, userId: number, inpage?: number, page?: number): Promise<Connection[]>;

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

@@ -1,2 +1,58 @@
+/**
+ * Module for retrieving incoming connections to a specific concept.
+ * Provides paginated access to connections where a concept is the target (toTheConcept).
+ *
+ * @module Api/GetConnectionToTheConcept
+ * @see https://documentation.freeschema.com for connection direction details
+ */
 import { Connection } from "../DataStructures/Connection";
+/**
+ * Retrieves all connections pointing to a specific concept with pagination support.
+ * Returns connections where the specified concept is the target (toTheConcept).
+ *
+ * @param typeId - The type ID to filter connections by connection type
+ * @param toTheConceptId - The ID of the target concept whose incoming connections to retrieve
+ * @param userId - The user ID for access control and filtering
+ * @param inpage - Number of connections per page (default: 10)
+ * @param page - Page number for pagination, 1-indexed (default: 1)
+ * @returns A promise that resolves to an array of Connection objects
+ *
+ * @example
+ * ```typescript
+ * // Get first 10 connections of type 3 pointing to concept 200 for user 1
+ * const connections = await GetConnectionToTheConcept(3, 200, 1);
+ * console.log(`Found ${connections.length} incoming connections`);
+ *
+ * // Get second page with 20 connections per page
+ * const moreConnections = await GetConnectionToTheConcept(3, 200, 1, 20, 2);
+ * ```
+ *
+ * @remarks
+ * Connection Direction:
+ * This function retrieves "incoming" or "to" connections where the specified
+ * concept is the target. In the CCS graph model, these represent relationships
+ * directed toward or pointing to the concept.
+ *
+ * Use Cases:
+ * - Finding all concepts that reference a specific concept
+ * - Discovering backlinks or reverse relationships
+ * - Building bidirectional relationship navigation
+ * - Analyzing concept dependencies
+ *
+ * Pagination:
+ * - Uses 1-based page numbering (page 1 is the first page)
+ * - Results are limited by the inpage parameter
+ * - Useful for large result sets to avoid loading all connections at once
+ *
+ * Filtering:
+ * - typeId filters connections by their type/relationship kind
+ * - userId enables user-specific visibility and access control
+ *
+ * The function does NOT automatically cache results in ConnectionData,
+ * unlike GetConnection or GetConnectionBulk. It returns the raw API response.
+ *
+ * @see Connection for the structure of connection objects
+ * @see GetConnectionOfTheConcept for retrieving outgoing connections
+ * @see GetConnectionBulk for bulk connection retrieval with caching
+ */
 export declare function GetConnectionToTheConcept(typeId: number, toTheConceptId: number, userId: number, inpage?: number, page?: number): Promise<Connection[]>;

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

@@ -1 +1,37 @@
+/**
+ * API module for fetching reserved connection IDs from the backend.
+ * Manages a pool of pre-allocated connection IDs to optimize performance when creating connections.
+ *
+ * @module Api/GetReservedConnectionIds
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Fetches reserved connection IDs from the backend and stores them in the local pool.
+ * Uses a queue-based system to prevent simultaneous requests and maintains a minimum
+ * threshold of available IDs.
+ *
+ * This function is critical for maintaining a pool of pre-allocated connection IDs,
+ * which improves performance by avoiding the need to request IDs individually when
+ * creating new connections in the Concept Connection System.
+ *
+ * @returns A promise that resolves when the IDs are successfully fetched and stored
+ *
+ * @example
+ * ```typescript
+ * // Ensure reserved connection IDs are available
+ * await GetReservedConnectionIds();
+ *
+ * // Now IDs can be consumed from ReservedConnectionIds.connectionIds
+ * const id = ReservedConnectionIds.GetId();
+ * ```
+ *
+ * @remarks
+ * - Skips fetching if more than 10 IDs are already available
+ * - Uses a queue system to serialize requests and prevent concurrent fetches
+ * - Automatically refills the pool when it runs low
+ * - Errors are logged but the promise is rejected to allow proper error handling
+ *
+ * @see ReservedConnectionIds for the storage data structure
+ * @see GetReservedIds for fetching regular concept IDs
+ */
 export declare function GetReservedConnectionIds(): Promise<void>;

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

@@ -1 +1,38 @@
+/**
+ * API module for fetching reserved concept IDs from the backend.
+ * Manages a pool of pre-allocated concept IDs to optimize performance when creating new concepts.
+ *
+ * @module Api/GetReservedIds
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Fetches reserved concept IDs from the backend and stores them in the local pool.
+ * Uses a queue-based system to prevent simultaneous requests and maintains a minimum
+ * threshold of available IDs.
+ *
+ * This function is essential for maintaining a pool of pre-allocated concept IDs,
+ * which significantly improves performance by avoiding the need to request IDs
+ * individually when creating new concepts in the Concept Connection System.
+ *
+ * @returns A promise that resolves when the IDs are successfully fetched and stored
+ *
+ * @example
+ * ```typescript
+ * // Ensure reserved concept IDs are available
+ * await GetReservedIds();
+ *
+ * // Now IDs can be consumed from ReservedIds.ids
+ * const id = ReservedIds.GetId();
+ * ```
+ *
+ * @remarks
+ * - Skips fetching if more than 10 IDs are already available
+ * - Uses a queue system to serialize requests and prevent concurrent fetches
+ * - Automatically refills the pool when it runs low during concept creation
+ * - Errors are logged with the endpoint URL for debugging purposes
+ * - The promise is rejected on error to allow proper error handling
+ *
+ * @see ReservedIds for the storage data structure
+ * @see GetReservedConnectionIds for fetching connection IDs
+ */
 export declare function GetReservedIds(): Promise<void>;

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

@@ -1 +1,39 @@
+/**
+ * API module for user authentication and login functionality.
+ * Handles user login by validating credentials against the backend and storing the access token.
+ *
+ * @module Api/Login
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Authenticates a user with the backend using email and password credentials.
+ * Upon successful authentication, stores the bearer access token for subsequent API requests.
+ *
+ * This function is used for logging existing users into the Concept Connection System,
+ * enabling them to perform authenticated operations such as creating and modifying concepts.
+ *
+ * @param email - The user's email address used for authentication
+ * @param password - The user's password for authentication
+ * @returns A promise that resolves to the login response containing user data and token, or undefined on error
+ *
+ * @example
+ * ```typescript
+ * // Login an existing user
+ * const result = await LoginToBackend('user@example.com', 'securePassword123');
+ * if (result) {
+ *   console.log('Login successful:', result.data);
+ *   // Token is automatically stored in TokenStorage.BearerAccessToken
+ * }
+ * ```
+ *
+ * @remarks
+ * - The bearer access token is automatically stored in TokenStorage.BearerAccessToken upon successful login
+ * - HTTP errors are handled through HandleHttpError for consistent error reporting
+ * - The function returns undefined if the response is not OK
+ * - Errors are logged to console and re-thrown for caller handling
+ *
+ * @see Signin for an alternative login implementation
+ * @see Signup for user registration
+ * @see TokenStorage for token management
+ */
 export declare function LoginToBackend(email: string, password: string): Promise<any>;

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

@@ -1 +1,40 @@
+/**
+ * API module for creating named concept entries in the backend.
+ * Registers concept names (referents) with their associated type information in the system.
+ *
+ * @module Api/MakeTheNameInBackend
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Creates a named concept entry in the backend by associating a referent (name) with a concept ID.
+ * This function registers the human-readable name for a concept along with its type classification.
+ *
+ * In the Concept Connection System, concepts are identified by numeric IDs, but they also need
+ * human-readable names (referents). This function establishes that association in the backend.
+ *
+ * @param newConceptId - The unique identifier of the concept being named
+ * @param referent - The human-readable name or label for the concept
+ * @param typeId - The type category ID that classifies this concept
+ * @param typeUserId - The user ID associated with the type
+ * @returns A promise that resolves when the name is successfully registered
+ *
+ * @example
+ * ```typescript
+ * // Create a named concept for "John Doe" as a person type
+ * await MakeTheNameInBackend(
+ *   12345,           // newConceptId
+ *   'John Doe',      // referent
+ *   999,             // typeId for 'person'
+ *   1                // typeUserId
+ * );
+ * ```
+ *
+ * @remarks
+ * - This function does not return a value on success, only throws on error
+ * - HTTP errors are handled through HandleHttpError
+ * - Requires authentication via GetRequestHeader
+ * - Errors are logged and re-thrown for caller handling
+ *
+ * @see MakeTheTypeConceptApi for creating type concepts
+ */
 export declare function MakeTheNameInBackend(newConceptId: number, referent: string, typeId: number, typeUserId: number): Promise<void>;

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

@@ -1,2 +1,42 @@
+/**
+ * API module for creating and retrieving type concepts.
+ * Type concepts define the categories and classifications used in the Concept Connection System.
+ *
+ * @module Api/MakeTheTypeConceptApi
+ * @see https://documentation.freeschema.com for reference
+ */
 import { Concept } from "../DataStructures/Concept";
+/**
+ * Retrieves or creates a type concept based on a string identifier.
+ * Type concepts are special concepts that define categories for other concepts in the system.
+ *
+ * This function first attempts to find an existing type concept locally, then queries the backend
+ * if not found. If the concept doesn't exist in the backend, it creates a new type concept.
+ * The function uses caching to prevent duplicate requests for the same type.
+ *
+ * @param type - The string identifier for the type concept (e.g., "the_person", "the_location")
+ * @param userId - The user ID associated with the request
+ * @returns A promise that resolves to the Concept object representing the type
+ *
+ * @example
+ * ```typescript
+ * // Get or create a "person" type concept
+ * const personType = await MakeTheTypeConceptApi('the_person', 123);
+ * console.log('Person type ID:', personType.id);
+ *
+ * // Use the type concept when creating new concepts
+ * const newPerson = await CreateConcept('John Doe', personType.id);
+ * ```
+ *
+ * @remarks
+ * - Uses local caching to prevent duplicate simultaneous requests
+ * - First searches for existing concept via GetConceptByCharacterAndCategory
+ * - Creates new type concept in backend if not found or if typeId is 4 (unknown type)
+ * - Automatically adds the retrieved concept to ConceptsData for local access
+ * - Cache entries are cleaned up after the fetch completes
+ * - Returns a default concept with id=0 if errors occur
+ *
+ * @see GetConceptByCharacterAndCategory for local concept searching
+ * @see MakeTheNameInBackend for creating named concepts
+ */
 export declare function MakeTheTypeConceptApi(type: string, userId: number): Promise<Concept>;

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

@@ -1 +1,44 @@
+/**
+ * API module for performing recursive searches through concept compositions.
+ * Enables complex queries that traverse concept relationships and compositions.
+ *
+ * @module Api/RecursiveSearch
+ * @see https://documentation.freeschema.com for reference
+ */
+/**
+ * Performs a recursive search through concept compositions using specified filters.
+ * This function searches through the network of concepts, following composition relationships
+ * and filtering by linker types and text content.
+ *
+ * Recursive search is a powerful feature of the Concept Connection System that allows
+ * navigation through complex concept hierarchies. It can find all concepts within a composition,
+ * filtered by specific relationship types (linkers) and text search terms.
+ *
+ * @param composition - The composition ID to search within (0 for global search)
+ * @param listLinkers - Array of linker type strings to filter connections (e.g., ['is_a', 'has_property'])
+ * @param textSearch - Text string to search for within concept names/properties
+ * @returns A promise that resolves to an array of concepts matching the search criteria
+ *
+ * @example
+ * ```typescript
+ * // Search for all concepts within composition 100 that have 'is_a' relationships
+ * const results = await RecursiveSearchApi(100, ['is_a']);
+ *
+ * // Search for concepts containing "person" in composition 200
+ * const personResults = await RecursiveSearchApi(200, [], 'person');
+ *
+ * // Combined search with linkers and text
+ * const filtered = await RecursiveSearchApi(300, ['has_property', 'located_at'], 'building');
+ * ```
+ *
+ * @remarks
+ * - Returns an empty array if the search fails or no results are found
+ * - The function retrieves both internal and external connections
+ * - Results are processed through GetCompositionFromConnectionsWithDataId to build full concept objects
+ * - HTTP errors are handled through HandleHttpError
+ * - Errors are logged and re-thrown for caller handling
+ *
+ * @see SearchQuery for the query data structure
+ * @see GetCompositionFromConnectionsWithDataId for result processing
+ */
 export declare function RecursiveSearchApi(composition?: number, listLinkers?: string[], textSearch?: string): Promise<any[]>;

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

@@ -1,2 +1,48 @@
+/**
+ * Freeschema Query API module for executing flexible schema-based queries.
+ * This module provides functionality to query concepts using the Freeschema query language,
+ * which allows for dynamic and flexible data retrieval from the Concept Connection System.
+ *
+ * @module Api/Search/FreeschemaQueryApi
+ * @see https://documentation.freeschema.com for Freeschema query syntax and examples
+ */
 import { FreeschemaQuery } from "../../DataStructures/Search/FreeschemaQuery";
+/**
+ * Executes a Freeschema query to retrieve concepts from the CCS backend.
+ * This function sends a POST request with a FreeschemaQuery object to perform
+ * flexible, schema-independent queries on the concept database. The Freeschema
+ * query language enables complex filtering, nested searches, and dynamic property
+ * access across different concept types.
+ *
+ * @param query - The FreeschemaQuery object containing query parameters, filters, and search criteria
+ * @param token - Optional authentication token for authorized access (defaults to empty string for public queries)
+ * @returns Promise resolving to an array of matching concepts, or empty array on error
+ *
+ * @example
+ * ```typescript
+ * // Search for concepts with specific properties
+ * const query: FreeschemaQuery = {
+ *   type: "Person",
+ *   filters: { age: { $gt: 18 } },
+ *   limit: 10
+ * };
+ * const results = await FreeschemaQueryApi(query, "auth-token-123");
+ * console.log(`Found ${results.length} matching concepts`);
+ * ```
+ *
+ * @remarks
+ * This function handles both HTTP errors and internal exceptions gracefully:
+ * - HTTP errors are logged and handled via HandleHttpError
+ * - Internal errors are caught and reported via HandleInternalError
+ * - Returns empty array on any failure to prevent null reference errors
+ *
+ * The Freeschema query system is particularly useful for:
+ * - Cross-composition searches
+ * - Dynamic property filtering
+ * - Complex relationship traversal
+ * - Type-independent queries
+ *
+ * @see SearchAllConcepts for simpler search operations
+ * @see SearchWithLinker for linked concept searches
+ */
 export declare function FreeschemaQueryApi(query: FreeschemaQuery, token?: string): Promise<any>;

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

@@ -1 +1,68 @@
+/**
+ * Search API module for querying concepts across compositions.
+ * This module provides the primary search functionality for the Concept Connection System,
+ * enabling users to search for concepts by type, name, and composition with pagination support.
+ *
+ * @module Api/Search/Search
+ * @see https://documentation.freeschema.com for search query patterns and best practices
+ */
+/**
+ * Searches for concepts across specified compositions with pagination.
+ * This is the primary search function for retrieving concepts based on type,
+ * search text, and composition. It performs a GET request with URL-encoded
+ * parameters to find matching concepts in the CCS database.
+ *
+ * @param type - The concept type to search for (e.g., "Person", "Organization", "Document")
+ * @param search - The search text to match against concept names or properties
+ * @param composition - The composition ID or name to search within
+ * @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
+ *
+ * @example
+ * ```typescript
+ * // Search for Person concepts in a specific composition
+ * const results = await SearchAllConcepts(
+ *   "Person",
+ *   "John",
+ *   "my-composition-123",
+ *   "auth-token-456",
+ *   20,  // 20 results per page
+ *   1    // first page
+ * );
+ * console.log(`Found ${results.length} matching persons`);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Search with default pagination
+ * const results = await SearchAllConcepts(
+ *   "Document",
+ *   "report",
+ *   "documents-composition",
+ *   authToken
+ * );
+ * // Returns first 10 results by default
+ * ```
+ *
+ * @remarks
+ * This function uses URL-encoded parameters for the GET request, which is ideal for
+ * simple search operations. For more complex queries, consider using FreeschemaQueryApi.
+ *
+ * Error handling:
+ * - HTTP errors are handled via HandleHttpError and logged
+ * - Network errors are caught, logged, and re-thrown
+ * - Returns empty array on HTTP errors, throws exception on network errors
+ *
+ * Pagination:
+ * - Results are paginated server-side
+ * - Use 'inpage' to control page size
+ * - Use 'page' to navigate through results
+ * - Page numbers start at 1, not 0
+ *
+ * @see FreeschemaQueryApi for complex queries
+ * @see SearchInternalApi for searching within internal compositions
+ * @see SearchWithLinker for linked concept searches
+ */
 export declare function SearchAllConcepts(type: string, search: string, composition: string, token: string, inpage?: number, page?: number): Promise<any>;