mftsccs-node 0.2.7 → 0.2.8

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

@@ -1,2 +1,73 @@
+/**
+ * Local Type Concept Creation Module
+ *
+ * This module handles the creation of type concepts in the local storage layer.
+ * Type concepts define the schema and categorization of other concepts in the system.
+ * It supports hierarchical type creation through recursive processing of composite type names.
+ *
+ * @module MakeTheTypeLocal
+ */
 import { LConcept } from "../../DataStructures/Local/LConcept";
+/**
+ * Creates or retrieves a type concept with support for hierarchical type structures.
+ *
+ * This function ensures that a type concept exists in the local storage. If the type
+ * doesn't exist, it creates it, handling both simple types and composite types.
+ * Composite types (e.g., "the_category_type") are split and processed recursively
+ * to establish proper type hierarchies.
+ *
+ * The function implements get-or-create logic to prevent duplicate type concepts
+ * and maintains the type system's integrity through proper categorization.
+ *
+ * @param typeString - The name of the type to create or retrieve (e.g., "the_user", "the_product")
+ * @param sessionId - Session information ID for tracking
+ * @param sessionUserId - User ID associated with the session
+ * @param userId - The ID of the user creating/owning the type
+ *
+ * @returns A promise that resolves to the type concept (existing or newly created)
+ *
+ * @remarks
+ * - First checks if type concept already exists by character value
+ * - If not found or invalid (id === 0), proceeds with creation logic
+ * - For simple types: Creates with typeId 51 (base "the" type) and category 4
+ * - For composite types: Splits on underscore and recursively creates category and type
+ * - Example: "the_category_type" splits into "the_category" (category) and "type" (type)
+ * - Uses accessId of 4 (default access level) for new types
+ * - The base type "the" (typeId 51) is the root of the type hierarchy
+ *
+ * @example
+ * ```typescript
+ * // Create a simple type
+ * const userType = await MakeTheTypeConceptLocal(
+ *   "the_user",
+ *   999,   // sessionId
+ *   123,   // sessionUserId
+ *   123    // userId
+ * );
+ * console.log(userType.characterValue); // "the_user"
+ * console.log(userType.typeId); // 51 (the base "the" type)
+ *
+ * // Create a composite type (creates category and type recursively)
+ * const productType = await MakeTheTypeConceptLocal(
+ *   "the_ecommerce_product",
+ *   999,
+ *   123,
+ *   123
+ * );
+ * // This creates:
+ * // 1. "the_ecommerce" as category
+ * // 2. "product" as type
+ * // 3. "the_ecommerce_product" as final type
+ *
+ * // Subsequent calls return existing type (no duplicate)
+ * const sameType = await MakeTheTypeConceptLocal("the_user", 999, 123, 123);
+ * console.log(sameType.id === userType.id); // true
+ * ```
+ *
+ * @see {@link GetConceptByCharacterLocal} - Checks if type already exists
+ * @see {@link MakeTheConceptLocal} - Creates concepts with uniqueness check
+ * @see {@link CreateTheConceptLocal} - Low-level concept creation
+ * @see {@link SplitStrings} - Splits composite type names
+ * @see {@link MakeTheInstanceConceptLocal} - Uses this to create types for instances
+ */
 export default function MakeTheTypeConceptLocal(typeString: string, sessionId: number, sessionUserId: number, userId: number): Promise<LConcept>;

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

@@ -1,2 +1,103 @@
+/**
+ * Local Composition Update Module
+ *
+ * This module provides functionality to update existing compositions in local storage
+ * by patching them with new data. It handles the complex process of modifying a graph
+ * structure, including replacing existing concepts, creating new ones, and managing
+ * connections while maintaining data integrity.
+ *
+ * @module UpdateCompositionLocal
+ */
 import { PatcherStructure } from '../../DataStructures/PatcherStructure';
