mftsccs-browser 2.2.20-beta → 2.2.22-beta

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

@@ -1,3 +1,24 @@
 import { Returner } from "../../DataStructures/Returner";
 import { TheCharacter } from "../../DataStructures/TheCharacter";
+/**
+ * Creates a character on the backend server with local caching.
+ *
+ * **Logic**:
+ * 1. Checks CharacterRepository for existing character by data value
+ * 2. If exists locally: Returns existing character ID
+ * 3. If not exists: Creates on server and adds to local repository
+ *
+ * Character data represents string values used across the system with deduplication.
+ *
+ * @param characterData - TheCharacter object to create
+ * @returns Returner object with character ID and metadata
+ * @throws Error if HTTP request fails
+ *
+ * @example
+ * const char = await CreateTheCharacter({
+ *   data: "user@example.com",
+ *   userId: 42
+ * });
+ * // If "user@example.com" already exists, returns existing ID
+ */
 export declare function CreateTheCharacter(characterData: TheCharacter): Promise<Returner>;

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

@@ -1,2 +1,20 @@
 import { Concept } from "../../DataStructures/Concept";
+/**
+ * Creates a concept on the backend server via API.
+ *
+ * Sends concept data to the backend server for creation. Returns the created
+ * concept with server-assigned positive ID.
+ *
+ * @param conceptData - Concept data to create (can be partial concept object)
+ * @returns Created Concept object with server-assigned ID
+ * @throws Error if HTTP request fails or server returns error status
+ *
+ * @example
+ * const newConcept = await CreateTheConceptApi({
+ *   characterValue: "Alice",
+ *   typeId: 100,
+ *   userId: 42
+ * });
+ * console.log(newConcept.id); // Positive ID from server (e.g., 12345)
+ */
 export declare function CreateTheConceptApi(conceptData: any): Promise<Concept | undefined>;

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

@@ -1,2 +1,18 @@
 import { Connection } from "../../DataStructures/Connection";
+/**
+ * Creates connections on the backend server via API.
+ *
+ * Sends an array of connection objects to the backend for bulk creation.
+ * Used for creating multiple connections in a single API call.
+ *
+ * @param connectionData - Array of Connection objects to create
+ * @returns Connection object (note: current implementation returns default connection)
+ * @throws Error if HTTP request fails
+ *
+ * @example
+ * const connections = await CreateTheConnectionApi([
+ *   { ofTheConceptId: 100, toTheConceptId: 200, typeId: 42, ... },
+ *   { ofTheConceptId: 100, toTheConceptId: 300, typeId: 42, ... }
+ * ]);
+ */
 export declare function CreateTheConnectionApi(connectionData: Connection[]): Promise<Connection>;

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

@@ -1,3 +1,28 @@
 import { Concept } from "../../DataStructures/Concept";
 import { Connection } from "../../app";
+/**
+ * Syncs local concepts and connections to the backend server in bulk (batch sync).
+ *
+ * **Complex Logic**:
+ * 1. Strips type objects from data to reduce payload size
+ * 2. If total items ≤2000: Sends in single request
+ * 3. If total items >2000: Chunks into 1000-item batches and sends in parallel
+ * 4. Returns arrays of created concepts and connections with real server IDs
+ *
+ * "Ghost" refers to preserving original local IDs (negative) as ghostId while assigning real positive IDs.
+ *
+ * @param conceptData - Array of Concept objects to sync (can include local negative IDs)
+ * @param connectionData - Array of Connection objects to sync
+ * @param withAuth - Whether to use authentication (default: true)
+ * @returns Object with {concepts: Concept[], connections: Connection[]} containing synced items
+ * @throws Error if any batch request fails
+ *
+ * @example
+ * const result = await CreateTheGhostConceptApi(
+ *   [concept1, concept2],
+ *   [connection1, connection2]
+ * );
+ * // result.concepts contains concepts with real server IDs
+ * // result.connections contains connections with real server IDs
+ */
 export declare function CreateTheGhostConceptApi(conceptData: Concept[], connectionData: Connection[], withAuth?: boolean): Promise<any>;

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

