mftsccs-node 0.0.56 → 0.0.58

package/dist/types/Services/Security/GetRequestHeader.d.ts

@@ -0,0 +1,10 @@
+export declare function GetRequestHeader(contentType?: string, Accept?: string): {
+    'Content-Type': string;
+    Authorization: string;
+    Accept: string;
+};
+export declare function GetRequestHeaderWithAuthorization(contentType?: string, token?: string, Accept?: string): {
+    'Content-Type': string;
+    Authorization: string;
+    Accept: string;
+};

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

@@ -0,0 +1,51 @@
+/**
+ * @fileoverview String utility module for splitting type strings in the CCS-JS system.
+ * This module provides functionality to parse type strings that follow a naming convention
+ * with underscore separators, commonly used for identifying concept types and their relationships.
+ * @module Services/SplitStrings
+ */
+/**
+ * Splits a type string into component parts based on the last underscore delimiter.
+ *
+ * This function is used throughout the CCS-JS system to parse type identifiers that follow
+ * a naming convention where the last underscore separates the base type from its suffix.
+ * For example, "concept_type_123" would be split into ["concept_type", "123"].
+ *
+ * The function uses the last occurrence of underscore as the split point, which allows
+ * for type names that contain underscores themselves. If no underscore is found, the
+ * original string is returned as a single-element array.
+ *
+ * @param typeString - The type identifier string to be split
+ * @returns An array containing the split components. Returns a two-element array [prefix, suffix]
+ *          if an underscore is found, or a single-element array [typeString] if no underscore exists.
+ *
+ * @example
+ * ```typescript
+ * // Split a composite type string
+ * const result = SplitStrings("user_profile_123");
+ * // Returns: ["user_profile", "123"]
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Handle string without underscore
+ * const result = SplitStrings("simpleType");
+ * // Returns: ["simpleType"]
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Split concept type identifier
+ * const result = SplitStrings("concept_type");
+ * // Returns: ["concept", "type"]
+ * ```
+ *
+ * @remarks
+ * The function specifically uses `lastIndexOf("_")` to find the splitting point, which means:
+ * - Only the last underscore is considered for splitting
+ * - All underscores before the last one remain part of the first element
+ * - The position check (pos > 0) ensures underscore is not the first character
+ *
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf | String.lastIndexOf}
+ */
+export declare function SplitStrings(typeString: string): string[];

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

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview Composition update service for the CCS-JS system.
+ * This module provides comprehensive functionality for updating composition structures,
+ * managing the complex process of patching objects into compositions, handling nested
+ * compositions, updating caches, and synchronizing changes with the backend.
+ * @module Services/UpdateComposition
+ */
+import { PatcherStructure } from '../DataStructures/PatcherStructure';
+/**
+ * Updates an existing composition by patching new data into it while maintaining cache consistency.
+ *
+ * This is a core function in the CCS-JS system that handles the complex process of updating
+ * compositions. It performs the following operations:
+ * 1. Retrieves the current composition and all its connections from the backend
+ * 2. Processes the patch object to create new concepts and connections
+ * 3. Identifies and removes outdated concepts and connections
+ * 4. Updates the composition cache and binary tree structure
+ * 5. Synchronizes changes with the backend
+ *
+ * The function handles both simple value updates and complex nested composition updates.
+ * It ensures data consistency by managing connection deletions, concept replacements, and
+ * cache invalidation across distributed servers.
+ *
+ * @param patcherStructure - Structure containing all necessary information for the update operation
+ *                           including compositionId, patchObject, userId, sessionId, and accessId
+ * @returns A promise that resolves to the updated composition cache data, or null if the composition
+ *          cannot be found or updated. The returned data includes the updated concepts, connections,
+ *          and subcompositions.
+ *
+ * @example
+ * ```typescript
+ * // Update a simple composition with new values
+ * import UpdateComposition from './UpdateComposition';
+ * import { PatcherStructure } from '../DataStructures/PatcherStructure';
+ *
+ * const patcher: PatcherStructure = {
+ *   compositionId: 123,
+ *   patchObject: { name: "Updated Name", age: 30 },
+ *   userId: 456,
+ *   sessionId: 999,
+ *   accessId: 4
+ * };
+ *
+ * const result = await UpdateComposition(patcher);
+ * console.log(result); // Updated composition data
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Update a nested composition
+ * const patcher: PatcherStructure = {
+ *   compositionId: 123,
+ *   ofTheCompositionId: 789, // Parent concept ID for nested update
+ *   patchObject: {
+ *     profile: {
+ *       firstName: "John",
+ *       lastName: "Doe"
+ *     },
+ *     settings: {
+ *       theme: "dark"
+ *     }
+ *   },
+ *   userId: 456,
+ *   sessionId: 999,
+ *   accessId: 4
+ * };
+ *
+ * const result = await UpdateComposition(patcher);
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Handle local concept conversion (negative ID to positive ID)
+ * const patcher: PatcherStructure = {
+ *   compositionId: -123, // Local concept ID
+ *   patchObject: { status: "active" },
+ *   userId: 456,
+ *   sessionId: 999,
+ *   accessId: 4
+ * };
+ *
+ * const result = await UpdateComposition(patcher);
+ * // Function will convert local ID to server ID before updating
+ * ```
+ *
+ * @remarks
+ * Complex behavior and important considerations:
+ *
+ * **Local Concept Handling:**
+ * - If compositionId is negative (local concept), the function attempts to find the persisted version
+ * - Returns null if the local concept hasn't been synced to the server yet
+ *
+ * **Cache Management:**
+ * - Marks the composition as "updating" to signal distributed servers to invalidate their cache
+ * - Rebuilds the composition cache with all updated concepts and connections
+ * - Updates the CompositionBinaryTree for fast access
+ *
+ * **Connection Management:**
+ * - Identifies existing concepts that match the new concepts being added
+ * - Removes old connections to those concepts before creating new ones
+ * - Deletes connections in bulk for efficiency
+ *
+ * **Nested Compositions:**
+ * - Supports updating subcompositions via the ofTheCompositionId parameter
+ * - Creates new composition concepts for object/array values
+ * - Recursively processes nested structures
+ *
+ * **Synchronization:**
+ * - Calls SyncData.SyncDataOnline() to push changes to the backend
+ * - Ensures consistency across distributed system
+ *
+ * **Performance Considerations:**
+ * - Fetches all connections from backend for latest data
+ * - Processes deletions and additions in batch
+ * - Uses caching to minimize redundant database queries
+ *
+ * @see {@link PatcherStructure} for the structure of the patcher parameter
+ * @see {@link CreateTheCompositionWithCache} for creating nested compositions
+ * @see {@link GetTheConcept} for concept retrieval
+ * @see {@link MakeTheInstanceConcept} for creating new concept instances
+ * @see {@link createTheConnection} for creating connections between concepts
+ * @see {@link DeleteConnectionById} for connection deletion
+ * @see {@link SyncData.SyncDataOnline} for backend synchronization
+ */
+export default function UpdateComposition(patcherStructure: PatcherStructure): Promise<any>;

