mftsccs-node 0.2.7 → 0.2.8

package/dist/types/Services/Local/CreateTheCompositionLocal.d.ts

@@ -1,2 +1,72 @@
+/**
+ * Local Composition Creation Module
+ *
+ * This module provides functionality to recursively create complex, nested concept compositions
+ * from JSON objects in the local storage layer. It transforms JSON structures into interconnected
+ * concepts and connections, preserving the hierarchical relationships.
+ *
+ * @module CreateTheCompositionLocal
+ */
 import { LConcept } from "../../DataStructures/Local/LConcept";
+/**
+ * Recursively creates a composition of concepts and connections from a JSON object.
+ *
+ * This function traverses a JSON object tree and converts each key-value pair into concepts
+ * with appropriate connections. It handles nested objects by recursively processing them,
+ * creating a graph structure that mirrors the original JSON hierarchy.
+ *
+ * The function distinguishes between:
+ * - Primitive values (string/number): Creates leaf concepts with the value as characterValue
+ * - Complex values (object/array): Creates composition concepts and recursively processes children
+ *
+ * @param json - The JSON object to convert into a concept composition
+ * @param ofTheConceptId - The ID of the parent concept (null for root level)
+ * @param ofTheConceptUserId - The user ID of the parent concept (null for root level)
+ * @param mainKey - The ID of the main/root composition concept (null for root level)
+ * @param userId - The user creating the composition (defaults to 999)
+ * @param accessId - Access control ID for created concepts (defaults to 999)
+ * @param sessionInformationId - Session ID for tracking (defaults to 4)
+ *
+ * @returns A promise that resolves to the main/root LConcept of the created composition
+ *
+ * @remarks
+ * - First invocation (when ofTheConceptId is null) creates the root concept
+ * - Subsequent recursive calls create child concepts connected to their parents
+ * - Uses `MakeTheInstanceConceptLocal` to create individual concepts
+ * - Uses `CreateTheConnectionLocal` to establish parent-child relationships
+ * - Maintains the structure through the mainKey parameter across recursive calls
+ * - Handles both object properties and array elements
+ *
+ * @example
+ * ```typescript
+ * // Create a composition from a nested JSON structure
+ * const userData = {
+ *   name: "John Doe",
+ *   age: 30,
+ *   address: {
+ *     street: "123 Main St",
+ *     city: "Boston"
+ *   }
+ * };
+ *
+ * const mainConcept = await CreateTheCompositionLocal(
+ *   userData,
+ *   null,  // ofTheConceptId
+ *   null,  // ofTheConceptUserId
+ *   null,  // mainKey
+ *   123,   // userId
+ *   4,     // accessId
+ *   999    // sessionInformationId
+ * );
+ *
+ * // Result: Creates concepts for "name", "age", "address", "street", "city"
+ * // with appropriate connections forming a tree structure
+ * console.log(mainConcept.id); // Root concept ID
+ * ```
+ *
+ * @see {@link MakeTheInstanceConceptLocal} - Creates individual concepts
+ * @see {@link CreateTheConnectionLocal} - Creates connections between concepts
+ * @see {@link CreateDefaultLConcept} - Creates default empty concept
+ * @see {@link GetCompositionLocal} - Related function for retrieving compositions
+ */
 export declare function CreateTheCompositionLocal(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null): Promise<LConcept>;

package/dist/types/Services/Local/CreateTheConceptLocal.d.ts

@@ -1,2 +1,60 @@
+/**
+ * Local Concept Creation Module
+ *
+ * This module provides functionality to create concepts in the local storage layer of the
+ * Concept Connection System (CCS). It handles the instantiation of local concepts with
+ * temporary IDs before they are synchronized with the backend.
+ *
+ * @module CreateTheConceptLocal
+ */
 import { LConcept } from "../../DataStructures/Local/LConcept";
