mftsccs-node 0.0.57 → 0.0.58

package/dist/types/Services/Conversion/ConvertConcepts.d.ts

@@ -1,7 +1,90 @@
+/**
+ * @module ConvertConcepts
+ * @description Provides conversion functions between Concept/Connection and LConcept/LConnection (local versions)
+ */
 import { Concept } from "../../DataStructures/Concept";
 import { Connection } from "../../DataStructures/Connection";
 import { LConcept } from "../../DataStructures/Local/LConcept";
 import { LConnection } from "../../DataStructures/Local/LConnection";
+/**
+ * Converts a standard Concept to a Local Concept (LConcept).
+ * LConcepts include additional properties for local/optimistic operations.
+ *
+ * @param {Concept} concept - The standard Concept to convert
+ * @returns {LConcept} The converted LConcept with all properties mapped
+ *
+ * @example
+ * ```typescript
+ * const concept: Concept = {
+ *   id: 123,
+ *   characterValue: "John",
+ *   typeId: 456,
+ *   ...
+ * };
+ * const lConcept = convertFromConceptToLConcept(concept);
+ * // lConcept includes all concept properties plus isTemp, typeCharacter
+ * ```
+ *
+ * @remarks
+ * - Maps all standard Concept properties to LConcept
+ * - Sets isTemp to false (not a temporary concept)
+ * - Includes typeCharacter from concept.type.characterValue
+ * - Used when loading concepts from backend into local cache
+ * - LConcepts are used for optimistic UI updates
+ */
 export declare function convertFromConceptToLConcept(concept: Concept): LConcept;
+/**
+ * Converts a Local Concept (LConcept) back to a standard Concept.
+ * Used when persisting local concepts to the backend.
+ *
+ * @param {LConcept} lconcept - The LConcept to convert
+ * @returns {Concept} The converted standard Concept
+ *
+ * @example
+ * ```typescript
+ * const lConcept: LConcept = {
+ *   id: 123,
+ *   ghostId: 456,
+ *   characterValue: "John",
+ *   isTemp: true,
+ *   ...
+ * };
+ * const concept = convertFromLConceptToConcept(lConcept);
+ * // concept is now a standard Concept without local-specific properties
+ * ```
+ *
+ * @remarks
+ * - Maps LConcept properties back to standard Concept
+ * - Drops local-specific properties (isTemp, typeCharacter)
+ * - Used when saving concepts to backend
+ * - Reverse operation of convertFromConceptToLConcept
+ */
 export declare function convertFromLConceptToConcept(lconcept: LConcept): Concept;
+/**
+ * Converts a standard Connection to a Local Connection (LConnection).
+ * LConnections include additional properties for local/optimistic operations.
+ *
+ * @param {Connection} connection - The standard Connection to convert
+ * @returns {LConnection} The converted LConnection with all properties mapped
+ *
+ * @example
+ * ```typescript
+ * const connection: Connection = {
+ *   id: 789,
+ *   ofTheConceptId: 123,
+ *   toTheConceptId: 456,
+ *   typeId: 999,
+ *   ...
+ * };
+ * const lConnection = convertFromConnectionToLConnection(connection);
+ * // lConnection includes all connection properties plus isTemp flag
+ * ```
+ *
+ * @remarks
+ * - Maps all standard Connection properties to LConnection
+ * - Sets isTemp to false (not a temporary connection)
+ * - Used when loading connections from backend into local cache
+ * - LConnections are used for optimistic UI updates
+ * - Enables local connection management before backend persistence
+ */
 export declare function convertFromConnectionToLConnection(connection: Connection): LConnection;

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

@@ -1 +1,39 @@
+/**
+ * Binary Tree Data Loading Service
+ *
+ * This module provides functionality for creating and populating binary tree data structures
+ * from persisted concept data stored in IndexedDB. It loads concept records and adds them
+ * to in-memory data structures for efficient access and querying.
+ *
+ * @module CreateBinaryTreeFromData
+ */
+/**
+ * Creates and populates a binary tree structure from concept data stored in the database.
+ *
+ * This function loads all concept records from IndexedDB and adds them to the in-memory
+ * ConceptsData structure for fast retrieval and manipulation. It measures the time taken
+ * to load all concepts for performance monitoring purposes.
+ *
+ * The function retrieves all records of type "concept" from the database and iterates through
+ * them, adding each concept to the ConceptsData memory structure. Note that the actual binary
+ * tree node creation is currently commented out, with only memory storage being active.
+ *
+ * @returns A promise that resolves when all concepts have been loaded into memory
+ *
+ * @example
+ * ```typescript
+ * // Initialize the binary tree with database data
+ * await CreateBinaryTreeFromData();
+ * console.log('Binary tree populated from database');
+ * ```
+ *
+ * @remarks
+ * - Performance is tracked using start and end timestamps
+ * - The actual BinaryTree node creation (lines 14-15) is commented out in current implementation
+ * - Only adds concepts to ConceptsData memory structure, not to the BinaryTree itself
+ * - Time measurement variables (startTime, endTime, time) are calculated but not returned or logged
+ *
+ * @see {@link ConceptsData.AddConceptToMemory} for how concepts are stored in memory
+ * @see {@link getFromDatabaseWithTypeOld} for database retrieval implementation
+ */
 export default function CreateBinaryTreeFromData(): Promise<void>;

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

@@ -1 +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

@@ -1,5 +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

@@ -1,3 +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

@@ -1,2 +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>;