package/dist/types/Services/User/UserTranslation.d.ts

@@ -0,0 +1,108 @@
+/**
+ * @module UserTranslation
+ * @description Provides functions to translate between ghost IDs and real IDs for user-specific concepts and connections
+ */
+import { LConcept } from './../../DataStructures/Local/LConcept';
+import { LConnection } from '../../app';
+/**
+ * Retrieves a local concept (LConcept) by its ghost ID for a specific user.
+ * Ghost IDs are temporary IDs used before concepts are persisted.
+ *
+ * @async
+ * @param {number} userId - The user ID who owns the concept
+ * @param {number} ghostId - The temporary ghost ID of the concept
+ * @param {number} [sessionId=999] - The session ID (defaults to 999)
+ * @param {number} [randomizer=999] - Additional randomizer for tree lookup (defaults to 999)
+ * @returns {Promise<LConcept>} A promise that resolves to the LConcept, or default empty concept if not found
+ *
+ * @example
+ * ```typescript
+ * const userId = 1;
+ * const ghostId = 12345;
+ * const concept = await GetUserGhostId(userId, ghostId);
+ * if (concept.id !== 0) {
+ *   console.log("Found concept with real ID:", concept.id);
+ * }
+ * ```
+ *
+ * @remarks
+ * - Searches the UserBinaryTree for the user's concepts
+ * - Returns default empty LConcept if user or concept not found
+ * - Used during concept creation before IDs are assigned
+ * - Ghost IDs are temporary until persisted to backend
+ */
+export declare function GetUserGhostId(userId: number, ghostId: number, sessionId?: number, randomizer?: number): Promise<LConcept>;
+/**
+ * Retrieves a local connection (LConnection) by its ghost ID for a specific user.
+ * Ghost IDs are temporary IDs used before connections are persisted.
+ *
+ * @async
+ * @param {number} userId - The user ID who owns the connection
+ * @param {number} ghostId - The temporary ghost ID of the connection
+ * @param {number} [sessionId=999] - The session ID (defaults to 999)
+ * @param {number} [randomizer=999] - Additional randomizer for tree lookup (defaults to 999)
+ * @returns {Promise<LConnection>} A promise that resolves to the LConnection, or default empty connection if not found
+ *
+ * @example
+ * ```typescript
+ * const userId = 1;
+ * const connectionGhostId = 67890;
+ * const connection = await GetUserGhostConnectionId(userId, connectionGhostId);
+ * if (connection.id !== 0) {
+ *   console.log("Found connection with real ID:", connection.id);
+ * }
+ * ```
+ *
+ * @remarks
+ * - Similar to GetUserGhostId but for connections instead of concepts
+ * - Searches UserBinaryTree's connection values
+ * - Returns default empty LConnection if not found
+ * - Used during connection creation before IDs are assigned
+ */
+export declare function GetUserGhostConnectionId(userId: number, ghostId: number, sessionId?: number, randomizer?: number): Promise<LConnection>;
+/**
+ * Adds a ghost concept to the UserBinaryTree for temporary storage.
+ * Stores concepts with ghost IDs before they are persisted.
+ *
+ * @async
+ * @param {LConcept} concept - The local concept to add
+ * @param {number} userId - The user ID who owns the concept
+ * @param {number} [sessionId=999] - The session ID (defaults to 999)
+ *
+ * @example
+ * ```typescript
+ * const ghostConcept: LConcept = {
+ *   ghostId: 12345,
+ *   characterValue: "Test",
+ *   ...
+ * };
+ * await AddGhostConcept(ghostConcept, 1, 999);
+ * ```
+ *
+ * @remarks
+ * - Stores concept in UserBinaryTree indexed by userId and sessionId
+ * - Used for optimistic UI updates before backend persistence
+ * - No return value (void function)
+ */
+export declare function AddGhostConcept(concept: LConcept, userId: number, sessionId?: number): Promise<void>;
+/**
+ * Adds a ghost connection to the UserBinaryTree for temporary storage.
+ * Stores connections with ghost IDs before they are persisted.
+ *
+ * @async
+ * @param {LConnection} connection - The local connection to add
+ * @param {number} userId - The user ID who owns the connection
+ * @param {number} [sessionId=999] - The session ID (defaults to 999)
+ *
+ * @example
+ * ```typescript
+ * const ghostConnection: LConnection = new LConnection(0, 12345, 123, 456, 999, 999);
+ * await AddGhostConnection(ghostConnection, 1, 999);
+ * ```
+ *
+ * @remarks
+ * - Stores connection in UserBinaryTree indexed by userId and sessionId
+ * - Used for optimistic UI updates before backend persistence
+ * - No return value (void function)
+ */
+export declare function AddGhostConnection(connection: LConnection, userId: number, sessionId?: number): Promise<void>;