@@ -1,2 +1,18 @@
 import { Connection } from "../../app";
+/**
+ * Syncs local connections to the backend server preserving ghost IDs.
+ *
+ * Creates connections on server while maintaining ghostId for local ID tracking.
+ * Used for syncing locally-created connections (negative IDs) to the backend.
+ *
+ * @param connectionData - Array of Connection objects to sync
+ * @returns Array of created Connection objects with server-assigned positive IDs
+ * @throws Error if HTTP request fails
+ *
+ * @example
+ * const synced = await CreateTheGhostConnectionApi([
+ *   { id: -123, ofTheConceptId: -100, toTheConceptId: -200, ... }
+ * ]);
+ * // Returns: [{ id: 5001, ghostId: -123, ofTheConceptId: 1001, toTheConceptId: 2001, ... }]
+ */
 export declare function CreateTheGhostConnectionApi(connectionData: Connection[]): Promise<Connection[] | undefined>;

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

@@ -1,2 +1,18 @@
 import { TheTexts } from "../../DataStructures/TheTexts";
+/**
+ * Creates text data on the backend server via API.
+ *
+ * Stores long-form text content (>255 characters) separately from concepts.
+ * Used for text values that exceed the characterValue field length limit.
+ *
+ * @param textData - TheTexts object containing text data to store
+ * @returns Created TheTexts object with server-assigned ID
+ * @throws Error if HTTP request fails or server returns error status
+ *
+ * @example
+ * const longText = await CreateTextData({
+ *   data: "Very long text content that exceeds 255 characters...",
+ *   userId: 42
+ * });
+ */
 export declare function CreateTextData(textData: TheTexts): Promise<TheTexts>;

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

@@ -1 +1,14 @@
+/**
+ * Deletes (trashes) a concept from the backend with explicit token auth.
+ *
+ * Alternative delete function that requires manual token passing.
+ * Similar to DeleteTheConcept but with explicit authentication parameter.
+ *
+ * @param id - The concept ID to delete
+ * @param token - Bearer authentication token
+ * @throws Error if deletion fails
+ *
+ * @example
+ * await TrashTheConcept(12345, userToken);
+ */
 export declare function TrashTheConcept(id: number, token: string): Promise<void>;

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

@@ -1 +1,19 @@
+/**
+ * Deletes a user account from the backend server.
+ *
+ * **Process**:
+ * 1. Sends delete request with user concept ID and API key
+ * 2. Backend deletes user and returns email concept ID
+ * 3. Deletes the associated email concept locally
+ *
+ * Used for complete user account removal including associated data.
+ *
+ * @param id - The user concept ID to delete
+ * @returns Email concept ID that was deleted, or undefined if error
+ * @throws Error if deletion fails
+ *
+ * @example
+ * const emailConceptId = await DeleteUserInBackend(userId);
+ * console.log("Deleted user and email concept:", emailConceptId);
+ */
 export declare function DeleteUserInBackend(id: number): Promise<number | undefined>;

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

@@ -0,0 +1 @@
+export default function DeleteTheConnectionBulkApi(ids: number[]): Promise<boolean>;

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

@@ -1 +1,20 @@
+/**
+ * Deletes multiple connections from the backend in a single bulk operation.
+ *
+ * **Process**:
+ * 1. Sends array of connection IDs to backend for bulk deletion
+ * 2. If successful: Marks all connections as deleted in local ConnectionData
+ * 3. Returns overall deletion success status
+ *
+ * More efficient than calling DeleteTheConnection multiple times.
+ *
+ * @param ids - Array of connection IDs to delete
+ * @returns boolean - true if bulk deletion successful, false otherwise
+ *
+ * @example
+ * const deleted = await DeleteTheConnectionBulkApi([5001, 5002, 5003]);
+ * if (deleted) {
+ *   console.log("All 3 connections deleted successfully");
+ * }
+ */
 export default function DeleteTheConnectionBulkApi(ids: number[]): Promise<boolean>;

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

