mftsccs-node 0.0.56 → 0.0.58

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

@@ -0,0 +1,43 @@
+/**
+ * Character-Based Binary Tree Data Loading Service
+ *
+ * This module provides functionality for creating and populating a character-based binary tree
+ * data structure from persisted concept data. The tree is organized by character values,
+ * allowing for efficient character-based searching and retrieval of concepts.
+ *
+ * @module CreateCharacterBinaryTreeFromData
+ */
+/**
+ * Creates and populates a character-based binary tree from concept data stored in the database.
+ *
+ * This function retrieves all concept records from IndexedDB and constructs a binary tree
+ * where nodes are organized by their character values. Each concept is wrapped in a Node
+ * with its characterValue as the key, enabling efficient character-based lookups and searches.
+ *
+ * The BinaryCharacterTree allows for alphabetical or character-based organization of concepts,
+ * which is useful for features like autocomplete, search suggestions, or character-based
+ * filtering of concept data.
+ *
+ * @returns A promise that resolves when the character binary tree has been fully populated
+ *
+ * @example
+ * ```typescript
+ * // Build the character-based binary tree from database
+ * await CreateCharacterBinaryTreeFromData();
+ *
+ * // The tree can now be used for character-based searches
+ * const results = BinaryCharacterTree.search('a');
+ * console.log('Concepts starting with "a":', results);
+ * ```
+ *
+ * @remarks
+ * - Creates a new BinaryCharacterTree instance at the start of execution
+ * - Each concept is converted to a Node using its characterValue property as the key
+ * - The tree is built incrementally by adding one node at a time
+ * - Character values determine the position in the binary tree for O(log n) search performance
+ *
+ * @see {@link BinaryCharacterTree.addNodeToTree} for how nodes are inserted into the tree
+ * @see {@link Node} for the node data structure used in the tree
+ * @see {@link getFromDatabaseWithTypeOld} for database retrieval implementation
+ */
+export declare function CreateCharacterBinaryTreeFromData(): Promise<void>;

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