+/**
+ * Updates an existing composition by patching it with new data.
+ *
+ * This function performs a sophisticated update operation on a composition by:
+ * 1. Fetching the current composition structure from the backend
+ * 2. Identifying concepts that need to be replaced (same type, different value)
+ * 3. Creating new concepts for the patch data
+ * 4. Removing old connections and concepts that are being replaced
+ * 5. Creating new connections for the updated structure
+ * 6. Triggering synchronization with the backend
+ *
+ * The function handles both simple property updates and complex nested composition updates.
+ *
+ * @param patcherStructure - Object containing update instructions
+ * @param patcherStructure.compositionId - ID of the root composition to update
+ * @param patcherStructure.ofTheCompositionId - ID of immediate parent (for nested updates)
+ * @param patcherStructure.patchObject - The new data to patch into the composition
+ * @param patcherStructure.userId - ID of the user performing the update
+ * @param patcherStructure.sessionId - Session tracking ID
+ * @param patcherStructure.accessId - Access control ID
+ *
+ * @returns A promise that resolves when the update is complete
+ *
+ * @remarks
+ * - Fetches latest composition data from backend to ensure consistency
+ * - Identifies existing concepts by type and marks them for deletion
+ * - Creates new concepts with the updated values
+ * - Establishes proper connections between parent and new concepts
+ * - Deletes old connections associated with replaced concepts
+ * - Triggers online synchronization via SyncData.SyncDataOnline()
+ * - Handles both primitive values and nested compositions (objects/arrays)
+ * - For nested compositions, recursively creates the structure
+ * - Converts backend Concept/Connection types to local LConcept/LConnection types
+ *
+ * @example
+ * ```typescript
+ * // Update a user's name and age
+ * const patcher: PatcherStructure = {
+ *   compositionId: 12345,        // User composition ID
+ *   ofTheCompositionId: null,    // No immediate parent (root level)
+ *   patchObject: {
+ *     name: "Jane Doe",          // Updated name
+ *     age: 31                    // Updated age
+ *   },
+ *   userId: 123,
+ *   sessionId: 999,
+ *   accessId: 4
+ * };
+ *
+ * await UpdateCompositionLocal(patcher);
+ * // Result: Old name/age concepts replaced with new ones
+ *
+ * // Update nested property
+ * const nestedPatcher: PatcherStructure = {
+ *   compositionId: 12345,
+ *   ofTheCompositionId: 12350,   // Address composition ID
+ *   patchObject: {
+ *     city: "New York"            // Update city within address
+ *   },
+ *   userId: 123,
+ *   sessionId: 999,
+ *   accessId: 4
+ * };
+ *
+ * await UpdateCompositionLocal(nestedPatcher);
+ *
+ * // Update with complex nested structure
+ * const complexPatcher: PatcherStructure = {
+ *   compositionId: 12345,
+ *   ofTheCompositionId: null,
+ *   patchObject: {
+ *     address: {                  // Nested composition
+ *       street: "123 Main St",
+ *       city: "Boston"
+ *     }
+ *   },
+ *   userId: 123,
+ *   sessionId: 999,
+ *   accessId: 4
+ * };
+ *
+ * await UpdateCompositionLocal(complexPatcher);
+ * ```
+ *
+ * @see {@link PatcherStructure} - Structure defining update parameters
+ * @see {@link MakeTheInstanceConceptLocal} - Creates new concepts during update
+ * @see {@link CreateTheCompositionLocal} - Handles nested composition creation
+ * @see {@link CreateTheConnectionLocal} - Creates connections for new concepts
+ * @see {@link DeleteConnectionById} - Removes old connections
+ * @see {@link SyncData.SyncDataOnline} - Synchronizes changes with backend
+ */
 export declare function UpdateCompositionLocal(patcherStructure: PatcherStructure): Promise<void>;

package/dist/types/Services/MakeTheCharacter.d.ts

@@ -1,2 +1,76 @@
+/**
+ * @module MakeTheCharacter
+ * @description Creates character-based concepts in the Concept Connection System (CCS).
+ * This module handles the creation of concepts representing character data, with special
+ * handling for single characters (using ASCII codes) versus multi-character strings.
+ * It serves as a fundamental building block for text and string representation in CCS.
+ */
 import { Concept } from "../DataStructures/Concept";