@@ -1 +1,20 @@
+/**
+ * Deletes a concept from the backend server by ID.
+ *
+ * **Process**:
+ * 1. Sends delete request to backend with concept ID
+ * 2. If successful: Marks concept as deleted in local ConceptsData (NPC list)
+ * 3. Returns deletion success status
+ *
+ * NPC (Non-Present Concept) list tracks deleted concept IDs to prevent reuse.
+ *
+ * @param id - The concept ID to delete
+ * @returns boolean - true if successfully deleted, false otherwise
+ *
+ * @example
+ * const deleted = await DeleteTheConcept(12345);
+ * if (deleted) {
+ *   console.log("Concept deleted successfully");
+ * }
+ */
 export default function DeleteTheConcept(id: number): Promise<boolean>;

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

@@ -1 +1,20 @@
+/**
+ * Deletes a connection from the backend server by ID.
+ *
+ * **Process**:
+ * 1. Sends delete request to backend with connection ID
+ * 2. If successful: Marks connection as deleted in local ConnectionData (NpConn list)
+ * 3. Returns deletion success status
+ *
+ * NpConn (Non-Present Connection) list tracks deleted connection IDs.
+ *
+ * @param id - The connection ID to delete
+ * @returns boolean - true if successfully deleted, false otherwise
+ *
+ * @example
+ * const deleted = await DeleteTheConnection(5001);
+ * if (deleted) {
+ *   console.log("Connection deleted successfully");
+ * }
+ */
 export default function DeleteTheConnection(id: number): Promise<boolean>;

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

@@ -1 +1,10 @@
+/**
+ * Fetches all AI-related concept data from the backend.
+ * Loads AI concepts into local ConceptsData cache and triggers database update.
+ *
+ * @returns void - Updates ConceptsData in-place with AI concepts
+ *
+ * @example
+ * await GetAiData(); // Loads all AI concepts into cache
+ */
 export declare function GetAiData(): Promise<void>;

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

@@ -1 +1,11 @@
+/**
+ * Retrieves all concepts belonging to a specific user.
+ * Fetches user's concepts from backend and caches them in ConceptsData.
+ *
+ * @param userId - ID of the user whose concepts to retrieve
+ * @returns void - Updates ConceptsData cache with user's concepts
+ *
+ * @example
+ * await GetAllUserConcepts(123); // Loads all concepts for user 123
+ */
 export declare function GetAllUserConcepts(userId: number): Promise<void>;

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

@@ -1 +1,12 @@
+/**
+ * Retrieves all concepts of a specific type for a user.
+ * Fetches concepts filtered by type string and user ID.
+ *
+ * @param type - Type string to filter concepts by
+ * @param userId - User ID to filter by
+ * @returns void - Updates ConceptsData cache with matching concepts
+ *
+ * @example
+ * await GetAllConceptsByType("person", 123);
+ */
 export declare function GetAllConceptsByType(type: string, userId: number): Promise<void>;

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

@@ -1 +1,11 @@
+/**
+ * Retrieves all connections belonging to a specific user.
+ * Fetches user's connections from backend and caches them in ConnectionData.
+ *
+ * @param userId - ID of the user whose connections to retrieve
+ * @returns void - Updates ConnectionData cache with user's connections
+ *
+ * @example
+ * await GetAllUserConnections(123); // Loads all connections for user 123
+ */
 export declare function GetAllUserConnections(userId: number): Promise<void>;

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

@@ -1,3 +1,23 @@
 import { Connection } from '../DataStructures/Connection';
