http-request-manager 19.2.5 → 22.0.0

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

@@ -1,40 +1,42 @@
 import * as rxjs from 'rxjs';
 import { Observable, Subscription, BehaviorSubject, OperatorFunction } from 'rxjs';
 import * as i0 from '@angular/core';
-import { InjectionToken, OnDestroy, Injector, OnInit, EventEmitter, ModuleWithProviders } from '@angular/core';
+import { InjectionToken, OnDestroy, Injector, DestroyRef, OnInit, OnChanges, SimpleChanges, EventEmitter, ModuleWithProviders } from '@angular/core';
 import { ComponentStore } from '@ngrx/component-store';
 import { HttpClient, HttpHeaders, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
-import * as i17 from 'toast-message-display';
+import * as http_request_manager from 'http-request-manager';
+import * as i18 from 'toast-message-display';
 import { ToastMessageDisplayService } from 'toast-message-display';
 import Dexie, { Table } from 'dexie';
-import * as i35 from '@ngx-translate/core';
+import { AST } from 'node-sql-parser/build/mysql';
+import * as i36 from '@ngx-translate/core';
 import { TranslateService } from '@ngx-translate/core';
 import * as _angular_forms from '@angular/forms';
 import { FormArray, FormBuilder, FormControl } from '@angular/forms';
 import { DataSource } from '@angular/cdk/collections';
 import * as i4 from '@angular/common';
 import * as i7 from '@angular/material/button';
-import * as i20 from '@angular/material/tabs';
-import * as i21 from '@angular/material/select';
-import * as i22 from '@angular/material/chips';
-import * as i23 from '@angular/material/menu';
+import * as i21 from '@angular/material/tabs';
+import * as i22 from '@angular/material/select';
+import * as i23 from '@angular/material/chips';
+import * as i24 from '@angular/material/menu';
 import * as i5 from '@angular/material/icon';
-import * as i25 from '@angular/material/table';
-import * as i26 from '@angular/material/button-toggle';
-import * as i27 from '@angular/material/autocomplete';
-import * as i28 from '@angular/material/progress-bar';
+import * as i26 from '@angular/material/table';
+import * as i27 from '@angular/material/button-toggle';
+import * as i28 from '@angular/material/autocomplete';
+import * as i29 from '@angular/material/progress-bar';
 import * as i6 from '@angular/material/progress-spinner';
 import { ProgressSpinnerMode } from '@angular/material/progress-spinner';
-import * as i30 from '@angular/material/slide-toggle';
-import * as i31 from '@angular/material/divider';
-import * as i32 from '@angular/material/form-field';
-import * as i33 from '@angular/material/input';
-import * as i34 from '@angular/material/toolbar';
-import * as i36 from '@angular/material/sidenav';
-import * as i37 from '@angular/material/datepicker';
-import * as i38 from '@angular/material/core';
+import * as i31 from '@angular/material/slide-toggle';
+import * as i32 from '@angular/material/divider';
+import * as i33 from '@angular/material/form-field';
+import * as i34 from '@angular/material/input';
+import * as i35 from '@angular/material/toolbar';
+import * as i37 from '@angular/material/sidenav';
+import * as i38 from '@angular/material/datepicker';
+import * as i39 from '@angular/material/core';
 import { ThemePalette } from '@angular/material/core';
-import * as i39 from '@angular/material/card';
+import * as i40 from '@angular/material/card';
 
 declare enum StorageType {
     GLOBAL = 0,
@@ -66,9 +68,9 @@ interface StorageOptionInterface {
 declare class StorageOption implements StorageOptionInterface {
     id?: string | undefined;
     name: string;
-    data?: any;
+    data?: any | undefined;
     options?: SettingOptions | undefined;
-    constructor(id?: string | undefined, name?: string, data?: any, options?: SettingOptions | undefined);
+    constructor(id?: string | undefined, name?: string, data?: any | undefined, options?: SettingOptions | undefined);
     static adapt(item?: any): StorageOption;
 }
 
@@ -93,8 +95,8 @@ interface StorageDataInterface {
 }
 declare class StorageData implements StorageDataInterface {
     id?: string | undefined;
-    data?: any;
-    constructor(id?: string | undefined, data?: any);
+    data?: any | undefined;
+    constructor(id?: string | undefined, data?: any | undefined);
     static adapt(item?: any): StorageData;
 }
 
@@ -127,7 +129,7 @@ declare class SymmetricalEncryptionService {
     constructor();
     generateCipherKey(): string;
     encrypt(str: any, key?: string): string | undefined;
-    decrypt(str: string, key?: string): string | null | undefined;
+    decrypt(str: string, key?: string): string | null;
     createSignature(url: string, len?: number): string;
     normalizeURL(url: string): string;
     generateSignature(url: string): string;
@@ -170,9 +172,9 @@ declare class WSOptions implements WSOptionsInterface {
     permissions?: string[] | undefined;
     channels?: string[] | undefined;
     wsUpdateChannels?: string[] | undefined;
-    user?: any;
+    user?: any | undefined;
     retry?: RetryOptions | undefined;
-    constructor(id?: string, wsServer?: string, 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, wsUpdateChannels?: string[] | undefined, user?: any | undefined, retry?: RetryOptions | undefined);
     static adapt(item?: any): WSOptions;
 }
 
@@ -201,30 +203,63 @@ interface ApiRequestInterface {
     stream?: boolean;
     streamType?: StreamType;
     displayError?: boolean;
+    displaySuccess?: boolean;
+    successMessage?: string;
+    errorMessage?: string;
     saveAs?: string;
     fileContentHeader?: string;
     ws?: WSOptions;
     env?: string;
+    uploadFiles?: File | File[];
+    uploadFieldName?: string;
+    uploadHttpMethod?: 'POST' | 'PUT';
+    allowedTypes?: string[];
+    maxFileSize?: number;
+    maxTotalSize?: number;
 }
 declare class ApiRequest implements ApiRequestInterface {
     server: string;
     path?: any[] | undefined;
-    headers?: any;
-    adapter?: any;
-    mapper?: any;
+    headers?: any | undefined;
+    adapter?: any | undefined;
+    mapper?: any | undefined;
     polling?: number | undefined;
     retry?: RetryOptions | undefined;
     stream?: boolean | undefined;
     streamType?: StreamType | undefined;
     displayError?: boolean | undefined;
+    displaySuccess?: boolean | undefined;
+    successMessage?: string | undefined;
+    errorMessage?: string | 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);
+    uploadFiles?: (File | File[]) | undefined;
+    uploadFieldName?: string | undefined;
+    uploadHttpMethod?: "POST" | "PUT" | undefined;
+    allowedTypes?: string[] | undefined;
+    maxFileSize?: number | undefined;
+    maxTotalSize?: number | undefined;
+    constructor(server?: string, path?: any[] | undefined, headers?: any | undefined, adapter?: any | undefined, mapper?: any | undefined, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, streamType?: StreamType | undefined, displayError?: boolean | undefined, displaySuccess?: boolean | undefined, successMessage?: string | undefined, errorMessage?: string | undefined, saveAs?: string | undefined, fileContentHeader?: string | undefined, ws?: WSOptions | undefined, env?: string | undefined, uploadFiles?: (File | File[]) | undefined, uploadFieldName?: string | undefined, uploadHttpMethod?: "POST" | "PUT" | undefined, allowedTypes?: string[] | undefined, maxFileSize?: number | undefined, maxTotalSize?: number | undefined);
     static adapt(item?: any): ApiRequest;
 }
 
+interface StreamProgressInterface {
+    received: number;
+    total?: number;
+    percent: number;
+    stage: 'connecting' | 'streaming' | 'complete' | 'error';
+}
+declare class StreamProgressModel implements StreamProgressInterface {
+    received: number;
+    total?: number | undefined;
+    percent: number;
+    stage: 'connecting' | 'streaming' | 'complete' | 'error';
+    constructor(received?: number, total?: number | undefined, percent?: number, stage?: 'connecting' | 'streaming' | 'complete' | 'error');
+    static adapt(item?: any): StreamProgressModel;
+}
+
 interface WSUserInterface {
     id: string;
     ldap?: string;
@@ -340,21 +375,101 @@ interface DatabaseStorageInterface {
 declare class DatabaseStorage implements DatabaseStorageInterface {
     table: string;
     expiresIn: '';
-    constructor(table: string, expiresIn: '');
+    constructor(table: string | undefined, expiresIn: '');
     static adapt(item?: any): any;
 }
 
 interface RequestOptionsInterface {
     path: any[];
     headers: any;
+    forceRefresh?: boolean;
+    ignoreQueryParams?: string[];
+    queryParamsExpiresIn?: string | number;
 }
 declare class RequestOptions implements RequestOptionsInterface {
     path: any[];
     headers: {};
-    constructor(path?: any[], headers?: {});
+    forceRefresh?: boolean | undefined;
+    ignoreQueryParams?: string[] | undefined;
+    queryParamsExpiresIn?: string | number | undefined;
+    constructor(path?: any[], headers?: {}, forceRefresh?: boolean | undefined, ignoreQueryParams?: string[] | undefined, queryParamsExpiresIn?: string | number | undefined);
     static adapt(item?: any): RequestOptions;
 }
 
+interface OperationResultInterface {
+    success: boolean;
+    operation: 'CREATE' | 'UPDATE' | 'DELETE';
+}
+declare class OperationResultModel implements OperationResultInterface {
+    success: boolean;
+    operation: 'CREATE' | 'UPDATE' | 'DELETE';
+    constructor(success?: boolean, operation?: 'CREATE' | 'UPDATE' | 'DELETE');
+    static adapt(item?: any): OperationResultModel;
+}
+
+interface StreamConfigInterface {
+    streamType: StreamType;
+    totalHeader?: string;
+}
+declare class StreamConfigModel implements StreamConfigInterface {
+    streamType: StreamType;
+    totalHeader: string;
+    constructor(streamType?: StreamType, totalHeader?: string);
+    static adapt(item?: any): StreamConfigModel;
+}
+
+interface StreamOutputInterface<T = any> {
+    data: T[];
+    progress: StreamProgressModel;
+    endpoint?: string;
+}
+declare class StreamOutputModel<T = any> implements StreamOutputInterface<T> {
+    data: T[];
+    progress: StreamProgressModel;
+    endpoint?: string | undefined;
+    constructor(data?: T[], progress?: StreamProgressModel, endpoint?: string | undefined);
+    static adapt<T = any>(item?: any): StreamOutputModel<T>;
+}
+
+interface StreamEventMetadataInterface {
+    timestamp: Date;
+    streamType: StreamType;
+    contentLength?: number;
+}
+declare class StreamEventMetadataModel implements StreamEventMetadataInterface {
+    timestamp: Date;
+    streamType: StreamType;
+    contentLength?: number | undefined;
+    constructor(timestamp?: Date, streamType?: StreamType, contentLength?: number | undefined);
+    static adapt(item?: any): StreamEventMetadataModel;
+}
+
+interface StreamEventInterface<T = any> {
+    type: 'progress' | 'complete' | 'data';
+    data: T;
+    metadata?: StreamEventMetadataModel;
+}
+declare class StreamEventModel<T = any> implements StreamEventInterface<T> {
+    type: 'progress' | 'complete' | 'data';
+    data: T;
+    metadata?: StreamEventMetadataModel | undefined;
+    constructor(type?: 'progress' | 'complete' | 'data', data?: T, metadata?: StreamEventMetadataModel | undefined);
+    static adapt<T = any>(item?: any): StreamEventModel<T>;
+}
+
+interface ParsingResultInterface<T = any> {
+    success: boolean;
+    data?: T[];
+    error?: string;
+}
+declare class ParsingResultModel<T = any> implements ParsingResultInterface<T> {
+    success: boolean;
+    data?: T[] | undefined;
+    error?: string | undefined;
+    constructor(success?: boolean, data?: T[] | undefined, error?: string | undefined);
+    static adapt<T = any>(item?: any): ParsingResultModel<T>;
+}
+
 interface TableSchemaDefInterface {
     table: string;
     schema: string;
@@ -385,14 +500,17 @@ declare class DbService extends Dexie {
         value: string | number;
     }, data: any): Promise<boolean>;
     protected createTable(tableName: string, schema: string): Promise<void>;
+    private _doCreateTable;
     protected DBOpened(): Promise<boolean>;
     private getCurrentSchema;
+    protected deleteAndReinitialize(): Observable<boolean>;
     protected cleanTableName(str: string): string;
     static ɵfac: i0.ɵɵFactoryDeclaration<DbService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DbService>;
 }
 
 declare class DatabaseManagerService extends DbService {
+    private localStorageManager;
     constructor();
     getDatabaseTables(): Observable<any[]>;
     databaseExists(): Observable<boolean>;
@@ -406,22 +524,39 @@ declare class DatabaseManagerService extends DbService {
     getTableRecords(table: string): Observable<unknown>;
     getTableRecord(table: string, id: number): Observable<any>;
     createTableRecord(table: string, record: any): Observable<any>;
-    createTableRecords(table: string, records: any[]): Observable<{
-        [key: string]: any;
-    }[]>;
-    updateTableRecord(table: string, record: any): Observable<{
-        [key: string]: any;
-    } | null>;
-    updateTableRecords(table: string, records: any[]): Observable<{
-        [key: string]: any;
-    }[]>;
+    createTableRecords(table: string, records: any[]): Observable<any[]>;
+    private inferSchemaFromRecords;
+    private isMissingObjectStoreError;
+    updateTableRecord(table: string, record: any): Observable<any>;
+    updateTableRecords(table: string, records: any[]): Observable<any[]>;
     deleteTableRecord<T>(table: string, id: number): Observable<number | null>;
     deleteTableRecords(table: string, ids: number[]): Observable<number[]>;
     clearTable(table: string): Observable<never[]>;
+    clearDatabase(): void;
+    resetDatabase(): Observable<boolean>;
     static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseManagerService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<DatabaseManagerService>;
 }
 
+declare class DatabaseManagerSignalsService {
+    private readonly dbManager;
+    private readonly isPendingSignal;
+    private readonly tablesSignal;
+    private readonly databaseReadySignal;
+    readonly isPending: i0.Signal<boolean>;
+    readonly tables: i0.Signal<string[]>;
+    readonly databaseReady: i0.Signal<boolean>;
+    getDatabaseTables(): Observable<string[]>;
+    databaseExists(): Observable<boolean>;
+    hasDatabaseTable(table: string): Observable<boolean>;
+    getDatabaseTable(table: string): Observable<any>;
+    getDatabaseTableSchema(table: string): Observable<string[]>;
+    createDatabaseTable(tableDef: TableSchemaDef): Observable<boolean>;
+    updateDatabaseTableSchema(tableDef: TableSchemaDef): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseManagerSignalsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatabaseManagerSignalsService>;
+}
+
 interface ChannelMessageInterface {
     messageId?: number;
     channel?: string;
@@ -458,6 +593,7 @@ declare class ChannelMessage implements ChannelMessageInterface {
  * ```
  */
 declare class LoggerService {
+    private static readonly DEBUG_FLAG_KEY;
     private debugMode;
     constructor();
     /**
@@ -484,6 +620,7 @@ declare class LoggerService {
      * Check if debug mode is enabled (development mode)
      */
     isDebugEnabled(): boolean;
+    private isDebugFlagEnabled;
     static ɵfac: i0.ɵɵFactoryDeclaration<LoggerService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LoggerService>;
 }
@@ -522,6 +659,8 @@ declare class HTTPManagerStateService<T extends {
     logger: LoggerService;
     error$: Observable<boolean>;
     isPending$: Observable<boolean>;
+    private operationSuccess;
+    operationSuccess$: Observable<OperationResultModel | null>;
     private page;
     page$: Observable<number>;
     private totalPages;
@@ -529,12 +668,16 @@ declare class HTTPManagerStateService<T extends {
     private percentage;
     percentage$: Observable<number>;
     private hasDatabase;
-    streamedResponse: never[];
+    streamedResponse: any[];
     private maxRetries;
     private retryDelay;
     private shouldRetry;
     private connectionStatusSubscription?;
     private databaseOptions?;
+    private readonly volatileHeaders;
+    private requestSignatureCache;
+    private inFlightRequestSignatures;
+    private _requestCachePaths;
     private wsRetryAttempts;
     wsRetryAttempts$: Observable<number>;
     private wsNextRetry;
@@ -568,7 +711,11 @@ declare class HTTPManagerStateService<T extends {
     private ownSessionId;
     wsOptions: WSOptions;
     connectionStatus$: Observable<boolean>;
-    constructor(apiOptions: ApiRequest, dataType: DataType | undefined, database?: DatabaseStorage);
+    isConnecting$: Observable<boolean>;
+    wsRetryCount$: Observable<number>;
+    wsMaxRetries$: Observable<number>;
+    connectionError$: Observable<string | null>;
+    constructor(apiOptions: ApiRequest | undefined, dataType: DataType | undefined, database?: DatabaseStorage);
     /**
      * Add appropriate prefix to a channel name if not already present
      */
@@ -600,6 +747,9 @@ declare class HTTPManagerStateService<T extends {
     readonly clearRecords: (observableOrValue?: void | Observable<void> | undefined) => Subscription;
     readonly fetchRecords: (options?: RequestOptions) => ((observableOrValue?: any) => Subscription) | ((observableOrValue: any) => Subscription);
     private initDBStorageAsync;
+    private buildSchemaFromAdapter;
+    private buildSchemaFromSample;
+    private persistStreamDataToDb;
     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);
@@ -704,11 +854,163 @@ declare class HTTPManagerStateService<T extends {
      */
     clearDatabase(): void;
     private isEmpty;
+    /**
+     * Update request options with provided headers
+     */
     private updateRequestOptions;
+    private normalizeObject;
+    private filterHeaders;
+    private resolvePath;
+    private stripBasePathPrefix;
+    private getEffectiveParams;
+    private buildRequestSignature;
+    private buildSchemaSignature;
+    private setCachedRequestSignature;
+    private tryBeginInFlightRequest;
+    private endInFlightRequest;
+    private getRequestCacheMetadata;
+    private getStoredSchemaSignature;
+    private saveSchemaSignature;
+    private saveRequestCacheMetadata;
+    private clearRequestCacheMetadata;
+    private trackerNormalizePath;
+    private trackerParsePathSegment;
+    private trackerSafeDecode;
+    private trackerNormalizePathSegments;
+    private trackerNormalizeParamKey;
+    private trackerNormalizeParamValue;
+    private trackerFilterQuery;
+    private checkTrackerAllowsRequest;
     static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerStateService<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerStateService<any>>;
 }
 
+interface BatchOptionsInterface {
+    mode?: 'sequential' | 'parallel';
+    stopOnError?: boolean;
+    concurrency?: number;
+    ignoreErrors?: boolean;
+    logErrors?: boolean;
+    displaySuccess?: boolean;
+    displayError?: boolean;
+}
+declare class BatchOptions implements BatchOptionsInterface {
+    mode: 'sequential' | 'parallel';
+    stopOnError: boolean;
+    concurrency: number;
+    ignoreErrors: boolean;
+    logErrors: boolean;
+    displaySuccess?: boolean | undefined;
+    displayError?: boolean | undefined;
+    constructor(mode?: 'sequential' | 'parallel', stopOnError?: boolean, concurrency?: number, ignoreErrors?: boolean, logErrors?: boolean, displaySuccess?: boolean | undefined, displayError?: boolean | undefined);
+    static adapt(item?: any): BatchOptions;
+}
+
+declare class HTTPManagerStateSignalsService<T = any> {
+    private readonly httpManagerSignalsService;
+    private readonly databaseManagerSignalsService;
+    private readonly localStorageSignalsManagerService;
+    private readonly utils;
+    private readonly logger;
+    private readonly destroyRef;
+    private readonly injector;
+    private readonly dataSignal;
+    private readonly dataObjectSignal;
+    private readonly operationSuccessSignal;
+    private readonly pageSignal;
+    private readonly totalPagesSignal;
+    private readonly percentageSignal;
+    private readonly streamedResponseSignal;
+    private readonly messagesSignal;
+    readonly data: i0.Signal<T[]>;
+    readonly dataObject: i0.Signal<T | null>;
+    readonly operationSuccess: i0.Signal<OperationResultModel | null>;
+    readonly page: i0.Signal<number>;
+    readonly totalPages: i0.Signal<number>;
+    readonly percentage: i0.Signal<number>;
+    readonly streamedResponse: i0.Signal<any[]>;
+    readonly messages: i0.Signal<any[]>;
+    readonly error: i0.WritableSignal<boolean>;
+    readonly isPending: i0.WritableSignal<boolean>;
+    readonly isConnecting: i0.Signal<boolean>;
+    readonly retryCount: i0.Signal<number>;
+    readonly maxRetries: i0.Signal<number>;
+    readonly connectionError: i0.Signal<string | null>;
+    constructor();
+    setData(items: T[]): void;
+    setDataObject(item: T | null): void;
+    setOperationSuccess(result: OperationResultModel | null): void;
+    setPage(n: number): void;
+    setTotalPages(n: number): void;
+    setPercentage(n: number): void;
+    appendStreamedItem(item: any): void;
+    clearStreamedResponse(): void;
+    clearMessages(): void;
+    getRequest<U = T>(options?: ApiRequest, params?: any[]): rxjs.Observable<U>;
+    postRequest<U extends {
+        id?: number | string;
+    } = any>(data: U, options: ApiRequest, params?: any[]): rxjs.Observable<U>;
+    putRequest<U extends {
+        id?: number | string;
+    } = any>(data: U, options: ApiRequest, params?: any[]): rxjs.Observable<U>;
+    deleteRequest<U = T>(options: ApiRequest, params?: any[]): rxjs.Observable<U>;
+    downloadRequest<U = T>(options: ApiRequest, params?: any[], saveAs?: string): rxjs.Observable<U>;
+    uploadRequest<U = T>(files: File | File[], options: ApiRequest, params?: any[]): rxjs.Observable<U>;
+    getBatchRequests<U = T>(requests: ApiRequest[], options?: BatchOptions): rxjs.Observable<U[]>;
+    getSequentialRequest<U = T>(requests: ApiRequest[], options?: BatchOptions): rxjs.Observable<U[]>;
+    getParallelRequest<U = T>(requests: ApiRequest[], options?: BatchOptions): rxjs.Observable<U[]>;
+    connect(options: WSOptions, jwtToken: string): void;
+    disconnect(): void;
+    subscribeToChannel(channel: string, userData?: any): void;
+    subscribeToChannels(channels: string[], userData?: any): void;
+    unsubscribeFromChannel(channel: string): void;
+    getSubscribedChannels(): Set<string>;
+    sendBroadcast(content: any): void;
+    sendMessageInChannel(channel: string, content: any): void;
+    sendChannelMessage(channel: string, content: any): void;
+    sendChannelMessageToChannels(channels: string[], content: any): void;
+    sendMessageToUser(user: string, content: any): void;
+    getAllChannels(): void;
+    createChannel(channel: string): void;
+    deleteChannel(channel: string): void;
+    getUsersInChannel(channel: string): void;
+    createNotificationChannel(channel: string): void;
+    getNotificationChannels(): void;
+    getTodaysNotificationChannels(): void;
+    subscribeToNotificationChannel(channel: string, options?: any, user?: any): void;
+    unsubscribeFromNotificationChannel(channel: string): void;
+    sendNotification(channel: string, content: any): void;
+    getDatabaseTables(): rxjs.Observable<string[]>;
+    databaseExists(): rxjs.Observable<boolean>;
+    hasDatabaseTable(table: string): rxjs.Observable<boolean>;
+    getDatabaseTable(table: string): rxjs.Observable<any>;
+    getDatabaseTableSchema(table: string): rxjs.Observable<string[]>;
+    createDatabaseTable(tableDef: TableSchemaDef): rxjs.Observable<boolean>;
+    updateDatabaseTableSchema(tableDef: TableSchemaDef): rxjs.Observable<any>;
+    createStore(store: {
+        id?: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }): void;
+    setStore(store: {
+        id: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }): void;
+    updateStore(store: {
+        name: string;
+        data: any;
+    }): void;
+    deleteStore(store: {
+        name: string;
+    }): void;
+    getStore(storeName: string): i0.Signal<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerStateSignalsService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerStateSignalsService<any>>;
+}
+
 declare class WebsocketService {
     private logger;
     private socket;
@@ -780,13 +1082,27 @@ declare class WebsocketService {
  */
 declare class WebSocketManagerService {
     private static socket;
-    private static isConnecting;
+    private static isConnectingSubject;
+    isConnecting$: Observable<boolean>;
     private static connectionInitialized;
+    private static shouldRetry;
     private static lastOptions;
+    private static lastJwtToken;
+    private static retryCount;
+    private static retryDelay;
+    private static retrySubscription;
+    private static maxRetries;
+    private static connectionReadyNotified;
+    private static retryCountSubject;
+    retryCount$: Observable<number>;
+    private static maxRetriesSubject;
+    maxRetries$: Observable<number>;
     private static messages;
     messages$: Observable<any>;
     private static connectionStatus;
     connectionStatus$: Observable<boolean>;
+    private static connectionError;
+    connectionError$: Observable<string | null>;
     private static isSubscribed;
     private static subscribedChannels;
     subscribedChannels$: Observable<Set<string>>;
@@ -1002,6 +1318,8 @@ declare class RequestService extends WebsocketService {
     isPending$: Observable<boolean>;
     progress: BehaviorSubject<number>;
     progress$: Observable<number>;
+    streamProgress: BehaviorSubject<StreamProgressModel>;
+    streamProgress$: Observable<StreamProgressModel>;
     getRecordRequest<T>(options: ApiRequest): Observable<T>;
     getRecordRequest<T>(options: ApiRequest): Observable<T>;
     getRecordRequest<T>(options: ApiRequest & {
@@ -1023,6 +1341,9 @@ declare class RequestService extends WebsocketService {
     private request;
     private requestStreaming;
     downloadFileRequest(options: ApiRequest): Observable<any>;
+    uploadFileRequest(options: ApiRequest): Observable<any>;
+    private validateUploadFiles;
+    private buildFormData;
     private handleFinalize;
     private downloadFile;
     private createFileType;
@@ -1042,23 +1363,6 @@ declare class RetryOptions implements RetryOptionsInterface {
     static adapt(item?: any): RetryOptions;
 }
 
-interface BatchOptionsInterface {
-    mode?: 'sequential' | 'parallel';
-    stopOnError?: boolean;
-    concurrency?: number;
-    ignoreErrors?: boolean;
-    logErrors?: boolean;
-}
-declare class BatchOptions implements BatchOptionsInterface {
-    mode: 'sequential' | 'parallel';
-    stopOnError: boolean;
-    concurrency: number;
-    ignoreErrors: boolean;
-    logErrors: boolean;
-    constructor(mode?: 'sequential' | 'parallel', stopOnError?: boolean, concurrency?: number, ignoreErrors?: boolean, logErrors?: boolean);
-    static adapt(item?: any): BatchOptions;
-}
-
 interface BatchResultInterface<T = any> {
     request: any;
     success: boolean;
@@ -1071,10 +1375,10 @@ declare class BatchResult<T = any> implements BatchResultInterface<T> {
     request: any;
     success: boolean;
     data?: T | undefined;
-    error?: any;
+    error?: any | undefined;
     index: number;
     timestamp: number;
-    constructor(request: any, success: boolean, data?: T | undefined, error?: any, index?: number, timestamp?: number);
+    constructor(request: any, success: boolean, data?: T | undefined, error?: any | undefined, index?: number, timestamp?: number);
     static adapt<T>(item?: any): BatchResult<T>;
 }
 
@@ -1127,16 +1431,18 @@ interface ConfigHTTPOptionsInterface {
     retry?: RetryOptions;
     stream?: boolean;
     displayError?: boolean;
+    displaySuccess?: boolean;
 }
 declare class ConfigHTTPOptions implements ConfigHTTPOptionsInterface {
     server: string;
     path?: any[] | undefined;
-    headers?: any;
+    headers?: any | undefined;
     polling?: number | undefined;
     retry?: RetryOptions | undefined;
     stream?: boolean | undefined;
     displayError?: boolean | undefined;
-    constructor(server?: string, path?: any[] | undefined, headers?: any, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, displayError?: boolean | undefined);
+    displaySuccess?: boolean | undefined;
+    constructor(server?: string, path?: any[] | undefined, headers?: any | undefined, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, displayError?: boolean | undefined, displaySuccess?: boolean | undefined);
     static adapt(item?: any): ConfigHTTPOptions;
 }
 
@@ -1171,19 +1477,31 @@ declare class ConfigOptions implements ConfigOptionsInterface {
  */
 declare const CONFIG_SETTINGS_TOKEN: InjectionToken<ConfigOptions>;
 
-interface UserDataInterface {
-    ldap: string;
-    name: string;
-    email: string;
-    color: string;
-}
-declare class UserData implements UserDataInterface {
-    ldap: string;
-    name: string;
-    email: string;
-    color: string;
-    constructor(ldap?: string, name?: string, email?: string, color?: string);
-    static adapt(item?: any): UserData;
+interface InvalidFileInfoInterface {
+    fileName: string;
+    fileSize: number;
+    fileType: string;
+    errors: string[];
+}
+declare class InvalidFileInfoModel implements InvalidFileInfoInterface {
+    fileName: string;
+    fileSize: number;
+    fileType: string;
+    errors: string[];
+    constructor(fileName?: string, fileSize?: number, fileType?: string, errors?: string[]);
+    static adapt(item?: any): InvalidFileInfoModel;
+}
+interface UploadValidationErrorInterface {
+    invalidFiles: InvalidFileInfoModel[];
+    validFilesCount: number;
+    totalFilesCount: number;
+}
+declare class UploadValidationErrorModel implements UploadValidationErrorInterface {
+    invalidFiles: InvalidFileInfoModel[];
+    validFilesCount: number;
+    totalFilesCount: number;
+    constructor(invalidFiles?: InvalidFileInfoModel[], validFilesCount?: number, totalFilesCount?: number);
+    static adapt(item?: any): UploadValidationErrorModel;
 }
 
 declare class ObjectMergerService {
@@ -1247,10 +1565,10 @@ declare class MessageTrackerService implements OnDestroy {
      * Map<channel, retryCount>
      */
     private gapRetryCount;
-    /** Batch acknowledgment timer */
-    private batchAckTimer;
     /** Subscription to WebSocket messages */
     private messagesSubscription;
+    /** Subject to signal destroy for takeUntil */
+    private destroy$;
     /**
      * Track channels we want to be subscribed to (survives disconnect/reconnect)
      * This is separate from WebSocketManagerService.subscribedChannels which tracks
@@ -1275,14 +1593,6 @@ declare class MessageTrackerService implements OnDestroy {
      * 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
      */
@@ -1363,6 +1673,10 @@ declare class HTTPManagerService<T> extends RequestService {
     connectionStatus$: Observable<boolean>;
     messages$: Observable<any>;
     subscribedChannels$: Observable<Set<string>>;
+    isConnecting$: Observable<boolean>;
+    retryCount$: Observable<number>;
+    maxRetries$: Observable<number>;
+    connectionError$: Observable<string | null>;
     private countdown;
     countdown$: Observable<number>;
     private error;
@@ -1371,6 +1685,7 @@ declare class HTTPManagerService<T> extends RequestService {
     data$: Observable<any>;
     private polling$;
     config: ApiRequest;
+    streamProgress$: Observable<http_request_manager.StreamProgressModel>;
     constructor(configOptions?: ConfigOptions | undefined);
     /**
      * Connect to WebSocket server
@@ -1466,11 +1781,13 @@ declare class HTTPManagerService<T> extends RequestService {
     }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
     deleteRequest<T>(options: ApiRequest, params?: any[]): Observable<T>;
     downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string): Observable<T>;
+    uploadRequest<T>(files: File | File[], options: ApiRequest, params?: any[]): Observable<T>;
     private createObservable;
     private createRequest;
     private prepareRequestData;
     private handleError;
     private handleErrorWithSnackBar;
+    private handleSuccessWithSnackBar;
     private stopPolling;
     private defineReqOptions;
     /**
@@ -1486,14 +1803,14 @@ declare class HTTPManagerService<T> extends RequestService {
      * @param options Optional batch configuration
      * @returns Observable emitting array of data when all requests complete
      */
-    getSequentialRequest<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<U[]>;
+    getSequentialRequest<U = T>(requests: ApiRequest[], options?: BatchOptions, successMessage?: string, errorMessage?: string): Observable<U[]>;
     /**
      * Execute requests in parallel with concurrency control
      * @param requests Array of ApiRequest configurations
      * @param options Optional batch configuration with concurrency limit
      * @returns Observable emitting array of data when all requests complete
      */
-    getParallelRequest<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<U[]>;
+    getParallelRequest<U = T>(requests: ApiRequest[], options?: BatchOptions, successMessage?: string, errorMessage?: string): Observable<U[]>;
     /**
      * Execute multiple HTTP requests and emit individual state changes in real-time
      * @param requests Array of ApiRequest configurations
@@ -1521,6 +1838,7 @@ declare class RequestSignalsService extends WebsocketService {
     private headersService;
     isPending: i0.WritableSignal<boolean>;
     progress: i0.WritableSignal<number>;
+    streamProgress: i0.WritableSignal<StreamProgressModel>;
     isIdle: i0.Signal<boolean>;
     getRecordRequest<T>(options: ApiRequest): Observable<T>;
     getRecordRequest<T>(options: ApiRequest & {
@@ -1538,6 +1856,9 @@ declare class RequestSignalsService extends WebsocketService {
     private request;
     private requestStreamingOperator;
     downloadFileRequest(options: ApiRequest): Observable<any>;
+    uploadFileRequest(options: ApiRequest): Observable<any>;
+    private validateUploadFiles;
+    private buildFormData;
     private handleFinalize;
     private downloadFile;
     private createFileType;
@@ -1557,8 +1878,12 @@ declare class HTTPManagerSignalsService<T> extends RequestSignalsService {
     messages$: Observable<any>;
     subscribedChannels$: Observable<Set<string>>;
     countdown: i0.WritableSignal<number>;
-    error: i0.WritableSignal<string | boolean>;
+    error: i0.WritableSignal<boolean>;
     data: i0.WritableSignal<any>;
+    isConnecting: i0.Signal<boolean>;
+    retryCount: i0.Signal<number>;
+    maxRetries: i0.Signal<number>;
+    connectionError: i0.Signal<string | null>;
     private polling$;
     config: ApiRequest;
     constructor(configOptions?: ConfigOptions | undefined);
@@ -1655,11 +1980,13 @@ declare class HTTPManagerSignalsService<T> extends RequestSignalsService {
     }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
     deleteRequest<T>(options: ApiRequest, params?: any[]): Observable<T>;
     downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string): Observable<T>;
+    uploadRequest<T>(files: File | File[], options: ApiRequest, params?: any[]): Observable<T>;
     private createObservable;
     private createRequest;
     private prepareRequestData;
     private handleError;
     private handleErrorWithSnackBar;
+    private handleSuccessWithSnackBar;
     private stopPolling;
     private defineReqOptions;
     /**
@@ -1675,14 +2002,14 @@ declare class HTTPManagerSignalsService<T> extends RequestSignalsService {
      * @param options Optional batch configuration
      * @returns Observable emitting array of data when all requests complete
      */
-    getSequentialRequest<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<U[]>;
+    getSequentialRequest<U = T>(requests: ApiRequest[], options?: BatchOptions, successMessage?: string, errorMessage?: string): Observable<U[]>;
     /**
      * Execute requests in parallel with concurrency control
      * @param requests Array of ApiRequest configurations
      * @param options Optional batch configuration with concurrency limit
      * @returns Observable emitting array of data when all requests complete
      */
-    getParallelRequest<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<U[]>;
+    getParallelRequest<U = T>(requests: ApiRequest[], options?: BatchOptions, successMessage?: string, errorMessage?: string): Observable<U[]>;
     /**
      * Execute multiple HTTP requests and emit individual state changes in real-time
      * @param requests Array of ApiRequest configurations
@@ -1710,23 +2037,6 @@ declare function delayedRetry<T>(delayMs: number, maxRetry?: number): (src: Obse
 
 declare function requestPolling<T>(pollInterval: number, stopCondition$: Observable<any>, isPending$: any): (source: Observable<T>) => Observable<T>;
 
-interface StreamConfig {
-    streamType: StreamType;
-}
-interface StreamEvent<T = any> {
-    type: 'progress' | 'complete' | 'data';
-    data: T;
-    metadata?: {
-        timestamp: Date;
-        streamType: StreamType;
-        contentLength?: number;
-    };
-}
-interface ParsingResult<T = any> {
-    success: boolean;
-    data?: T[];
-    error?: string;
-}
 /**
  * COMPREHENSIVE REQUEST STREAMING OPERATOR - FULLY ABSTRACTED
  * Refactored for better type safety and memory management
@@ -1742,15 +2052,15 @@ interface ParsingResult<T = any> {
  *   this.http.get(url, options).pipe(requestStreaming()).subscribe(data => {...})
  *   this.http.get(url, options).pipe(requestStreaming({ streamType: StreamType.NDJSON })).subscribe(data => {...})
  */
-declare function requestStreaming<T = any>(config?: StreamConfig): OperatorFunction<any, T[]>;
+declare function requestStreaming<T = any>(config?: StreamConfigModel): OperatorFunction<any, StreamOutputModel<T>>;
 /**
  * Convenience functions for common use cases
  */
-declare function streamJSON<T = any>(): OperatorFunction<any, T[]>;
-declare function streamNDJSON<T = any>(): OperatorFunction<any, T[]>;
-declare function streamAI<T = any>(): OperatorFunction<any, T[]>;
-declare function streamEvents<T = any>(): OperatorFunction<any, T[]>;
-declare function streamAuto<T = any>(): OperatorFunction<any, T[]>;
+declare function streamJSON<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;
+declare function streamNDJSON<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;
+declare function streamAI<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;
+declare function streamEvents<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;
+declare function streamAuto<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;
 
 interface State {
     localStores: StorageData[];
@@ -1833,6 +2143,7 @@ declare class LocalStorageManagerService extends ComponentStore<State> implement
      * Returns true if data appears corrupted
      */
     checkForCorruptedData(): boolean;
+    private tryParseSettingsArray;
     static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageManagerService, [{ optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageManagerService>;
 }
@@ -1845,6 +2156,7 @@ declare class LocalStorageSignalsManagerService {
     defaultOptions: SettingOptions;
     stateRetrieved: boolean;
     encrypted: boolean;
+    destroyRef: DestroyRef;
     app: AppService;
     utils: UtilsService;
     objectMergerService: ObjectMergerService;
@@ -1883,6 +2195,7 @@ declare class LocalStorageSignalsManagerService {
     private isObjectOrArray;
     private isString;
     private validStoreName;
+    private tryParseSettingsArray;
     static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageSignalsManagerService, [{ optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageSignalsManagerService>;
 }
@@ -1900,6 +2213,25 @@ declare class StateStorageOptions implements StateStorageOptionsInterface {
     static adapt(item?: any): StateStorageOptions;
 }
 
+interface StateOperationResultInterface {
+    success: boolean;
+    operation: 'CREATE' | 'UPDATE' | 'DELETE';
+    key?: string;
+    value?: any;
+    timestamp: number;
+    error?: string;
+}
+declare class StateOperationResult implements StateOperationResultInterface {
+    success: boolean;
+    operation: 'CREATE' | 'UPDATE' | 'DELETE';
+    key?: string | undefined;
+    value?: any | undefined;
+    timestamp: number;
+    error?: string | undefined;
+    constructor(success?: boolean, operation?: 'CREATE' | 'UPDATE' | 'DELETE', key?: string | undefined, value?: any | undefined, timestamp?: number, error?: string | undefined);
+    static adapt(item?: any): StateOperationResult;
+}
+
 interface StateStoreManagerData$1<T> {
 }
 declare class StoreStateManagerService<T extends object = StateStoreManagerData$1<any>> extends ComponentStore<T> {
@@ -1908,13 +2240,18 @@ declare class StoreStateManagerService<T extends object = StateStoreManagerData$
     subscriptions: Subscription;
     settings: any;
     private isRestoring;
+    private operationResult;
+    operationResult$: Observable<StateOperationResult | null>;
     constructor(options?: StateStorageOptions);
     private static init;
     init(options?: StateStorageOptions): void;
     restoreState(): Subscription;
     updateState(state: any): void;
-    readonly data$: rxjs.Observable<any>;
+    readonly data$: Observable<any>;
     readonly updateData: (() => void) | ((observableOrValue: any) => Subscription);
+    createRecord(key: string, value: any): void;
+    updateRecord(key: string, value: any): void;
+    deleteRecord(key: string): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<StoreStateManagerService<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<StoreStateManagerService<any>>;
 }
@@ -1923,9 +2260,12 @@ interface StateStoreManagerData<T> {
 }
 declare class StoreStateManagerSignalsService<T extends object = StateStoreManagerData<any>> {
     private localStorageManagerService;
+    private injector;
     private state;
     private isRestoring;
     private settings;
+    private operationResultSignal;
+    readonly operationResult: i0.Signal<StateOperationResult | null>;
     readonly data: i0.Signal<T | null>;
     readonly transformedData: i0.Signal<any>;
     constructor();
@@ -1933,11 +2273,102 @@ declare class StoreStateManagerSignalsService<T extends object = StateStoreManag
     restoreState(): void;
     updateState(state: Partial<T>): void;
     updateData(data: Partial<T>): void;
+    createRecord(key: string, value: any): void;
+    updateRecord(key: string, value: any): void;
+    deleteRecord(key: string): void;
     resetState(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<StoreStateManagerSignalsService<any>, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<StoreStateManagerSignalsService<any>>;
 }
 
+interface DexieSqlOptions {
+    strict?: boolean;
+}
+
+declare class DexieSqlService {
+    private readonly _parser;
+    private readonly _validator;
+    private readonly _planner;
+    private readonly _executor;
+    /**
+     * Execute a MySQL-syntax SQL SELECT string against the DexieJS IndexedDB database.
+     * Returns an Observable that emits the result array and completes, or errors with
+     * SqlParseError / SqlValidationError if the query is invalid.
+     */
+    query(sql: string, options?: DexieSqlOptions): Observable<any[]>;
+    private _run;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DexieSqlService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DexieSqlService>;
+}
+
+declare class SqlParseError extends Error {
+    name: string;
+    constructor(message: string);
+}
+declare class SqlValidationError extends Error {
+    name: string;
+    constructor(message: string);
+}
+
+declare enum ExecutionPlanType {
+    SIMPLE = "SIMPLE",
+    AND_BOUNDED = "AND_BOUNDED",
+    AND_COMPOUND = "AND_COMPOUND",
+    OR_MERGE = "OR_MERGE",
+    JOIN_HASH = "JOIN_HASH"
+}
+type DexieOp = 'equals' | 'notEqual' | 'above' | 'aboveOrEqual' | 'below' | 'belowOrEqual' | 'between' | 'anyOf' | 'noneOf' | 'startsWith';
+interface PlanStep {
+    col: string;
+    op: DexieOp;
+    val: any;
+}
+interface JoinInfo {
+    leftTable: string;
+    rightTable: string;
+    leftKey: string;
+    rightKey: string;
+    joinType: 'inner' | 'left';
+}
+interface ExecutionPlan {
+    type: ExecutionPlanType;
+    table: string;
+    primaryStep: PlanStep | null;
+    boundedFilters: PlanStep[];
+    compoundIndex?: string;
+    compoundValues?: any[];
+    compoundWarnCols?: string[];
+    orBranches?: PlanStep[];
+    joinInfo?: JoinInfo;
+    orderBy?: {
+        col: string;
+        dir: 'asc' | 'desc';
+    } | null;
+    limit?: number | null;
+    offset?: number | null;
+    projection?: string[] | null;
+    aggregate?: 'count' | null;
+    distinct?: boolean;
+    dedupeKey?: string;
+}
+
+interface ParseResult {
+    ast: AST;
+    tableList: string[];
+    columnList: string[];
+}
+
+interface TableSchemaInfo {
+    pk: string;
+    simpleIndexes: string[];
+    compoundIndexes: string[][];
+}
+interface ValidatedQuery {
+    ast: any;
+    schemas: Record<string, TableSchemaInfo>;
+    aliases: Record<string, string>;
+}
+
 declare class HeadersService {
     headers: {};
     generateHeaders(headers?: Record<string, string>): {
@@ -2202,6 +2633,21 @@ declare class RequestManagerBasicDemoComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerBasicDemoComponent, "app-request-manager-basic-demo", never, {}, {}, never, never, false, never>;
 }
 
+interface UserDataInterface {
+    ldap: string;
+    name: string;
+    email: string;
+    color: string;
+}
+declare class UserData implements UserDataInterface {
+    ldap: string;
+    name: string;
+    email: string;
+    color: string;
+    constructor(ldap?: string, name?: string, email?: string, color?: string);
+    static adapt(item?: any): UserData;
+}
+
 declare class HttpRequestServicesDemoComponent implements OnInit {
     private configOptions?;
     wsServer: string;
@@ -2223,6 +2669,12 @@ declare class HttpRequestServicesDemoComponent implements OnInit {
         new: boolean;
         divider?: undefined;
         disabled?: undefined;
+    } | {
+        name: string;
+        value: string;
+        new: boolean;
+        divider: boolean;
+        disabled?: undefined;
     } | {
         name: string;
         value: string;
@@ -2263,11 +2715,12 @@ declare class ClientInfo$1 implements ClientInfoInterface$1 {
 declare class StateManagerDemoService extends HTTPManagerStateService<any> {
     constructor();
     setAPIOptions(apiOptions: ApiRequest, dataType: DataType, database?: DatabaseStorage): void;
-    getClients(): void;
+    getClients(options?: RequestOptions): void;
     createClient(data: any): void;
     updateClient(data: ClientInfo$1): void;
     deleteClient(data: ClientInfo$1): void;
-    streamRequest(): void;
+    streamRequest(options?: RequestOptions): void;
+    sendWsMessage(channel: string, method: string, path: (string | number)[]): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<StateManagerDemoService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<StateManagerDemoService>;
 }
@@ -2301,10 +2754,13 @@ declare class RequestManagerStateDemoComponent implements OnInit {
     adapter?: Function;
     mapper?: Function;
     stateManagerDemoService: StateManagerDemoService;
+    databaseManagerService: DatabaseManagerService;
     displayedColumns: string[];
     getColumnsFromData(data: any[]): string[];
     updateDisplayedColumns(data: any[]): void;
     isObject(value: any): boolean;
+    getRecordLabel(item: any): string;
+    private normalizeLabelValue;
     getDataLength(data: any): number;
     selectedRecord$?: Observable<ClientInfo$1 | null>;
     fb: FormBuilder;
@@ -2335,10 +2791,16 @@ declare class RequestManagerStateDemoComponent implements OnInit {
     STREAM_AI$: Observable<any>;
     failedState: any;
     pollingState: any;
+    DBState: any;
     questionControl: _angular_forms.FormControl<string | null>;
     requestType: string;
     prompts: string[];
     AIType: number;
+    wsMessageForm: _angular_forms.FormGroup<{
+        channel: _angular_forms.FormControl<string | null>;
+        method: _angular_forms.FormControl<string | null>;
+        path: _angular_forms.FormControl<string | null>;
+    }>;
     get dataObservable$(): BehaviorSubject<any> | BehaviorSubject<null> | BehaviorSubject<{
         response: string;
     }[]>;
@@ -2369,6 +2831,8 @@ declare class RequestManagerStateDemoComponent implements OnInit {
         database: _angular_forms.FormGroup<{
             table: _angular_forms.FormControl<string | null>;
             expiresIn: _angular_forms.FormControl<string | null>;
+            ignoreQueryParams: _angular_forms.FormControl<string | null>;
+            queryParamsExpiresIn: _angular_forms.FormControl<string | null>;
         }>;
     }>;
     get hasChanged(): boolean;
@@ -2376,6 +2840,8 @@ declare class RequestManagerStateDemoComponent implements OnInit {
     get database(): {
         table: string | null;
         expiresIn: string | null;
+        ignoreQueryParams: string | null;
+        queryParamsExpiresIn: string | null;
     } | undefined;
     get retry(): {
         times: number | null;
@@ -2404,12 +2870,17 @@ declare class RequestManagerStateDemoComponent implements OnInit {
     onStreamType(type: string): void;
     addHeader(): void;
     removeHeader(index: number): void;
+    private parsePathInput;
+    private normalizeQueryValue;
     compileRequest(): {
         apiOptions: ApiRequest;
-        path: string[];
+        path: any[];
     };
+    private parseIgnoreParams;
+    private buildDemoRequestOptions;
     onSetStateOptions(): void;
     onClearRecords(): void;
+    deleteDatabase(): void;
     onGetRequest(): void;
     onCreateRequest(): void;
     onUpdateRequest(): void;
@@ -2418,6 +2889,7 @@ declare class RequestManagerStateDemoComponent implements OnInit {
     errorHandling(err: any, type: string): void;
     onSelectAIType(type: number): void;
     onClearHistory(): void;
+    onSendWsMessage(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<RequestManagerStateDemoComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerStateDemoComponent, "app-request-manager-state-demo", never, { "server": { "alias": "server"; "required": false; }; "adapter": { "alias": "adapter"; "required": false; }; "mapper": { "alias": "mapper"; "required": false; }; }, {}, never, never, false, never>;
 }
@@ -3020,7 +3492,7 @@ declare class NotificationServiceDemo {
     static ɵprov: i0.ɵɵInjectableDeclaration<NotificationServiceDemo>;
 }
 
-declare class RequestManagerWsDemoComponent implements OnInit {
+declare class RequestManagerWsDemoComponent implements OnInit, OnChanges {
     httpManagerService: HTTPManagerService<any>;
     stateService: StateServiceDemo;
     fb: FormBuilder;
@@ -3030,12 +3502,15 @@ declare class RequestManagerWsDemoComponent implements OnInit {
     user: any;
     path: string[];
     user$: rxjs.Observable<WSUser | null>;
-    attempts$: rxjs.Observable<number>;
-    nextRetry$: rxjs.Observable<number>;
+    retryCount$: rxjs.Observable<number>;
+    maxRetries$: rxjs.Observable<number>;
     connectionStatus$: rxjs.Observable<boolean>;
+    isConnecting$: rxjs.Observable<boolean>;
+    connectionError$: rxjs.Observable<string | null>;
     data$: rxjs.Observable<any>;
     isPending$: rxjs.Observable<boolean>;
     ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): 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; }; }, {}, never, never, false, never>;
 }
@@ -3070,11 +3545,17 @@ interface TableRecord {
 }
 declare class DatabaseDataDemoComponent implements OnInit, OnDestroy {
     db: DatabaseManagerService;
+    sql: DexieSqlService;
     private destroy$;
     dataToDisplay: TableRecord[];
     dataSource: DatabaseDataSource;
     displayedColumns: string[];
     names: string[];
+    sqlQuery: string;
+    sqlResults: any[];
+    sqlResultCols: string[];
+    sqlError: string | null;
+    sqlLoading: boolean;
     constructor();
     ngOnDestroy(): void;
     addData(): void;
@@ -3091,6 +3572,7 @@ declare class DatabaseDataDemoComponent implements OnInit, OnDestroy {
     createTableRecord<T>(table: string, record: T): Observable<any>;
     updateTableRecord<T>(table: string, record: T): Observable<any>;
     deleteTableRecord<T>(table: string, id: number): Observable<any>;
+    runSqlQuery(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseDataDemoComponent, never>;
     static ɵcmp: i0.ɵɵComponentDeclaration<DatabaseDataDemoComponent, "app-database-data-demo", never, {}, {}, never, never, false, never>;
 }
@@ -3117,7 +3599,7 @@ declare class StateDataRequestService extends HTTPManagerStateService<any> {
     static ɵprov: i0.ɵɵInjectableDeclaration<StateDataRequestService>;
 }
 
-declare class WsDataControlComponent implements OnInit {
+declare class WsDataControlComponent implements OnInit, OnChanges {
     server: string;
     wsServer: string;
     jwtToken: string;
@@ -3130,7 +3612,9 @@ declare class WsDataControlComponent implements OnInit {
     userAction$: rxjs.Observable<any>;
     data$: rxjs.Observable<any>;
     isUser: (user: any, userItem: any) => boolean;
+    getUserLabel: (user: any) => any;
     ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
     onGetData(): void;
     onAddData(): void;
     onUpdateData(data: any[]): void;
@@ -3194,11 +3678,11 @@ declare class DisplayConfig implements DisplayConfigInterface {
     type: DisplayType;
     supportsMarkdown?: boolean | undefined;
     stackable?: boolean | undefined;
-    queueBehavior?: ("replace" | "queue" | "ignore") | undefined;
+    queueBehavior?: "replace" | "queue" | "ignore" | undefined;
     autoDismiss?: number | undefined;
     width?: string | undefined;
     height?: string | undefined;
-    constructor(type?: DisplayType, supportsMarkdown?: boolean | undefined, stackable?: boolean | undefined, queueBehavior?: ("replace" | "queue" | "ignore") | undefined, autoDismiss?: number | undefined, width?: string | undefined, height?: string | undefined);
+    constructor(type?: DisplayType, supportsMarkdown?: boolean | undefined, stackable?: boolean | undefined, queueBehavior?: "replace" | "queue" | "ignore" | undefined, autoDismiss?: number | undefined, width?: string | undefined, height?: string | undefined);
     static adapt(item?: any): DisplayConfig;
 }
 
@@ -3224,8 +3708,8 @@ declare class MessageContent implements MessageContentInterface {
     actions?: Action[] | undefined;
     messageType?: string | undefined;
     icon?: string | undefined;
-    data?: any;
-    constructor(displayConfig?: DisplayConfig | undefined, title?: string | undefined, message?: string, slides?: Slide[] | undefined, image?: string | undefined, images?: string[] | undefined, actions?: Action[] | undefined, messageType?: string | undefined, icon?: string | undefined, data?: any);
+    data?: any | undefined;
+    constructor(displayConfig?: DisplayConfig | undefined, title?: string | undefined, message?: string, slides?: Slide[] | undefined, image?: string | undefined, images?: string[] | undefined, actions?: Action[] | undefined, messageType?: string | undefined, icon?: string | undefined, data?: any | undefined);
     static adapt(item?: any): MessageContent;
 }
 interface CommunicationMessageInterface {
@@ -3442,6 +3926,42 @@ declare class WsChatsComponent implements OnInit {
     static ɵcmp: i0.ɵɵComponentDeclaration<WsChatsComponent, "app-ws-chats", never, {}, {}, never, never, false, never>;
 }
 
+interface UploadStateInterface {
+    selectedFiles: File[];
+    isUploading: boolean;
+    progress: number;
+    currentFile: string | null;
+    errorMessage: string | null;
+    successMessage: string | null;
+}
+declare class UploadStateModel implements UploadStateInterface {
+    selectedFiles: File[];
+    isUploading: boolean;
+    progress: number;
+    currentFile: string | null;
+    errorMessage: string | null;
+    successMessage: string | null;
+    constructor(selectedFiles?: File[], isUploading?: boolean, progress?: number, currentFile?: string | null, errorMessage?: string | null, successMessage?: string | null);
+    static adapt(item?: any): UploadStateModel;
+}
+
+declare class UploadDemoComponent implements OnInit, OnDestroy {
+    private httpManager;
+    private toastService;
+    uploadState: UploadStateModel;
+    allowedTypes: string[];
+    maxFileSize: number;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onFileSelected(event: Event): void;
+    validateFile(file: File): string | null;
+    clearSelection(): void;
+    startUpload(): void;
+    getFileSizeString(size: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UploadDemoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UploadDemoComponent, "lib-upload-demo", never, {}, {}, never, never, false, never>;
+}
+
 declare class SpinnerComponent implements OnInit {
     color: ThemePalette;
     diameter?: number;
@@ -3523,7 +4043,7 @@ declare class FileDownloaderModule {
 declare class HttpRequestManagerModule {
     static forRoot(config?: ConfigOptions): ModuleWithProviders<HttpRequestManagerModule>;
     static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestManagerModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<HttpRequestManagerModule, [typeof RequestManagerBasicDemoComponent, typeof HttpRequestServicesDemoComponent, typeof RequestManagerStateDemoComponent, typeof RequestManagerDemoComponent, typeof RequestSignalsManagerDemoComponent, typeof LocalStorageDemoComponent, typeof LocalStorageSignalsDemoComponent, typeof RequestManagerWsDemoComponent, typeof StoreStateManagerDemoComponent, typeof DatabaseDataDemoComponent, typeof WsDataControlComponent, typeof WsMessagingComponent, typeof WsNotificationsComponent, typeof WsAiMessagingComponent, typeof WsChatsComponent], [typeof i4.CommonModule, typeof i17.ToastMessageDisplayModule, typeof _angular_forms.FormsModule, typeof _angular_forms.ReactiveFormsModule, typeof i7.MatButtonModule, typeof i20.MatTabsModule, typeof i21.MatSelectModule, typeof i22.MatChipsModule, typeof i23.MatMenuModule, typeof i5.MatIconModule, typeof i25.MatTableModule, typeof i26.MatButtonToggleModule, typeof i27.MatAutocompleteModule, typeof i28.MatProgressBarModule, typeof i6.MatProgressSpinnerModule, typeof i30.MatSlideToggleModule, typeof i31.MatDividerModule, typeof i32.MatFormFieldModule, typeof i33.MatInputModule, typeof i34.MatToolbarModule, typeof i30.MatSlideToggleModule, typeof i35.TranslateModule, typeof i36.MatSidenavModule, typeof i37.MatDatepickerModule, typeof i38.MatNativeDateModule, typeof i39.MatCardModule, typeof FileDownloaderModule], [typeof HttpRequestServicesDemoComponent]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<HttpRequestManagerModule, [typeof RequestManagerBasicDemoComponent, typeof HttpRequestServicesDemoComponent, typeof RequestManagerStateDemoComponent, typeof RequestManagerDemoComponent, typeof RequestSignalsManagerDemoComponent, typeof LocalStorageDemoComponent, typeof LocalStorageSignalsDemoComponent, typeof RequestManagerWsDemoComponent, typeof StoreStateManagerDemoComponent, typeof DatabaseDataDemoComponent, typeof WsDataControlComponent, typeof WsMessagingComponent, typeof WsNotificationsComponent, typeof WsAiMessagingComponent, typeof WsChatsComponent, typeof UploadDemoComponent], [typeof i4.CommonModule, typeof i18.ToastMessageDisplayModule, typeof _angular_forms.FormsModule, typeof _angular_forms.ReactiveFormsModule, typeof i7.MatButtonModule, typeof i21.MatTabsModule, typeof i22.MatSelectModule, typeof i23.MatChipsModule, typeof i24.MatMenuModule, typeof i5.MatIconModule, typeof i26.MatTableModule, typeof i27.MatButtonToggleModule, typeof i28.MatAutocompleteModule, typeof i29.MatProgressBarModule, typeof i6.MatProgressSpinnerModule, typeof i31.MatSlideToggleModule, typeof i32.MatDividerModule, typeof i33.MatFormFieldModule, typeof i34.MatInputModule, typeof i35.MatToolbarModule, typeof i31.MatSlideToggleModule, typeof i36.TranslateModule, typeof i37.MatSidenavModule, typeof i38.MatDatepickerModule, typeof i39.MatNativeDateModule, typeof i40.MatCardModule, typeof FileDownloaderModule], [typeof HttpRequestServicesDemoComponent, typeof UploadDemoComponent]>;
     static ɵinj: i0.ɵɵInjectorDeclaration<HttpRequestManagerModule>;
 }
 
@@ -3539,8 +4059,8 @@ declare class StoreStateSignalsDemoComponent implements OnInit {
     reset(): void;
     addToHistory(): void;
     static ɵfac: i0.ɵɵFactoryDeclaration<StoreStateSignalsDemoComponent, never>;
-    static ɵcmp: i0.ɵɵComponentDeclaration<StoreStateSignalsDemoComponent, "app-store-state-signals-demo", never, {}, {}, never, never, false, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StoreStateSignalsDemoComponent, "app-store-state-signals-demo", never, {}, {}, never, never, true, never>;
 }
 
-export { ApiRequest, AppService, AsymmetricalEncryptionService, BatchOptions, BatchResult, CONFIG_SETTINGS_TOKEN, ChannelType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, ErrorDisplaySettings, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsDemoComponent, LocalStorageSignalsManagerService, LoggerService, NotificationMessage, PathQueryService, PublicMessage, Random, RandomHSLColor, RandomHexColor, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomPaletteColor, RandomSignature, RandomStr, RandomVisibleColor, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, StateMessage, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, StoreStateManagerSignalsService, StoreStateSignalsDemoComponent, StreamType, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UserData, UtilsService, WSOptions, WebSocketMessageService, WithCredentialsInterceptor, calculateBatchProgress, countdown, createChannelName, delayedRetry, isErrorState, isPendingState, isSuccessState, requestPolling, requestStreaming, streamAI, streamAuto, streamEvents, streamJSON, streamNDJSON };
-export type { APIStateManagerData, ApiRequestInterface, BatchErrorState, BatchOptionsInterface, BatchPendingState, BatchProgress, BatchRequestState, BatchResultInterface, BatchSuccessState, ConfigHTTPOptionsInterface, ConfigOptionsInterface, DatabaseStorageInterface, ErrorDisplaySettingsInterface, GlobalStoreOptionsInterface, LocalStorageOptionsInterface, NotificationMessageInterface, ParsingResult, PublicMessageInterface, RequestOptionsInterface, RetryOptionsInterface, SettingOptionsInterface, State, StateMessageInterface, StateStorageOptionsInterface, StateStoreManagerData$1 as StateStoreManagerData, StorageDataInterface, StorageOptionInterface, StreamConfig, StreamEvent, TableRecord, TableSchemaDefInterface, UserDataInterface, WSOptionsInterface };
+export { ApiRequest, AppService, AsymmetricalEncryptionService, BatchOptions, BatchResult, CONFIG_SETTINGS_TOKEN, ChannelType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseManagerSignalsService, DatabaseStorage, DbService, DexieSqlService, ErrorDisplaySettings, ExecutionPlanType, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HTTPManagerStateSignalsService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, InvalidFileInfoModel, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsDemoComponent, LocalStorageSignalsManagerService, LoggerService, NotificationMessage, OperationResultModel, ParsingResultModel, PathQueryService, PublicMessage, Random, RandomHSLColor, RandomHexColor, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomPaletteColor, RandomSignature, RandomStr, RandomVisibleColor, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, SqlParseError, SqlValidationError, StateMessage, StateOperationResult, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, StoreStateManagerSignalsService, StoreStateSignalsDemoComponent, StreamConfigModel, StreamEventMetadataModel, StreamEventModel, StreamOutputModel, StreamProgressModel, StreamType, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UploadDemoComponent, UploadValidationErrorModel, UserData, UtilsService, WSOptions, WebSocketMessageService, WithCredentialsInterceptor, calculateBatchProgress, countdown, createChannelName, delayedRetry, isErrorState, isPendingState, isSuccessState, requestPolling, requestStreaming, streamAI, streamAuto, streamEvents, streamJSON, streamNDJSON };
+export type { APIStateManagerData, ApiRequestInterface, BatchErrorState, BatchOptionsInterface, BatchPendingState, BatchProgress, BatchRequestState, BatchResultInterface, BatchSuccessState, ConfigHTTPOptionsInterface, ConfigOptionsInterface, DatabaseStorageInterface, DexieOp, DexieSqlOptions, ErrorDisplaySettingsInterface, ExecutionPlan, GlobalStoreOptionsInterface, InvalidFileInfoInterface, JoinInfo, LocalStorageOptionsInterface, NotificationMessageInterface, OperationResultInterface, ParseResult, ParsingResultInterface, PlanStep, PublicMessageInterface, RequestOptionsInterface, RetryOptionsInterface, SettingOptionsInterface, State, StateMessageInterface, StateOperationResultInterface, StateStorageOptionsInterface, StateStoreManagerData$1 as StateStoreManagerData, StorageDataInterface, StorageOptionInterface, StreamConfigInterface, StreamEventInterface, StreamEventMetadataInterface, StreamOutputInterface, StreamProgressInterface, TableRecord, TableSchemaDefInterface, TableSchemaInfo, UploadValidationErrorInterface, UserDataInterface, ValidatedQuery, WSOptionsInterface };