+/**
+ * Creates a character concept for the given character data.
+ *
+ * This function creates concepts that represent character data in the CCS system.
+ * It handles two distinct cases based on the length of the input:
+ *
+ * 1. Single character: Uses the ASCII character code as the referent ID and type 49
+ * 2. Multiple characters: Uses character data ID as referent and type 51
+ *
+ * Both cases first create the underlying character data before creating the concept.
+ *
+ * @param the_character_data - The character string to create a concept for (e.g., "a", "hello")
+ * @param userId - The ID of the user creating this character concept
+ * @param securityId - The security control ID for access management
+ * @param accessId - The access control ID determining visibility
+ * @param accessUserId - The user ID for access control
+ * @param sessionId - The session ID for tracking this operation
+ *
+ * @returns Promise resolving to the created character Concept
+ *
+ * @remarks
+ * - Single characters use ASCII charCodeAt(0) as their referent ID
+ * - Single characters are typed with ID 49 (character type)
+ * - Multi-character strings are typed with ID 51 (character data type)
+ * - Multi-character strings reference the created character data as referent
+ * - Category ID is always 4 for character concepts
+ * - Always creates new character data before creating the concept
+ *
+ * @example
+ * ```typescript
+ * // Create a single character concept
+ * const charA = await MakeTheCharacter(
+ *   "a",
+ *   1,
+ *   999,
+ *   100,
+ *   1,
+ *   999
+ * );
+ * // Uses ASCII code 97 as referent ID
+ *
+ * // Create a multi-character concept
+ * const hello = await MakeTheCharacter(
+ *   "hello",
+ *   1,
+ *   999,
+ *   100,
+ *   1,
+ *   999
+ * );
+ * // Creates character data first, then references it
+ *
+ * // Create a type string
+ * const typeName = await MakeTheCharacter(
+ *   "the_user",
+ *   1,
+ *   999,
+ *   100,
+ *   1,
+ *   999
+ * );
+ * ```
+ *
+ * @see {@link MakeTheCharacterData} - Creates the underlying character data
+ * @see {@link MakeTheConcept} - Creates the concept entity
+ * @see {@link Returner} - Return type for character data creation
+ */
 export default function MakeTheCharacter(the_character_data: string, userId: number, securityId: number, accessId: number, accessUserId: number, sessionId: number): Promise<Concept>;

package/dist/types/Services/MakeTheCharacterData.d.ts

@@ -1,2 +1,67 @@
+/**
+ * @module MakeTheCharacterData
+ * @description Creates character data entries in the Concept Connection System (CCS).
+ * This module handles the storage of character strings as data entities that can be
+ * referenced by concepts. It creates TheCharacter objects and persists them through
+ * the API, providing metadata about whether the character data is newly created.
+ */
 import { Returner } from "../DataStructures/Returner";
