http-request-manager 19.0.0 → 22.0.0

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

@@ -0,0 +1,4066 @@
+import * as rxjs from 'rxjs';
+import { Observable, Subscription, BehaviorSubject, OperatorFunction } from 'rxjs';
+import * as i0 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 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 { 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 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 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 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 i40 from '@angular/material/card';
+
+declare enum StorageType {
+    GLOBAL = 0,
+    SESSION = 1,
+    DB = 2
+}
+
+interface SettingOptionsInterface {
+    storage?: StorageType;
+    expires?: number;
+    expiresIn?: string;
+    encrypted?: boolean;
+}
+declare class SettingOptions implements SettingOptionsInterface {
+    storage?: StorageType | undefined;
+    expires?: number | undefined;
+    expiresIn?: string | undefined;
+    encrypted?: boolean | undefined;
+    constructor(storage?: StorageType | undefined, expires?: number | undefined, expiresIn?: string | undefined, encrypted?: boolean | undefined);
+    static adapt(item?: any): SettingOptions;
+}
+
+interface StorageOptionInterface {
+    id?: string;
+    name: string;
+    data?: any;
+    options?: SettingOptions;
+}
+declare class StorageOption implements StorageOptionInterface {
+    id?: string | undefined;
+    name: string;
+    data?: any | undefined;
+    options?: SettingOptions | undefined;
+    constructor(id?: string | undefined, name?: string, data?: any | undefined, options?: SettingOptions | undefined);
+    static adapt(item?: any): StorageOption;
+}
+
+interface GlobalStoreOptionsInterface {
+    encryption?: boolean;
+    expiresIn?: string;
+    expires?: number;
+    stores: StorageOption[] | null;
+}
+declare class GlobalStoreOptions implements GlobalStoreOptionsInterface {
+    encryption: boolean;
+    expiresIn?: string | undefined;
+    expires?: number | undefined;
+    stores: StorageOption[] | null;
+    constructor(encryption?: boolean, expiresIn?: string | undefined, expires?: number | undefined, stores?: StorageOption[] | null);
+    static adapt(item?: any): GlobalStoreOptions;
+}
+
+interface StorageDataInterface {
+    id?: string;
+    data?: any;
+}
+declare class StorageData implements StorageDataInterface {
+    id?: string | undefined;
+    data?: any | undefined;
+    constructor(id?: string | undefined, data?: any | undefined);
+    static adapt(item?: any): StorageData;
+}
+
+declare class UtilsService {
+    http: HttpClient;
+    constructor();
+    isString(x: string | number): boolean;
+    isObject(obj: any): boolean;
+    JSONToString(value: any): any;
+    stringToJSON(value: string): any;
+    isJSON(str: any): boolean;
+    getValueByProp(obj: any, prop: string): any;
+    objectsEqual(x: any, y: any): boolean;
+    getJSON(file: string): rxjs.Observable<Object>;
+    get today(): number;
+    base32ToHex(base32: string): string;
+    binaryToHex(binary: string): string;
+    expires(str?: string): number | undefined;
+    hasExpired(expiryDate: number): boolean;
+    hasExpiry(setting: any): boolean;
+    expiresIn(expiryDate: number): string | undefined;
+    lc: (str: string) => string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilsService>;
+}
+
+declare class SymmetricalEncryptionService {
+    appID: string;
+    private appService;
+    constructor();
+    generateCipherKey(): string;
+    encrypt(str: any, key?: string): string | undefined;
+    decrypt(str: string, key?: string): string | null;
+    createSignature(url: string, len?: number): string;
+    normalizeURL(url: string): string;
+    generateSignature(url: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SymmetricalEncryptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SymmetricalEncryptionService>;
+}
+
+declare class EncryptionTestService {
+    constructor();
+    private isBase64;
+    private isHexadecimal;
+    private hasHighEntropy;
+    isEncrypted(str: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EncryptionTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EncryptionTestService>;
+}
+
+declare class AppService {
+    private id;
+    appID: string;
+    constructor(id: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
+}
+
+interface WSOptionsInterface {
+    id: string;
+    wsServer: string;
+    jwtToken: string;
+    permissions?: string[];
+    channels?: string[];
+    wsUpdateChannels?: string[];
+    user?: any;
+    retry?: RetryOptions;
+}
+declare class WSOptions implements WSOptionsInterface {
+    id: string;
+    wsServer: string;
+    jwtToken: string;
+    permissions?: string[] | undefined;
+    channels?: string[] | undefined;
+    wsUpdateChannels?: string[] | undefined;
+    user?: any | undefined;
+    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;
+}
+
+/**
+ * Enum representing valid streaming format types
+ *
+ * This enum defines all supported streaming formats for HTTP requests.
+ * Each enum value corresponds to a specific data format and parsing strategy.
+ */
+declare enum StreamType {
+    JSON = "json",
+    NDJSON = "ndjson",
+    AI_STREAMING = "ai_streaming",
+    EVENT_STREAM = "event_stream",
+    AUTO = "auto"
+}
+
+interface ApiRequestInterface {
+    server: string;
+    path?: any[];
+    headers?: any;
+    adapter?: any;
+    mapper?: any;
+    polling?: number;
+    retry?: RetryOptions;
+    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 | 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;
+    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;
+    name?: string;
+    email?: string;
+    [key: string]: any;
+}
+declare class WSUser implements WSUserInterface {
+    id: string;
+    ldap: string;
+    name: string;
+    email: string;
+    constructor(id?: string, ldap?: string, name?: string, email?: string);
+    static adapt(item?: any): WSUser;
+}
+
+interface StateMessageInterface {
+    sessionId: {
+        id: string;
+        ldap?: string;
+        name?: string;
+        email?: string;
+    };
+    content: any;
+}
+declare class StateMessage implements StateMessageInterface {
+    sessionId: {
+        id: string;
+        ldap?: string;
+        name?: string;
+        email?: string;
+    };
+    content: any;
+    constructor(sessionId?: {
+        id: string;
+        ldap?: string;
+        name?: string;
+        email?: string;
+    }, content?: any);
+    static adapt(item?: any): StateMessage;
+}
+
+interface PublicMessageInterface {
+    sessionId: {
+        id: string;
+        ldap?: string;
+        name?: string;
+        email?: string;
+    };
+    content: {
+        message: string;
+        [key: string]: any;
+    };
+}
+declare class PublicMessage implements PublicMessageInterface {
+    sessionId: {
+        id: string;
+        ldap?: string;
+        name?: string;
+        email?: string;
+    };
+    content: {
+        message: string;
+        [key: string]: any;
+    };
+    constructor(sessionId?: {
+        id: string;
+        ldap?: string;
+        name?: string;
+        email?: string;
+    }, content?: {
+        message: string;
+        [key: string]: any;
+    });
+    static adapt(item?: any): PublicMessage;
+}
+
+interface NotificationMessageInterface {
+    sessionId: {
+        id: string;
+        ldap?: string;
+        name?: string;
+        email?: string;
+        color?: string;
+    };
+    message: string;
+    [key: string]: any;
+}
+declare class NotificationMessage implements NotificationMessageInterface {
+    sessionId: {
+        id: string;
+        ldap?: string;
+        name?: string;
+        email?: string;
+        color?: string;
+    };
+    message: string;
+    [key: string]: any;
+    constructor(sessionId?: {
+        id: string;
+        ldap?: string;
+        name?: string;
+        email?: string;
+        color?: string;
+    }, message?: string, additionalProperties?: any);
+    static adapt(item?: any): NotificationMessage;
+}
+
+interface DatabaseStorageInterface {
+    table: string;
+    expiresIn: string;
+}
+declare class DatabaseStorage implements DatabaseStorageInterface {
+    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: {};
+    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;
+}
+declare class TableSchemaDef implements TableSchemaDefInterface {
+    table: string;
+    schema: string;
+    constructor(table?: string, schema?: string);
+    static adapt(item?: any): TableSchemaDef;
+    static cleanString(str: string): string;
+}
+
+declare class DbService extends Dexie {
+    readonly storageDB = "global_storage_db";
+    get db(): this;
+    private dbReady;
+    constructor();
+    private init;
+    protected createNewDatabase(): Promise<void>;
+    get vr(): number;
+    get nextVr(): number;
+    get getTables(): string[];
+    hasDatabase(): Promise<boolean>;
+    getTable(tableName: string): Table<any, any> | undefined;
+    tableExists(tableName: string): boolean;
+    protected updateTable(tableName: string, find: {
+        key: string;
+        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>;
+    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>;
+    findTableRecords(table: string, column: string, value: any): Observable<unknown>;
+    findTableRecord(table: string, column: string, value: any): Observable<any>;
+    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<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;
+    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;
+    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;
+}
+
+/**
+ * LoggerService for http-request-manager library
+ *
+ * Automatically enables debug logging in development mode,
+ * disables it in production mode.
+ *
+ * Usage:
+ * ```typescript
+ * constructor(private logger: LoggerService) {}
+ *
+ * this.logger.debug('WebSocket', 'Connected successfully');
+ * this.logger.info('HTTP', 'Request completed', { status: 200 });
+ * this.logger.warn('State', 'Cache miss for key', { key: 'user' });
+ * this.logger.error('Database', 'Connection failed', error);
+ * ```
+ */
+declare class LoggerService {
+    private static readonly DEBUG_FLAG_KEY;
+    private debugMode;
+    constructor();
+    /**
+     * Debug level logging - only shown in development mode
+     * Use for: Detailed diagnostic information, state changes, connection events
+     */
+    debug(context: string, message: string, data?: any): void;
+    /**
+     * Info level logging - only shown in development mode
+     * Use for: Important operational messages, successful operations
+     */
+    info(context: string, message: string, data?: any): void;
+    /**
+     * Warning level logging - always shown
+     * Use for: Potential issues, deprecated usage, recoverable errors
+     */
+    warn(context: string, message: string, data?: any): void;
+    /**
+     * Error level logging - always shown
+     * Use for: Actual errors, failures, exceptions
+     */
+    error(context: string, message: string, data?: any): void;
+    /**
+     * Check if debug mode is enabled (development mode)
+     */
+    isDebugEnabled(): boolean;
+    private isDebugFlagEnabled;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LoggerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LoggerService>;
+}
+
+/**
+ * Channel type enum for different communication purposes
+ * - STATE: Private channels for state synchronization (SYS- prefix)
+ * - MESSAGE: Public messaging/communication channels (PUB- prefix)
+ * - NOTIFICATION: Notification channels with DB persistence (MES- prefix)
+ */
+declare enum ChannelType {
+    STATE = "SYS",
+    MESSAGE = "PUB",
+    NOTIFICATION = "MES"
+}
+/**
+ * Utility function to create prefixed channel name
+ * @param channelType - The type of channel
+ * @param channelName - The base channel name
+ * @returns Prefixed channel name (e.g., 'SYS-USERS123')
+ */
+declare function createChannelName(channelType: ChannelType, channelName: string): string;
+interface APIStateManagerData<T> {
+    data: T[];
+    dataObject: T | null;
+}
+declare class HTTPManagerStateService<T extends {
+    id: number | string;
+}> extends ComponentStore<APIStateManagerData<T>> {
+    private apiOptions;
+    private dataType;
+    httpManagerService: HTTPManagerService<any>;
+    dbManagerService: DatabaseManagerService;
+    localStorageManagerService: LocalStorageManagerService;
+    utils: UtilsService;
+    logger: LoggerService;
+    error$: Observable<boolean>;
+    isPending$: Observable<boolean>;
+    private operationSuccess;
+    operationSuccess$: Observable<OperationResultModel | null>;
+    private page;
+    page$: Observable<number>;
+    private totalPages;
+    totalPages$: Observable<number>;
+    private percentage;
+    percentage$: Observable<number>;
+    private hasDatabase;
+    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;
+    wsNextRetry$: Observable<number>;
+    private messages;
+    messages$: Observable<any[]>;
+    private userListByChannel;
+    userListByChannel$: Observable<Map<string, any[]>>;
+    getUsersForChannel$(channel: string): Observable<any[]>;
+    private userList;
+    userList$: Observable<any[]>;
+    private user;
+    user$: Observable<WSUser | null>;
+    private channels;
+    channels$: Observable<string[] | null>;
+    private notificationChannels;
+    notificationChannels$: Observable<string[]>;
+    private todaysNotificationChannels;
+    todaysNotificationChannels$: Observable<string[]>;
+    private notificationMessages;
+    notificationMessages$: Observable<any[]>;
+    private latestNotification;
+    latestNotification$: Observable<any>;
+    private communicationMessages;
+    communicationMessages$: Observable<any[]>;
+    private latestCommunicationMessages;
+    latestCommunicationMessages$: Observable<any>;
+    private userAction;
+    userAction$: Observable<any>;
+    private static wsCommunicationQueue;
+    private ownSessionId;
+    wsOptions: WSOptions;
+    connectionStatus$: Observable<boolean>;
+    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
+     */
+    private prefixChannel;
+    /**
+     * Remove any known prefix from a channel name
+     */
+    private stripChannelPrefix;
+    /**
+     * Get the base channel name without prefix (for display/user reference)
+     */
+    getBaseChannelName(channel: string): string;
+    setApiRequestOptions(apiOptions?: ApiRequest, dataType?: DataType, database?: DatabaseStorage): void;
+    private setupConnectionStatus;
+    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) => Subscription;
+    initializeState(data: any): void;
+    readonly data$: Observable<T | T[] | null>;
+    readonly selectRecord$: (id: number) => Observable<T | T[] | null>;
+    private readonly setData$;
+    private updateArrayState;
+    private readonly addData$;
+    private readonly deleteData$;
+    private readonly updateData$;
+    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);
+    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
+     * @param channels - Optional array of channel names (passed as-is, caller should include prefix)
+     *                   Use 'allChannels' to broadcast to all
+     */
+    wsMessaging(message: ChannelMessage, channels?: string[]): void;
+    /**
+     * Subscribe to a messaging channel
+     * @param channel - Base channel name (MES- prefix added automatically)
+     */
+    subscribeToMessageChannel(channel: string): void;
+    /**
+     * Unsubscribe from a messaging channel
+     * @param channel - Base channel name (MES- prefix added automatically)
+     */
+    unsubscribeFromMessageChannel(channel: string): void;
+    /**
+     * Subscribe to a single channel (no automatic prefix)
+     * Use subscribeToMessageChannel() for MES- prefixed channels
+     */
+    subscribeToChannel(channel: string): void;
+    /**
+     * Subscribe to multiple channels at once
+     */
+    subscribeToChannels(channels: string[]): void;
+    /**
+     * Unsubscribe from a channel
+     */
+    unsubscribeFromChannel(channel: string): void;
+    /**
+     * Get observable of currently subscribed channels
+     */
+    get subscribedChannels$(): Observable<Set<string>>;
+    /**
+     * Get current subscribed channels synchronously
+     */
+    getSubscribedChannels(): Set<string>;
+    /**
+     * Create a new channel on the server
+     */
+    createChannel(channel: string): void;
+    /**
+     * Delete a channel from the server
+     */
+    deleteChannel(channel: string): void;
+    /**
+     * Request list of all channels from server
+     */
+    getAllChannels(): void;
+    /**
+     * Get users in a specific channel
+     */
+    getUsersInChannel(channel: string): void;
+    /**
+     * Create a notification channel on the server
+     * @param channel - Base channel name (MES- prefix added automatically)
+     */
+    createNotificationChannel(channel: string): void;
+    /**
+     * Request list of all notification channels from server (in-memory)
+     */
+    getNotificationChannels(): void;
+    /**
+     * Request list of today's notification channels from database
+     * Returns unique channels that have notifications posted today
+     */
+    getTodaysNotificationChannels(): void;
+    /**
+     * Subscribe to a notification channel with optional date filters
+     * @param channel - Base channel name (MES- prefix added automatically)
+     */
+    subscribeToNotificationChannel(channel: string, options?: {
+        startEpoch?: number;
+        endEpoch?: number;
+    }, user?: any): void;
+    /**
+     * Unsubscribe from a notification channel
+     * @param channel - Base channel name (MES- prefix added automatically)
+     */
+    unsubscribeFromNotificationChannel(channel: string): void;
+    /**
+     * Send a notification to a channel
+     * @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;
+    /**
+     * 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;
+    private messages;
+    messages$: Observable<any>;
+    private connectionStatus;
+    connectionStatus$: Observable<boolean>;
+    private isSubscribed;
+    private subscribedChannels;
+    subscribedChannels$: Observable<Set<string>>;
+    private lastOptions;
+    private getSessionId;
+    private sendSubscribe;
+    connect(options: WSOptions, jwtToken: string): void;
+    disconnect(): void;
+    subscribeToChannel(channelName: string): void;
+    subscribeToChannels(channelNames: string[]): void;
+    unsubscribeFromChannel(channel: string): void;
+    unsubscribeToChannel(channel: string): void;
+    getSubscribedChannels(): Set<string>;
+    sendBroadcast(content: any): void;
+    sendMessageInChannel(channel: string, content: any): void;
+    /**
+     * Send a message to a specific channel for channel-based messaging
+     * 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;
+    deleteChannel(channel: string): void;
+    getUsersInChannel(channel: string): void;
+    /**
+     * Create a notification channel
+     */
+    createNotificationChannel(channel: string): void;
+    /**
+     * Get all notification channels (in-memory)
+     */
+    getNotificationChannels(): void;
+    getTodaysNotificationChannels(): void;
+    subscribeToNotificationChannel(channel: string, options?: {
+        startEpoch?: number;
+        endEpoch?: number;
+    }, user?: any): void;
+    unsubscribeFromNotificationChannel(channel: string): void;
+    sendNotification(channel: string, content: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebsocketService, never>;
+    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 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>>;
+    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;
+    /**
+     * Send notification to channel
+     * @param channel - Channel name (should include MES- prefix)
+     * @param content - Notification content
+     */
+    sendNotification(channel: string, content: any): 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>;
+}
+
+/**
+ * WebSocketMessageService - Unified service for sending WebSocket messages
+ *
+ * Provides type-safe methods for sending messages with automatic prefix management.
+ * Supports three message types: State (SYS-), Public (PUB-), and Notification (MES-).
+ *
+ * Features:
+ * - Type-safe message models
+ * - Automatic prefix management
+ * - Runtime validation
+ * - Boolean return values for success/failure
+ * - Silent failure with console errors
+ */
+declare class WebSocketMessageService {
+    private wsManagerService;
+    private logger;
+    /**
+     * Send state message (SYS- prefix)
+     * Used for CRUD operations and state synchronization
+     *
+     * @param path - Path array (e.g., ['ai', 'tests'])
+     * @param payload - StateMessage with sessionId and content
+     * @returns true if sent successfully, false otherwise
+     */
+    sendStateMessage(path: (string | number)[], payload: StateMessage): boolean;
+    /**
+     * Send public message (PUB- prefix)
+     * Used for chat, broadcast, general messaging
+     *
+     * @param channel - Channel name (without prefix)
+     * @param payload - PublicMessage with sessionId and content.message
+     * @returns true if sent successfully, false otherwise
+     */
+    sendPublicMessage(channel: string, payload: PublicMessage): boolean;
+    /**
+     * Send notification (MES- prefix)
+     * Used for persistent notifications with history
+     *
+     * @param channel - Channel name (without prefix)
+     * @param payload - NotificationMessage with sessionId and message
+     * @returns true if sent successfully, false otherwise
+     */
+    sendNotification(channel: string, payload: NotificationMessage): boolean;
+    /**
+     * Send to custom channel (no prefix)
+     * User provides full channel name
+     *
+     * @param channel - Full channel name
+     * @param payload - Any message payload
+     * @returns true if sent successfully, false otherwise
+     */
+    sendToCustomChannel(channel: string, payload: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebSocketMessageService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebSocketMessageService>;
+}
+
+declare class RequestService extends WebsocketService {
+    private http;
+    private pathQueryService;
+    private headersService;
+    isPending: BehaviorSubject<boolean>;
+    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 & {
+        stream: true;
+    }): Observable<T[]>;
+    createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+    createRecordRequest<T>(options: ApiRequest & {
+        stream: true;
+    }, data: any): Observable<T[]>;
+    createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+    createRecordRequest<T>(options: ApiRequest & {
+        stream: true;
+    }, data: any): Observable<T[]>;
+    updateRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+    deleteRecordRequest<T>(options: ApiRequest): Observable<T>;
+    private buildUrlPath;
+    private buildHeaders;
+    private buildCombinedHeaders;
+    private request;
+    private requestStreaming;
+    downloadFileRequest(options: ApiRequest): Observable<any>;
+    uploadFileRequest(options: ApiRequest): Observable<any>;
+    private validateUploadFiles;
+    private buildFormData;
+    private handleFinalize;
+    private downloadFile;
+    private createFileType;
+    private combineHeaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequestService>;
+}
+
+interface RetryOptionsInterface {
+    times?: number;
+    delay?: number;
+}
+declare class RetryOptions implements RetryOptionsInterface {
+    times: number;
+    delay: number;
+    constructor(times?: number, delay?: number);
+    static adapt(item?: any): RetryOptions;
+}
+
+interface BatchResultInterface<T = any> {
+    request: any;
+    success: boolean;
+    data?: T;
+    error?: any;
+    index: number;
+    timestamp: number;
+}
+declare class BatchResult<T = any> implements BatchResultInterface<T> {
+    request: any;
+    success: boolean;
+    data?: T | undefined;
+    error?: any | undefined;
+    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>;
+}
+
+type BatchRequestState<T> = BatchPendingState | BatchSuccessState<T> | BatchErrorState;
+interface BatchPendingState {
+    index: number;
+    request: any;
+    isPending: true;
+    data?: undefined;
+    error?: undefined;
+}
+interface BatchSuccessState<T> {
+    index: number;
+    request: any;
+    isPending: false;
+    data: T;
+    error?: undefined;
+}
+interface BatchErrorState {
+    index: number;
+    request: any;
+    isPending: false;
+    data?: undefined;
+    error: any;
+}
+declare function isPendingState<T>(state: BatchRequestState<T>): state is BatchPendingState;
+declare function isSuccessState<T>(state: BatchRequestState<T>): state is BatchSuccessState<T>;
+declare function isErrorState<T>(state: BatchRequestState<T>): state is BatchErrorState;
+
+interface BatchProgress {
+    total: number;
+    pending: number;
+    completed: number;
+    failed: number;
+    percent: number;
+}
+declare function calculateBatchProgress<T>(states: BatchRequestState<T>[]): BatchProgress;
+
+declare enum DataType {
+    ANY = 0,
+    ARRAY = 1,
+    OBJECT = 2
+}
+
+interface ConfigHTTPOptionsInterface {
+    server: string;
+    path?: any[];
+    headers?: any;
+    polling?: number;
+    retry?: RetryOptions;
+    stream?: boolean;
+    displayError?: boolean;
+    displaySuccess?: boolean;
+}
+declare class ConfigHTTPOptions implements ConfigHTTPOptionsInterface {
+    server: string;
+    path?: any[] | undefined;
+    headers?: any | undefined;
+    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;
+}
+
+interface LocalStorageOptionsInterface {
+    storageName?: string;
+    storageSettingsName?: string;
+    options?: SettingOptions;
+}
+declare class LocalStorageOptions implements LocalStorageOptionsInterface {
+    storageName?: string | undefined;
+    storageSettingsName?: string | undefined;
+    options?: SettingOptions | undefined;
+    constructor(storageName?: string | undefined, storageSettingsName?: string | undefined, options?: SettingOptions | undefined);
+    static adapt(item?: any): LocalStorageOptions;
+}
+
+interface ConfigOptionsInterface {
+    httpRequestOptions?: ConfigHTTPOptions;
+    LocalStorageOptions?: LocalStorageOptions;
+}
+declare class ConfigOptions implements ConfigOptionsInterface {
+    httpRequestOptions?: ConfigHTTPOptions | undefined;
+    LocalStorageOptions?: LocalStorageOptions | undefined;
+    constructor(httpRequestOptions?: ConfigHTTPOptions | undefined, LocalStorageOptions?: LocalStorageOptions | undefined);
+    static adapt(item?: any): ConfigOptions;
+}
+
+/**
+ * An injection token that provides the configuration settings for the application.
+ * This token can be used to inject the `ConfigSettings` instance into components or services
+ * that require access to the application configuration.
+ */
+declare const CONFIG_SETTINGS_TOKEN: InjectionToken<ConfigOptions>;
+
+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 {
+    private configOptions?;
+    utils: UtilsService;
+    constructor(configOptions?: ConfigOptions | undefined);
+    mergeOptions(options?: ApiRequest): ApiRequest;
+    mergeStorageOptions(options?: SettingOptions): SettingOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectMergerService, [{ optional: true; }]>;
+    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;
+    /** 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
+     * 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;
+    /**
+     * 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>>;
+    isConnecting$: Observable<boolean>;
+    retryCount$: Observable<number>;
+    maxRetries$: Observable<number>;
+    connectionError$: Observable<string | null>;
+    private countdown;
+    countdown$: Observable<number>;
+    private error;
+    error$: Observable<boolean>;
+    private data;
+    data$: Observable<any>;
+    private polling$;
+    config: ApiRequest;
+    streamProgress$: Observable<http_request_manager.StreamProgressModel>;
+    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;
+    /**
+     * Send notification to channel
+     */
+    sendNotification(channel: string, content: any): void;
+    getRequest<T>(options?: ApiRequest, params?: any[]): Observable<T>;
+    postRequest<T extends {
+        id?: number | string;
+    }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
+    putRequest<T extends {
+        id?: number | string;
+    }>(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;
+    /**
+     * Execute multiple HTTP requests with configurable execution strategy
+     * @param requests Array of ApiRequest configurations
+     * @param options Optional batch configuration (all properties optional)
+     * @returns Observable emitting array of data in the order of requests provided
+     */
+    getBatchRequests<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<U[]>;
+    /**
+     * Execute requests sequentially (one at a time, in order)
+     * @param requests Array of ApiRequest configurations
+     * @param options Optional batch configuration
+     * @returns Observable emitting array of data when all requests complete
+     */
+    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, successMessage?: string, errorMessage?: string): Observable<U[]>;
+    /**
+     * Execute multiple HTTP requests and emit individual state changes in real-time
+     * @param requests Array of ApiRequest configurations
+     * @param options Optional batch configuration (all properties optional)
+     * @returns Observable stream of individual request states
+     */
+    getBatchRequestsStream<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<BatchRequestState<U>>;
+    /**
+     * Execute requests sequentially and emit state changes
+     */
+    private getSequentialStream;
+    /**
+     * Execute requests in parallel and emit state changes
+     */
+    private getParallelStream;
+    private handleSequentialError;
+    private handleParallelError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerService<any>, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerService<any>>;
+}
+
+declare class RequestSignalsService extends WebsocketService {
+    private http;
+    private pathQueryService;
+    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 & {
+        stream: true;
+    }): Observable<T[]>;
+    createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+    createRecordRequest<T>(options: ApiRequest & {
+        stream: true;
+    }, data: any): Observable<T[]>;
+    updateRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+    deleteRecordRequest<T>(options: ApiRequest): Observable<T>;
+    private buildUrlPath;
+    private buildHeaders;
+    private buildCombinedHeaders;
+    private request;
+    private requestStreamingOperator;
+    downloadFileRequest(options: ApiRequest): Observable<any>;
+    uploadFileRequest(options: ApiRequest): Observable<any>;
+    private validateUploadFiles;
+    private buildFormData;
+    private handleFinalize;
+    private downloadFile;
+    private createFileType;
+    private combineHeaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestSignalsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequestSignalsService>;
+}
+
+declare class HTTPManagerSignalsService<T> extends RequestSignalsService {
+    private configOptions?;
+    toastMessage: ToastMessageDisplayService;
+    ng_injector: Injector;
+    objectMergerService: ObjectMergerService;
+    wsManager: WebSocketManagerService;
+    messageTracker: MessageTrackerService;
+    connectionStatus$: Observable<boolean>;
+    messages$: Observable<any>;
+    subscribedChannels$: Observable<Set<string>>;
+    countdown: i0.WritableSignal<number>;
+    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);
+    /**
+     * Connect to WebSocket server
+     */
+    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;
+    /**
+     * Send notification to channel
+     */
+    sendNotification(channel: string, content: any): void;
+    getRequest<T>(options?: ApiRequest, params?: any[]): Observable<T>;
+    postRequest<T extends {
+        id?: number | string;
+    }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
+    putRequest<T extends {
+        id?: number | string;
+    }>(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;
+    /**
+     * Execute multiple HTTP requests with configurable execution strategy
+     * @param requests Array of ApiRequest configurations
+     * @param options Optional batch configuration (all properties optional)
+     * @returns Observable emitting array of data in the order of requests provided
+     */
+    getBatchRequests<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<U[]>;
+    /**
+     * Execute requests sequentially (one at a time, in order)
+     * @param requests Array of ApiRequest configurations
+     * @param options Optional batch configuration
+     * @returns Observable emitting array of data when all requests complete
+     */
+    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, successMessage?: string, errorMessage?: string): Observable<U[]>;
+    /**
+     * Execute multiple HTTP requests and emit individual state changes in real-time
+     * @param requests Array of ApiRequest configurations
+     * @param options Optional batch configuration (all properties optional)
+     * @returns Observable stream of individual request states
+     */
+    getBatchRequestsStream<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<BatchRequestState<U>>;
+    /**
+     * Execute requests sequentially and emit state changes
+     */
+    private getSequentialStream;
+    /**
+     * Execute requests in parallel and emit state changes
+     */
+    private getParallelStream;
+    private handleSequentialError;
+    private handleParallelError;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerSignalsService<any>, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerSignalsService<any>>;
+}
+
+declare function countdown(duration: number): Observable<number>;
+
+declare function delayedRetry<T>(delayMs: number, maxRetry?: number): (src: Observable<T>) => Observable<T>;
+
+declare function requestPolling<T>(pollInterval: number, stopCondition$: Observable<any>, isPending$: any): (source: Observable<T>) => Observable<T>;
+
+/**
+ * COMPREHENSIVE REQUEST STREAMING OPERATOR - FULLY ABSTRACTED
+ * Refactored for better type safety and memory management
+ *
+ * Single function that handles ALL streaming formats without hardcoded assumptions:
+ * - JSON format (Individual JSON objects)
+ * - NDJSON format (Newline delimited JSON)
+ * - AI streaming format (Real-time AI responses)
+ * - Server-Sent Events format
+ * - Auto-detection mode
+ *
+ * Usage:
+ *   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?: StreamConfigModel): OperatorFunction<any, StreamOutputModel<T>>;
+/**
+ * Convenience functions for common use cases
+ */
+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[];
+    sessionStores: StorageData[];
+    settings: StorageOption[];
+}
+declare class LocalStorageManagerService extends ComponentStore<State> implements OnDestroy {
+    private configOptions?;
+    storageName: string;
+    storageSettingsName: string;
+    defaultOptions: SettingOptions;
+    stateRetrieved: boolean;
+    encrypted: boolean;
+    app: AppService;
+    utils: UtilsService;
+    objectMergerService: ObjectMergerService;
+    encryption: SymmetricalEncryptionService;
+    encryptionTest: EncryptionTestService;
+    private readonly data$;
+    readonly stores$: rxjs.Observable<StorageOption[]>;
+    readonly storeExists$: (store: string) => rxjs.Observable<boolean>;
+    readonly store$: (store: string) => rxjs.Observable<any>;
+    readonly settings$: rxjs.Observable<StorageOption[]>;
+    readonly setting$: (store: string) => rxjs.Observable<StorageOption | null>;
+    persistence$: rxjs.Subscription;
+    startTimer(): void;
+    private updateState;
+    constructor(configOptions?: ConfigOptions | undefined);
+    readonly setStore: (observableOrValue: {
+        id: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    } | rxjs.Observable<{
+        id: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }>) => rxjs.Subscription;
+    readonly createStore: (observableOrValue: {
+        id?: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    } | rxjs.Observable<{
+        id?: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }>) => rxjs.Subscription;
+    readonly updateStore: (observableOrValue: {
+        name: string;
+        data: any;
+    } | rxjs.Observable<{
+        name: string;
+        data: any;
+    }>) => rxjs.Subscription;
+    readonly deleteStore: (observableOrValue: {
+        name: string;
+    } | rxjs.Observable<{
+        name: string;
+    }>) => rxjs.Subscription;
+    resetStore(): void;
+    private persistState;
+    private expired;
+    retrieveState(): void;
+    private isObjectOrArray;
+    private isString;
+    private fixAndParseJSON;
+    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;
+    private tryParseSettingsArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageManagerService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageManagerService>;
+}
+
+declare class LocalStorageSignalsManagerService {
+    private configOptions?;
+    private state;
+    storageName: string;
+    storageSettingsName: string;
+    defaultOptions: SettingOptions;
+    stateRetrieved: boolean;
+    encrypted: boolean;
+    destroyRef: DestroyRef;
+    app: AppService;
+    utils: UtilsService;
+    objectMergerService: ObjectMergerService;
+    encryption: SymmetricalEncryptionService;
+    encryptionTest: EncryptionTestService;
+    readonly stores: i0.Signal<StorageOption[]>;
+    readonly storeExists: (store: string) => i0.Signal<boolean>;
+    readonly store: (store: string) => i0.Signal<any>;
+    readonly settings: i0.Signal<StorageOption[]>;
+    readonly setting: (store: string) => i0.Signal<StorageOption | null>;
+    constructor(configOptions?: ConfigOptions | undefined);
+    setStore(store: {
+        id: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }): void;
+    createStore(store: {
+        id?: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }): void;
+    updateStore(store: {
+        name: string;
+        data: any;
+    }): void;
+    deleteStore(store: {
+        name: string;
+    }): void;
+    resetStore(): void;
+    private persistState;
+    private expired;
+    retrieveState(): void;
+    private hasGlobalStorage;
+    private isObjectOrArray;
+    private isString;
+    private validStoreName;
+    private tryParseSettingsArray;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageSignalsManagerService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageSignalsManagerService>;
+}
+
+interface StateStorageOptionsInterface {
+    store?: string;
+    options?: SettingOptions;
+    model?: (state: any) => any;
+}
+declare class StateStorageOptions implements StateStorageOptionsInterface {
+    store?: string | undefined;
+    options?: SettingOptions | undefined;
+    model?: ((state: any) => any) | undefined;
+    constructor(store?: string | undefined, options?: SettingOptions | undefined, model?: ((state: any) => any) | undefined);
+    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> {
+    private options;
+    localStorageManagerService: LocalStorageManagerService;
+    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$: 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>>;
+}
+
+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();
+    init(options: StateStorageOptions): void;
+    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>): {
+        headers: HttpHeaders;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeadersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeadersService>;
+}
+
+declare class PathQueryService {
+    buildAPIPath(server: string | string[], params?: any[] | any): string;
+    private buildRestPath;
+    private buildQueryPath;
+    private cleanUrlPath;
+    private isObject;
+    private removeEmptyParams;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PathQueryService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PathQueryService>;
+}
+
+/**
+ * Generate a random hex color code
+ * @returns A random hex color string (e.g., "#FF5733")
+ */
+declare const RandomHexColor: () => string;
+/**
+ * Generate a random hex color with constraints to ensure good visibility
+ * @param options Optional constraints for color generation
+ * @returns A random hex color string with good contrast
+ */
+declare const RandomVisibleColor: (options?: {
+    minBrightness?: number;
+    maxBrightness?: number;
+}) => string;
+/**
+ * Generate a random color from a predefined palette
+ * @returns A hex color from a set of visually distinct colors
+ */
+declare const RandomPaletteColor: () => string;
+/**
+ * Generate a random HSL color
+ * @param options Optional constraints for HSL generation
+ * @returns A random HSL color string (e.g., "hsl(120, 100%, 50%)")
+ */
+declare const RandomHSLColor: (options?: {
+    saturation?: [number, number];
+    lightness?: [number, number];
+}) => string;
+
+declare class AsymmetricalEncryptionService {
+    constructor();
+    generateKeyPair(modulusLength?: number): Observable<CryptoKeyPair>;
+    encryptData(publicKey: CryptoKey, data: string): Observable<string>;
+    decryptData(privateKey: CryptoKey, encryptedData: string): Observable<string>;
+    pemToArrayBuffer(pem: string): ArrayBuffer;
+    base64ToArrayBuffer(base64: string): ArrayBuffer;
+    arrayBufferToBase64(buffer: ArrayBuffer): string;
+    base64ToPEM(base64Key: string, publicKey?: boolean): string;
+    pemToCryptoKey(pem: string, algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[], format?: any): Observable<CryptoKey>;
+    testGenerateKeys(): Observable<string>;
+    testDecryptionWithKeys(): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsymmetricalEncryptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AsymmetricalEncryptionService>;
+}
+
+declare const Random: () => number;
+declare const RandomNumber: (min: number, max: number) => number;
+declare const RandomNumbers: (min: number, max: number, length: number) => number[];
+declare const RandomNumbersUnique: (min: number, max: number, length: number) => number[];
+declare const RandomStr: () => string;
+declare const RandomSignature: () => number;
+declare const UUID: () => `${string}-${string}-${string}-${string}-${string}`;
+/**
+ * Generate a UUID string (legacy format)
+ */
+declare const UUID_STR: () => string;
+
+interface ErrorDisplaySettingsInterface {
+    displayTime: number;
+    position: string;
+}
+declare class ErrorDisplaySettings implements ErrorDisplaySettingsInterface {
+    displayTime: number;
+    position: string;
+    constructor(displayTime?: number, position?: string);
+    static adapt(item?: any): ErrorDisplaySettings;
+}
+
+declare class WithCredentialsInterceptor implements HttpInterceptor {
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WithCredentialsInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WithCredentialsInterceptor>;
+}
+
+declare class RequestHeadersInterceptor implements HttpInterceptor {
+    private translate;
+    subscriptions: Subscription;
+    language: string;
+    get currentDate(): string;
+    constructor(translate: TranslateService);
+    intercept(request: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestHeadersInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequestHeadersInterceptor>;
+}
+
+declare class RequestErrorInterceptor implements HttpInterceptor {
+    toastMessage: ToastMessageDisplayService;
+    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestErrorInterceptor, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequestErrorInterceptor>;
+}
+
+interface ClientInfoInterface$2 {
+    domain: string;
+    service: string;
+    id: number;
+    name: string;
+}
+declare class ClientInfo$2 implements ClientInfoInterface$2 {
+    domain: string;
+    service: string;
+    id: number;
+    name: string;
+    constructor(domain?: string, service?: string, id?: number, name?: string);
+    static adapt(item?: any): ClientInfo$2;
+}
+
+interface ClientInfoMapperInterface$2 {
+    id: number;
+    first_name: string;
+    last_name: string;
+    email: string;
+}
+declare class ClientInfoMapper$2 implements ClientInfoMapperInterface$2 {
+    id: number;
+    first_name: string;
+    last_name: string;
+    email: string;
+    constructor(id?: number, first_name?: string, last_name?: string, email?: string);
+    static adapt(item?: any): ClientInfoMapper$2;
+}
+
+interface AIPromptInterface$2 {
+    response: string;
+}
+declare class AIPrompt$2 implements AIPromptInterface$2 {
+    response: string;
+    constructor(response?: string);
+    static adapt(item?: any): AIPrompt$2;
+}
+
+declare class RequestManagerBasicDemoComponent implements OnInit {
+    server: string;
+    adapter?: Function;
+    mapper?: Function;
+    displayedColumns: string[];
+    getColumnsFromData(data: any[]): string[];
+    updateDisplayedColumns(data: any[]): void;
+    isObject(value: any): boolean;
+    private fb;
+    private toastMessage;
+    questionControl: _angular_forms.FormControl<string | null>;
+    httpManagerService: HTTPManagerService<any>;
+    isPending$: Observable<boolean>;
+    countdown$: Observable<number>;
+    GET_error$: BehaviorSubject<string>;
+    POST_error$: BehaviorSubject<string>;
+    PUT_error$: BehaviorSubject<string>;
+    DELETE_error$: BehaviorSubject<string>;
+    STREAM_error$: BehaviorSubject<string>;
+    STREAM_AI_error$: BehaviorSubject<string>;
+    GET$?: Observable<any>;
+    POST$?: Observable<any>;
+    PUT$?: Observable<any>;
+    DELETE$?: Observable<any>;
+    STREAM$?: Observable<any>;
+    STREAM_AI$?: Observable<any>;
+    requestParams: {
+        GET: ApiRequest;
+        POST: ApiRequest;
+        PUT: ApiRequest;
+        DELETE: ApiRequest;
+        STREAM: ApiRequest;
+    };
+    streamTypes: {
+        id: string;
+        value: string;
+    }[];
+    streamType: string;
+    failedState: any;
+    pollingState: any;
+    downloadRequest: ApiRequest;
+    sampleClientData: {
+        id: number;
+        name: string;
+        domain: string;
+        service: string;
+        spiffe: string;
+        secret: string;
+        created: number;
+        modified: number;
+        icon: string;
+        imageFile: string;
+        email: string;
+    };
+    requestForm: _angular_forms.FormGroup<{
+        path: _angular_forms.FormControl<string | null>;
+        headers: FormArray<_angular_forms.FormControl<unknown>>;
+        adapter: _angular_forms.FormControl<null>;
+        mapper: _angular_forms.FormControl<null>;
+        retry: _angular_forms.FormGroup<{
+            times: _angular_forms.FormControl<number | null>;
+            delay: _angular_forms.FormControl<number | null>;
+        }>;
+        polling: _angular_forms.FormControl<number | null>;
+    }>;
+    AIType: number;
+    sampleAdaptors: ({
+        label: string;
+        value: typeof ClientInfo$2.adapt;
+    } | {
+        label: string;
+        value: typeof AIPrompt$2.adapt;
+    })[];
+    sampleMappers: ({
+        label: string;
+        value: typeof ClientInfoMapper$2.adapt;
+    } | {
+        label: string;
+        value: typeof AIPrompt$2.adapt;
+    })[];
+    get retry(): {
+        times: number | null;
+        delay: number | null;
+    } | undefined;
+    get headers(): FormArray;
+    get isValid(): boolean;
+    hasId: (arr: any[]) => boolean;
+    props: (adapter: any) => any;
+    arrayObjectsToObjects: (arr: any[]) => any;
+    constructor();
+    ngOnInit(): void;
+    onStreamType(type: string): void;
+    addHeader(): void;
+    removeHeader(index: number): void;
+    compileRequest(): {
+        apiOptions: ApiRequest;
+        path: string[];
+    };
+    onGetRequest(): void;
+    onCreateRequest(): void;
+    onUpdateRequest(): void;
+    onDeleteRequest(): void;
+    onStreamPostRequest(): void;
+    onStreamRequest(): void;
+    onDownloadCompleted(): void;
+    onDownloadFailed(err: string): void;
+    errorHandling(err: any, type: string): void;
+    onSelectAIType(type: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestManagerBasicDemoComponent, never>;
+    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;
+    jwtToken: string;
+    server: string;
+    user?: UserData;
+    path: string[];
+    adapter?: Function;
+    mapper?: Function;
+    requestTypes: ({
+        name: string;
+        value: string;
+        new?: undefined;
+        divider?: undefined;
+        disabled?: undefined;
+    } | {
+        name: string;
+        value: string;
+        new: boolean;
+        divider?: undefined;
+        disabled?: undefined;
+    } | {
+        name: string;
+        value: string;
+        new: boolean;
+        divider: boolean;
+        disabled?: undefined;
+    } | {
+        name: string;
+        value: string;
+        divider: boolean;
+        disabled: boolean;
+        new?: undefined;
+    } | {
+        name: string;
+        value: string;
+        divider: boolean;
+        new?: undefined;
+        disabled?: undefined;
+    })[];
+    selectedService: string;
+    injectionOptions?: ConfigOptions;
+    constructor(configOptions?: ConfigOptions | undefined);
+    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; }; "adapter": { "alias": "adapter"; "required": false; }; "mapper": { "alias": "mapper"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface ClientInfoInterface$1 {
+    domain: string;
+    service: string;
+    id: number;
+    name: string;
+}
+declare class ClientInfo$1 implements ClientInfoInterface$1 {
+    domain: string;
+    service: string;
+    id: number;
+    name: string;
+    constructor(domain?: string, service?: string, id?: number, name?: string);
+    static adapt(item?: any): ClientInfo$1;
+}
+
+declare class StateManagerDemoService extends HTTPManagerStateService<any> {
+    constructor();
+    setAPIOptions(apiOptions: ApiRequest, dataType: DataType, database?: DatabaseStorage): void;
+    getClients(options?: RequestOptions): void;
+    createClient(data: any): void;
+    updateClient(data: ClientInfo$1): void;
+    deleteClient(data: ClientInfo$1): 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>;
+}
+
+interface ClientInfoMapperInterface$1 {
+    id: number;
+    first_name: string;
+    last_name: string;
+    email: string;
+}
+declare class ClientInfoMapper$1 implements ClientInfoMapperInterface$1 {
+    id: number;
+    first_name: string;
+    last_name: string;
+    email: string;
+    constructor(id?: number, first_name?: string, last_name?: string, email?: string);
+    static adapt(item?: any): ClientInfoMapper$1;
+}
+
+interface AIPromptInterface$1 {
+    response: string;
+}
+declare class AIPrompt$1 implements AIPromptInterface$1 {
+    response: string;
+    constructor(response?: string);
+    static adapt(item?: any): AIPrompt$1;
+}
+
+declare class RequestManagerStateDemoComponent implements OnInit {
+    server: string;
+    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;
+    streamTypes: {
+        id: string;
+        value: string;
+    }[];
+    streamType: string;
+    httpManagerService: HTTPManagerService<any>;
+    isPending$: Observable<boolean>;
+    error$: Observable<boolean>;
+    countdown$: Observable<number>;
+    GET_error$: BehaviorSubject<string>;
+    POST_error$: BehaviorSubject<string>;
+    PUT_error$: BehaviorSubject<string>;
+    DELETE_error$: BehaviorSubject<string>;
+    STREAM_error$: BehaviorSubject<string>;
+    STREAM_AI_error$: BehaviorSubject<string>;
+    GET$: BehaviorSubject<any>;
+    POST$: BehaviorSubject<null>;
+    PUT$: BehaviorSubject<null>;
+    DELETE$: BehaviorSubject<null>;
+    STREAM: BehaviorSubject<null>;
+    STREAM$: Observable<null>;
+    STREAM_AI: BehaviorSubject<{
+        response: string;
+    }[]>;
+    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;
+    }[]>;
+    sampleClientData: {
+        id: number;
+        name: string;
+        domain: string;
+        service: string;
+        spiffe: string;
+        secret: string;
+        created: number;
+        modified: number;
+        icon: string;
+        imageFile: string;
+    };
+    selectedRecord: _angular_forms.FormControl<null>;
+    requestForm: _angular_forms.FormGroup<{
+        datatype: _angular_forms.FormControl<string | null>;
+        path: _angular_forms.FormControl<string | null>;
+        headers: FormArray<_angular_forms.FormControl<unknown>>;
+        adapter: _angular_forms.FormControl<null>;
+        mapper: _angular_forms.FormControl<null>;
+        retry: _angular_forms.FormGroup<{
+            times: _angular_forms.FormControl<number | null>;
+            delay: _angular_forms.FormControl<number | null>;
+        }>;
+        polling: _angular_forms.FormControl<number | null>;
+        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;
+    get dataType(): string | null | undefined;
+    get database(): {
+        table: string | null;
+        expiresIn: string | null;
+        ignoreQueryParams: string | null;
+        queryParamsExpiresIn: string | null;
+    } | undefined;
+    get retry(): {
+        times: number | null;
+        delay: number | null;
+    } | undefined;
+    sampleAdaptors: ({
+        label: string;
+        value: typeof ClientInfo$1.adapt;
+    } | {
+        label: string;
+        value: typeof AIPrompt$1.adapt;
+    })[];
+    sampleMappers: ({
+        label: string;
+        value: typeof ClientInfoMapper$1.adapt;
+    } | {
+        label: string;
+        value: typeof AIPrompt$1.adapt;
+    })[];
+    get headers(): FormArray;
+    get isValid(): boolean;
+    arrayObjectsToObjects: (arr: any[]) => any;
+    props: (adapter: any) => any;
+    constructor();
+    ngOnInit(): void;
+    onStreamType(type: string): void;
+    addHeader(): void;
+    removeHeader(index: number): void;
+    private parsePathInput;
+    private normalizeQueryValue;
+    compileRequest(): {
+        apiOptions: ApiRequest;
+        path: any[];
+    };
+    private parseIgnoreParams;
+    private buildDemoRequestOptions;
+    onSetStateOptions(): void;
+    onClearRecords(): void;
+    deleteDatabase(): void;
+    onGetRequest(): void;
+    onCreateRequest(): void;
+    onUpdateRequest(): void;
+    onDeleteRequest(): void;
+    onStreamRequest(): void;
+    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>;
+}
+
+declare class RequestManagerDemoComponent implements OnInit {
+    server: string;
+    adapter?: Function;
+    mapper?: Function;
+    displayedColumns: string[];
+    getColumnsFromData(data: any[]): string[];
+    updateDisplayedColumns(data: any[]): void;
+    isObject(value: any): boolean;
+    private fb;
+    private toastMessage;
+    questionControl: _angular_forms.FormControl<string | null>;
+    httpManagerService: HTTPManagerService<any>;
+    isPending$: Observable<boolean>;
+    countdown$: Observable<number>;
+    GET_error$: BehaviorSubject<string>;
+    POST_error$: BehaviorSubject<string>;
+    PUT_error$: BehaviorSubject<string>;
+    DELETE_error$: BehaviorSubject<string>;
+    STREAM_error$: BehaviorSubject<string>;
+    STREAM_AI_error$: BehaviorSubject<string>;
+    GET$?: Observable<any>;
+    POST$?: Observable<any>;
+    PUT$?: Observable<any>;
+    DELETE$?: Observable<any>;
+    STREAM$?: Observable<any>;
+    STREAM_AI$?: Observable<any>;
+    parallelBatch$?: Observable<any[]>;
+    sequentialBatch$?: Observable<any[]>;
+    parallelExecutionTime?: number;
+    sequentialExecutionTime?: number;
+    parallelResults?: any[];
+    sequentialResults?: any[];
+    isParallelLoading: boolean;
+    isSequentialLoading: boolean;
+    parallelError?: string;
+    sequentialError?: string;
+    parallelBatchStates: (BatchRequestState<any> | undefined)[];
+    sequentialBatchStates: (BatchRequestState<any> | undefined)[];
+    streamBatchStates: (BatchRequestState<any> | undefined)[];
+    streamProgress?: BatchProgress;
+    streamExecutionTime?: number;
+    isStreamLoading: boolean;
+    streamError?: string;
+    get filteredParallelStates(): BatchRequestState<any>[];
+    get filteredSequentialStates(): BatchRequestState<any>[];
+    get filteredStreamStates(): BatchRequestState<any>[];
+    requestParams: {
+        GET: ApiRequest;
+        POST: ApiRequest;
+        PUT: ApiRequest;
+        DELETE: ApiRequest;
+        STREAM: ApiRequest;
+    };
+    streamTypes: {
+        id: string;
+        value: string;
+    }[];
+    streamType: string;
+    failedState: any;
+    pollingState: any;
+    downloadRequest: ApiRequest;
+    sampleClientData: {
+        id: number;
+        name: string;
+        domain: string;
+        service: string;
+        spiffe: string;
+        secret: string;
+        created: number;
+        modified: number;
+        icon: string;
+        imageFile: string;
+        email: string;
+    };
+    requestForm: _angular_forms.FormGroup<{
+        path: _angular_forms.FormControl<string | null>;
+        headers: FormArray<_angular_forms.FormControl<unknown>>;
+        adapter: _angular_forms.FormControl<null>;
+        mapper: _angular_forms.FormControl<null>;
+        retry: _angular_forms.FormGroup<{
+            times: _angular_forms.FormControl<number | null>;
+            delay: _angular_forms.FormControl<number | null>;
+        }>;
+        polling: _angular_forms.FormControl<number | null>;
+    }>;
+    AIType: number;
+    sampleAdaptors: ({
+        label: string;
+        value: typeof ClientInfo$1.adapt;
+    } | {
+        label: string;
+        value: typeof AIPrompt$1.adapt;
+    })[];
+    sampleMappers: ({
+        label: string;
+        value: typeof ClientInfoMapper$1.adapt;
+    } | {
+        label: string;
+        value: typeof AIPrompt$1.adapt;
+    })[];
+    get retry(): {
+        times: number | null;
+        delay: number | null;
+    } | undefined;
+    get headers(): FormArray;
+    get isValid(): boolean;
+    hasId: (arr: any[]) => boolean;
+    props: (adapter: any) => any;
+    arrayObjectsToObjects: (arr: any[]) => any;
+    constructor();
+    ngOnInit(): void;
+    onStreamType(type: string): void;
+    addHeader(): void;
+    removeHeader(index: number): void;
+    compileRequest(): {
+        apiOptions: ApiRequest;
+        path: string[];
+    };
+    onGetRequest(): void;
+    onCreateRequest(): void;
+    onUpdateRequest(): void;
+    onDeleteRequest(): void;
+    onStreamPostRequest(): void;
+    onStreamRequest(): void;
+    onDownloadCompleted(): void;
+    onDownloadFailed(err: string): void;
+    errorHandling(err: any, type: string): void;
+    onSelectAIType(type: number): void;
+    /**
+     * Execute parallel batch request - fetch 5 users from JSONPlaceholder with individual states
+     */
+    onExecuteParallelBatch(): void;
+    /**
+     * Execute sequential batch request - fetch 5 todos from JSONPlaceholder with individual states
+     */
+    onExecuteSequentialBatch(): void;
+    /**
+     * Execute stream batch request - fetch 5 posts with real-time state updates
+     */
+    onExecuteStreamBatch(): void;
+    /**
+     * Type guard for pending state
+     */
+    isPendingState(state: BatchRequestState<any>): boolean;
+    /**
+     * Type guard for success state
+     */
+    isSuccessState(state: BatchRequestState<any>): boolean;
+    /**
+     * Type guard for error state
+     */
+    isErrorState(state: BatchRequestState<any>): boolean;
+    /**
+     * Helper to create batch requests from IDs
+     */
+    private createBatchRequests;
+    /**
+     * Check if result is successful (not undefined)
+     */
+    isSuccess(result: any): boolean;
+    /**
+     * Format execution time for display
+     */
+    formatTime(ms: number): string;
+    /**
+     * Get success count from results array
+     */
+    getSuccessCount(results?: any[]): number;
+    /**
+     * Get failure count from results array
+     */
+    getFailureCount(results?: any[]): number;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestManagerDemoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerDemoComponent, "app-request-manager-demo", never, { "server": { "alias": "server"; "required": false; }; "adapter": { "alias": "adapter"; "required": false; }; "mapper": { "alias": "mapper"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+interface ClientInfoInterface {
+    domain: string;
+    service: string;
+    id: number;
+    name: string;
+}
+declare class ClientInfo implements ClientInfoInterface {
+    domain: string;
+    service: string;
+    id: number;
+    name: string;
+    constructor(domain?: string, service?: string, id?: number, name?: string);
+    static adapt(item?: any): ClientInfo;
+}
+
+interface ClientInfoMapperInterface {
+    id: number;
+    first_name: string;
+    last_name: string;
+    email: string;
+}
+declare class ClientInfoMapper implements ClientInfoMapperInterface {
+    id: number;
+    first_name: string;
+    last_name: string;
+    email: string;
+    constructor(id?: number, first_name?: string, last_name?: string, email?: string);
+    static adapt(item?: any): ClientInfoMapper;
+}
+
+interface AIPromptInterface {
+    response: string;
+}
+declare class AIPrompt implements AIPromptInterface {
+    response: string;
+    constructor(response?: string);
+    static adapt(item?: any): AIPrompt;
+}
+
+declare class RequestSignalsManagerDemoComponent implements OnInit {
+    displayedColumns: string[];
+    private fb;
+    private toastMessage;
+    httpManagerSignalsService: HTTPManagerSignalsService<any>;
+    isPending: i0.WritableSignal<boolean>;
+    countdown: i0.WritableSignal<number>;
+    GET_result: any;
+    POST_result: any;
+    PUT_result: any;
+    DELETE_result: any;
+    STREAM_result: any;
+    STREAM_AI_result: any;
+    GET_error: string;
+    POST_error: string;
+    PUT_error: string;
+    DELETE_error: string;
+    STREAM_error: string;
+    STREAM_AI_error: string;
+    requestParams: {
+        GET: ApiRequest;
+        POST: ApiRequest;
+        PUT: ApiRequest;
+        DELETE: ApiRequest;
+        STREAM: ApiRequest;
+    };
+    failedState: any;
+    pollingState: any;
+    questionControl: _angular_forms.FormControl<string | null>;
+    downloadRequest: ApiRequest;
+    sampleClientData: {
+        id: number;
+        name: string;
+        domain: string;
+        service: string;
+        spiffe: string;
+        secret: string;
+        created: number;
+        modified: number;
+        icon: string;
+        imageFile: string;
+        email: string;
+    };
+    requestForm: _angular_forms.FormGroup<{
+        path: _angular_forms.FormControl<string | null>;
+        headers: FormArray<_angular_forms.FormControl<unknown>>;
+        adapter: _angular_forms.FormControl<null>;
+        mapper: _angular_forms.FormControl<null>;
+        retry: _angular_forms.FormGroup<{
+            times: _angular_forms.FormControl<number | null>;
+            delay: _angular_forms.FormControl<number | null>;
+        }>;
+        polling: _angular_forms.FormControl<number | null>;
+    }>;
+    AIType: number;
+    sampleAdaptors: ({
+        label: string;
+        value: typeof ClientInfo.adapt;
+    } | {
+        label: string;
+        value: typeof AIPrompt.adapt;
+    })[];
+    sampleMappers: ({
+        label: string;
+        value: typeof ClientInfoMapper.adapt;
+    } | {
+        label: string;
+        value: typeof AIPrompt.adapt;
+    })[];
+    get retry(): {
+        times: number | null;
+        delay: number | null;
+    } | undefined;
+    get headers(): FormArray;
+    get isValid(): boolean;
+    hasId: (arr: any[]) => boolean;
+    props: (adapter: any) => any;
+    arrayObjectsToObjects: (arr: any[]) => any;
+    constructor();
+    ngOnInit(): void;
+    addHeader(): void;
+    removeHeader(index: number): void;
+    compileRequest(): {
+        apiOptions: ApiRequest;
+        path: string[];
+    };
+    onGetRequest(): void;
+    onCreateRequest(): void;
+    onUpdateRequest(): void;
+    onDeleteRequest(): void;
+    onStreamPostRequest(): void;
+    onStreamRequest(): void;
+    onDownloadCompleted(): void;
+    onDownloadFailed(err: string): void;
+    errorHandling(err: any, type: string): any;
+    onSelectAIType(type: number): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestSignalsManagerDemoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RequestSignalsManagerDemoComponent, "app-request-signals-manager-demo", never, {}, {}, never, never, false, never>;
+}
+
+declare class LocalStorageDemoComponent implements OnInit {
+    private configOptions?;
+    fb: FormBuilder;
+    utils: UtilsService;
+    type$: BehaviorSubject<StorageType>;
+    get type(): number;
+    typeControl: _angular_forms.FormControl<string | null>;
+    localStorageManagerService: LocalStorageManagerService;
+    settings$: Observable<any>;
+    setting$: (store: string) => Observable<StorageOption | null>;
+    storageForm: _angular_forms.FormGroup<{
+        store: _angular_forms.FormControl<string | null>;
+        type: _angular_forms.FormControl<string | null>;
+        settingType: _angular_forms.FormControl<string | null>;
+        encrypted: _angular_forms.FormControl<boolean | null>;
+        data: _angular_forms.FormControl<string | null>;
+    }>;
+    newStoreForm: _angular_forms.FormGroup<{
+        name: _angular_forms.FormControl<string | null>;
+        storage: _angular_forms.FormControl<string | null>;
+        encrypted: _angular_forms.FormControl<boolean | null>;
+        data: _angular_forms.FormControl<string | null>;
+        expiresIn: _angular_forms.FormControl<string | null>;
+    }>;
+    store$?: Observable<any>;
+    storeData$: Observable<any> | undefined;
+    expiresIn: (epoch: number) => string | undefined;
+    get isValid(): boolean;
+    get isValidData(): boolean;
+    isValidJSON: (str: string) => boolean;
+    displayedColumns: string[];
+    filterData: (values: SettingOptions[]) => SettingOptions[];
+    data$?: Observable<any>;
+    store: any;
+    create: boolean;
+    storeProps?: LocalStorageOptions;
+    options?: SettingOptions;
+    constructor(configOptions?: ConfigOptions | undefined);
+    ngOnInit(): void;
+    onCreateStore(): void;
+    onUpdateStore(store: any): void;
+    onSelectedRow(store: any): void;
+    onCreate(): void;
+    onDelete(store: StorageOption): void;
+    onCancel(): void;
+    onUpdate(store: StorageOption, data: any): void;
+    onReset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageDemoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LocalStorageDemoComponent, "app-local-storage-demo", never, {}, {}, never, never, false, never>;
+}
+
+declare class LocalStorageSignalsDemoComponent implements OnInit {
+    private configOptions?;
+    fb: FormBuilder;
+    utils: UtilsService;
+    get type(): number;
+    typeControl: _angular_forms.FormControl<string | null>;
+    localStorageManagerService: LocalStorageSignalsManagerService;
+    readonly settings: i0.Signal<StorageOption[]>;
+    storeSelected: i0.WritableSignal<StorageOption | null>;
+    selectedStoreData: i0.Signal<string>;
+    selectedType: i0.WritableSignal<number>;
+    filteredSettings: i0.Signal<StorageOption[]>;
+    storageForm: _angular_forms.FormGroup<{
+        store: _angular_forms.FormControl<string | null>;
+        type: _angular_forms.FormControl<string | null>;
+        settingType: _angular_forms.FormControl<string | null>;
+        encrypted: _angular_forms.FormControl<boolean | null>;
+        data: _angular_forms.FormControl<string | null>;
+    }>;
+    newStoreForm: _angular_forms.FormGroup<{
+        name: _angular_forms.FormControl<string | null>;
+        storage: _angular_forms.FormControl<string | null>;
+        encrypted: _angular_forms.FormControl<boolean | null>;
+        data: _angular_forms.FormControl<string | null>;
+        expiresIn: _angular_forms.FormControl<string | null>;
+    }>;
+    expiresIn: (epoch: number) => string | undefined;
+    get isValid(): boolean;
+    get isValidData(): boolean;
+    isValidJSON: (str: string) => boolean;
+    displayedColumns: string[];
+    filterData: (values: StorageOption[] | null | undefined) => StorageOption[];
+    settingFor(name: string): StorageOption | null;
+    store: any;
+    create: boolean;
+    storeProps?: LocalStorageOptions;
+    options?: SettingOptions;
+    constructor(configOptions?: ConfigOptions | undefined);
+    ngOnInit(): void;
+    onCreateStore(): void;
+    onUpdateStore(store: any): void;
+    onSelectedRow(store: any): void;
+    onCreate(): void;
+    onDelete(store: StorageOption): void;
+    onCancel(): void;
+    onUpdate(store: StorageOption, data: any): void;
+    onReset(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageSignalsDemoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<LocalStorageSignalsDemoComponent, "app-local-storage-signals-demo", never, {}, {}, never, never, false, never>;
+}
+
+/**
+ * StateServiceDemo - Core state management and WebSocket connection service
+ *
+ * Handles:
+ * - WebSocket connection setup
+ * - Base HTTP state management
+ * - Connection status and retry logic
+ */
+declare class StateServiceDemo extends HTTPManagerStateService<any> {
+    attempts$: rxjs.Observable<number>;
+    nextRetry$: rxjs.Observable<number>;
+    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, path?: (string | number)[]): void;
+    /**
+     * Get all available channels
+     */
+    getAllChannels(): void;
+    /**
+     * Subscribe to a channel
+     */
+    subscribeToChannel(channel: string): void;
+    /**
+     * Unsubscribe from a channel
+     */
+    unsubscribeFromChannel(channel: string): void;
+    /**
+     * Create a notification channel (MES- prefix)
+     */
+    createNotificationChannel(channel: string): void;
+    /**
+     * Get all notification channels list (in-memory)
+     */
+    getNotificationChannels(): void;
+    /**
+     * Get today's notification channels from database
+     * Returns unique channels that have notifications posted today
+     */
+    getTodaysNotificationChannels(): void;
+    /**
+     * Define and load previous day's notification channels from database
+     * Creates channels in memory and broadcasts updated list
+     */
+    definePreviousNotificationChannels(): void;
+    /**
+     * Subscribe to notification channel with optional date filters
+     */
+    subscribeToNotificationChannel(channel: string, options?: {
+        startEpoch?: number;
+        endEpoch?: number;
+    }, user?: any): void;
+    /**
+     * Unsubscribe from notification channel
+     */
+    unsubscribeFromNotificationChannel(channel: string): void;
+    /**
+     * Send a notification to a channel
+     */
+    sendNotification(channel: string, content: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateServiceDemo, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StateServiceDemo>;
+}
+
+/**
+ * MessageServiceDemo - Channel messaging service (PUB- prefix channels)
+ *
+ * Handles:
+ * - Sending messages to channels
+ * - Channel subscription for messaging
+ * - Real-time message broadcast
+ */
+declare class MessageServiceDemo {
+    private stateService;
+    channels$: rxjs.Observable<string[] | null>;
+    subscribedChannels$: rxjs.Observable<Set<string>>;
+    communicationMessages$: rxjs.Observable<any[]>;
+    latestCommunicationMessages$: rxjs.Observable<any>;
+    connectionStatus$: rxjs.Observable<boolean>;
+    user$: rxjs.Observable<WSUser | null>;
+    data$: rxjs.Observable<any>;
+    /**
+     * Helper to ensure channel has PUB- prefix
+     */
+    private toPublicChannel;
+    /**
+     * Helper to strip PUB- prefix for display
+     */
+    private fromPublicChannel;
+    /**
+     * Create a new public channel
+     */
+    createChannel(channel: string): void;
+    /**
+     * Get all available channels
+     */
+    getAllChannels(): void;
+    /**
+     * Subscribe to a channel to receive messages
+     */
+    subscribeToChannel(channel: string): void;
+    /**
+     * Unsubscribe from a channel
+     */
+    unsubscribeFromChannel(channel: string): void;
+    /**
+     * Send a message to one or more channels
+     */
+    sendMessage(data: ChannelMessage, channels?: string[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageServiceDemo, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageServiceDemo>;
+}
+
+/**
+ * NotificationServiceDemo - Notification channel service (MES- prefix channels)
+ *
+ * Handles:
+ * - Creating notification channels
+ * - Subscribing to notifications with date filters
+ * - Sending notifications (persisted to database)
+ * - Receiving real-time and historical notifications
+ */
+declare class NotificationServiceDemo {
+    private stateService;
+    notificationChannels$: rxjs.Observable<string[]>;
+    todaysNotificationChannels$: rxjs.Observable<string[]>;
+    private subscribedNotificationChannelsSubject;
+    subscribedNotificationChannels$: rxjs.Observable<Set<string>>;
+    notificationMessages$: rxjs.Observable<any[]>;
+    latestNotification$: rxjs.Observable<any>;
+    connectionStatus$: rxjs.Observable<boolean>;
+    /**
+     * Create a notification channel
+     * NOTE: MES- prefix is added automatically by HTTPManagerStateService
+     */
+    createNotificationChannel(channel: string): void;
+    /**
+     * Get all notification channels (in-memory)
+     */
+    getNotificationChannels(): void;
+    /**
+     * Get today's notification channels from database
+     * Returns unique channels that have notifications posted today
+     */
+    getTodaysNotificationChannels(): void;
+    /**
+     * Define and load previous day's notification channels from database
+     * Creates channels in memory and broadcasts updated list
+     */
+    definePreviousNotificationChannels(): void;
+    /**
+     * Subscribe to a notification channel with optional date filter
+     * NOTE: MES- prefix is added automatically by HTTPManagerStateService
+     * @param channel Base channel name (without MES- prefix)
+     * @param options { startEpoch?, endEpoch? }
+     * @param user User info for subscription
+     */
+    subscribeToNotificationChannel(channel: string, options?: {
+        startEpoch?: number;
+        endEpoch?: number;
+    }, user?: any): void;
+    /**
+     * Unsubscribe from a notification channel
+     * NOTE: MES- prefix is added automatically by HTTPManagerStateService
+     */
+    unsubscribeFromNotificationChannel(channel: string): void;
+    /**
+     * Send a notification to a channel
+     * NOTE: MES- prefix is added automatically by HTTPManagerStateService
+     */
+    sendNotification(channel: string, content: any, user?: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationServiceDemo, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationServiceDemo>;
+}
+
+declare class RequestManagerWsDemoComponent implements OnInit, OnChanges {
+    httpManagerService: HTTPManagerService<any>;
+    stateService: StateServiceDemo;
+    fb: FormBuilder;
+    server: string;
+    wsServer: string;
+    jwtToken: string;
+    user: any;
+    path: string[];
+    user$: rxjs.Observable<WSUser | null>;
+    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>;
+}
+
+declare class SettingsStateService extends StoreStateManagerService {
+    constructor();
+    updateEnum_1(value: any): void;
+    updateEnum_2(value: any): void;
+    getEnum(key: string): rxjs.Observable<any>;
+    getEnum_1(): rxjs.Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsStateService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsStateService>;
+}
+
+declare class StoreStateManagerDemoComponent implements OnInit {
+    settingsStateService: SettingsStateService;
+    dataState$: rxjs.Observable<any>;
+    dataEnum$: rxjs.Observable<any>;
+    ngOnInit(): void;
+    onUpdateEnum_1(): void;
+    onUpdateEnum_2(): void;
+    onGetEnum_1(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoreStateManagerDemoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<StoreStateManagerDemoComponent, "app-store-state-manager-demo", never, {}, {}, never, never, false, never>;
+}
+
+interface TableRecord {
+    id: number;
+    last_name: string;
+    age: number;
+    amount: number;
+}
+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;
+    removeData(): void;
+    updateData(): void;
+    clearAllData(): void;
+    private refreshData;
+    ngOnInit(): void;
+    createTable(tableDef: TableSchemaDef): Observable<boolean>;
+    findTableRecords(table: string, column: string, value: any): Observable<any>;
+    findTableRecord(table: string, column: string, value: any): Observable<any>;
+    getTableRecords(table: string): Observable<any>;
+    getTableRecord(table: string, id: number): Observable<any>;
+    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>;
+}
+declare class DatabaseDataSource extends DataSource<TableRecord> {
+    private _dataStream;
+    constructor(initialData: TableRecord[]);
+    connect(): Observable<TableRecord[]>;
+    disconnect(): void;
+    setData(data: TableRecord[]): void;
+}
+
+declare class StateDataRequestService extends HTTPManagerStateService<any> {
+    attempts$: rxjs.Observable<number>;
+    nextRetry$: rxjs.Observable<number>;
+    path: (string | number)[];
+    constructor();
+    updateConnection(server: string, wsServer: string, jwtToken: string, user: any, path?: (string | number)[]): void;
+    addData(): void;
+    sendMessage(data: ChannelMessage): void;
+    getData(): void;
+    updateData(data: any): void;
+    deleteData(data: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateDataRequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StateDataRequestService>;
+}
+
+declare class WsDataControlComponent implements OnInit, OnChanges {
+    server: string;
+    wsServer: string;
+    jwtToken: string;
+    user: any;
+    path: (string | number)[];
+    stateDataRequestService: StateDataRequestService;
+    webSocketMessageService: WebSocketMessageService;
+    user$: rxjs.Observable<WSUser | null>;
+    users$: rxjs.Observable<any[]>;
+    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;
+    onRemoveData(data: any): void;
+    /**
+     * Test direct state message via WebSocketMessageService
+     * Sends an UPDATE message that should trigger fetchRecord() in the state manager
+     *
+     * @param recordId - The record ID to update (default: 63)
+     * @param useFakeSessionId - If true, uses a fake sessionId to avoid filtering (default: true)
+     * @param customSessionId - Optional custom sessionId (overrides useFakeSessionId if provided)
+     */
+    onTestDirectStateMessage(recordId?: number, useFakeSessionId?: boolean, customSessionId?: string): 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; }; }, {}, never, never, false, never>;
+}
+
+interface SlideInterface {
+    title: string;
+    message: string;
+    image?: string;
+    icon?: string;
+}
+declare class Slide implements SlideInterface {
+    title: string;
+    message: string;
+    image?: string | undefined;
+    icon?: string | undefined;
+    constructor(title?: string, message?: string, image?: string | undefined, icon?: string | undefined);
+    static adapt(item?: any): Slide;
+}
+
+interface ActionInterface {
+    label: string;
+    action: 'close' | 'navigate' | 'callback' | 'custom';
+    target?: string;
+    callback?: string;
+    primary?: boolean;
+}
+declare class Action implements ActionInterface {
+    label: string;
+    action: 'close' | 'navigate' | 'callback' | 'custom';
+    target?: string | undefined;
+    callback?: string | undefined;
+    primary?: boolean | undefined;
+    constructor(label?: string, action?: 'close' | 'navigate' | 'callback' | 'custom', target?: string | undefined, callback?: string | undefined, primary?: boolean | undefined);
+    static adapt(item?: any): Action;
+}
+
+type DisplayType = 'snackbar' | 'dialog' | 'carousel' | 'banner' | 'inline';
+interface DisplayConfigInterface {
+    type: DisplayType;
+    supportsMarkdown?: boolean;
+    stackable?: boolean;
+    queueBehavior?: 'replace' | 'queue' | 'ignore';
+    autoDismiss?: number;
+    width?: string;
+    height?: string;
+}
+declare class DisplayConfig implements DisplayConfigInterface {
+    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;
+}
+
+interface MessageContentInterface {
+    displayConfig?: DisplayConfig;
+    title?: string;
+    message: string;
+    slides?: Slide[];
+    image?: string;
+    images?: string[];
+    actions?: Action[];
+    messageType?: string;
+    icon?: string;
+    data?: any;
+}
+declare class MessageContent implements MessageContentInterface {
+    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;
+    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 {
+    type: string;
+    messageId?: number;
+    channel?: string;
+    sessionId?: {
+        id: string;
+    };
+    timestamp?: string;
+    content: MessageContent;
+}
+declare class CommunicationMessage implements CommunicationMessageInterface {
+    type: string;
+    messageId?: number | undefined;
+    channel?: string | undefined;
+    sessionId?: {
+        id: string;
+    } | undefined;
+    timestamp?: string | undefined;
+    content: MessageContent;
+    constructor(type?: string, messageId?: number | undefined, channel?: string | undefined, sessionId?: {
+        id: string;
+    } | undefined, timestamp?: string | undefined, content?: MessageContent);
+    static adapt(item?: any): CommunicationMessage;
+}
+
+interface IDisplayStrategy {
+    name: string;
+    canHandle(message: CommunicationMessage): boolean;
+    display(message: CommunicationMessage, config: DisplayConfig): void;
+}
+
+interface DisplayRuleInterface {
+    id: string;
+    name?: string;
+    match: (message: CommunicationMessage) => boolean;
+    display: DisplayConfig;
+}
+declare class DisplayRule implements DisplayRuleInterface {
+    id: string;
+    name?: string | undefined;
+    match: (message: CommunicationMessage) => boolean;
+    display: DisplayConfig;
+    constructor(id?: string, name?: string | undefined, match?: (message: CommunicationMessage) => boolean, display?: DisplayConfig);
+    static adapt(item?: any): DisplayRule;
+}
+
+declare class MessageDisplayRouterService {
+    private snackbarStrategy;
+    private strategies;
+    private rules;
+    display(message: CommunicationMessage): void;
+    registerStrategies(strategies: IDisplayStrategy[]): void;
+    setRules(rules: DisplayRule[]): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MessageDisplayRouterService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MessageDisplayRouterService>;
+}
+
+declare class WsMessagingComponent implements OnInit, OnDestroy {
+    server: string;
+    wsServer: string;
+    jwtToken: string;
+    user: any;
+    path: (string | number)[];
+    private destroy$;
+    fb: FormBuilder;
+    messageService: MessageServiceDemo;
+    stateService: StateServiceDemo;
+    messageDisplayService: MessageDisplayRouterService;
+    channels$: Observable<string[]>;
+    subscribedChannels$: Observable<string[]>;
+    user$: Observable<WSUser | null>;
+    data$: Observable<any>;
+    connectionStatus$: Observable<boolean>;
+    newChannelName: FormControl<string | null>;
+    messages: _angular_forms.FormGroup<{
+        selectedChannels: FormControl<string[] | null>;
+        content: FormControl<string | null>;
+    }>;
+    get selectedChannels(): FormControl;
+    get content(): FormControl;
+    communicationMessages$: Observable<any[]>;
+    latestCommunicationMessages$: Observable<any>;
+    chat$: Observable<{
+        user: any;
+        messages: any[];
+    } | any>;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Create a new public channel without auto-subscribing
+     * NOTE: PUB- prefix is added by messageService.createChannel
+     */
+    onCreateChannel(): void;
+    /**
+     * Subscribe to a channel to receive messages
+     * NOTE: PUB- prefix is added by messageService.subscribeToChannel
+     */
+    onSubscribeToChannel(channel: string): void;
+    /**
+     * Unsubscribe from a channel
+     * NOTE: PUB- prefix is added by messageService.unsubscribeFromChannel
+     */
+    onUnsubscribeFromChannel(channel: string): void;
+    /**
+     * Handle chip toggle for subscribe/unsubscribe
+     */
+    onChipToggle(event: any, channel: string): void;
+    /**
+     * Check if currently subscribed to a channel
+     * Compares display names (without PUB- prefix)
+     */
+    isSubscribed(channel: string, subscribedChannels: string[]): boolean;
+    onSendMessage(): 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; }; "path": { "alias": "path"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class WsNotificationsComponent implements OnInit, OnDestroy {
+    server: string;
+    wsServer: string;
+    jwtToken: string;
+    user: any;
+    private destroy$;
+    fb: FormBuilder;
+    notificationService: NotificationServiceDemo;
+    stateService: StateServiceDemo;
+    todaysNotificationChannels$: rxjs.Observable<string[]>;
+    subscribedNotificationChannels$: rxjs.Observable<string[]>;
+    notificationMessages$: rxjs.Observable<any[]>;
+    connectionStatus$: rxjs.Observable<boolean>;
+    /**
+     * Helper to ensure channel has MES- prefix for outgoing communication
+     */
+    private toNotificationChannel;
+    newChannelName: FormControl<string | null>;
+    selectedConnectionChannel: FormControl<string | null>;
+    connectedChannel: string | null;
+    displayedColumns: string[];
+    dateFilter: _angular_forms.FormGroup<{
+        startDate: FormControl<Date | null>;
+        endDate: FormControl<Date | null>;
+    }>;
+    notificationForm: _angular_forms.FormGroup<{
+        content: FormControl<string | null>;
+    }>;
+    get content(): FormControl;
+    /**
+     * Check if currently connected to a channel
+     */
+    isChannelConnected(subscribedChannels: string[]): boolean;
+    /**
+     * Connect to the selected channel
+     */
+    onConnectToChannel(): void;
+    /**
+     * Disconnect from the current channel
+     */
+    onDisconnectFromChannel(): void;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    /**
+     * Create a new notification channel
+     */
+    onCreateChannel(): void;
+    /**
+     * Define and load previous channels
+     */
+    onDefinePreviousChannels(): void;
+    /**
+     * Subscribe to a notification channel with optional date filter
+     */
+    onSubscribeToChannel(channel: string): void;
+    /**
+     * Unsubscribe from a notification channel
+     */
+    onUnsubscribeFromChannel(channel: string): void;
+    /**
+     * Check if currently subscribed to a channel
+     */
+    isSubscribed(channel: string, subscribedChannels: string[]): boolean;
+    /**
+     * Handle chip click - toggle subscription state
+     */
+    onChipClick(channel: string, subscribedChannels: string[]): void;
+    /**
+     * Send a notification
+     */
+    onSendNotification(): void;
+    /**
+     * Format epoch timestamp to readable date/time
+     */
+    formatTimestamp(epoch: number): string;
+    /**
+     * Get today's date in YYYY-MM-DD format for date input default
+     */
+    getTodayDate(): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WsNotificationsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WsNotificationsComponent, "app-ws-notifications", 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>;
+}
+
+declare class WsAiMessagingComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WsAiMessagingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WsAiMessagingComponent, "app-ws-ai-messaging", never, {}, {}, never, never, false, never>;
+}
+
+declare class WsChatsComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WsChatsComponent, never>;
+    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;
+    display?: string | number;
+    mode?: ProgressSpinnerMode;
+    strokeWidth?: number;
+    value: number;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerComponent, "app-spinner", never, { "color": { "alias": "color"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "display": { "alias": "display"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class DownloadFileComponent implements OnInit {
+    private subscriptions;
+    event?: Function;
+    displayError: number;
+    diameter: number;
+    mode: ProgressSpinnerMode;
+    isPending: boolean;
+    active: boolean;
+    disabled: boolean;
+    error: EventEmitter<void>;
+    private _progress;
+    set progress(value: any);
+    get progress(): any;
+    private _hasError;
+    private errorTimerActive;
+    set hasError(value: boolean | any);
+    get hasError(): boolean | any;
+    ngOnInit(): void;
+    onAction(): void;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DownloadFileComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DownloadFileComponent, "app-download-file", never, { "event": { "alias": "event"; "required": false; }; "displayError": { "alias": "displayError"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "isPending": { "alias": "isPending"; "required": false; }; "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; }, { "error": "error"; }, never, never, false, never>;
+}
+
+interface DownloadLabelsInterface {
+    error: string;
+    action: string;
+    icon: string;
+}
+declare class DownloadLabels implements DownloadLabelsInterface {
+    error: string;
+    action: string;
+    icon: string;
+    constructor(error?: string, action?: string, icon?: string);
+    static adapt(item?: any): DownloadLabelsInterface;
+}
+
+declare class FileDownloaderComponent extends HTTPManagerService<any> implements OnInit {
+    delayError: number;
+    apiRequest: ApiRequest;
+    displayErrorMessage: boolean;
+    saveFileAs?: string;
+    _labels: DownloadLabelsInterface;
+    set labels(value: DownloadLabels);
+    active: boolean;
+    subscription: Subscription;
+    get labels(): DownloadLabels;
+    completed: EventEmitter<void>;
+    failed: EventEmitter<string>;
+    disabled: boolean;
+    constructor();
+    ngOnInit(): void;
+    onDownloadStreaming(): Subscription | undefined;
+    onError(message: string): void;
+    OnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileDownloaderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<FileDownloaderComponent, "app-file-downloader", never, { "delayError": { "alias": "delayError"; "required": false; }; "apiRequest": { "alias": "apiRequest"; "required": false; }; "displayErrorMessage": { "alias": "displayErrorMessage"; "required": false; }; "saveFileAs": { "alias": "saveFileAs"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "completed": "completed"; "failed": "failed"; }, never, never, false, never>;
+}
+
+declare class FileDownloaderModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileDownloaderModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FileDownloaderModule, [typeof SpinnerComponent, typeof DownloadFileComponent, typeof FileDownloaderComponent], [typeof i4.CommonModule, typeof i5.MatIconModule, typeof i6.MatProgressSpinnerModule, typeof i7.MatButtonModule], [typeof FileDownloaderComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<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 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>;
+}
+
+declare class StoreStateSignalsDemoComponent implements OnInit {
+    private stateManager;
+    stateJson: i0.WritableSignal<string>;
+    historyLength: i0.WritableSignal<number>;
+    history: i0.WritableSignal<number[]>;
+    ngOnInit(): void;
+    private updateSignals;
+    increment(): void;
+    decrement(): void;
+    reset(): void;
+    addToHistory(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoreStateSignalsDemoComponent, 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, 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 };