+/**
+ * Retrieves all connections belonging to a specific composition.
+ * Checks local cache first, then fetches from backend if needed.
+ *
+ * **Complex Logic**: First checks ConnectionData cache, then fetches from API,
+ * compares with cached data to detect deletions, and updates cache.
+ *
+ * @param composition_id - ID of the composition whose connections to retrieve
+ * @returns Array of Connection objects for the composition
+ *
+ * @example
+ * const connections = await GetAllConnectionsOfComposition(456);
+ */
 export declare function GetAllConnectionsOfComposition(composition_id: number): Promise<Connection[]>;
+/**
+ * Fetches connections for a composition directly from the backend.
+ * Internal helper function for GetAllConnectionsOfComposition.
+ *
+ * @param composition_id - ID of the composition
+ * @returns Array of Connection objects from backend
+ */
 export declare function GetAllConnectionsOfCompositionOnline(composition_id: number): Promise<Connection[] | undefined>;

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

@@ -1,3 +1,23 @@
 import { Connection } from '../DataStructures/Connection';
+/**
+ * Retrieves connections for multiple compositions in bulk.
+ * Optimizes fetching by batching multiple composition IDs in one request.
+ *
+ * **Complex Logic**: Checks in-memory cache, fetches from API, detects deletions
+ * by comparing old and new data, and bulk-fetches related concepts.
+ *
+ * @param composition_ids - Array of composition IDs to fetch connections for
+ * @returns Array of Connection objects for all compositions
+ *
+ * @example
+ * const connections = await GetAllConnectionsOfCompositionBulk([123, 456, 789]);
+ */
 export declare function GetAllConnectionsOfCompositionBulk(composition_ids?: number[]): Promise<any>;
+/**
+ * Fetches connections for multiple compositions directly from backend.
+ * Internal helper function for GetAllConnectionsOfCompositionBulk.
+ *
+ * @param composition_ids - Array of composition IDs
+ * @returns Array of Connection objects from backend
+ */
 export declare function GetAllConnectionsOfCompositionOnline(composition_ids?: number[]): Promise<Connection[] | undefined>;

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

@@ -1,2 +1,12 @@
 import { Connection } from "../DataStructures/Connection";
+/**
+ * Retrieves all linker connections originating from a specific concept.
+ * Fetches connections where the concept is the source/origin.
+ *
+ * @param conceptId - ID of the concept to get linker connections from
+ * @returns Array of Connection objects originating from the concept
+ *
+ * @example
+ * const connections = await GetAllLinkerConnectionsFromTheConcept(123);
+ */
 export declare function GetAllLinkerConnectionsFromTheConcept(conceptId: number): Promise<Connection[]>;

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

@@ -1,2 +1,12 @@
 import { Connection } from "../DataStructures/Connection";
+/**
+ * Retrieves all linker connections pointing to a specific concept.
+ * Fetches connections where the concept is the target/destination.
+ *
+ * @param conceptId - ID of the concept to get linker connections to
+ * @returns Array of Connection objects pointing to the concept
+ *
+ * @example
+ * const connections = await GetAllLinkerConnectionsToTheConcept(123);
+ */
 export declare function GetAllLinkerConnectionsToTheConcept(conceptId: number): Promise<Connection[]>;

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

@@ -1 +1,12 @@
+/**
+ * Prefetches connections for a user with pagination.
+ * Loads connections into local storage for improved performance.
+ *
+ * @param userId - ID of the user whose connections to prefetch
+ * @param inpage - Number of connections per page
+ * @returns void - Updates ConnectionData storage with prefetched connections
+ *
+ * @example
+ * await GetAllPrefetchConnections(123, 50); // Prefetch 50 connections for user 123
+ */
 export declare function GetAllPrefetchConnections(userId: number, inpage: number): Promise<void>;

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

@@ -1,2 +1,12 @@
 import { TheCharacter } from "../DataStructures/TheCharacter";
+/**
+ * Retrieves character data by character value string.
+ * Fetches TheCharacter object containing character metadata.
+ *
+ * @param characterValue - String value of the character to retrieve
+ * @returns TheCharacter object or undefined on error
+ *
+ * @example
+ * const char = await GetCharacterByCharacter("the_person");
+ */
 export declare function GetCharacterByCharacter(characterValue: string): Promise<TheCharacter | undefined>;

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