+/**
+ * Creates a new concept in the local storage layer.
+ *
+ * This function generates a new local concept with a temporary random ID and stores it
+ * in both the in-memory data structure and the local IndexedDB database. The concept
+ * is marked as temporary and new, indicating it needs to be synchronized with the
+ * backend server when online.
+ *
+ * The function is essential for offline-first functionality, allowing users to create
+ * concepts even when disconnected from the backend server.
+ *
+ * @param referent - The character value or name of the concept being created
+ * @param typecharacter - The character representation of the concept's type
+ * @param userId - The ID of the user creating the concept
+ * @param categoryId - The category this concept belongs to
+ * @param typeId - The ID of the type concept that defines this concept's type
+ * @param accessId - Access control ID determining permissions for this concept
+ * @param referentId - Optional ID linking to a referent concept (defaults to 0)
+ *
+ * @returns A promise that resolves to the newly created LConcept instance
+ *
+ * @remarks
+ * - Generates a random temporary ID between 0 and 100,000,000
+ * - Sets `isTemp` flag to true to indicate this is a local-only concept
+ * - Sets `isNew` flag to true to mark it for synchronization
+ * - Stores the concept in both memory (LocalConceptsData) and IndexedDB
+ * - The temporary ID will be replaced with a backend-generated ID upon sync
+ *
+ * @example
+ * ```typescript
+ * // Create a concept with type "the_name" for user 123
+ * const concept = await CreateTheConceptLocal(
+ *   "John Doe",      // referent
+ *   "the_name",      // typecharacter
+ *   123,             // userId
+ *   4,               // categoryId
+ *   51,              // typeId
+ *   4,               // accessId
+ *   0                // referentId
+ * );
+ *
+ * console.log(concept.id); // Random ID like 45892371
+ * console.log(concept.isTemp); // true
+ * ```
+ *
+ * @see {@link LConcept} - The local concept data structure
+ * @see {@link LocalConceptsData.AddConcept} - Adds concept to in-memory storage
+ * @see {@link storeToDatabase} - Persists concept to IndexedDB
+ */
 export default function CreateTheConceptLocal(referent: string, typecharacter: string, userId: number, categoryId: number, typeId: number, accessId: number, referentId?: number): Promise<LConcept>;

package/dist/types/Services/Local/CreateTheConnectionLocal.d.ts

@@ -1,2 +1,58 @@
+/**
+ * Local Connection Creation Module
+ *
+ * This module provides functionality to create connections between concepts in the local
+ * storage layer. Connections represent relationships between concepts, forming the graph
+ * structure of the Concept Connection System.
+ *
+ * @module CreateTheConnectionLocal
+ */
 import { LConnection } from "../../DataStructures/Local/LConnection";
+/**
+ * Creates a connection between two concepts in the local storage layer.
+ *
+ * This function establishes a directed relationship from one concept to another,
+ * storing it in both memory and IndexedDB. The connection is marked as temporary
+ * until synchronized with the backend server.
+ *
+ * The function includes validation to prevent self-referential connections
+ * (a concept connecting to itself), returning an empty connection object in such cases.
+ *
+ * @param ofTheConceptId - The ID of the source concept (from which the connection originates)
+ * @param toTheConceptId - The ID of the target concept (to which the connection points)
+ * @param typeId - The ID of the type concept defining the relationship type
+ * @param orderId - The order/sequence number for this connection (defaults to 1)
+ *
+ * @returns The newly created LConnection instance, or an empty connection if validation fails
+ *
+ * @remarks
+ * - Automatically assigns accessId of 4 (default access level)
+ * - Generates a random temporary ID between 0 and 100,000,000
+ * - Sets `isTemp` flag to true for synchronization tracking
+ * - Prevents self-referential connections (where ofTheConceptId === toTheConceptId)
+ * - Stores the connection in both memory (LocalConnectionData) and IndexedDB
+ *
+ * @example
+ * ```typescript
+ * // Create a connection from concept 100 to concept 200 with type 51
+ * const connection = CreateTheConnectionLocal(
+ *   100,   // ofTheConceptId (source)
+ *   200,   // toTheConceptId (target)
+ *   51,    // typeId (relationship type)
+ *   1      // orderId (optional, defaults to 1)
+ * );
+ *
+ * console.log(connection.id); // Random ID like 78234561
+ * console.log(connection.isTemp); // true
+ *
+ * // This will return an empty connection (0,0,0,0,0,0)
+ * const selfConnection = CreateTheConnectionLocal(100, 100, 51);
+ * console.log(selfConnection.id); // 0
+ * ```
+ *
+ * @see {@link LConnection} - The local connection data structure
+ * @see {@link LocalConnectionData.AddConnection} - Adds connection to in-memory storage
+ * @see {@link storeToDatabase} - Persists connection to IndexedDB
+ * @see {@link CreateTheConceptLocal} - Related function for creating concepts
+ */
 export declare function CreateTheConnectionLocal(ofTheConceptId: number, toTheConceptId: number, typeId: number, orderId?: number): LConnection;

package/dist/types/Services/Local/GetCompositionListLocal.d.ts

