mftsccs-browser 2.2.20-beta → 2.2.22-beta

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

@@ -1,19 +1,51 @@
 import { DependencyObserver } from "./DepenedencyObserver";
 /**
- * This wrapper will wrap the listing function and then allow users to return the list.
+ * Observable wrapper for retrieving a paginated list of compositions by type with automatic updates.
  */
 export declare class GetCompositionListObservable extends DependencyObserver {
+    /** The composition type character name */
     compositionName: string;
+    /** The user ID who owns the compositions */
     userId: number;
+    /** Number of items per page */
     inpage: number;
+    /** Current page number */
     page: number;
+    /** List of composition data */
     data: any;
+    /** Starting page index */
     startPage: number;
+    /**
+     * Creates a new composition list observable.
+     * @param compositionName - The composition type name
+     * @param userId - The user ID who owns the compositions
+     * @param inpage - Number of items per page
+     * @param page - Page number (1-indexed)
+     * @param format - Output format (JUSTDATA, DATAID, NORMAL)
+     */
     constructor(compositionName: string, userId: number, inpage: number, page: number, format: number);
+    /**
+     * Fetches paginated composition list and sets up change listeners.
+     * @returns Array of formatted composition data
+     */
     bind(): Promise<any>;
+    /**
+     * Builds the list of compositions in the specified format.
+     * @returns Array of formatted composition data
+     */
     build(): Promise<any>;
 }
 /**
- * This function will give you the list of the concepts by composition name with a listener to any data change.
+ * Creates an observable that tracks a paginated list of compositions and updates subscribers when they change.
+ * @param compositionName - The composition type name
+ * @param userId - The user ID who owns the compositions
+ * @param inpage - Number of items per page
+ * @param page - Page number (1-indexed)
+ * @param format - Output format (JUSTDATA, DATAID, NORMAL)
+ * @returns Observable instance for the composition list
+ *
+ * @example
+ * const observer = GetCompositionListListener("BlogPost", 123, 10, 1, JUSTDATA);
+ * observer.subscribe((data) => console.log(data));
  */
 export declare function GetCompositionListListener(compositionName: string, userId: number, inpage: number, page: number, format?: number): GetCompositionListObservable;

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

@@ -1,13 +1,35 @@
 import { DependencyObserver } from "./DepenedencyObserver";
+/**
+ * Observable wrapper for retrieving a composition with automatic updates when the composition changes.
+ */
 export declare class GetCompositionObservable extends DependencyObserver {
+    /** The composition ID to observe */
     id: number;
+    /**
+     * Creates a new composition observable.
+     * @param id - The composition concept ID
+     * @param format - Output format (JUSTDATA, DATAID, NORMAL)
+     */
     constructor(id: number, format?: number);
+    /**
+     * Fetches composition data and sets up change listeners.
+     * @returns The formatted composition data
+     */
     bind(): Promise<any>;
+    /**
+     * Builds the composition data in the specified format.
+     * @returns The formatted composition data
+     */
     build(): Promise<any>;
 }
 /**
+ * Creates an observable that tracks a composition and updates subscribers when it changes.
+ * @param id - The composition concept ID to observe
+ * @param format - Output format (JUSTDATA, DATAID, NORMAL)
+ * @returns Observable instance for the composition
  *
- * @param id Id of the composition
- * @returns composition of the id given in the json form.
+ * @example
+ * const observer = GetCompositionListener(123, JUSTDATA);
+ * observer.subscribe((data) => console.log(data));
  */
 export declare function GetCompositionListener(id: number, format?: number): GetCompositionObservable;

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

@@ -1,28 +1,57 @@
 import { SearchQuery, SearchStructure } from "../app";
 import { DependencyObserver } from "./DepenedencyObserver";