@@ -1 +1,13 @@
+/**
+ * Retrieves composition connections between two concepts.
+ * Fetches connections linking two concepts filtered by a main key.
+ *
+ * @param ofConceptId - Source concept ID
+ * @param toConcept - Target concept ID
+ * @param mainKey - Main key to filter connections
+ * @returns Array of Connection objects between the two concepts
+ *
+ * @example
+ * const connections = await GetCompositionConnectionsBetweenTwoConcepts(123, 456, 789);
+ */
 export declare function GetCompositionConnectionsBetweenTwoConcepts(ofConceptId: number, toConcept: number, mainKey: number): Promise<any>;

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

@@ -7,4 +7,14 @@ import { Concept } from "./../DataStructures/Concept";
  * @returns list of concepts
  */
 export declare function GetConceptBulk(passedConcepts: number[]): Promise<Concept[]>;
+/**
+ * Alternative API for fetching multiple concepts by IDs.
+ * Simpler version without caching logic, directly fetches from backend.
+ *
+ * @param bulkConceptFetch - Array of concept IDs to fetch
+ * @returns Array of Concept objects
+ *
+ * @example
+ * const concepts = await BulkConceptGetterApi([1, 2, 3, 4, 5]);
+ */
 export declare function BulkConceptGetterApi(bulkConceptFetch: number[]): Promise<Concept[]>;

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

@@ -1 +1,15 @@
+/**
+ * Retrieves a concept by character value and type ID.
+ * Checks local cache first, then fetches from backend if not found.
+ *
+ * **Complex Logic**: Checks local ConceptsData cache, falls back to API,
+ * supports service worker for offline capability.
+ *
+ * @param characterValue - Character value string to search for
+ * @param typeId - Type ID to filter by
+ * @returns Concept object or null if not found
+ *
+ * @example
+ * const concept = await GetConceptByCharacterAndType("the_person", 5);
+ */
 export declare function GetConceptByCharacterAndType(characterValue: string, typeId: number): Promise<any>;

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

@@ -1,2 +1,12 @@
 import { Concept } from "../DataStructures/Concept";
+/**
+ * Retrieves a concept by its character value.
+ * Fetches concept matching the character string and adds type information.
+ *
+ * @param characterValue - Character value string to search for
+ * @returns Concept object or default concept if not found
+ *
+ * @example
+ * const concept = await GetConceptByCharacterValue("the_person");
+ */
 export declare function GetConceptByCharacterValue(characterValue: string): Promise<Concept>;

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

@@ -1,2 +1,15 @@
 import { Connection } from "../DataStructures/Connection";
+/**
+ * Retrieves a connection by its ID.
+ * Checks local cache first, then fetches from backend if needed.
+ *
+ * **Complex Logic**: Checks ConnectionData cache, falls back to API request,
+ * supports cache server fallback for resilience.
+ *
+ * @param id - Connection ID to retrieve
+ * @returns Connection object or default connection if not found
+ *
+ * @example
+ * const connection = await GetConnection(789);
+ */
 export declare function GetConnection(id: number): Promise<Connection | undefined>;

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

@@ -1 +1,15 @@
+/**
+ * Retrieves connections originating from a specific concept.
+ * Fetches connections filtered by type, concept, user, and pagination.
+ *
+ * @param typeId - Type ID to filter connections by
+ * @param ofTheConceptId - Concept ID that is the source of connections
+ * @param userId - User ID to filter by
+ * @param inpage - Number of results per page (default: 10)
+ * @param page - Page number (default: 1)
+ * @returns Array of Connection objects
+ *
+ * @example
+ * const connections = await GetConnectionOfTheConcept(5, 123, 456, 20, 1);
+ */
 export declare function GetConnectionOfTheConcept(typeId: number, ofTheConceptId: number, userId: number, inpage?: number, page?: number): Promise<any>;

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