+/**
+ * Creates or retrieves character data for a given character string.
+ *
+ * This function creates a TheCharacter data object with the provided character string
+ * and persists it to the database through the API. The character data serves as a
+ * storage mechanism for string values that can be referenced by multiple concepts.
+ *
+ * The created character data includes all necessary metadata for access control,
+ * security, and session tracking. The Returner object indicates whether the
+ * character data was newly created or already existed.
+ *
+ * @param the_character_data - The character string to store (e.g., "hello", "user_name")
+ * @param userId - The ID of the user creating this character data
+ * @param securityId - The security control ID for access management
+ * @param accessId - The access control ID determining visibility
+ * @param sessionId - The session ID for tracking this operation
+ *
+ * @returns Promise resolving to a Returner object containing the character data ID,
+ *          user ID, and a flag indicating if it was newly created
+ *
+ * @remarks
+ * - Creates a TheCharacter object with empty string for last parameter
+ * - Sets isNew flag to false initially in TheCharacter constructor
+ * - The actual isNew status comes from the API response in Returner
+ * - All user IDs (category, access, security, session) are set to the same userId
+ * - Character data is immutable once created and can be shared across concepts
+ *
+ * @example
+ * ```typescript
+ * // Create character data for a username
+ * const result = await MakeTheCharacterData(
+ *   "john_doe",
+ *   1,
+ *   999,
+ *   100,
+ *   999
+ * );
+ * console.log(result.id); // Character data ID
+ * console.log(result.isNew); // true if newly created
+ *
+ * // Create character data for a type name
+ * const typeData = await MakeTheCharacterData(
+ *   "the_user",
+ *   1,
+ *   999,
+ *   100,
+ *   999
+ * );
+ *
+ * // Use in character concept creation
+ * const charData = await MakeTheCharacterData("hello", 1, 999, 100, 999);
+ * // charData.id can now be used as a referent in concept creation
+ * ```
+ *
+ * @see {@link CreateTheCharacter} - API function that persists the character data
+ * @see {@link TheCharacter} - Data structure representing character data
+ * @see {@link Returner} - Return type containing ID and creation status
+ */
 export default function MakeTheCharacterData(the_character_data: string, userId: number, securityId: number, accessId: number, sessionId: number): Promise<Returner>;

package/dist/types/Services/MakeTheInstanceConcept.d.ts

@@ -1,3 +1,78 @@
+/**
+ * @module MakeTheInstanceConcept
+ * @description Creates instance concepts in the Concept Connection System (CCS).
+ * This module handles the creation of concepts with specific types and referents,
+ * managing various scenarios including compositions, text data, and character concepts.
+ * It serves as a core factory function for instantiating typed concepts in the system.
+ */
 import { Concept } from "../DataStructures/Concept";
 import { InnerActions } from "../DataStructures/Transaction/Transaction";
+/**
+ * Creates an instance concept with a specific type and referent.
+ *
+ * This function is the primary factory for creating typed concepts in the CCS system.
+ * It handles three main scenarios:
+ * 1. Composition concepts - Creates concepts using the composition pattern
+ * 2. Text concepts - Creates concepts for strings longer than 255 characters, storing them as text data
+ * 3. Standard concepts - Creates or retrieves existing concepts for standard character values
+ *
+ * The function automatically prefixes type names with "the_" if not already present and
+ * manages all necessary associations (category, type, referent, security, access, session).
+ *
+ * @param type - The type identifier for the concept (e.g., "user", "post", "comment").
+ *                Will be automatically prefixed with "the_" if not present.
+ * @param referent - The actual value or data for the concept (e.g., username, post content)
+ * @param composition - If true, creates a composition concept bypassing character checks
+ * @param userId - The ID of the user creating this concept
+ * @param passedAccessId - The access control ID determining who can access this concept
+ * @param passedSessionId - The session ID for tracking this operation (default: 999)
+ * @param referentId - Optional ID of a referent concept (default: 0)
+ * @param actions - Transaction actions for batch operations (default: empty actions)
+ *
+ * @returns Promise resolving to the created or retrieved Concept with type information populated
+ *
+ * @remarks
+ * - For composition concepts, bypasses character lookup and creates immediately
+ * - For strings > 255 chars, creates both a concept and a separate text data entry
+ * - For standard concepts, checks for existing concepts by character and type before creating
+ * - Includes performance timing logs (commented out) for optimization analysis
+ * - The type concept is always attached to the returned concept for reference
+ *
+ * @example
+ * ```typescript
+ * // Create a standard user concept
+ * const userConcept = await MakeTheInstanceConcept(
+ *   "user",
+ *   "john_doe",
+ *   false,
+ *   1,
+ *   100,
+ *   999
+ * );
+ *
+ * // Create a composition concept
+ * const compositionConcept = await MakeTheInstanceConcept(
+ *   "custom_type",
+ *   "complex_data",
+ *   true,
+ *   1,
+ *   100
+ * );
+ *
+ * // Create a text concept for long content
+ * const longText = "Lorem ipsum...".repeat(100);
+ * const textConcept = await MakeTheInstanceConcept(
+ *   "article",
+ *   longText,
+ *   false,
+ *   1,
+ *   100
+ * );
+ * ```
+ *
+ * @see {@link MakeTheTypeConceptApi} - Creates or retrieves type concepts
+ * @see {@link CreateTheConcept} - Creates the actual concept entity
+ * @see {@link GetConceptByCharacterAndType} - Retrieves existing concepts
+ * @see {@link CreateTextData} - Stores long text separately
+ */
 export default function MakeTheInstanceConcept(type: string, referent: string, composition: boolean | undefined, userId: number, passedAccessId: number, passedSessionId?: number, referentId?: number, actions?: InnerActions): Promise<Concept>;