@@ -1,2 +1,105 @@
+/**
+ * Local Composition List Retrieval Module
+ *
+ * This module provides functionality to retrieve multiple compositions of the same type
+ * from local storage. It enables batch retrieval of all compositions that match a specific
+ * type and belong to a particular user.
+ *
+ * @module GetCompositionListLocal
+ */
+/**
+ * Retrieves all compositions of a specific type for a given user.
+ *
+ * This function finds all concept instances of a specified type (by name) that belong
+ * to a particular user, then fetches and reconstructs each composition as JSON.
+ * The result is an array of composition objects.
+ *
+ * @param compositionName - The character/name of the composition type to retrieve (e.g., "the_user")
+ * @param userId - The ID of the user whose compositions to retrieve
+ *
+ * @returns A promise that resolves to an array of composition JSON objects
+ *
+ * @remarks
+ * - First looks up the type concept by its character value
+ * - Then queries all concepts of that type belonging to the user
+ * - Fetches complete composition data for each matching concept
+ * - Returns an empty array if the type concept doesn't exist
+ * - Each element in the returned array is a complete composition object
+ *
+ * @example
+ * ```typescript
+ * // Retrieve all user compositions for user 123
+ * const users = await GetCompositionListLocal("the_user", 123);
+ *
+ * // Output might look like:
+ * // [
+ * //   { "the_user": { name: "John", age: 30 } },
+ * //   { "the_user": { name: "Jane", age: 25 } },
+ * //   { "the_user": { name: "Bob", age: 35 } }
+ * // ]
+ *
+ * console.log(`Found ${users.length} users`);
+ * users.forEach(user => {
+ *   console.log(user.the_user.name);
+ * });
+ *
+ * // Retrieve all product compositions
+ * const products = await GetCompositionListLocal("the_product", 123);
+ * ```
+ *
+ * @see {@link GetCompositionListLocalWithId} - Similar function that includes concept IDs
+ * @see {@link GetCompositionLocal} - Retrieves a single composition
+ * @see {@link GetConceptByCharacterLocal} - Looks up type concept by name
+ * @see {@link LocalConceptsData.GetConceptsByTypeIdAndUser} - Queries concepts by type and user
+ */
 export declare function GetCompositionListLocal(compositionName: string, userId: number): Promise<any>;
+/**
+ * Retrieves all compositions of a specific type with their IDs included in results.
+ *
+ * Similar to GetCompositionListLocal, but each composition in the returned array
+ * includes both the composition data and its root concept ID. This is useful when
+ * you need to perform operations on the compositions and need to track their IDs.
+ *
+ * @param compositionName - The character/name of the composition type to retrieve
+ * @param userId - The ID of the user whose compositions to retrieve
+ *
+ * @returns A promise that resolves to an array of objects with 'data' and 'id' properties
+ *
+ * @remarks
+ * - Each element in the array has structure: { data: {composition}, id: conceptId }
+ * - Useful for update or delete operations where you need the concept ID
+ * - Uses GetCompositionLocalWithId internally for each composition
+ * - Returns empty array if the type concept doesn't exist
+ *
+ * @example
+ * ```typescript
+ * // Retrieve all users with their IDs
+ * const usersWithIds = await GetCompositionListLocalWithId("the_user", 123);
+ *
+ * // Output structure:
+ * // [
+ * //   { data: { "the_user": { name: "John" } }, id: 1001 },
+ * //   { data: { "the_user": { name: "Jane" } }, id: 1002 }
+ * // ]
+ *
+ * // Update each user
+ * for (const userObj of usersWithIds) {
+ *   console.log(`Updating user ${userObj.id}`);
+ *   const userData = userObj.data.the_user;
+ *   await updateComposition(userObj.id, { ...userData, updated: true });
+ * }
+ *
+ * // Filter and process
+ * const specificUser = usersWithIds.find(u =>
+ *   u.data.the_user.name === "John"
+ * );
+ * if (specificUser) {
+ *   console.log(`John's ID is ${specificUser.id}`);
+ * }
+ * ```
+ *
+ * @see {@link GetCompositionListLocal} - Similar function without IDs
+ * @see {@link GetCompositionLocalWithId} - Retrieves single composition with ID
+ * @see {@link UpdateCompositionLocal} - Uses this format for updates
+ */
 export declare function GetCompositionListLocalWithId(compositionName: string, userId: number): Promise<any>;

package/dist/types/Services/Local/GetCompositionLocal.d.ts