@@ -1,2 +1,17 @@
 import { Connection } from "../DataStructures/Connection";
+/**
+ * Retrieves connections pointing to a specific concept.
+ * Fetches connections filtered by type, target concept, user, and pagination.
+ *
+ * @param typeId - Type ID to filter connections by
+ * @param toTheConceptId - Concept ID that is the target of connections
+ * @param userId - User ID to filter by
+ * @param inpage - Number of results per page (default: 10)
+ * @param page - Page number (default: 1)
+ * @returns Array of Connection objects
+ * @throws Error if fetch fails
+ *
+ * @example
+ * const connections = await GetConnectionToTheConcept(5, 123, 456, 20, 1);
+ */
 export declare function GetConnectionToTheConcept(typeId: number, toTheConceptId: number, userId: number, inpage?: number, page?: number): Promise<Connection[]>;

package/dist/types/Api/GetConnections/GetConnectionsByTypeApi.d.ts

@@ -1,3 +1,15 @@
 import { Connection } from "../../app";
 import { GetConnectionsByTypes } from "../../DataStructures/ConnectionByType/GetConnectionByType";
+/**
+ * Retrieves connections filtered by multiple connection type criteria.
+ * Fetches connections matching the specified type filters.
+ *
+ * @param connectionTypes - GetConnectionsByTypes object containing type filter criteria
+ * @returns Array of Connection objects matching the type filters
+ *
+ * @example
+ * const types = new GetConnectionsByTypes();
+ * types.typeIds = [1, 2, 3];
+ * const connections = await GetConnectionsByApiTypes(types);
+ */
 export declare function GetConnectionsByApiTypes(connectionTypes: GetConnectionsByTypes): Promise<Connection[]>;

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

@@ -1 +1,10 @@
+/**
+ * Fetches reserved connection IDs from the backend.
+ * Loads system-reserved connection IDs into ReservedConnectionIds cache.
+ *
+ * @returns void - Updates ReservedConnectionIds cache with reserved IDs
+ *
+ * @example
+ * await GetReservedConnectionIds(); // Loads reserved connection IDs
+ */
 export declare function GetReservedConnectionIds(): Promise<void>;

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

@@ -1 +1,10 @@
+/**
+ * Fetches reserved concept IDs from the backend.
+ * Loads system-reserved concept IDs into ReservedIds cache.
+ *
+ * @returns void - Updates ReservedIds cache with reserved concept IDs
+ *
+ * @example
+ * await GetReservedIds(); // Loads reserved concept IDs
+ */
 export declare function GetReservedIds(): Promise<void>;

package/dist/types/Api/Images/GetImages.d.ts

@@ -1 +1,15 @@
+/**
+ * Retrieves an image by name from the cached images endpoint.
+ * Returns a readable stream for the image data.
+ *
+ * @param imageName - Name/identifier of the image to retrieve
+ * @returns Promise resolving to ReadableStream of image data, or null/undefined on error
+ * @throws Image stream on error (legacy behavior)
+ *
+ * @example
+ * const imageStream = await GetImageApi("profile-pic-123.jpg");
+ * if (imageStream) {
+ *   // Process image stream
+ * }
+ */
 export declare function GetImageApi(imageName: string): Promise<ReadableStream<Uint8Array> | null | undefined>;

package/dist/types/Api/Local/GetLocalConceptByCharacterValue.d.ts

@@ -1,2 +1,13 @@
 import { Concept } from "../../DataStructures/Concept";
+/**
+ * Retrieves a local concept by its character value.
+ * Fetches from backend and caches in LocalConceptsData.
+ *
+ * @param characterValue - Character value string to search for
+ * @returns Local Concept object or default local concept if not found
+ * @throws Default concept on error (legacy behavior)
+ *
+ * @example
+ * const localConcept = await GetLocalConceptByCharacterValue("the_local_person");
+ */
 export declare function GetLocalConceptByCharacterValue(characterValue: string): Promise<Concept>;