@@ -0,0 +1,211 @@
+/**
+ * Typed Connection Creation Between Concepts
+ *
+ * This module provides specialized functions for creating semantic, bidirectional, and
+ * counted connections between concepts. It implements a sophisticated connection naming
+ * scheme that incorporates concept types and relationship semantics, enabling queries
+ * like "show all books_s_authored_s_by author" in the system.
+ *
+ * The module supports:
+ * - Forward and backward (bidirectional) connections
+ * - Automatic relationship counting
+ * - Type-aware connection naming patterns
+ *
+ * @module CreateConnectionBetweenTwoConcepts
+ */
+import { Concept } from "../DataStructures/Concept";
+import { Connection } from "../DataStructures/Connection";
+/**
+ * Creates a typed connection between two concepts with optional bidirectionality and counting.
+ *
+ * This function establishes semantic connections using a naming pattern that includes the
+ * concept types. For example, connecting a "book" to an "author" with linker "authored"
+ * creates a connection of type "books_s_authored_s". This enables type-aware querying and
+ * relationship navigation in the system.
+ *
+ * The function can optionally create bidirectional connections (both directions) and
+ * maintain relationship counts, which is useful for analytics and relationship tracking.
+ *
+ * @param ofTheConcept - The source concept from which the connection originates
+ * @param toTheConcept - The target concept to which the connection points
+ * @param linker - The semantic relationship name (e.g., "authored", "contains", "belongs_to")
+ * @param both - If true, creates connections in both directions (default: false)
+ * @param count - If true, maintains a count of relationships for this linker type (default: false)
+ *
+ * @returns A promise that resolves to the created forward Connection object
+ *
+ * @example
+ * ```typescript
+ * // Create a one-way "authored" connection
+ * const authorConcept = await GetTheConcept(123); // type: "author"
+ * const bookConcept = await GetTheConcept(456);   // type: "book"
+ *
+ * const connection = await CreateConnectionBetweenTwoConcepts(
+ *   authorConcept,
+ *   bookConcept,
+ *   "authored",
+ *   false,
+ *   false
+ * );
+ * // Creates connection type: "authors_s_authored_s"
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create bidirectional "friends_with" connections with counting
+ * const userConcept1 = await GetTheConcept(789);
+ * const userConcept2 = await GetTheConcept(101);
+ *
+ * await CreateConnectionBetweenTwoConcepts(
+ *   userConcept1,
+ *   userConcept2,
+ *   "friends_with",
+ *   true,  // Create both directions
+ *   true   // Enable counting
+ * );
+ * // Creates: "users_s_friends_with_s" and "users_s_friends_with_by"
+ * // Maintains count concepts for relationship tracking
+ * ```
+ *
+ * @remarks
+ * - Forward connection type pattern: `{sourceType}_s_{linker}_s`
+ * - Backward connection type pattern: `{targetType}_s_{linker}_by`
+ * - Count concept pattern: `{type}_s_{linker}_count`
+ * - Uses session information ID 999 and access level 4 as defaults
+ * - Counting creates/updates a separate count concept for relationship analytics
+ * - The backward connection is created first if both=true
+ *
+ * @see {@link CreateConnectionBetweenTwoConceptsGeneral} for the version using reserved IDs
+ * @see {@link CountRelationship} for understanding how relationship counting works
+ * @see {@link MakeTheInstanceConcept} for connection type concept creation
+ */
+export declare function CreateConnectionBetweenTwoConcepts(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean, count?: boolean): Promise<Connection>;
+/**
+ * Maintains a count of relationships for a specific connection type on a concept.
+ *
+ * This function implements a counting mechanism that tracks how many times a particular
+ * relationship type has been used with a concept. It retrieves any existing count,
+ * increments it, creates a new count concept, and connects it to the source concept.
+ *
+ * The counting system works by:
+ * 1. Looking for existing count connections using a special count connection type
+ * 2. Retrieving the current count value from the connected count concept
+ * 3. Incrementing the count
+ * 4. Deleting old count connections
+ * 5. Creating a new count concept with the updated value
+ * 6. Connecting the new count concept back to the source
+ *
+ * This enables analytics like "how many books has this author authored?" or
+ * "how many followers does this user have?"
+ *
+ * @param linker - The relationship name being counted (e.g., "authored_s", "follows_s")
+ * @param concept - The concept for which relationships are being counted
+ * @param passedUserId - Optional user ID to use instead of the concept's userId (default: null, uses concept.userId)
+ *
+ * @returns A promise that resolves when the count has been updated
+ *
+ * @example
+ * ```typescript
+ * // Count how many times an author has "authored" something
+ * const authorConcept = await GetTheConcept(123);
+ * await CountRelationship("authored_s", authorConcept);
+ *
+ * // Later, retrieve the count
+ * const countConnectionType = await GetConceptByCharacter("authors_s_authored_s_count");
+ * const countConnections = await GetConnectionOfTheConcept(
+ *   countConnectionType.id,
+ *   authorConcept.id,
+ *   authorConcept.userId
+ * );
+ * const countConcept = await GetTheConcept(countConnections[0].toTheConceptId);
+ * console.log("Author has written", countConcept.characterValue, "books");
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Count relationships with a specific user ID
+ * const userConcept = await GetTheConcept(456);
+ * await CountRelationship("follows_s", userConcept, 999);
+ * ```
+ *
+ * @remarks
+ * - Count connection type pattern: `{conceptType}_s_{linker}_count`
+ * - Creates a new "count" type concept with the numeric value as characterValue
+ * - Deletes all previous count connections before creating the new one
+ * - If no existing count is found, starts from 1
+ * - If parsing the count value fails, defaults to 0 and increments to 1
+ * - Uses session information ID 999, access level 4, and security ID 999
+ * - The count concept itself is of type "count"
+ *
+ * @see {@link CreateConnectionBetweenTwoConcepts} for functions that use counting
+ * @see {@link GetConnectionOfTheConcept} for retrieving count connections
+ * @see {@link MakeTheInstanceConcept} for creating count concepts
+ */
+export declare function CountRelationship(linker: string, concept: Concept, passedUserId?: number | null): Promise<void>;
+/**
+ * Creates a typed connection with reserved IDs between two concepts.
+ *
+ * This is the production-ready version of CreateConnectionBetweenTwoConcepts that uses
+ * reserved IDs and the CreateTheConnectionGeneral function. It provides the same
+ * semantic connection naming and bidirectional support, but ensures connections are
+ * properly persisted with system-reserved IDs.
+ *
+ * Unlike the basic version, this function uses CreateTheConnectionGeneral instead of
+ * directly creating Connection objects, which means connections get proper ID reservation,
+ * update flags, and transaction tracking.
+ *
+ * @param ofTheConcept - The source concept from which the connection originates
+ * @param toTheConcept - The target concept to which the connection points
+ * @param linker - The semantic relationship name (e.g., "authored", "contains", "belongs_to")
+ * @param both - If true, creates connections in both directions (default: false)
+ * @param count - If true, maintains a count of relationships for this linker type (default: false)
+ *
+ * @returns A promise that resolves to the created forward Connection object with reserved ID
+ *
+ * @example
+ * ```typescript
+ * // Create a production-grade bidirectional "collaborates_with" connection
+ * const researcher1 = await GetTheConcept(123);
+ * const researcher2 = await GetTheConcept(456);
+ *
+ * const connection = await CreateConnectionBetweenTwoConceptsGeneral(
+ *   researcher1,
+ *   researcher2,
+ *   "collaborates_with",
+ *   true,  // Bidirectional
+ *   true   // Track counts
+ * );
+ *
+ * console.log("Connection ID:", connection.id);
+ * // Both researchers now have collaboration connections and counts
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Create a one-way "belongs_to" connection with reserved ID
+ * const itemConcept = await GetTheConcept(789);
+ * const categoryConcept = await GetTheConcept(101);
+ *
+ * await CreateConnectionBetweenTwoConceptsGeneral(
+ *   itemConcept,
+ *   categoryConcept,
+ *   "belongs_to",
+ *   false,
+ *   false
+ * );
+ * ```
+ *
+ * @remarks
+ * - Uses CreateTheConnectionGeneral for proper ID reservation and persistence
+ * - Forward connection type pattern: `{sourceType}_s_{linker}_s`
+ * - Backward connection type pattern: `{targetType}_s_{linker}_by`
+ * - Backward connections still use basic Connection creation (not CreateTheConnectionGeneral)
+ * - Uses session information ID 999, order 1000, and access level 4
+ * - Connection is marked for update (toUpdate = true) via CreateTheConnectionGeneral
+ * - Recommended for production use over CreateConnectionBetweenTwoConcepts
+ *
+ * @see {@link CreateConnectionBetweenTwoConcepts} for the temporary version
+ * @see {@link CreateTheConnectionGeneral} for the underlying connection creation
+ * @see {@link CountRelationship} for relationship counting implementation
+ */
+export declare function CreateConnectionBetweenTwoConceptsGeneral(ofTheConcept: Concept, toTheConcept: Concept, linker: string, both?: boolean, count?: boolean): Promise<Connection>;

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