package/dist/types/Services/View/ViewInternalData.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @module ViewInternalData
+ * @description Provides functionality to view and format internal composition data for multiple concepts
+ */
+/**
+ * Retrieves and formats internal data for multiple concepts by their IDs.
+ * Fetches internal connections and builds composition structures for each concept.
+ *
+ * @async
+ * @param {number[]} ids - Array of concept IDs to retrieve internal data for
+ * @returns {Promise<any[]>} A promise that resolves to array of formatted composition objects with id and data fields
+ *
+ * @example
+ * ```typescript
+ * const conceptIds = [123, 456, 789];
+ * const internalData = await ViewInternalData(conceptIds);
+ * // internalData = [
+ * //   { id: 123, data: { user: { name: "John", email: "john@example.com" } } },
+ * //   { id: 456, data: { post: { title: "Hello", content: "World" } } },
+ * //   { id: 789, data: { type: "value" } }
+ * // ]
+ * ```
+ *
+ * @remarks
+ * This function:
+ * - Fetches internal connections for all provided concept IDs
+ * - For concepts with connections: builds composition structure using recursiveFetch
+ * - For concepts without connections: returns concept's type and character value
+ * - Each result includes id field and data field
+ * - Handles missing connections gracefully
+ * - Useful for viewing composition internals in list format
+ */
+export declare function ViewInternalData(ids: number[]): Promise<any[]>;