package/dist/types/Services/MakeTheName.d.ts

@@ -1,2 +1,83 @@
+/**
+ * @module MakeTheName
+ * @description Creates name concepts in the Concept Connection System (CCS).
+ * This module provides functionality for creating concepts that represent names,
+ * utilizing character concepts as referents. It handles both existing concepts
+ * (by retrieving their referent) and new concepts (by creating character concepts).
+ */
 import { Concept } from "../DataStructures/Concept";
+/**
+ * Creates a name concept with character data as its referent.
+ *
+ * This function creates concepts specifically designed to represent names in the CCS system.
+ * It has two execution paths based on whether an existing concept is provided:
+ *
+ * 1. Existing concept (id > 0): Retrieves the referent of the existing concept and uses it
+ * 2. New concept: Creates a new character concept and uses it as the referent for the name
+ *
+ * Name concepts are typed with ID 12 (name type) and use character concepts as their
+ * referent, establishing a link between the name and its character representation.
+ *
+ * @param theCharacterData - The character string representing the name (e.g., "John Doe", "Product Name")
+ * @param userId - The ID of the user creating this name concept
+ * @param securityId - The security control ID for access management
+ * @param securityUserId - The user ID for security control
+ * @param accessId - The access control ID determining visibility
+ * @param accessUserId - The user ID for access control
+ * @param sessionInformationId - The session ID for tracking this operation
+ * @param sessionInformationUserId - The user ID associated with the session
+ * @param typeId - The type ID for the concept (used when creating from existing)
+ * @param typeUserId - The user ID associated with the type
+ * @param existingConcept - An existing concept to use as base (or empty concept to create new)
+ *
+ * @returns Promise resolving to the created or updated name Concept
+ *
+ * @remarks
+ * - Name type ID is fixed at 12
+ * - Category ID is fixed at 4
+ * - Session ID defaults to 999 if not provided (using nullish coalescing)
+ * - Access ID defaults to 4 if not provided
+ * - For existing concepts with valid ID, retrieves and reuses the referent
+ * - For new concepts, creates a character concept first, then creates the name concept
+ * - Category user ID is always 999
+ *
+ * @example
+ * ```typescript
+ * // Create a new name concept
+ * const emptyExisting = new Concept();
+ * const nameConcept = await MakeTheName(
+ *   "John Doe",
+ *   1,
+ *   999,
+ *   1,
+ *   100,
+ *   1,
+ *   999,
+ *   999,
+ *   12,
+ *   1,
+ *   emptyExisting
+ * );
+ *
+ * // Update existing concept with name
+ * const existing = await GetConcept(123);
+ * const updatedName = await MakeTheName(
+ *   "Jane Smith",
+ *   1,
+ *   999,
+ *   1,
+ *   100,
+ *   1,
+ *   999,
+ *   999,
+ *   12,
+ *   1,
+ *   existing
+ * );
+ * ```
+ *
+ * @see {@link MakeTheCharacter} - Creates the character concept used as referent
+ * @see {@link GetTheReferent} - Retrieves the referent from existing concepts
+ * @see {@link MakeTheConcept} - Creates the actual name concept entity
+ */
 export declare function MakeTheName(theCharacterData: string, userId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number, typeId: number, typeUserId: number, existingConcept: Concept): Promise<Concept>;