@@ -0,0 +1,117 @@
+/**
+ * Default Concept Factory
+ *
+ * This module provides utility functions for creating default/empty concept instances
+ * and formatting date values. These utilities are used throughout the system when
+ * initializing concepts or handling date operations.
+ *
+ * @module CreateDefaultConcept
+ */
+import { Concept } from "../DataStructures/Concept";
+/**
+ * Creates a default concept with zero/empty values and current timestamps.
+ *
+ * This factory function is used throughout the system when a concept instance is needed
+ * but not yet populated with real data. It's particularly useful as a placeholder during
+ * concept retrieval operations, initialization, or when a null-safe concept object is required.
+ *
+ * The created concept has all numeric fields set to 0, characterValue set to "0",
+ * isComposition set to false, and timestamps set to the current date/time.
+ *
+ * @returns A new Concept instance with default values
+ *
+ * @example
+ * ```typescript
+ * // Use as a placeholder during concept retrieval
+ * let concept = CreateDefaultConcept();
+ *
+ * try {
+ *   concept = await GetTheConcept(123);
+ * } catch (error) {
+ *   console.log("Using default concept due to error");
+ * }
+ *
+ * if (concept.id === 0) {
+ *   console.log("Concept not found, using default");
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Initialize a concept variable before conditional assignment
+ * let resultConcept = CreateDefaultConcept();
+ *
+ * if (useCache) {
+ *   resultConcept = await ConceptsData.GetConcept(id);
+ * } else {
+ *   resultConcept = await GetConcept(id);
+ * }
+ * ```
+ *
+ * @remarks
+ * - All ID fields (id, typeId, userId, etc.) are set to 0
+ * - characterValue is set to "0" string
+ * - isComposition is set to false
+ * - created_on and updated_on are set to current date/time using formatDate()
+ * - The concept is not added to any data store; it's just an instance
+ * - Commonly used as a null-safe alternative when concept retrieval might fail
+ *
+ * @see {@link formatDate} for the date formatting function used
+ * @see {@link Concept} for the concept data structure
+ */
+export declare function CreateDefaultConcept(): Concept;
+/**
+ * Formats a Date object into a human-readable string with 12-hour time format.
+ *
+ * This utility function converts JavaScript Date objects into a consistent string
+ * format used throughout the CCS system for timestamps. The format includes the date
+ * in MM/DD/YYYY format and time in 12-hour format with AM/PM indicator.
+ *
+ * The function is primarily used for setting created_on and updated_on timestamps
+ * on concepts and connections.
+ *
+ * @param date - The Date object to format
+ *
+ * @returns A formatted date string in the pattern "M/D/YYYY h:mm:ss AM/PM"
+ *
+ * @example
+ * ```typescript
+ * // Format current date
+ * const now = new Date();
+ * const formatted = formatDate(now);
+ * console.log(formatted); // "1/15/2024 3:45:30 PM"
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use when creating a concept
+ * const concept = new Concept(
+ *   123,
+ *   456,
+ *   999,
+ *   // ... other fields
+ *   formatDate(new Date()),  // created_on
+ *   formatDate(new Date())   // updated_on
+ * );
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Format a specific date
+ * const specificDate = new Date(2024, 0, 15, 15, 30, 45);
+ * console.log(formatDate(specificDate)); // "1/15/2024 3:30:45 PM"
+ * ```
+ *
+ * @remarks
+ * - Months are 1-indexed in output (January = 1) but 0-indexed in JavaScript Date
+ * - Uses 12-hour time format with AM/PM
+ * - Minutes and seconds are zero-padded to 2 digits
+ * - Hours are NOT zero-padded (e.g., "3:05 PM" not "03:05 PM")
+ * - Date components are NOT zero-padded (e.g., "1/5/2024" not "01/05/2024")
+ * - Output format: "M/D/YYYY h:mm:ss AM/PM"
+ * - Midnight (00:00) is represented as "12:00 AM"
+ * - Noon (12:00) is represented as "12:00 PM"
+ *
+ * @see {@link CreateDefaultConcept} which uses this function for timestamps
+ */
+export declare function formatDate(date: Date): string;

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