package/dist/types/WrapperFunctions/SchemaQueryObservable.d.ts

@@ -0,0 +1,159 @@
+/**
+ * @fileoverview Observable wrapper for schema query operations in the CCS-JS system.
+ * @module WrapperFunctions/SchemaQueryObservable
+ */
+import { FreeschemaQuery } from "../DataStructures/Search/FreeschemaQuery";
+/**
+ * Observable wrapper for handling multiple linked concept searches.
+ *
+ * @remarks
+ * SearchLinkMultipleAllObservable encapsulates the state and configuration for executing
+ * schema queries that retrieve multiple linked concepts. It maintains query parameters,
+ * formatting options, and the results of API calls including concept IDs, internal
+ * connections, linkers, and other relationship data.
+ *
+ * This class is designed to work with the FreeschemaQuery system and can format results
+ * in various output formats (NORMAL, DATAID, JUSTDATA, ALLID).
+ *
+ * @example
+ * ```typescript
+ * const query = new FreeschemaQuery();
+ * query.outputFormat = DATAID;
+ * query.order = "ASC";
+ *
+ * const observable = new SearchLinkMultipleAllObservable(query, "auth-token");
+ * console.log(observable.format); // DATAID
+ * console.log(observable.order); // "ASC"
+ * ```
+ */
+export declare class SearchLinkMultipleAllObservable {
+    /**
+     * Array of main composition IDs retrieved from the query.
+     * @defaultValue []
+     */
+    mainCompositionIds: number[];
+    /**
+     * The FreeschemaQuery object containing query parameters and configuration.
+     * @defaultValue new FreeschemaQuery()
+     */
+    query: FreeschemaQuery;
+    /**
+     * Array of encoded count information strings returned from the API.
+     * @defaultValue []
+     */
+    countInfoStrings: string[];
+    /**
+     * Sort order for the query results.
+     * @defaultValue "DESC"
+     */
+    order: string;
+    /**
+     * Output format for the query results.
+     * @defaultValue DATAID
+     *
+     * @remarks
+     * Valid values include NORMAL, DATAID, JUSTDATA, and ALLID from FormatConstants.
+     */
+    format: number;
+    /**
+     * Flag indicating whether data has been loaded from the API.
+     * @defaultValue false
+     */
+    isDataLoaded: boolean;
+    /**
+     * Array of concept IDs retrieved from the query.
+     * @defaultValue []
+     */
+    conceptIds: number[];
+    /**
+     * Array of internal connection IDs showing relationships between concepts.
+     * @defaultValue []
+     */
+    internalConnections: number[];
+    /**
+     * Array of linker IDs representing the types of connections.
+     * @defaultValue []
+     */
+    linkers: number[];
+    /**
+     * Array of reverse relationship indicators.
+     * @defaultValue []
+     */
+    reverse: number[];
+    /**
+     * The processed data result from the query.
+     *
+     * @remarks
+     * The structure and content of this property depends on the format setting.
+     */
+    data: any;
+    /**
+     * Creates a new SearchLinkMultipleAllObservable instance.
+     *
+     * @param query - The FreeschemaQuery object containing query parameters
+     * @param token - Authentication token for API requests (currently unused in constructor)
+     *
+     * @remarks
+     * The constructor initializes the observable with the provided query and extracts
+     * the output format and order settings from the query object. The token parameter
+     * is accepted but not currently stored or used within the constructor.
+     *
+     * @example
+     * ```typescript
+     * const query = new FreeschemaQuery();
+     * query.outputFormat = JUSTDATA;
+     * query.order = "ASC";
+     *
+     * const observable = new SearchLinkMultipleAllObservable(query, "my-token");
+     * console.log(observable.format); // JUSTDATA
+     * console.log(observable.order); // "ASC"
+     * ```
+     */
+    constructor(query: FreeschemaQuery, token: string);
+}
+/**
+ * Executes a schema query and formats the results according to the specified output format.
+ *
+ * @param query - The FreeschemaQuery object containing query parameters and configuration
+ * @param token - Authentication token for API requests
+ * @returns Promise resolving to formatted query results (structure varies by output format)
+ *
+ * @remarks
+ * This function serves as the main entry point for executing schema queries. It performs
+ * the following operations:
+ * 1. Temporarily changes the output format to ALLID to retrieve all relationship data
+ * 2. Calls the FreeschemaQueryApi to execute the query
+ * 3. Extracts concept IDs, connections, linkers, and metadata from the result
+ * 4. Decodes count information strings
+ * 5. Formats the data according to the original output format setting
+ *
+ * The function supports three output formats:
+ * - DATAID: Formatted with data IDs included
+ * - JUSTDATA: Formatted with only data, no IDs
+ * - NORMAL (or any other value): Standard formatting
+ *
+ * @example
+ * ```typescript
+ * // Create and configure a query
+ * const query = new FreeschemaQuery();
+ * query.outputFormat = DATAID;
+ * query.order = "DESC";
+ * // ... set other query parameters
+ *
+ * // Execute the query
+ * const results = await SchemaQueryListener(query, "auth-token");
+ * console.log(results); // Formatted results based on DATAID format
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Query with JUSTDATA format
+ * const query = new FreeschemaQuery();
+ * query.outputFormat = JUSTDATA;
+ * query.order = "ASC";
+ *
+ * const results = await SchemaQueryListener(query, "my-token");
+ * // Results contain only data without IDs
+ * ```
+ */
+export declare function SchemaQueryListener(query: FreeschemaQuery, token: string): Promise<any>;