@@ -1,2 +1,98 @@
+/**
+ * Local Composition Retrieval Module
+ *
+ * This module provides functionality to retrieve and reconstruct concept compositions from
+ * local storage. It converts the graph structure of interconnected concepts and connections
+ * back into hierarchical JSON objects, making them easy to work with in application code.
+ *
+ * @module GetCompositionLocal
+ */
+/**
+ * Retrieves a composition and converts it to a JSON object structure.
+ *
+ * This function fetches a concept composition by its ID and recursively reconstructs
+ * the original hierarchical JSON structure from the graph of concepts and connections.
+ * The root concept's type becomes the top-level key in the returned object.
+ *
+ * @param id - The ID of the root concept of the composition to retrieve
+ *
+ * @returns A promise that resolves to a JSON object representing the composition hierarchy
+ *
+ * @remarks
+ * - Fetches all connections associated with the composition
+ * - Identifies all concepts involved in the composition
+ * - Recursively traverses the graph to rebuild the JSON structure
+ * - The returned object has the root concept's type as its key
+ * - Uses helper function `recursiveFetchLocal` for tree traversal
+ *
+ * @example
+ * ```typescript
+ * // Retrieve a user composition by ID
+ * const userJson = await GetCompositionLocal(12345);
+ *
+ * // Output might look like:
+ * // {
+ * //   "the_user": {
+ * //     "name": "John Doe",
+ * //     "age": 30,
+ * //     "address": {
+ * //       "street": "123 Main St",
+ * //       "city": "Boston"
+ * //     }
+ * //   }
+ * // }
+ *
+ * console.log(userJson.the_user.name); // "John Doe"
+ * ```
+ *
+ * @see {@link GetCompositionLocalWithId} - Similar function that includes the composition ID
+ * @see {@link recursiveFetchLocal} - Helper function for recursive traversal
+ * @see {@link CreateTheCompositionLocal} - Related function for creating compositions
+ */
 export declare function GetCompositionLocal(id: number): Promise<any>;
+/**
+ * Retrieves a composition with its ID included in the result.
+ *
+ * Similar to GetCompositionLocal, but wraps the result in an object that includes
+ * both the composition data and the root concept ID. This is useful when you need
+ * to track which composition the data came from.
+ *
+ * @param id - The ID of the root concept of the composition to retrieve
+ *
+ * @returns A promise that resolves to an object with 'data' and 'id' properties
+ *
+ * @remarks
+ * - Returns an object with two properties: 'data' (the composition JSON) and 'id' (the root concept ID)
+ * - Useful when working with multiple compositions and need to track their origins
+ * - Only includes data if the concept exists (concept.id !== 0)
+ * - Uses the same recursive fetching logic as GetCompositionLocal
+ *
+ * @example
+ * ```typescript
+ * const result = await GetCompositionLocalWithId(12345);
+ *
+ * // Output structure:
+ * // {
+ * //   data: {
+ * //     "the_user": { name: "John", age: 30 }
+ * //   },
+ * //   id: 12345
+ * // }
+ *
+ * console.log(result.id); // 12345
+ * console.log(result.data.the_user.name); // "John"
+ *
+ * // Useful for batch operations
+ * const compositions = await Promise.all([
+ *   GetCompositionLocalWithId(100),
+ *   GetCompositionLocalWithId(200)
+ * ]);
+ * compositions.forEach(comp => {
+ *   console.log(`Composition ${comp.id}:`, comp.data);
+ * });
+ * ```
+ *
+ * @see {@link GetCompositionLocal} - Similar function without ID in result
+ * @see {@link recursiveFetchLocal} - Helper function for recursive traversal
+ */
 export declare function GetCompositionLocalWithId(id: number): Promise<any>;

package/dist/types/Services/Local/GetConceptByCharacterLocal.d.ts

