mftsccs-node 0.2.7 → 0.2.8

package/dist/types/Services/Search/SearchWithTypeAndLinker.d.ts

@@ -1,34 +1,102 @@
+/**
+ * @module SearchWithTypeAndLinker
+ * @description Provides various formatting functions for search results with different output formats (Normal, DATA-ID, JustId)
+ */
 import { CountInfo } from "../../DataStructures/Count/CountInfo";
 /**
- * ## Format Normal ##
- * This function fetches all the connections and then converts all the connections to the single level connections
- * Then those single level objects are then stiched together to create a complex json/ array.
- * @param linkers
- * @param conceptIds
- * @param mainCompositionIds
- * @param reverse
- * @returns
+ * Formats connections in the Normal format by fetching connections, converting them to single-level objects,
+ * and stitching them together to create a complex JSON structure or array.
+ *
+ * @async
+ * @param {number[]} linkers - Array of connection IDs that act as linkers between concepts
+ * @param {number[]} conceptIds - Array of concept IDs involved in the connections
+ * @param {number[]} mainCompositionIds - Array of main composition IDs to format
+ * @param {number[]} reverse - Array of connection IDs that should be treated as reverse connections
+ * @param {CountInfo[]} countInfos - Array of count information objects for connection statistics
+ * @returns {Promise<any[]>} A promise that resolves to an array of formatted composition data
+ *
+ * @example
+ * ```typescript
+ * const linkers = [101, 102];
+ * const conceptIds = [1, 2, 3];
+ * const mainIds = [100];
+ * const reverse = [102];
+ * const countInfos: CountInfo[] = [];
+ * const result = await formatConnections(linkers, conceptIds, mainIds, reverse, countInfos);
+ * ```
+ *
+ * @remarks
+ * Format: Normal - This format is used for standard composition retrieval
+ * Process:
+ * 1. Fetches all connections using the provided linker IDs
+ * 2. Orders the connections (descending by default)
+ * 3. Formats connections to single-level objects
+ * 4. Formats data connections
+ * 5. Combines and stitches all data into a complex structure
  */
 export declare function formatConnections(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[]): Promise<any>;
 /**
- * ## Format DATA-ID ##
- * This function fetches all the connections and then converts all the connections to the single level connections
- * Then those single level objects are then stiched together to create a complex json/ array.
- * @param linkers
- * @param conceptIds
- * @param mainCompositionIds
- * @param reverse
- * @returns
+ * Formats connections in the DATA-ID format, which includes both data and ID information for each concept.
+ * Fetches connections, converts them to single-level objects, and stitches them together.
+ *
+ * @async
+ * @param {number[]} linkers - Array of connection IDs that act as linkers between concepts
+ * @param {number[]} conceptIds - Array of concept IDs involved in the connections
+ * @param {number[]} mainCompositionIds - Array of main composition IDs to format
+ * @param {number[]} reverse - Array of connection IDs that should be treated as reverse connections
+ * @param {CountInfo[]} countInfos - Array of count information objects for connection statistics
+ * @param {string} [order="DESC"] - Sort order for connections ("ASC" or "DESC")
+ * @returns {Promise<any[]>} A promise that resolves to an array of formatted composition data with ID and data fields
+ *
+ * @example
+ * ```typescript
+ * const result = await formatConnectionsDataId(
+ *   [101, 102],
+ *   [1, 2, 3],
+ *   [100],
+ *   [102],
+ *   [],
+ *   "ASC"
+ * );
+ * // Result format: [{ id: 100, data: {...}, created_on: timestamp }]
+ * ```
+ *
+ * @remarks
+ * Format: DATA-ID - Each result includes concept ID, data object, and creation timestamp
+ * This format is useful when you need to track both the identity and content of concepts
+ * The order parameter allows sorting connections by ID in ascending or descending order
  */
 export declare function formatConnectionsDataId(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;
 /**
- * ## Format JustId ##
- * This function fetches all the connections and then converts all the connections to the single level connections
- * Then those single level objects are then stiched together to create a complex json/ array.
- * @param linkers
- * @param conceptIds
- * @param mainCompositionIds
- * @param reverse
- * @returns
+ * Formats connections in the JustId format, which provides a simplified view with IDs and minimal data.
+ * Fetches connections, converts them to single-level objects, and stitches them together.
+ *
+ * @async
+ * @param {number[]} linkers - Array of connection IDs that act as linkers between concepts
+ * @param {number[]} conceptIds - Array of concept IDs involved in the connections
+ * @param {number[]} mainCompositionIds - Array of main composition IDs to format
+ * @param {number[]} reverse - Array of connection IDs that should be treated as reverse connections
+ * @param {CountInfo[]} countInfos - Array of count information objects for connection statistics
+ * @param {string} [order="DESC"] - Sort order for connections ("ASC" or "DESC")
+ * @returns {Promise<any[]>} A promise that resolves to an array of formatted composition data with simplified ID structure
+ *
+ * @example
+ * ```typescript
+ * const result = await formatConnectionsJustId(
+ *   [101, 102],
+ *   [1, 2, 3],
+ *   [100],
+ *   [],
+ *   [],
+ *   "DESC"
+ * );
+ * // Result format: [{ id: 100, type: { id: 1, data: "value", created_on: timestamp } }]
+ * ```
+ *
+ * @remarks
+ * Format: JustId - This format provides a lightweight representation with IDs and essential data
+ * Useful for list views and when you need to minimize data transfer
+ * Each linked concept includes: ID, data value, and creation timestamp
  */
 export declare function formatConnectionsJustId(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;
+export declare function formatConnectionsV2(linkers: number[], conceptIds: number[], mainCompositionIds: number[], reverse: number[], countInfos: CountInfo[], order?: string): Promise<any>;

package/dist/types/Services/Search/orderingConnections.d.ts

@@ -1,2 +1,36 @@
+/**
+ * @module orderingConnections
+ * @description Provides functionality to sort connections by ID in ascending or descending order
+ */
 import { Connection } from "../../app";
+/**
+ * Sorts an array of connections by their ID in the specified order.
+ *
+ * @param {Connection[]} connections - Array of Connection objects to sort
+ * @param {string} [order="DESC"] - Sort order: "ASC" for ascending, "DESC" for descending
+ * @returns {Connection[]} The sorted array of connections (mutates the original array)
+ *
+ * @example
+ * ```typescript
+ * const connections: Connection[] = [
+ *   { id: 103, ... },
+ *   { id: 101, ... },
+ *   { id: 102, ... }
+ * ];
+ *
+ * // Sort in descending order (newest first)
+ * const sorted = orderTheConnections(connections, "DESC");
+ * // Result: [{ id: 103 }, { id: 102 }, { id: 101 }]
+ *
+ * // Sort in ascending order (oldest first)
+ * const sortedAsc = orderTheConnections(connections, "ASC");
+ * // Result: [{ id: 101 }, { id: 102 }, { id: 103 }]
+ * ```
+ *
+ * @remarks
+ * - This function mutates the original array in place
+ * - Default order is "DESC" (descending, newest first)
+ * - Uses the connection ID for sorting
+ * - Any value other than "ASC" will result in descending order
+ */
 export declare function orderTheConnections(connections: Connection[], order?: string): Connection[];

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

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

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

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

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

@@ -1,24 +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";
  *
- * @param id this is the id whose links need to be found
- * @param linker this is the type connection that is connected to the mainConcept(id)
- * @param inpage number of outputs that has to be displayed
- * @param page the page which needs to be displayed as per the inpage parameter
- * @param format the format in which the output should be displayed (NORMAL, DATAID,JUSTDATA,DATAIDDATE)
+ * const results = await SchemaQueryListener(query, "my-token");
+ * // Results contain only data without IDs
+ * ```
  */
 export declare function SchemaQueryListener(query: FreeschemaQuery, token: string): Promise<any>;