package/dist/types/app.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Main application module for the Concept Connection System (CCS-JS).
+ * This module serves as the primary entry point and exports all public-facing APIs,
+ * data structures, and utilities for managing concepts, connections, and compositions.
+ *
+ * @module app
+ * @see {@link https://documentation.freeschema.com} for detailed documentation
+ */
+export { init, updateAccessToken };
+export { SplitStrings } from './Services/SplitStrings';
+export { GetCompositionList, GetCompositionListWithId } from './Services/GetCompositionList';
+export { GetCompositionListLocal, GetCompositionListLocalWithId } from './Services/Local/GetCompositionListLocal';
+export { GetAllConnectionsOfComposition } from './Api/GetAllConnectionsOfComposition';
+export { GetComposition, GetCompositionWithId, recursiveFetch, GetCompositionWithAllIds } from './Services/GetComposition';
+export { GetCompositionLocal, GetCompositionLocalWithId } from './Services/Local/GetCompositionLocal';
+export { default as CreateComposition } from './Services/CreateTheComposition';
+export { CreateTheCompositionLocal } from './Services/Local/CreateTheCompositionLocal';
+export { CreateConnectionBetweenTwoConcepts, CreateConnectionBetweenTwoConceptsGeneral } from './Services/CreateConnectionBetweenTwoConcepts';
+export { default as GetTheConcept } from './Services/GetTheConcept';
+export { default as MakeTheInstanceConcept } from './Services/MakeTheInstanceConcept';
+export { MakeTheInstanceConceptLocal } from './Services/Local/MakeTheInstanceConceptLocal';
+export { storeToDatabase, getFromDatabaseWithType, getFromDatabaseWithTypeOld } from './Database/NoIndexDb';
+export { createTheConnection as CreateTheConnection } from './Services/CreateTheConnection';
+export { default as GetConceptByCharacter } from './Services/GetConceptByCharacter';
+export { GetLink, GetLinkRaw } from './Services/GetLink';
+export { CreateDefaultConcept } from './Services/CreateDefaultConcept';
+export { MakeTheTypeConcept } from './Services/MakeTheTypeConcept';
+export { MakeTheTypeConceptApi } from './Api/MakeTheTypeConceptApi';
+export { GetLinkerConnectionFromConcepts, GetLinkerConnectionToConcepts } from './Services/GetLinkerConnectionFromConcept';
+export { DeleteConceptById } from './Services/DeleteConcept';
+export { DeleteConnectionById } from './Services/DeleteConnection';
+export { TrashTheConcept } from './Api/Delete/DeleteConceptInBackend';
+export { GetConnectionById } from './Services/GetConnections';
+export { MakeTheTimestamp } from './Services/MakeTheTimestamp';
+export { RecursiveSearchApi } from './Api/RecursiveSearch';
+export { GetCompositionBulkWithDataId, GetCompositionBulk, GetCompositionFromConnectionsWithDataId } from './Services/GetCompositionBulk';
+export { GetConceptBulk } from './Api/GetConceptBulk';
+export { GetConnectionBulk } from './Api/GetConnectionBulk';
+export { GetAllConnectionsOfCompositionBulk } from './Api/GetAllConnectionsOfCompositionBulk';
+export { LoginToBackend } from './Api/Login';
+export { GetConnectionOfTheConcept } from './Api/GetConnectionOfTheConcept';
+export { default as Signup } from './Api/Signup';
+export { default as Signin } from './Api/Signin';
+export { default as UpdateComposition } from './Services/UpdateComposition';
+export { SearchAllConcepts } from './Api/Search/Search';
+export { SearchWithLinker } from './Api/Search/SearchWithLinker';
+export { GetCompositionWithCache, GetCompositionWithDataIdWithCache, GetCompositionWithDataIdBulk } from './Services/Composition/CompositionCache';
+export { CreateSession } from './Api/Session/CreateSession';
+export { CreateSessionVisit } from './Api/Session/CreateSessionVisit';
+export {} from './Api/GetConceptByCharacterAndType';
+export { GetRelation, GetRelationRaw } from './Services/GetRelation';
+export { recursiveFetchNew } from './Services/Composition/BuildComposition';
+export { CreateTheCompositionWithCache } from './Services/Composition/CreateCompositionCache';
+export { CreateDefaultLConcept } from './Services/Local/CreateDefaultLConcept';
+export { CreateTheConnectionGeneral, CreateConnection } from './Services/CreateTheConnectionGeneral';
+export { CreateTheConnectionLocal } from './Services/Local/CreateTheConnectionLocal';
+export { GetUserGhostId, AddGhostConcept, GetUserGhostConnectionId, AddGhostConnection } from './Services/User/UserTranslation';
+export { SearchLinkMultipleAll, FormatFromConnections } from './Services/Search/SearchLinkMultiple';
+export { UpdateCompositionLocal } from './Services/Local/UpdateCompositionLocal';
+export { GetCompositionFromConnectionsWithDataIdInObject } from './Services/GetCompositionBulk';
+export { ViewInternalData } from './Services/View/ViewInternalData';
+export { convertFromLConceptToConcept } from './Services/Conversion/ConvertConcepts';
+export { SearchLinkInternal } from './Services/Search/SearchLinkInternal';
+export { HandleHttpError } from './Services/Common/ErrorPosting';
+export { GetConceptByCharacterAndType } from './Api/GetConceptByCharacterAndType';
+export { GetConceptByCharacterAndCategoryDirectApi } from './Api/SearchConcept/GetConceptByCharacterAndCategoryDirect';
+export { SearchLinkMultipleApi } from './Api/Search/SearchLinkMultipleApi';
+export { GetCompositionWithIdFromMemoryFromConnections, GetCompositionWithIdFromMemory } from './Services/GetComposition';
+export { GetConceptByTypeBulk } from './Api/GetConceptByCharacterAndType';
+export { DeleteConnectionByTypeBulk, GetConnectionByTypeBulk } from './Services/Delete/DeleteConnectionByType';
+export { SyncData } from './DataStructures/SyncData';
+export { Concept } from './DataStructures/Concept';
+export { LConcept } from './DataStructures/Local/LConcept';
+export { LConnection } from './DataStructures/Local/LConnection';
+export { Connection } from './DataStructures/Connection';
+export { ConceptsData } from './DataStructures/ConceptData';
+export { ConnectionData } from './DataStructures/ConnectionData';
+export { BinaryTree } from './DataStructures/BinaryTree';
+export { SearchQuery } from './DataStructures/SearchQuery';
+export { SignupModel } from './DataStructures/SignupModel';
+export { SigninModel } from './DataStructures/SigninModel';
+export { FreeschemaResponse } from './DataStructures/Responses/StandardResponses';
+export { PatcherStructure } from './DataStructures/PatcherStructure';
+export { SessionData } from './DataStructures/Session/SessionData';
+export { Composition } from './DataStructures/Composition/Composition';
+export { CompositionBinaryTree } from './DataStructures/Composition/CompositionBinaryTree';
+export { CompositionNode } from './DataStructures/Composition/CompositionNode';
+export { UserBinaryTree } from './DataStructures/User/UserBinaryTree';
+export { FilterSearch } from './DataStructures/FilterSearch';
+export { SearchStructure } from './DataStructures/Search/SearchStructure';
+export { FreeSchemaResponse } from './DataStructures/Responses/ErrorResponse';
+export { BaseUrl } from './DataStructures/BaseUrl';
+export { SchemaQueryListener } from './WrapperFunctions/SchemaQueryObservable';
+export { FreeschemaQuery } from './DataStructures/Search/FreeschemaQuery';
+export { GiveConnection, GetAllTheConnectionsByTypeAndOfTheConcept } from './Services/Delete/GetAllConnectionByType';
+export { DATAID, NORMAL, JUSTDATA, ALLID, DATAIDDATE, RAW, LISTNORMAL } from './Constants/FormatConstants';
+export { Transaction } from './DataStructures/Transaction/Transaction';
+/**
+ * Updates the bearer access token used for authenticating API requests to the backend.
+ * This token is stored globally and used by all API calls that require authentication.
+ *
+ * @param accessToken - The new bearer access token to use for API authentication. Defaults to empty string if not provided.
+ *
+ * @example
+ * ```typescript
+ * // Update the access token after user login
+ * updateAccessToken('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...');
+ * ```
+ *
+ * @see TokenStorage for token storage implementation
+ * @see https://documentation.freeschema.com for authentication details
+ */
+declare function updateAccessToken(accessToken?: string): void;
+/**
+ * Initializes the Concept Connection System with backend URLs and authentication.
+ * This is the primary initialization function that must be called before using any CCS features.
+ * It performs the following operations asynchronously:
+ *
+ * 1. Sets up base URLs for the main API and AI services
+ * 2. Stores the authentication token for API requests
+ * 3. Initializes the system (database setup)
+ * 4. Creates binary trees from concept data for efficient querying (by ID, character, and type)
+ * 5. Creates local binary trees for offline/local concept management
+ * 6. Loads connection data from IndexedDB into memory
+ * 7. Loads local connection data for offline operations
+ *
+ * All data loading operations run in parallel for optimal performance. The IdentifierFlags
+ * are updated as each operation completes to indicate which data structures are ready for use.
+ *
+ * @param url - The base URL for the main backend API endpoint (e.g., 'https://api.example.com')
+ * @param aiurl - The base URL for the AI service endpoint (e.g., 'https://ai.example.com')
+ * @param accessToken - The bearer access token for authenticating API requests
+ *
+ * @example
+ * ```typescript
+ * // Initialize the system with backend URLs and auth token
+ * init(
+ *   'https://api.freeschema.com',
+ *   'https://ai.freeschema.com',
+ *   'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...'
+ * );
+ *
+ * // After initialization, check if data is loaded before querying
+ * if (IdentifierFlags.isDataLoaded) {
+ *   // Safe to query concepts
+ * }
+ * ```
+ *
+ * @remarks
+ * The initialization process is asynchronous but does not return a Promise. Instead,
+ * it uses IdentifierFlags to signal when different components are ready:
+ * - `isDataLoaded`, `isCharacterLoaded`, `isTypeLoaded` - Remote concept data ready
+ * - `isLocalDataLoaded`, `isLocalTypeLoaded`, `isLocalCharacterLoaded` - Local concept data ready
+ * - `isConnectionLoaded`, `isConnectionTypeLoaded` - Remote connection data ready
+ * - `isLocalConnectionLoaded` - Local connection data ready
+ *
+ * @see IdentifierFlags for checking initialization status
+ * @see InitializeSystem for database initialization details
+ * @see CreateBinaryTreeFromData for concept tree creation
+ * @see https://documentation.freeschema.com/#installation for setup guide
+ */
+declare function init(url?: string, aiurl?: string, accessToken?: string): void;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mftsccs-node",
-  "version": "0.0.56",
+  "version": "0.0.58",
   "environment": "production",
   "description": "Full Pack of concept and connection system",
   "main": "dist/bundle.js",