+/**
+ * Observable wrapper for searching linked concepts with complex query structures and automatic updates.
+ */
 export declare class GetLinkListObservable extends DependencyObserver {
+    /** Array of search query conditions */
     searchQuery: SearchQuery[];
+    /** Search structure defining composition and linker types */
     searchStructure: SearchStructure;
+    /** Output format */
     format: number;
+    /** List of main composition IDs */
     mainCompositionIds: number[];
+    /** Character value of the search composition */
     searchCharacter: string;
+    /** Authentication token */
     token: string;
+    /**
+     * Creates a new link list observable.
+     * @param searchStructure - Defines composition and linker types for the search
+     * @param searchQuery - Array of query conditions to filter results
+     * @param token - Authentication token
+     * @param format - Output format (DATAID, NORMAL)
+     */
     constructor(searchStructure: SearchStructure, searchQuery: SearchQuery[], token: string, format?: number);
     /**
- * This function will be called when there is a need to listen to a certain type of concept that will update
- *  the ui.
- * @param id this is the type id which needs to be tracked
- */
+     * Overrides base method to handle new compositions of the searched type being created.
+     * @param id - The type concept ID to track
+     */
     listenToEventType(id: number): void;
+    /**
+     * Executes the search query and sets up change listeners.
+     * @returns Array of formatted search results
+     */
     bind(): Promise<any>;
+    /**
+     * Builds the search results in the specified format.
+     * @returns Array of formatted search results
+     */
     build(): Promise<any>;
 }
 /**
+ * Creates an observable that tracks search results with complex query conditions and updates subscribers when results change.
+ * @param searchStructure - Defines composition and linker types for the search
+ * @param searchQuery - Array of query conditions to filter results
+ * @param token - Authentication token
+ * @param format - Output format (DATAID, NORMAL)
+ * @returns Observable instance for the search results
  *
- * @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)
+ * @example
+ * const structure = { composition: "BlogPost", linker: ["Author", "Category"] };
+ * const queries = [{ type: "BlogPost", searchField: "title", searchText: "tutorial" }];
+ * const observer = GetLinkListListener(structure, queries, token, DATAID);
+ * observer.subscribe((results) => console.log(results));
  */
 export declare function GetLinkListListener(searchStructure: SearchStructure, searchQuery: SearchQuery[], token: string, format?: number): GetLinkListObservable;

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

@@ -1,32 +1,50 @@
 import { Connection } from "../app";
 import { DependencyObserver } from "./DepenedencyObserver";
 /**
- * This is a class that will give you the observable for the links from a certain concept.
+ * Observable wrapper for retrieving linked concepts from a source concept with automatic updates.
  */
 export declare class GetLinkObservable extends DependencyObserver {
+    /** The linker type name defining the relationship */
     linker: string;
+    /** Number of items per page */
     inpage: number;
+    /** Current page number */
     page: number;
+    /** List of connection objects */
     connections: Connection[];
+    /** Array of linked composition data */
     data: any;
     /**
-     *
-     * @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)
+     * Creates a new link observable.
+     * @param id - The source concept ID whose links to retrieve
+     * @param linker - The linker type name defining the relationship
+     * @param inpage - Number of items per page
+     * @param page - Page number (1-indexed)
+     * @param format - Output format (NORMAL, DATAID, JUSTDATA, DATAIDDATE)
      */
     constructor(id: number, linker: string, inpage: number, page: number, format: number);
+    /**
+     * Fetches linked concepts and sets up change listeners.
+     * @returns Array of linked composition data
+     */
     bind(): Promise<any>;
+    /**
+     * Builds the array of linked compositions in the specified format.
+     * @returns Array of formatted linked composition data
+     */
     build(): Promise<any>;
 }
 /**
+ * Creates an observable that tracks linked concepts and updates subscribers when links change.
+ * @param id - The source concept ID whose links to retrieve
+ * @param linker - The linker type name defining the relationship
+ * @param inpage - Number of items per page
+ * @param page - Page number (1-indexed)
+ * @param format - Output format (NORMAL, DATAID, JUSTDATA, DATAIDDATE)
+ * @returns Observable instance for the linked concepts
  *
- * @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)
+ * @example
+ * const observer = GetLinkListener(123, "Author", 10, 1, NORMAL);
+ * observer.subscribe((linkedData) => console.log(linkedData));
  */
 export declare function GetLinkListener(id: number, linker: string, inpage: number, page: number, format?: number): GetLinkObservable;

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

@@ -1,37 +1,55 @@
 import { Connection, DependencyObserver } from "../app";