@@ -0,0 +1,103 @@
+/**
+ * Composition Creation Service
+ *
+ * This module provides functionality for converting JSON objects into interconnected
+ * concept structures (compositions) in the Concept Connection System. It recursively
+ * traverses JSON structures and creates corresponding concepts and connections,
+ * effectively serializing complex data structures into the graph database.
+ *
+ * This enables storing and retrieving structured data like user profiles, documents,
+ * or any hierarchical data within the CCS framework.
+ *
+ * @module CreateTheComposition
+ */
+import { Concept } from "../DataStructures/Concept";
+/**
+ * Recursively converts a JSON object into a composition of interconnected concepts.
+ *
+ * This function is the core serialization mechanism for storing structured data in CCS.
+ * It traverses a JSON object recursively, creating concepts for each key-value pair and
+ * establishing connections between them to preserve the hierarchical structure.
+ *
+ * The function handles both object structures (which become nested compositions) and
+ * primitive values (which become leaf concepts with character values). The resulting
+ * structure can be later reconstructed using GetComposition functions.
+ *
+ * The recursion works as follows:
+ * - Object/nested structures: Create a concept for the key, recurse into the value
+ * - Primitive values (string/number): Create a concept with the key as type and value as characterValue
+ * - Root level: If no parent concept is provided, creates a new root concept
+ *
+ * @param json - The JSON object to convert into a composition
+ * @param ofTheConceptId - The ID of the parent concept to connect to (null for root level)
+ * @param ofTheConceptUserId - The user ID of the parent concept (null for root level)
+ * @param mainKey - The ID of the root concept, used as connection type throughout the composition
+ * @param userId - The user ID to assign to all created concepts (default: 999)
+ * @param accessId - The access level for created concepts (default: 4)
+ * @param sessionInformationId - The session ID for tracking this operation (default: 999)
+ *
+ * @returns A promise that resolves to the main (root) Concept of the created composition
+ *
+ * @example
+ * ```typescript
+ * // Create a user profile composition
+ * const userProfile = {
+ *   name: "Alice Johnson",
+ *   age: 30,
+ *   address: {
+ *     street: "123 Main St",
+ *     city: "Springfield",
+ *     country: "USA"
+ *   },
+ *   hobbies: ["reading", "hiking", "photography"]
+ * };
+ *
+ * const rootConcept = await CreateTheComposition(
+ *   userProfile,
+ *   null,  // No parent, this is root
+ *   null,
+ *   null,
+ *   999,   // User ID
+ *   4,     // Access level
+ *   999    // Session ID
+ * );
+ *
+ * console.log("Profile composition created:", rootConcept.id);
+ * // Can later retrieve with: GetComposition(rootConcept.id)
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Add a nested composition to an existing concept
+ * const parentConcept = await GetTheConcept(456);
+ * const metadata = {
+ *   created: "2024-01-15",
+ *   modified: "2024-01-20",
+ *   version: 2
+ * };
+ *
+ * const metadataConcept = await CreateTheComposition(
+ *   metadata,
+ *   parentConcept.id,
+ *   parentConcept.userId,
+ *   parentConcept.id,  // Use parent as mainKey
+ *   parentConcept.userId
+ * );
+ * ```
+ *
+ * @remarks
+ * - Creates concepts for each JSON key, using the key as the concept's type
+ * - Primitive values (strings, numbers) are stored as characterValue in leaf concepts
+ * - Nested objects and arrays are recursively converted into sub-compositions
+ * - All concepts are connected using the mainKey (root concept ID) as the connection type
+ * - Uses temporary connections (via createTheConnection) with random IDs
+ * - Default values: userId=999, accessId=4, sessionInformationId=999
+ * - The function modifies SyncData by adding all created concepts and connections
+ * - Complex objects become type concepts with isComposition=true
+ * - Primitive values become instance concepts with isComposition=false
+ *
+ * @see {@link GetComposition} for reconstructing compositions back to JSON
+ * @see {@link MakeTheInstanceConcept} for individual concept creation
+ * @see {@link createTheConnection} for connection creation logic
+ */
+export default function CreateTheComposition(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null): Promise<Concept>;

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