package/dist/types/Services/MakeTheTimestamp.d.ts

@@ -1,2 +1,70 @@
+/**
+ * @module MakeTheTimestamp
+ * @description Creates timestamp concepts in the Concept Connection System (CCS).
+ * This module provides a specialized function for creating concepts that represent
+ * timestamps or time-based data. It ensures proper type prefixing and creates
+ * concepts with standardized metadata for temporal tracking within the system.
+ */
 import { Concept } from "../DataStructures/Concept";
+/**
+ * Creates a timestamp concept with the specified type and referent.
+ *
+ * This function creates concepts specifically designed for representing timestamps
+ * and temporal data in the CCS system. It follows a simplified creation flow compared
+ * to MakeTheInstanceConcept, focusing on straightforward type-referent associations.
+ *
+ * The function automatically ensures the type string is prefixed with "the_" if not
+ * already present, then creates the type concept and associates it with a new concept
+ * containing the timestamp referent value.
+ *
+ * @param type - The type identifier for the timestamp concept (e.g., "created_at", "updated_at").
+ *               Will be automatically prefixed with "the_" if not present.
+ * @param referent - The timestamp value or temporal data (e.g., ISO date string, Unix timestamp)
+ * @param userId - The ID of the user creating this timestamp concept
+ * @param accessId - The access control ID determining visibility
+ * @param sessionInformationId - The session ID for tracking this operation (default: 999)
+ *
+ * @returns Promise resolving to the created timestamp Concept
+ *
+ * @remarks
+ * - Category ID is fixed at 4 for timestamp concepts
+ * - Referent ID is set to 0 (no referent concept)
+ * - Security ID is fixed at 999
+ * - Session information ID is overridden to 999 regardless of parameter
+ * - Access ID is overridden to 4 regardless of parameter
+ * - All user IDs are derived from the userId parameter
+ * - Type concept is created before the timestamp concept
+ *
+ * @example
+ * ```typescript
+ * // Create a timestamp for creation time
+ * const createdAt = await MakeTheTimestamp(
+ *   "created_at",
+ *   new Date().toISOString(),
+ *   1,
+ *   100
+ * );
+ *
+ * // Create a timestamp with explicit session
+ * const updatedAt = await MakeTheTimestamp(
+ *   "the_updated_at",
+ *   Date.now().toString(),
+ *   1,
+ *   100,
+ *   999
+ * );
+ *
+ * // Create a custom temporal concept
+ * const expiryTime = await MakeTheTimestamp(
+ *   "expires_at",
+ *   "2025-12-31T23:59:59Z",
+ *   1,
+ *   100
+ * );
+ * ```
+ *
+ * @see {@link MakeTheTypeConceptApi} - Creates or retrieves the type concept
+ * @see {@link MakeTheConcept} - Creates the actual concept entity
+ * @see {@link CreateDefaultConcept} - Creates a default concept structure
+ */
 export declare function MakeTheTimestamp(type: string, referent: string, userId: number, accessId: number, sessionInformationId?: number): Promise<Concept>;

package/dist/types/Services/MakeTheTypeConcept.d.ts

@@ -1,3 +1,71 @@
+/**
+ * @module MakeTheTypeConcept
+ * @description Creates type concepts in the Concept Connection System (CCS).
+ * This module handles the creation of type concepts which define the structure and
+ * categorization of instance concepts. It supports both simple types and composite
+ * types using recursive parsing and creation strategies.
+ */
 import { Concept } from "../DataStructures/Concept";
 import { InnerActions } from "../DataStructures/Transaction/Transaction";