+/**
+ * Observable wrapper for recursive multi-level searches following linker paths with automatic updates.
+ */
 declare class RecursiveSearchObservable extends DependencyObserver {
+    /** Array of linker type names defining the search path */
     searchLinkers: string[];
+    /** Search text placeholder */
     searchText: string;
+    /** Text to search for in linked concepts */
     textSearch: string;
+    /** List of connection objects */
     connections: Connection[];
+    /** List of external (linker) connection IDs */
     externalConnectionIds: number[];
+    /** Search result data */
     data: any;
     /**
-     *
-     * @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 (RAW, undefined)
+     * Creates a new recursive search observable.
+     * @param id - The starting concept ID for the recursive search
+     * @param linkers - Array of linker type names defining the traversal path
+     * @param textSearch - Optional text to search for in linked concepts
+     * @param format - Output format (RAW for raw IDs, undefined for formatted compositions)
      */
     constructor(id: number, linkers: string[], textSearch?: string, format?: number);
     /**
-     * This is the of the concept id that needs to be listened . If this is called. All the connections that are
-     * created with of the concepts id with this passed id then the event is fired.
-     *
-     * @param id Of the concept id that needs to be listened.
+     * Overrides base method to track connection changes for concepts in the search results.
+     * @param id - The concept ID to track
      */
     listenToEvent(id: number): void;
+    /**
+     * Executes recursive search and sets up change listeners for all found compositions.
+     * @returns Formatted search results or raw ID structure
+     */
     bind(): Promise<any>;
+    /**
+     * Builds the search results in the specified format.
+     * @returns Formatted composition data or raw ID structure
+     */
     build(): Promise<any>;
 }
 /**
- * Method to listen the changes in recursive search data
- * @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 (RAW, undefined)
+ * Creates an observable that performs recursive multi-level searches and updates subscribers when results change.
+ * @param id - The starting concept ID for the recursive search
+ * @param linkers - Array of linker type names defining the traversal path
+ * @param searchText - Optional text to search for in linked concepts
+ * @param format - Output format (RAW for raw IDs, undefined for formatted compositions)
+ * @returns Observable instance for the recursive search
+ *
+ * @example
+ * const observer = RecursiveSearchListener(123, ["Author", "Category"], "tutorial", RAW);
+ * observer.subscribe((results) => console.log(results));
  */
 export declare function RecursiveSearchListener(id: number, linkers: string[], searchText?: string, format?: number): RecursiveSearchObservable;
 export {};

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

@@ -1,22 +1,58 @@
 import { FreeschemaQuery } from "../app";
 import { DependencyObserver } from "./DepenedencyObserver";
+/**
+ * Observable wrapper for executing free-schema queries with automatic updates.
+ * Supports complex filtering, sorting, and pagination with multiple output formats.
+ */
 export declare class SearchLinkMultipleAllObservable extends DependencyObserver {
+    /** The free-schema query object containing all search parameters */
     query: FreeschemaQuery;
+    /** Encoded count information strings */
     countInfoStrings: string[];
+    /** Sort order for results */
     order: string;
+    /** Total count of matching results */
     totalCount: number;
+    /**
+     * Creates a new schema query observable.
+     * @param query - FreeschemaQuery object with search parameters
+     * @param token - Authentication token
+     */
     constructor(query: FreeschemaQuery, token: string);
+    /**
+     * Executes the query once without subscribing to updates.
+     * @returns Formatted query results
+     */
     run(): Promise<any>;
+    /**
+     * Executes the query and sets up change listeners for all matching compositions.
+     * @returns Formatted query results
+     */
     bind(): Promise<any>;
+    /**
+     * Builds the query results in the specified format.
+     * @returns Formatted query results based on the output format
+     */
     build(): Promise<any>;
 }
 /**
+ * Creates an observable that executes a free-schema query and updates subscribers when results change.
+ * @param query - FreeschemaQuery object with search, filter, sort, and pagination parameters
+ * @param token - Authentication token
+ * @returns Observable instance for the query results
  *
- * @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)
+ * @example
+ * const query = new FreeschemaQuery();
+ * query.type = "BlogPost";
+ * query.outputFormat = DATAID;
+ * const observer = SchemaQueryListener(query, token);
+ * observer.subscribe((results) => console.log(results));
  */
 export declare function SchemaQueryListener(query: FreeschemaQuery, token: string): SearchLinkMultipleAllObservable;