@@ -1 +1,58 @@
+/**
+ * Local Concept Character Lookup Module
+ *
+ * This module provides a simple interface for retrieving concepts by their character value
+ * (string content/name) from local storage. It's commonly used to look up type concepts
+ * or find concepts by their textual representation.
+ *
+ * @module GetConceptByCharacterLocal
+ */
+/**
+ * Retrieves a concept from local storage by its character value.
+ *
+ * This function performs a lookup to find a concept whose characterValue (string content)
+ * matches the provided string. This is particularly useful for finding type concepts
+ * by their names (e.g., "the_user", "the_product") or for locating concepts by their
+ * textual representation.
+ *
+ * @param characterValue - The character/string value to search for
+ *
+ * @returns A promise that resolves to the matching LConcept, or a default concept if not found
+ *
+ * @remarks
+ * - Performs case-sensitive exact string matching
+ * - Utilizes LocalConceptsData's internal indexing for efficient lookup
+ * - If using character binary tree, lookup is O(log n), otherwise may be O(n)
+ * - Returns a default/empty concept if no match is found (check concept.id === 0)
+ * - Commonly used to look up type concepts before creating instances
+ *
+ * @example
+ * ```typescript
+ * // Look up a type concept
+ * const userType = await GetConceptByCharacterLocal("the_user");
+ * if (userType.id !== 0) {
+ *   console.log(`Found user type with ID: ${userType.id}`);
+ * }
+ *
+ * // Look up a concept by name
+ * const johnConcept = await GetConceptByCharacterLocal("John Doe");
+ * if (johnConcept.id !== 0) {
+ *   console.log(`John exists with ID ${johnConcept.id}`);
+ * } else {
+ *   console.log("John not found in local storage");
+ * }
+ *
+ * // Use in composition retrieval
+ * async function getUserCompositions(userId: number) {
+ *   const typeId = (await GetConceptByCharacterLocal("the_user")).id;
+ *   if (typeId === 0) return [];
+ *   return await LocalConceptsData.GetConceptsByTypeIdAndUser(typeId, userId);
+ * }
+ * ```
+ *
+ * @see {@link LocalConceptsData.GetConceptByCharacter} - Underlying lookup method
+ * @see {@link CreateLocalCharacterBinaryTreeFromData} - Initializes character-based indexing
+ * @see {@link MakeTheTypeLocal} - Uses this function to check for existing types
+ * @see {@link GetCompositionListLocal} - Uses this to find type concepts
+ */
 export default function GetConceptByCharacterLocal(characterValue: string): Promise<import("../../app").LConcept>;

package/dist/types/Services/Local/MakeTheConceptLocal.d.ts

@@ -1,2 +1,73 @@
+/**
+ * Local Concept Creation with Uniqueness Check Module
+ *
+ * This module provides "get-or-create" functionality for concepts in local storage.
+ * It checks if a concept with the specified character value and type already exists,
+ * and only creates a new one if it doesn't, preventing duplicate concepts.
+ *
+ * @module MakeTheConceptLocal
+ */
 import { LConcept } from "../../DataStructures/Local/LConcept";
+/**
+ * Gets an existing concept or creates a new one if it doesn't exist.
+ *
+ * This function implements a "get-or-create" pattern by first checking if a concept
+ * with the given character value and type already exists in local storage. If found,
+ * it returns the existing concept; otherwise, it creates and returns a new one.
+ *
+ * This prevents duplicate concepts from being created for the same character value
+ * and type combination, maintaining data integrity and uniqueness constraints.
+ *
+ * @param referent - The character value/name for the concept
+ * @param typeCharacter - The character representation of the concept's type
+ * @param userId - The ID of the user creating/owning the concept
+ * @param categoryId - The category ID for the concept
+ * @param typeId - The ID of the type concept
+ *
+ * @returns A promise that resolves to the found or newly created LConcept
+ *
+ * @remarks
+ * - First queries for existing concept using character value and type ID
+ * - Only creates a new concept if no match is found (concept.id === 0)
+ * - Automatically uses accessId of 4 (default access level) for new concepts
+ * - Ensures referent uniqueness within the same type
+ * - Particularly useful for maintaining referential integrity
+ *
+ * @example
+ * ```typescript
+ * // First call creates the concept
+ * const concept1 = await MakeTheConceptLocal(
+ *   "John Doe",     // referent
+ *   "the_name",     // typeCharacter
+ *   123,            // userId
+ *   4,              // categoryId
+ *   51              // typeId
+ * );
+ * console.log(`Created concept with ID: ${concept1.id}`);
+ *
+ * // Second call returns the same concept (no duplicate)
+ * const concept2 = await MakeTheConceptLocal(
+ *   "John Doe",     // same referent
+ *   "the_name",     // same typeCharacter
+ *   123,            // userId
+ *   4,              // categoryId
+ *   51              // same typeId
+ * );
+ * console.log(concept1.id === concept2.id); // true
+ *
+ * // Different type allows same referent
+ * const concept3 = await MakeTheConceptLocal(
+ *   "John Doe",     // same referent
+ *   "the_company",  // different type
+ *   123,
+ *   4,
+ *   52              // different typeId
+ * );
+ * console.log(concept3.id !== concept1.id); // true
+ * ```
+ *
+ * @see {@link CreateTheConceptLocal} - Creates new concepts
+ * @see {@link LocalConceptsData.GetConceptByCharacterAndTypeLocal} - Checks for existing concepts
+ * @see {@link MakeTheInstanceConceptLocal} - Higher-level concept creation with type handling
+ */
 export default function MakeTheConceptLocal(referent: string, typeCharacter: string, userId: number, categoryId: number, typeId: number): Promise<LConcept>;

