http-request-manager 18.7.31 → 18.9.1

package/types/http-request-manager.d.ts

@@ -1,7 +1,7 @@
 import * as rxjs from 'rxjs';
-import { Observable, BehaviorSubject, OperatorFunction, Subscription } from 'rxjs';
+import { Observable, Subscription, BehaviorSubject, OperatorFunction } from 'rxjs';
 import * as i0 from '@angular/core';
-import { InjectionToken, Injector, OnDestroy, OnInit, EventEmitter, ModuleWithProviders } from '@angular/core';
+import { InjectionToken, OnDestroy, Injector, OnInit, EventEmitter, ModuleWithProviders } from '@angular/core';
 import { ComponentStore } from '@ngrx/component-store';
 import { HttpClient, HttpHeaders, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
 import * as i16 from 'toast-message-display';
@@ -127,7 +127,7 @@ declare class SymmetricalEncryptionService {
     constructor();
     generateCipherKey(): string;
     encrypt(str: any, key?: string): string | undefined;
-    decrypt(str: string, key?: string): string | undefined;
+    decrypt(str: string, key?: string): string | null | undefined;
     createSignature(url: string, len?: number): string;
     normalizeURL(url: string): string;
     generateSignature(url: string): string;
@@ -159,6 +159,7 @@ interface WSOptionsInterface {
     jwtToken: string;
     permissions?: string[];
     channels?: string[];
+    wsUpdateChannels?: string[];
     user?: any;
     retry?: RetryOptions;
 }
@@ -168,9 +169,10 @@ declare class WSOptions implements WSOptionsInterface {
     jwtToken: string;
     permissions?: string[] | undefined;
     channels?: string[] | undefined;
+    wsUpdateChannels?: string[] | undefined;
     user?: any;
     retry?: RetryOptions | undefined;
-    constructor(id?: string, wsServer?: string, jwtToken?: string, permissions?: string[] | undefined, channels?: string[] | undefined, user?: any, retry?: RetryOptions | undefined);
+    constructor(id?: string, wsServer?: string, jwtToken?: string, permissions?: string[] | undefined, channels?: string[] | undefined, wsUpdateChannels?: string[] | undefined, user?: any, retry?: RetryOptions | undefined);
     static adapt(item?: any): WSOptions;
 }
 
@@ -202,6 +204,7 @@ interface ApiRequestInterface {
     saveAs?: string;
     fileContentHeader?: string;
     ws?: WSOptions;
+    env?: string;
 }
 declare class ApiRequest implements ApiRequestInterface {
     server: string;
@@ -217,7 +220,8 @@ declare class ApiRequest implements ApiRequestInterface {
     saveAs?: string | undefined;
     fileContentHeader?: string | undefined;
     ws?: WSOptions | undefined;
-    constructor(server?: string, path?: any[] | undefined, headers?: any, adapter?: any, mapper?: any, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, streamType?: StreamType | undefined, displayError?: boolean | undefined, saveAs?: string | undefined, fileContentHeader?: string | undefined, ws?: WSOptions | undefined);
+    env?: string | undefined;
+    constructor(server?: string, path?: any[] | undefined, headers?: any, adapter?: any, mapper?: any, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, streamType?: StreamType | undefined, displayError?: boolean | undefined, saveAs?: string | undefined, fileContentHeader?: string | undefined, ws?: WSOptions | undefined, env?: string | undefined);
     static adapt(item?: any): ApiRequest;
 }
 
@@ -338,19 +342,27 @@ declare class DatabaseManagerService extends DbService {
     }[]>;
     deleteTableRecord<T>(table: string, id: number): Observable<number | null>;
     deleteTableRecords(table: string, ids: number[]): Observable<number[]>;
-    clearTable(table: string): Observable<unknown>;
+    clearTable(table: string): Observable<never[]>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseManagerService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DatabaseManagerService>;
 }
 
 interface ChannelMessageInterface {
+    messageId?: number;
+    channel?: string;
+    isReplay?: boolean;
     sessionId: any;
     content: any;
+    timestamp?: string;
 }
 declare class ChannelMessage implements ChannelMessageInterface {
+    messageId?: number | undefined;
+    channel?: string | undefined;
+    isReplay?: boolean | undefined;
     sessionId: any;
     content: any;
-    constructor(sessionId?: any, content?: any);
+    timestamp?: string | undefined;
+    constructor(messageId?: number | undefined, channel?: string | undefined, isReplay?: boolean | undefined, sessionId?: any, content?: any, timestamp?: string | undefined);
     static adapt(item?: any): ChannelMessage;
 }
 
@@ -381,7 +393,6 @@ declare class HTTPManagerStateService<T extends {
 }> extends ComponentStore<APIStateManagerData<T>> {
     private apiOptions;
     private dataType;
-    private database?;
     httpManagerService: HTTPManagerService<any>;
     dbManagerService: DatabaseManagerService;
     localStorageManagerService: LocalStorageManagerService;
@@ -399,6 +410,7 @@ declare class HTTPManagerStateService<T extends {
     private maxRetries;
     private retryDelay;
     private shouldRetry;
+    private connectionStatusSubscription?;
     private databaseOptions?;
     private wsRetryAttempts;
     wsRetryAttempts$: Observable<number>;
@@ -429,10 +441,10 @@ declare class HTTPManagerStateService<T extends {
     latestCommunicationMessages$: Observable<any>;
     private userAction;
     userAction$: Observable<any>;
-    wsConnection: boolean;
+    private static wsCommunicationQueue;
     wsOptions: WSOptions;
     connectionStatus$: Observable<boolean>;
-    constructor(apiOptions: ApiRequest, dataType: DataType | undefined, database?: DatabaseStorage | undefined);
+    constructor(apiOptions: ApiRequest, dataType: DataType | undefined, database?: DatabaseStorage);
     /**
      * Add appropriate prefix to a channel name if not already present
      */
@@ -447,12 +459,12 @@ declare class HTTPManagerStateService<T extends {
     getBaseChannelName(channel: string): string;
     setApiRequestOptions(apiOptions?: ApiRequest, dataType?: DataType, database?: DatabaseStorage): void;
     private setupConnectionStatus;
-    readonly initWS: (observableOrValue: WSOptions | Observable<WSOptions>) => rxjs.Subscription;
+    readonly initWS: (observableOrValue: WSOptions | Observable<WSOptions>) => Subscription;
     appendMessages(message: any): void;
     latestMessage(): void;
     clearMessages(): void;
     get ApiRequestOptions(): ApiRequest;
-    readonly initDBStorage: (observableOrValue?: void | Observable<void> | undefined) => rxjs.Subscription;
+    readonly initDBStorage: (observableOrValue?: void | Observable<void> | undefined) => Subscription;
     initializeState(data: any): void;
     readonly data$: Observable<T | T[] | null>;
     readonly selectRecord$: (id: number) => Observable<T | T[] | null>;
@@ -461,16 +473,20 @@ declare class HTTPManagerStateService<T extends {
     private readonly addData$;
     private readonly deleteData$;
     private readonly updateData$;
-    readonly clearRecords: (observableOrValue?: void | Observable<void> | undefined) => rxjs.Subscription;
-    readonly fetchRecords: (options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
+    readonly clearRecords: (observableOrValue?: void | Observable<void> | undefined) => Subscription;
+    readonly fetchRecords: (options?: RequestOptions) => ((observableOrValue?: any) => Subscription) | ((observableOrValue: any) => Subscription);
     private initDBStorageAsync;
-    readonly fetchRecord: (options: RequestOptions, method: string) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
-    readonly createRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
-    readonly updateRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
-    readonly deleteRecord: (options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
-    readonly createStream: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
-    readonly fetchStream: (options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
+    readonly fetchRecord: (options: RequestOptions, method: string) => ((observableOrValue?: any) => Subscription) | ((observableOrValue: any) => Subscription);
+    readonly createRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => Subscription) | ((observableOrValue: any) => Subscription);
+    readonly updateRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => Subscription) | ((observableOrValue: any) => Subscription);
+    readonly deleteRecord: (options?: RequestOptions) => ((observableOrValue?: any) => Subscription) | ((observableOrValue: any) => Subscription);
+    readonly createStream: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => Subscription) | ((observableOrValue: any) => Subscription);
+    readonly fetchStream: (options?: RequestOptions) => ((observableOrValue?: any) => Subscription) | ((observableOrValue: any) => Subscription);
     private wsCommunication;
+    /**
+     * Actually send the WebSocket message (called when connected or from queue)
+     */
+    private sendWsCommunication;
     /**
      * Send a message to channel(s)
      * @param message - The message content
@@ -557,6 +573,12 @@ declare class HTTPManagerStateService<T extends {
      * @param channel - Base channel name (MES- prefix added automatically)
      */
     sendNotification(channel: string, content: any): void;
+    /**
+     * Clear/flush all records from the database table
+     * Does not clear localStorage metadata (expires info)
+     * Does not re-fetch from API - leaves state empty for manual refresh
+     */
+    clearDatabase(): void;
     private isEmpty;
     private updateRequestOptions;
     static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerStateService<any>, never>;
@@ -589,6 +611,11 @@ declare class WebsocketService {
      * This uses the 'message' type which broadcasts to all subscribers in the channel
      */
     sendChannelMessage(channel: string, content: any): void;
+    /**
+     * Send a message to multiple channels at once (batch)
+     * Sends the new batch format and falls back to legacy per-channel messages for compatibility
+     */
+    sendChannelMessageToChannels(channels: string[], content: any): void;
     sendMessageToUser(user: string, content: any): void;
     getAllChannels(): void;
     createChannel(channel: string): void;
@@ -626,6 +653,173 @@ declare class WebsocketService {
     static ɵprov: i0.ɵɵInjectableDeclaration<WebsocketService>;
 }
 
+/**
+ * WebSocketManagerService - Singleton WebSocket connection manager
+ *
+ * This service ensures only ONE WebSocket connection exists across ALL instances
+ * of HTTPManagerStateService. It uses static properties to track connection state
+ * globally, preventing duplicate connections when multiple state services are created.
+ *
+ * Usage:
+ * - Inject into HTTPManagerService (or directly into state services)
+ * - Call connect() with WSOptions - only the first call establishes connection
+ * - Subsequent calls detect existing connection and skip reconnection
+ * - All instances share the same connectionStatus$ and messages$ observables
+ */
+declare class WebSocketManagerService {
+    private static socket;
+    private static isConnecting;
+    private static connectionInitialized;
+    private static lastOptions;
+    private static messages;
+    messages$: Observable<any>;
+    private static connectionStatus;
+    connectionStatus$: Observable<boolean>;
+    private static isSubscribed;
+    private static subscribedChannels;
+    subscribedChannels$: Observable<Set<string>>;
+    static getSubscribedChannels(): Set<string>;
+    static addSubscribedChannel(channelName: string): void;
+    private static onReconnect;
+    onReconnect$: Observable<void>;
+    private getSessionId;
+    /**
+     * Connect to WebSocket server
+     *
+     * IMPORTANT: Only the first call across ALL instances will establish a connection.
+     * Subsequent calls will detect the existing connection and return immediately.
+     *
+     * @param options - WebSocket configuration options
+     * @param jwtToken - Optional JWT token for authentication
+     */
+    connect(options: WSOptions, jwtToken: string): void;
+    /**
+     * Disconnect from WebSocket server
+     */
+    disconnect(): void;
+    private sendSubscribe;
+    /**
+     * Send subscribe with lastSeenId for message sync support
+     * @param channelName - Channel name to subscribe to
+     * @param user - User data
+     * @param lastSeenId - Last message ID seen (for replay)
+     */
+    sendSubscribeWithLastSeen(channelName: string, user: any, lastSeenId: number): void;
+    /**
+     * Subscribe to a channel
+     * @param channelName - Channel name to subscribe to
+     */
+    subscribeToChannel(channelName: string): void;
+    /**
+     * Subscribe to multiple channels
+     * @param channelNames - Array of channel names to subscribe to
+     */
+    subscribeToChannels(channelNames: string[]): void;
+    /**
+     * Unsubscribe from a channel
+     * @param channel - Channel name to unsubscribe from
+     */
+    unsubscribeFromChannel(channel: string): void;
+    /**
+     * Get currently subscribed channels
+     * @returns Set of subscribed channel names
+     */
+    getSubscribedChannels(): Set<string>;
+    /**
+     * Generic send method for message tracking (acks, gap requests, etc.)
+     * @param message - Message object to send
+     */
+    send(message: any): void;
+    /**
+     * Send broadcast message
+     * @param content - Message content to broadcast
+     */
+    sendBroadcast(content: any): void;
+    /**
+     * Send message in channel (state manager message)
+     * @param channel - Channel name
+     * @param content - Message content
+     */
+    sendMessageInChannel(channel: string, content: any): void;
+    /**
+     * Send channel message (broadcasts to all subscribers in the channel)
+     * @param channel - Channel name
+     * @param content - Message content
+     */
+    sendChannelMessage(channel: string, content: any): void;
+    /**
+     * Send message to multiple channels at once (batch)
+     * @param channels - Array of channel names
+     * @param content - Message content
+     */
+    sendChannelMessageToChannels(channels: string[], content: any): void;
+    /**
+     * Send message to specific user
+     * @param user - User identifier
+     * @param content - Message content
+     */
+    sendMessageToUser(user: string, content: any): void;
+    /**
+     * Request list of all channels from server
+     */
+    getAllChannels(): void;
+    /**
+     * Create a new channel on server
+     * @param channel - Channel name to create
+     */
+    createChannel(channel: string): void;
+    /**
+     * Delete a channel from server
+     * @param channel - Channel name to delete
+     */
+    deleteChannel(channel: string): void;
+    /**
+     * Get users in a specific channel
+     * @param channel - Channel name
+     */
+    getUsersInChannel(channel: string): void;
+    /**
+     * Create a notification channel
+     * @param channel - Channel name (should include MES- prefix)
+     */
+    createNotificationChannel(channel: string): void;
+    /**
+     * Get all notification channels (in-memory)
+     */
+    getNotificationChannels(): void;
+    /**
+     * Get today's notification channels from database
+     */
+    getTodaysNotificationChannels(): void;
+    /**
+     * Subscribe to a notification channel with optional date filters
+     * @param channel - Channel name
+     * @param options - Optional start/end epoch filters
+     * @param user - User information
+     */
+    subscribeToNotificationChannel(channel: string, options?: {
+        startEpoch?: number;
+        endEpoch?: number;
+    }, user?: any): void;
+    /**
+     * Unsubscribe from a notification channel
+     * @param channel - Channel name
+     */
+    unsubscribeFromNotificationChannel(channel: string): void;
+    /**
+     * Check if WebSocket connection is currently open
+     * @returns true if connected, false otherwise
+     */
+    static isConnected(): boolean;
+    /**
+     * Check if connection has been initialized (attempted at least once)
+     * @returns true if connection was initialized, false otherwise
+     */
+    static isInitialized(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebSocketManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebSocketManagerService>;
+}
+
 declare class RequestService extends WebsocketService {
     private http;
     private pathQueryService;
@@ -757,11 +951,173 @@ declare class ObjectMergerService {
     static ɵprov: i0.ɵɵInjectableDeclaration<ObjectMergerService>;
 }
 
+/**
+ * Message Tracker Service - Guaranteed Message Delivery
+ *
+ * Tracks message IDs, detects gaps, manages acknowledgments, and handles sync.
+ * Ensures frontend clients never miss messages even during disconnections.
+ *
+ * Features:
+ * - Per-channel message sequence tracking
+ * - Automatic gap detection and recovery
+ * - Batch acknowledgments (configurable interval)
+ * - Reconnection sync with last-seen tracking
+ * - Gap threshold alerting (10 messages before UI notification)
+ */
+declare class MessageTrackerService implements OnDestroy {
+    private wsManager;
+    /** Batch acknowledgment interval in milliseconds */
+    private readonly BATCH_ACK_INTERVAL_MS;
+    /** Maximum gap before alerting UI */
+    private readonly GAP_THRESHOLD;
+    /** Maximum messages to store in pending acks before forcing batch */
+    private readonly MAX_PENDING_ACKS;
+    /**
+     * Track last seen message ID per channel
+     * Map<channelName, lastMessageId>
+     */
+    private lastSeen;
+    /**
+     * Expected next message ID per channel (for gap detection)
+     * Map<channelName, nextExpectedId>
+     */
+    private expectedSequence;
+    /**
+     * Pending acknowledgments per channel
+     * Map<channelName, Set<messageId>>
+     */
+    private pendingAcks;
+    /**
+     * Gap count per channel (for threshold alerting)
+     * Map<channelName, gapCount>
+     */
+    private gapCounts;
+    /**
+     * Replay mode tracking (per channel)
+     * Used to distinguish replay vs live messages
+     */
+    private inReplayMode;
+    /**
+     * Gap retry count (for retry logic)
+     * Map<channel, retryCount>
+     */
+    private gapRetryCount;
+    /** Batch acknowledgment timer */
+    private batchAckTimer;
+    /** Subscription to WebSocket messages */
+    private messagesSubscription;
+    /**
+     * Track channels we want to be subscribed to (survives disconnect/reconnect)
+     * This is separate from WebSocketManagerService.subscribedChannels which tracks
+     * actual active subscriptions
+     */
+    private intendedChannels;
+    /** Observable to emit processed messages to UI components */
+    private messagesSubject;
+    messages$: Observable<any>;
+    constructor(wsManager: WebSocketManagerService);
+    ngOnDestroy(): void;
+    /**
+     * Process incoming message
+     * Tracks ID, detects gaps, queues acknowledgment
+     */
+    private onMessage;
+    /**
+     * Track message ID and detect gaps
+     */
+    private trackMessage;
+    /**
+     * Queue message for batch acknowledgment
+     */
+    private queueAck;
+    /**
+     * Start batch acknowledgment timer
+     */
+    private startBatchAckTimer;
+    /**
+     * Stop batch acknowledgment timer
+     */
+    private stopBatchAckTimer;
+    /**
+     * Send batch acknowledgments for all channels with pending acks
+     */
+    private sendAllBatchAcks;
+    /**
+     * Send batch acknowledgment for a specific channel
+     */
+    private sendBatchAck;
+    /**
+     * Request missing messages from server
+     */
+    private requestGapFill;
+    /**
+     * Handle gap threshold exceeded (optional: alert UI)
+     */
+    private onGapThresholdExceeded;
+    /**
+     * Subscribe to channel with sync support
+     * Automatically includes lastSeenId for replay
+     */
+    subscribeToChannel(channel: string, userData?: any): void;
+    /**
+     * Re-subscribe to all previously subscribed channels after reconnect
+     * Includes lastSeenId for each channel to trigger message replay
+     */
+    private reSubscribeAllChannels;
+    /**
+     * Persist lastSeen to sessionStorage (survives page reload)
+     */
+    private persistLastSeen;
+    /**
+     * Restore lastSeen from sessionStorage
+     */
+    private restoreLastSeen;
+    /**
+     * Persist intendedChannels to sessionStorage
+     */
+    private persistIntendedChannels;
+    /**
+     * Restore intendedChannels from sessionStorage
+     */
+    private restoreIntendedChannels;
+    /**
+     * Get last seen message ID for a channel
+     */
+    getLastSeenId(channel: string): number;
+    /**
+     * Get expected next message ID for a channel
+     */
+    getExpectedNextId(channel: string): number;
+    /**
+     * Check if currently in replay mode for a channel
+     */
+    isInReplayMode(channel: string): boolean;
+    /**
+     * Get gap count for a channel
+     */
+    getGapCount(channel: string): number;
+    /**
+     * Get skipped IDs between expected and received (for detailed gap reporting)
+     */
+    private getSkippedIds;
+    /**
+     * Clear all tracking state (useful for debugging or manual reset)
+     */
+    clearState(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageTrackerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageTrackerService>;
+}
+
 declare class HTTPManagerService<T> extends RequestService {
     private configOptions?;
     toastMessage: ToastMessageDisplayService;
     ng_injector: Injector;
     objectMergerService: ObjectMergerService;
+    wsManager: WebSocketManagerService;
+    messageTracker: MessageTrackerService;
+    connectionStatus$: Observable<boolean>;
+    messages$: Observable<any>;
+    subscribedChannels$: Observable<Set<string>>;
     private countdown;
     countdown$: Observable<number>;
     private error;
@@ -771,6 +1127,87 @@ declare class HTTPManagerService<T> extends RequestService {
     private polling$;
     config: ApiRequest;
     constructor(configOptions?: ConfigOptions | undefined);
+    /**
+     * Connect to WebSocket server
+     * Only the first call across ALL instances will establish a connection
+     */
+    connect(options: any, jwtToken: string): void;
+    /**
+     * Disconnect from WebSocket server
+     */
+    disconnect(): void;
+    /**
+     * Subscribe to a channel
+     */
+    subscribeToChannel(channel: string, userData?: any): void;
+    /**
+     * Subscribe to multiple channels
+     */
+    subscribeToChannels(channels: string[], userData?: any): void;
+    /**
+     * Unsubscribe from a channel
+     */
+    unsubscribeFromChannel(channel: string): void;
+    /**
+     * Get currently subscribed channels
+     */
+    getSubscribedChannels(): Set<string>;
+    /**
+     * Send broadcast message
+     */
+    sendBroadcast(content: any): void;
+    /**
+     * Send message in channel (state manager message)
+     */
+    sendMessageInChannel(channel: string, content: any): void;
+    /**
+     * Send channel message
+     */
+    sendChannelMessage(channel: string, content: any): void;
+    /**
+     * Send message to multiple channels
+     */
+    sendChannelMessageToChannels(channels: string[], content: any): void;
+    /**
+     * Send message to user
+     */
+    sendMessageToUser(user: string, content: any): void;
+    /**
+     * Get all channels
+     */
+    getAllChannels(): void;
+    /**
+     * Create channel
+     */
+    createChannel(channel: string): void;
+    /**
+     * Delete channel
+     */
+    deleteChannel(channel: string): void;
+    /**
+     * Get users in channel
+     */
+    getUsersInChannel(channel: string): void;
+    /**
+     * Create notification channel
+     */
+    createNotificationChannel(channel: string): void;
+    /**
+     * Get notification channels
+     */
+    getNotificationChannels(): void;
+    /**
+     * Get today's notification channels
+     */
+    getTodaysNotificationChannels(): void;
+    /**
+     * Subscribe to notification channel
+     */
+    subscribeToNotificationChannel(channel: string, options?: any, user?: any): void;
+    /**
+     * Unsubscribe from notification channel
+     */
+    unsubscribeFromNotificationChannel(channel: string): void;
     getRequest<T>(options?: ApiRequest, params?: any[]): Observable<T>;
     postRequest<T extends {
         id?: number | string;
@@ -965,6 +1402,16 @@ declare class LocalStorageManagerService extends ComponentStore<State> implement
     private validStoreName;
     private hasGlobalStorage;
     ngOnDestroy(): void;
+    /**
+     * Clears all stored data from localStorage and sessionStorage
+     * Use this method to recover from corrupted data errors
+     */
+    clearAllStoredData(): void;
+    /**
+     * Checks if stored data appears to be corrupted
+     * Returns true if data appears corrupted
+     */
+    checkForCorruptedData(): boolean;
     static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageManagerService, [{ optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageManagerService>;
 }
@@ -1171,7 +1618,6 @@ declare class HttpRequestServicesDemoComponent implements OnInit {
     server: string;
     user?: UserData;
     path: string[];
-    wsChannel: string;
     adapter?: Function;
     mapper?: Function;
     requestTypes: ({
@@ -1199,7 +1645,7 @@ declare class HttpRequestServicesDemoComponent implements OnInit {
     ngOnInit(): void;
     onSelected(type: number): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestServicesDemoComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<HttpRequestServicesDemoComponent, "app-http-request-services-demo", never, { "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "server": { "alias": "server"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; "wsChannel": { "alias": "wsChannel"; "required": false; }; "adapter": { "alias": "adapter"; "required": false; }; "mapper": { "alias": "mapper"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<HttpRequestServicesDemoComponent, "app-http-request-services-demo", never, { "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "server": { "alias": "server"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; "adapter": { "alias": "adapter"; "required": false; }; "mapper": { "alias": "mapper"; "required": false; }; }, {}, never, never, false, never>;
 }
 
 interface ClientInfoInterface$1 {
@@ -1746,8 +2192,13 @@ declare class StateServiceDemo extends HTTPManagerStateService<any> {
     constructor();
     /**
      * Initialize WebSocket connection with server configuration
+     * @param server - Backend server URL
+     * @param wsServer - WebSocket server URL
+     * @param jwtToken - JWT authentication token
+     * @param user - User information
+     * @param path - Path for constructing channel name (e.g., ['ai','tests'])
      */
-    updateConnection(server: string, wsServer: string, jwtToken: string, user: any): void;
+    updateConnection(server: string, wsServer: string, jwtToken: string, user: any, path?: (string | number)[]): void;
     /**
      * Get all available channels
      */
@@ -1917,7 +2368,6 @@ declare class RequestManagerWsDemoComponent implements OnInit {
     jwtToken: string;
     user: any;
     path: string[];
-    wsChannel: string;
     user$: rxjs.Observable<WSUser | null>;
     attempts$: rxjs.Observable<number>;
     nextRetry$: rxjs.Observable<number>;
@@ -1926,7 +2376,7 @@ declare class RequestManagerWsDemoComponent implements OnInit {
     isPending$: rxjs.Observable<boolean>;
     ngOnInit(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RequestManagerWsDemoComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerWsDemoComponent, "app-request-manager-ws-demo", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; "wsChannel": { "alias": "wsChannel"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerWsDemoComponent, "app-request-manager-ws-demo", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; }, {}, never, never, false, never>;
 }
 
 declare class SettingsStateService extends StoreStateManagerService {
@@ -1994,9 +2444,9 @@ declare class DatabaseDataSource extends DataSource<TableRecord> {
 declare class StateDataRequestService extends HTTPManagerStateService<any> {
     attempts$: rxjs.Observable<number>;
     nextRetry$: rxjs.Observable<number>;
-    path: string[];
+    path: (string | number)[];
     constructor();
-    updateConnection(server: string, wsServer: string, jwtToken: string, user: any, path?: string[], wsChannel?: string): void;
+    updateConnection(server: string, wsServer: string, jwtToken: string, user: any, path?: (string | number)[]): void;
     addData(): void;
     sendMessage(data: ChannelMessage): void;
     getData(): void;
@@ -2011,8 +2461,7 @@ declare class WsDataControlComponent implements OnInit {
     wsServer: string;
     jwtToken: string;
     user: any;
-    path: string[];
-    wsChannel: string;
+    path: (string | number)[];
     stateDataRequestService: StateDataRequestService;
     user$: rxjs.Observable<http_request_manager.WSUser | null>;
     users$: rxjs.Observable<any[]>;
@@ -2025,7 +2474,7 @@ declare class WsDataControlComponent implements OnInit {
     onUpdateData(data: any[]): void;
     onRemoveData(data: any): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WsDataControlComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WsDataControlComponent, "app-ws-data-control", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; "wsChannel": { "alias": "wsChannel"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WsDataControlComponent, "app-ws-data-control", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; }, {}, never, never, false, never>;
 }
 
 declare class WsMessagingComponent implements OnInit, OnDestroy {
@@ -2033,6 +2482,7 @@ declare class WsMessagingComponent implements OnInit, OnDestroy {
     wsServer: string;
     jwtToken: string;
     user: any;
+    path: (string | number)[];
     private destroy$;
     fb: FormBuilder;
     messageService: MessageServiceDemo;
@@ -2088,7 +2538,7 @@ declare class WsMessagingComponent implements OnInit, OnDestroy {
     onChipClick(channel: string, subscribedChannels: string[]): void;
     onSendMessage(user: WSUser): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<WsMessagingComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<WsMessagingComponent, "app-ws-messaging", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; }, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WsMessagingComponent, "app-ws-messaging", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; }, {}, never, never, false, never>;
 }
 
 declare class WsNotificationsComponent implements OnInit, OnDestroy {
@@ -2273,5 +2723,5 @@ declare class HttpRequestManagerModule {
     static ɵinj: i0.ɵɵInjectorDeclaration<HttpRequestManagerModule>;
 }
 
-export { ApiRequest, AppService, AsymmetricalEncryptionService, CONFIG_SETTINGS_TOKEN, ChannelInfo, ChannelType, CommunicationType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, ErrorDisplaySettings, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsManagerService, PathQueryService, Random, RandomHSLColor, RandomHexColor, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomPaletteColor, RandomSignature, RandomStr, RandomVisibleColor, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, StreamType, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UserData, UtilsService, WSOptions, WSUser, WebsocketService, WithCredentialsInterceptor, countdown, createChannelName, delayedRetry, requestPolling, requestStreaming, streamAI, streamAuto, streamEvents, streamJSON, streamNDJSON };
+export { ApiRequest, AppService, AsymmetricalEncryptionService, CONFIG_SETTINGS_TOKEN, ChannelInfo, ChannelType, CommunicationType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, ErrorDisplaySettings, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsManagerService, PathQueryService, Random, RandomHSLColor, RandomHexColor, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomPaletteColor, RandomSignature, RandomStr, RandomVisibleColor, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, StreamType, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UserData, UtilsService, WSOptions, WSUser, WebSocketManagerService, WebsocketService, WithCredentialsInterceptor, countdown, createChannelName, delayedRetry, requestPolling, requestStreaming, streamAI, streamAuto, streamEvents, streamJSON, streamNDJSON };
 export type { APIStateManagerData, ApiRequestInterface, ChannelInfoInterface, ConfigHTTPOptionsInterface, ConfigOptionsInterface, DatabaseStorageInterface, ErrorDisplaySettingsInterface, GlobalStoreOptionsInterface, LocalStorageOptionsInterface, ParsingResult, RequestOptionsInterface, RetryOptionsInterface, SettingOptionsInterface, State, StateStorageOptionsInterface, StateStoreManagerData, StorageDataInterface, StorageOptionInterface, StreamConfig, StreamEvent, TableRecord, TableSchemaDefInterface, UserDataInterface, WSOptionsInterface, WSUserInterface };