+/**
+ * Executes a free-schema query once without creating a subscription.
+ * @param query - FreeschemaQuery object with search parameters
+ * @param token - Authentication token
+ * @returns Promise resolving to formatted query results
+ */
 export declare function SchemaQuery(query: FreeschemaQuery, token: string): Promise<void>;

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

@@ -1,15 +1,36 @@
 import { SearchQuery } from "../app";
 import { DependencyObserver } from "./DepenedencyObserver";
+/**
+ * Observable wrapper for executing multiple search queries with automatic updates.
+ */
 export declare class SearchLinkMultipleAllObservable extends DependencyObserver {
+    /** Array of search query conditions */
     searchQuery: SearchQuery[];
+    /** Output format */
     format: number;
+    /**
+     * Creates a new multi-search observable.
+     * @param searchQuery - Array of SearchQuery objects defining search conditions
+     * @param token - Authentication token
+     * @param format - Output format (DATAID by default)
+     */
     constructor(searchQuery: SearchQuery[], token: string, format?: number);
+    /**
+     * Executes the search queries and sets up change listeners.
+     * @returns Formatted search results
+     */
     bind(): Promise<any>;
 }
 /**
+ * Creates an observable that executes multiple search queries and updates subscribers when results change.
+ * @param searchQueries - Array of SearchQuery objects defining search conditions
+ * @param token - Authentication token
+ * @param format - Output format (DATAID by default)
+ * @returns Observable instance for the search results
  *
- * @param searchQueries Queries that need to be executed.
- * @param token token of the user.
- * @returns  returns the json format of the output.
+ * @example
+ * const queries = [{ composition: 123, type: "BlogPost", searchField: "title", searchText: "tutorial" }];
+ * const observer = searchLinkMultipleListener(queries, token, DATAID);
+ * observer.subscribe((results) => console.log(results));
  */
 export declare function searchLinkMultipleListener(searchQueries: SearchQuery[], token?: string, format?: number): SearchLinkMultipleAllObservable;

package/dist/types/app.d.ts

@@ -129,7 +129,7 @@ export { CountInfo } from './DataStructures/Count/CountInfo';
 export { LogEvent } from './Services/Logs/LogEvent';
 export { Selector } from './Api/Prototype/Selector';
 export { AccessControlService } from './Services/AccessControl/AccessControl';
-export { importLatestWidget, renderImportedWidget, renderLatestWidget, renderPage, renderWidget, convertWidgetTreeToWidgetWithWrapper, getWidgetFromId, convertWidgetTreeToWidget, unwrapContainers, getWidgetBulkFromId } from './Widgets/RenderWidgetService';
+export { importLatestWidget, importRecentWidget, renderImportedWidget, renderLatestWidget, renderPage, renderWidget, convertWidgetTreeToWidgetWithWrapper, getWidgetFromId, convertWidgetTreeToWidget, unwrapContainers, getWidgetBulkFromId } from './Widgets/RenderWidgetService';
 export { CreateData } from './Services/automated/automated-concept-connection';
 export { Prototype } from './DataStructures/Prototype/Prototype';
 export { createPrototypeLocal } from './prototype/prototype.service';