package/dist/types/Services/Local/MakeTheInstanceConceptLocal.d.ts

@@ -1,2 +1,91 @@
+/**
+ * Local Instance Concept Creation Module
+ *
+ * This module provides high-level functionality for creating instance concepts with
+ * automatic type management. It handles type creation, naming conventions (the_ prefix),
+ * and different scenarios like compositions, large text values, and standard concepts.
+ *
+ * @module MakeTheInstanceConceptLocal
+ */
 import { LConcept } from "../../DataStructures/Local/LConcept";
+/**
+ * Creates an instance concept with automatic type handling and smart referent management.
+ *
+ * This high-level function handles the complete process of creating a concept instance,
+ * including:
+ * - Ensuring the type concept exists (creates if needed)
+ * - Adding "the_" prefix to types if not present
+ * - Handling composition concepts (nested objects)
+ * - Managing long text values (> 255 characters)
+ * - Preventing duplicate concepts with get-or-create logic
+ *
+ * @param type - The type name for the concept (e.g., "user", "product")
+ * @param referent - The string value/content of the concept
+ * @param composition - Whether this is a composition concept (has nested structure)
+ * @param userId - The ID of the user creating the concept
+ * @param accessId - Access control ID for the concept
+ * @param sessionInformationId - Session tracking ID (defaults to 999)
+ * @param referentId - Optional ID linking to another concept (defaults to 0)
+ *
+ * @returns A promise that resolves to the created or found LConcept with its type attached
+ *
+ * @remarks
+ * - Automatically prepends "the_" to type names if not already present
+ * - For compositions: Always creates a new concept regardless of existing ones
+ * - For text > 255 chars: Creates concept with full text stored
+ * - For text <= 255 chars: Uses get-or-create logic to prevent duplicates
+ * - Always ensures the type concept exists before creating the instance
+ * - Sets category ID to 4 by default
+ * - Returns concept with its type property populated for immediate use
+ *
+ * @example
+ * ```typescript
+ * // Create a simple string concept
+ * const nameConcept = await MakeTheInstanceConceptLocal(
+ *   "name",           // type (becomes "the_name")
+ *   "John Doe",       // referent
+ *   false,            // not a composition
+ *   123,              // userId
+ *   4,                // accessId
+ *   999               // sessionInformationId
+ * );
+ * console.log(nameConcept.type.characterValue); // "the_name"
+ *
+ * // Create a composition concept for nested objects
+ * const addressConcept = await MakeTheInstanceConceptLocal(
+ *   "address",        // type (becomes "the_address")
+ *   "",               // empty referent for compositions
+ *   true,             // is a composition
+ *   123,
+ *   4,
+ *   999
+ * );
+ *
+ * // Handle long text
+ * const longText = "A".repeat(300);
+ * const articleConcept = await MakeTheInstanceConceptLocal(
+ *   "article",
+ *   longText,         // > 255 characters
+ *   false,
+ *   123,
+ *   4,
+ *   999
+ * );
+ *
+ * // Type name with "the_" prefix already included
+ * const userConcept = await MakeTheInstanceConceptLocal(
+ *   "the_user",       // already has "the_" prefix
+ *   "user123",
+ *   false,
+ *   123,
+ *   4,
+ *   999
+ * );
+ * ```
+ *
+ * @see {@link MakeTheTypeConceptLocal} - Creates or retrieves type concepts
+ * @see {@link CreateTheConceptLocal} - Creates the actual concept instance
+ * @see {@link LocalConceptsData.GetConceptByCharacterAndTypeLocal} - Checks for existing concepts
+ * @see {@link CreateTheCompositionLocal} - Uses this function to create composition elements
+ */
 export declare function MakeTheInstanceConceptLocal(type: string, referent: string, composition: boolean | undefined, userId: number, accessId: number, sessionInformationId?: number, referentId?: number): Promise<LConcept>;