@@ -0,0 +1,184 @@
+/**
+ * Concept creation service module.
+ * Provides functions for creating concepts in different modes: normal, temporary, and immediate.
+ *
+ * @module Services/CreateTheConcept
+ * @see https://documentation.freeschema.com/#concept for concept documentation
+ */
+import { Concept } from "../DataStructures/Concept";
+import { InnerActions } from "../DataStructures/Transaction/Transaction";
+/**
+ * Creates a new concept and adds it to the sync queue for backend synchronization.
+ * This is the standard way to create a concept that will be persisted to the backend.
+ * The concept is marked as new (isNew=true) and non-temporary (isTemp=false), and
+ * added to both SyncData (for backend sync) and the transaction actions list.
+ *
+ * @param referent - The character/string value representing the concept's content
+ * @param userId - The ID of the user creating this concept
+ * @param categoryId - The ID of the category concept this concept belongs to
+ * @param categoryUserId - The user ID of the category concept owner
+ * @param typeId - The ID of the type concept that defines this concept's type
+ * @param typeUserId - The user ID of the type concept owner
+ * @param referentId - The ID of the referent concept (what this concept refers to)
+ * @param referentUserId - The user ID of the referent concept owner
+ * @param securityId - The ID of the security concept controlling access
+ * @param securityUserId - The user ID of the security concept owner
+ * @param accessId - The ID of the access concept defining permissions
+ * @param accessUserId - The user ID of the access concept owner
+ * @param sessionInformationId - The ID of the session concept for tracking
+ * @param sessionInformationUserId - The user ID of the session concept owner
+ * @param actions - Transaction object to track all concepts and connections created in this operation
+ * @returns A Promise that resolves to the newly created Concept instance
+ *
+ * @example
+ * ```typescript
+ * // Create a new concept with all required metadata
+ * const concept = await CreateTheConcept(
+ *   'John Doe',           // referent (the actual value)
+ *   1,                    // userId
+ *   10, 1,                // categoryId, categoryUserId
+ *   20, 1,                // typeId, typeUserId (e.g., "Person" type)
+ *   0, 0,                 // referentId, referentUserId (no referent)
+ *   30, 1,                // securityId, securityUserId
+ *   40, 1,                // accessId, accessUserId
+ *   50, 1,                // sessionInformationId, sessionInformationUserId
+ *   { concepts: [], connections: [] }  // transaction actions
+ * );
+ *
+ * console.log(concept.id);  // Auto-generated unique ID
+ * console.log(concept.isNew);  // true - will be synced to backend
+ * console.log(concept.isTemp);  // false - permanent concept
+ * ```
+ *
+ * @remarks
+ * - Automatically generates a unique ID using ReservedIds.getId()
+ * - Sets creation and update timestamps to current time
+ * - Marks concept as new (isNew=true) for backend synchronization
+ * - Marks concept as non-temporary (isTemp=false) for persistence
+ * - Adds concept to SyncData queue for eventual backend sync
+ * - Adds concept to transaction actions for tracking within a transaction context
+ * - Does NOT immediately call the backend API; sync happens separately
+ *
+ * @see CreateTheConceptTemporary for creating temporary concepts
+ * @see CreateTheConceptImmediate for creating concepts with immediate backend sync
+ * @see Concept for the concept data structure
+ * @see SyncData for sync queue management
+ * @see ReservedIds for ID generation
+ */
+export default function CreateTheConcept(referent: string, userId: number, categoryId: number, categoryUserId: number, typeId: number, typeUserId: number, referentId: number, referentUserId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number, actions?: InnerActions): Promise<Concept>;
+/**
+ * Creates a temporary concept that is NOT added to the sync queue or persisted to backend.
+ * Temporary concepts are useful for UI state management, draft operations, or transient data
+ * that doesn't need to be saved. The concept is marked as temporary (isTemp=true) and new (isNew=true).
+ *
+ * @param referent - The character/string value representing the concept's content
+ * @param userId - The ID of the user creating this concept
+ * @param categoryId - The ID of the category concept this concept belongs to
+ * @param categoryUserId - The user ID of the category concept owner
+ * @param typeId - The ID of the type concept that defines this concept's type
+ * @param typeUserId - The user ID of the type concept owner
+ * @param referentId - The ID of the referent concept (what this concept refers to)
+ * @param referentUserId - The user ID of the referent concept owner
+ * @param securityId - The ID of the security concept controlling access
+ * @param securityUserId - The user ID of the security concept owner
+ * @param accessId - The ID of the access concept defining permissions
+ * @param accessUserId - The user ID of the access concept owner
+ * @param sessionInformationId - The ID of the session concept for tracking
+ * @param sessionInformationUserId - The user ID of the session concept owner
+ * @returns A Promise that resolves to the newly created temporary Concept instance
+ *
+ * @example
+ * ```typescript
+ * // Create a temporary concept for UI draft state
+ * const draftConcept = await CreateTheConceptTemporary(
+ *   'Draft Note',         // referent
+ *   1,                    // userId
+ *   10, 1,                // categoryId, categoryUserId
+ *   20, 1,                // typeId, typeUserId
+ *   0, 0,                 // referentId, referentUserId
+ *   30, 1,                // securityId, securityUserId
+ *   40, 1,                // accessId, accessUserId
+ *   50, 1                 // sessionInformationId, sessionInformationUserId
+ * );
+ *
+ * console.log(draftConcept.isTemp);  // true - won't be synced
+ * console.log(draftConcept.isNew);   // true - marked as new
+ * // This concept will NOT be added to SyncData or saved to backend
+ * ```
+ *
+ * @remarks
+ * - Automatically generates a unique ID using ReservedIds.getId()
+ * - Sets creation and update timestamps to current time
+ * - Marks concept as new (isNew=true) but also temporary (isTemp=true)
+ * - Does NOT add concept to SyncData (no backend sync)
+ * - Does NOT add concept to transaction actions
+ * - Useful for draft states, temporary UI elements, or client-only data
+ * - The concept exists only in client memory until explicitly converted/saved
+ *
+ * @see CreateTheConcept for creating persistent concepts
+ * @see CreateTheConceptImmediate for creating concepts with immediate backend sync
+ * @see Concept for the concept data structure
+ */
+export declare function CreateTheConceptTemporary(referent: string, userId: number, categoryId: number, categoryUserId: number, typeId: number, typeUserId: number, referentId: number, referentUserId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number): Promise<Concept>;
+/**
+ * Creates a concept and immediately adds it to ConceptsData for instant availability in queries.
+ * Unlike CreateTheConcept, this function adds the concept to the in-memory ConceptsData store
+ * immediately (not just SyncData), making it instantly searchable. It also sets updateRecursion=true
+ * to enable recursive updates. The concept is marked as not new (isNew=false) and non-temporary.
+ *
+ * @param referent - The character/string value representing the concept's content
+ * @param userId - The ID of the user creating this concept
+ * @param categoryId - The ID of the category concept this concept belongs to
+ * @param categoryUserId - The user ID of the category concept owner
+ * @param typeId - The ID of the type concept that defines this concept's type
+ * @param typeUserId - The user ID of the type concept owner
+ * @param referentId - The ID of the referent concept (what this concept refers to)
+ * @param referentUserId - The user ID of the referent concept owner
+ * @param securityId - The ID of the security concept controlling access
+ * @param securityUserId - The user ID of the security concept owner
+ * @param accessId - The ID of the access concept defining permissions
+ * @param accessUserId - The user ID of the access concept owner
+ * @param sessionInformationId - The ID of the session concept for tracking
+ * @param sessionInformationUserId - The user ID of the session concept owner
+ * @param actions - Transaction object to track all concepts and connections created in this operation
+ * @returns A Promise that resolves to the newly created Concept instance
+ *
+ * @example
+ * ```typescript
+ * // Create a concept that's immediately available for queries
+ * const concept = await CreateTheConceptImmediate(
+ *   'Important User',     // referent
+ *   1,                    // userId
+ *   10, 1,                // categoryId, categoryUserId
+ *   20, 1,                // typeId, typeUserId
+ *   0, 0,                 // referentId, referentUserId
+ *   30, 1,                // securityId, securityUserId
+ *   40, 1,                // accessId, accessUserId
+ *   50, 1,                // sessionInformationId, sessionInformationUserId
+ *   { concepts: [], connections: [] }  // transaction actions
+ * );
+ *
+ * // Concept is immediately available in ConceptsData
+ * const found = ConceptsData.getConceptById(concept.id);
+ * console.log(found !== null);  // true - immediately findable
+ * console.log(concept.isNew);   // false - treated as existing
+ * console.log(concept.updateRecursion);  // true - enables recursive updates
+ * ```
+ *
+ * @remarks
+ * - Automatically generates a unique ID using ReservedIds.getId()
+ * - Sets creation and update timestamps to current time
+ * - Marks concept as NOT new (isNew=false) - treated as existing concept
+ * - Marks concept as non-temporary (isTemp=false)
+ * - Adds concept to ConceptsData immediately for instant query availability
+ * - Sets updateRecursion=true to enable recursive composition updates
+ * - Adds concept to SyncData for backend synchronization
+ * - Adds concept to transaction actions for tracking
+ * - The commented-out line suggests this previously triggered immediate API sync
+ *
+ * @see CreateTheConcept for standard concept creation with delayed sync
+ * @see CreateTheConceptTemporary for creating temporary concepts
+ * @see ConceptsData for the in-memory concept store
+ * @see SyncData for sync queue management
+ */
+export declare function CreateTheConceptImmediate(referent: string, userId: number, categoryId: number, categoryUserId: number, typeId: number, typeUserId: number, referentId: number, referentUserId: number, securityId: number, securityUserId: number, accessId: number, accessUserId: number, sessionInformationId: number, sessionInformationUserId: number, actions?: InnerActions): Promise<Concept>;