@@ -146,22 +146,193 @@ export declare let subscribedListeners: listeners[];
 export declare let hasActivatedSW: boolean;
 export declare function setHasActivatedSW(value: boolean): void;
 /**
- * This function lets you update the access token that the package uses. If this is not passed you cannot create, update, view or delete
- * Your concepts using this package.
- * @param accessToken access token got from the sign in process
+ * Updates the JWT access token used for authenticated API requests.
+ *
+ * This function should be called after user authentication to set or update the bearer token
+ * that will be used for all subsequent authenticated operations. The token is stored in
+ * TokenStorage and automatically included in API request headers.
+ *
+ * **When to Use:**
+ * - After successful login (LoginToBackend or Signin)
+ * - When refreshing an expired token
+ * - When switching between user sessions
+ * - When restoring a saved session on app reload
+ *
+ * **Token Flow:**
+ * 1. User logs in via LoginToBackend() or Signin()
+ * 2. Backend returns JWT token
+ * 3. Call updateAccessToken() with the token
+ * 4. Token is stored in memory (TokenStorage.BearerAccessToken)
+ * 5. All API calls automatically use this token
+ * 6. If service worker enabled, token is synced to service worker
+ *
+ * **Security Notes:**
+ * - Token is stored in memory only (not persisted to disk)
+ * - Token is cleared on page refresh (unless you save/restore it)
+ * - Never expose token in logs or client-side code
+ * - Token should be refreshed before expiration
+ *
+ * @param accessToken - The JWT bearer token obtained from authentication.
+ *                     Format: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+ *                     Pass empty string to clear the token (logout).
+ *
+ * @param session - Optional session information to sync with token.
+ *                 Reserved for future use. Currently not fully implemented.
+ *
+ * @returns void
+ *
+ * @example
+ * // After login, update token
+ * const loginResult = await LoginToBackend("user@example.com", "password");
+ * updateAccessToken(loginResult.data.token);
+ * console.log("Token updated - now authenticated");
+ *
+ * @example
+ * // Restore token from localStorage on app reload
+ * const savedToken = localStorage.getItem("authToken");
+ * if (savedToken) {
+ *   updateAccessToken(savedToken);
+ * }
+ *
+ * @example
+ * // Clear token on logout
+ * updateAccessToken("");
+ * console.log("Token cleared - logged out");
+ *
+ * @example
+ * // Refresh expired token
+ * const newToken = await refreshTokenFromBackend();
+ * updateAccessToken(newToken);
+ *
+ * @see {@link LoginToBackend} for obtaining initial token
+ * @see {@link Signin} for alternative authentication
+ * @see {@link init} which can also set initial token
  */
 declare function updateAccessToken(accessToken?: string, session?: any): void;
 /**
+ * Initializes the mftsccs-browser package and sets up all required subsystems.
+ *
+ * This is the FIRST function you must call before using any other functionality in the package.
+ * It configures the backend connections, initializes local databases, sets up service workers,
+ * and prepares the system for concept and connection operations.
+ *
+ * **Initialization Process:**
+ * 1. Configures Base URLs for backend, AI, and node servers
+ * 2. Sets up access token for authenticated requests
+ * 3. Generates unique application randomizer for IndexedDB identification
+ * 4. Initializes feature flags (logging, access tracking, etc.)
+ * 5. Checks for service worker support
+ * 6. Initializes local IndexedDB databases for caching
+ * 7. Sets up message listeners for service worker communication
+ * 8. Optionally registers and activates service worker
+ * 9. Falls back to main thread if service worker unavailable
+ *
+ * **Subsystems Initialized:**
+ * - IndexedDB databases (concepts, connections, settings)
+ * - Service worker (if enabled and supported)
+ * - Message passing between main thread and service worker
+ * - Broadcast channel for cross-tab communication
+ * - Access token storage
+ * - Logging and monitoring systems
+ * - Access tracking (if enabled)
  *
- * @param url This is the url for the backend c# system or our main data fabric server
- * @param aiurl This is the AI url that pulls in the data using our AI system . If you do not enter this then also disable the enableAi flag.
+ * @param url - The backend API base URL (C# data fabric server).
+ *             This is the primary server for concept and connection data.
+ *             Example: "https://api.example.com" or "https://backend.yourdomain.com"
+ *             **Required** for most operations.
+ *
+ * @param aiurl - The AI service URL for AI-powered features and data preloading.
+ *               If not using AI features, pass empty string and set enableAi to false.
+ *               Example: "https://ai.example.com"
+ *
+ * @param accessToken - JWT bearer token for authenticated API requests.
+ *                     Can be empty string on initialization - set later with updateAccessToken().
+ *                     Token is obtained through LoginToBackend() or Signin().
+ *                     Example: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
+ *
+ * @param nodeUrl - The Node.js server URL for business logic and security features.
+ *                 Used for additional server-side operations.
+ *                 Example: "https://node.example.com"
+ *
+ * @param enableAi - Flag to enable/disable AI features and AI data preloading to IndexedDB.
+ *                  Set to false if not using AI features or if aiurl is not provided.
+ *                  Default: true
+ *
+ * @param applicationName - Unique identifier for your application.
+ *                         Used to create separate IndexedDB instances for different apps.
+ *                         Example: "my-app-v1", "project-manager", "knowledge-base"
+ *                         Useful when multiple applications share the same domain.
+ *
+ * @param enableSW - Service worker configuration object. Service worker enables background
+ *                  processing for better performance and offline capabilities.
+ *                  - activate: boolean - Enable/disable service worker
+ *                  - scope: string (optional) - Service worker scope path (default: "/")
+ *                  - pathToSW: string (optional) - Path to service worker file (default: "/service-worker.js")
+ *                  - manual: boolean (optional) - If true, assumes SW already registered manually
+ *                  Example: {activate: true, scope: "/", pathToSW: "/sw.js"}
+ *
+ * @param flags - Feature flags object for enabling/disabling various features:
+ *               - logApplication: boolean - Enable application-level logging
+ *               - logPackage: boolean - Enable package-level logging
+ *               - accessTracker: boolean - Enable access tracking/analytics
+ *               - isTest: boolean - Mark as test environment
+ *               All default to false if not specified.
+ *
+ * @param parameters - Additional configuration parameters:
+ *                    - logserver: string - Custom log server URL (default: "https://logdev.freeschema.com")
+ *
+ * @returns Promise<boolean> - Returns true if initialization succeeds, undefined if it fails.
+ *         On failure, falls back to main thread operation and logs warnings.
+ *
+ * @example
+ * // Basic initialization (minimum required)
+ * await init(
+ *   "https://api.myapp.com",     // backend URL
+ *   "",                           // no AI
+ *   "",                           // no token yet
+ *   "",                           // no node server
+ *   false,                        // disable AI
+ *   "my-app"                      // app name
+ * );
+ *
+ * @example
+ * // Full initialization with service worker
+ * await init(
+ *   "https://api.myapp.com",
+ *   "https://ai.myapp.com",
+ *   "",
+ *   "https://node.myapp.com",
+ *   true,
+ *   "my-app-v2",
+ *   {
+ *     activate: true,
+ *     scope: "/",
+ *     pathToSW: "/service-worker.js"
+ *   },
+ *   {
+ *     logApplication: true,
+ *     accessTracker: true
+ *   },
+ *   {
+ *     logserver: "https://logs.myapp.com"
+ *   }
+ * );
+ *
+ * @example
+ * // Initialize then login
+ * await init("https://api.example.com", "", "", "", false, "my-app");
+ * const loginResult = await LoginToBackend("user@example.com", "password");
+ * updateAccessToken(loginResult.data.token);
+ * // Now ready to use all authenticated operations
+ *
+ * @throws Does not throw - logs warnings and falls back to main thread on errors.
+ *        Common issues: Service worker registration failures, IndexedDB access denied.
+ *
+ * @see {@link updateAccessToken} for updating the access token after initialization
+ * @see {@link LoginToBackend} for obtaining an access token
+ * @see {@link sendMessage} for communicating with service worker after initialization
  * @param accessControlUrl This is the url for the access control system. This is another server in the data fabric that is used as server for business logic and security features.
- * @param accessToken This is the JWT token that needs to be passed (But since you have just initilized the system). There is no way we can get access token
- * So this access token can be empty string. You can set it afterwards with another function UpdateAccessToken();
- * @param nodeUrl This is the url for the node server. This is another server in the data fabric that is used as server for business logic and security features.
- * @param enableAi This flag is used to enable or disable the AI feature that preloads data in the indexdb.
- * @param applicationName This is an unique name that is given to a program. Use this to discern one indexdb from another.
- * @param enableSW {activate: boolean, scope?: string, pathToSW?: string, manual?: boolean} | undefined - This is for enabling service worker with its scope
+ *
  */
 declare function init(url?: string, aiurl?: string, accessToken?: string, nodeUrl?: string, enableAi?: boolean, applicationName?: string, enableSW?: {
     activate: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mftsccs-browser",
-  "version": "2.2.20-beta",
+  "version": "2.2.22-beta",
 
   "environment": "production",
   "description": "Full Pack of concept and connection system",