+/**
+ * Creates or retrieves a type concept in the CCS system.
+ *
+ * This function manages the creation of type concepts which define the structure
+ * and classification for instance concepts. It uses a recursive approach to handle
+ * composite types by splitting type strings and creating category and type hierarchies.
+ *
+ * The function follows this logic:
+ * 1. First checks if a concept with the given character value exists
+ * 2. If not found, splits the type string to determine if it's a composite type
+ * 3. For simple types, creates a character-based concept
+ * 4. For composite types (e.g., "category_typename"), recursively creates both parts
+ *
+ * @param typeString - The string identifier for the type (e.g., "user", "post", "the_category_type")
+ * @param sessionId - The session ID for tracking this operation
+ * @param sessionUserId - The user ID associated with the session
+ * @param userId - The ID of the user creating this type concept
+ * @param actions - Transaction actions for batch operations (default: empty actions)
+ *
+ * @returns Promise resolving to the created or retrieved type Concept
+ *
+ * @remarks
+ * - Uses SplitStrings to parse composite type names
+ * - Recursively creates type hierarchies for composite types
+ * - The first part of a split becomes the category, the second part becomes the type
+ * - Simple types (no split) are created as character concepts
+ * - Includes debug logging for split string arrays
+ *
+ * @example
+ * ```typescript
+ * // Create a simple type
+ * const userType = await MakeTheTypeConcept(
+ *   "the_user",
+ *   999,
+ *   1,
+ *   1
+ * );
+ *
+ * // Create a composite type
+ * const compositeType = await MakeTheTypeConcept(
+ *   "category_typename",
+ *   999,
+ *   1,
+ *   1
+ * );
+ *
+ * // With transaction actions
+ * const typeWithActions = await MakeTheTypeConcept(
+ *   "the_post",
+ *   999,
+ *   1,
+ *   1,
+ *   { concepts: [], connections: [] }
+ * );
+ * ```
+ *
+ * @see {@link GetConceptByCharacter} - Checks for existing type concepts
+ * @see {@link MakeTheCharacter} - Creates character-based concepts for simple types
+ * @see {@link SplitStrings} - Parses composite type strings
+ * @see {@link CreateTheConceptImmediate} - Creates the concept entity for composite types
+ */
 export declare function MakeTheTypeConcept(typeString: string, sessionId: number, sessionUserId: number, userId: number, actions?: InnerActions): Promise<Concept>;

package/dist/types/Services/Mqtt/publishMessage.d.ts

@@ -1 +1,28 @@
+/**
+ * @module publishMessage
+ * @description Provides MQTT message publishing functionality for real-time communication
+ */
+/**
+ * Publishes a message to an MQTT topic if a connection is established.
+ * Used for real-time notifications and updates across the system.
+ *
+ * @param {string} topic - The MQTT topic to publish to
+ * @param {any} message - The message payload to publish
+ *
+ * @example
+ * ```typescript
+ * // Publish a composition update notification
+ * publishMessage("compositionUpdate", "123");
+ *
+ * // Publish a complex message
+ * publishMessage("user/notifications", { type: "follow", userId: 456 });
+ * ```
+ *
+ * @remarks
+ * - Only publishes if BaseUrl.MQTT_CONNECTION is available
+ * - No-op if MQTT connection is not established
+ * - No return value (void function)
+ * - Message format depends on subscriber expectations
+ * - Used for cache invalidation and real-time updates
+ */
 export declare function publishMessage(topic: string, message: any): void;

package/dist/types/Services/Mqtt/subscribeMessage.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @module subscribeMessage
+ * @description Provides MQTT message subscription functionality for real-time cache invalidation (Currently commented out/unused)
+ */
+/**
+ * MQTT message subscription handler (Currently disabled).
+ * When enabled, this function would subscribe to MQTT topics and handle incoming messages.
+ *
+ * @remarks
+ * This functionality is currently commented out and not in use.
+ * When enabled, it would:
+ * - Subscribe to MQTT message events
+ * - Listen for "compositionUpdate" topic
+ * - Parse composition IDs from messages
+ * - Remove compositions from cache (CompositionBinaryTree)
+ * - Provide real-time cache invalidation when compositions change
+ *
+ * To enable:
+ * 1. Uncomment the function code
+ * 2. Ensure global.mqttconn is properly initialized
+ * 3. Import CompositionBinaryTree
+ * 4. Set up proper MQTT connection management
+ */