http-request-manager 18.7.21 → 18.7.27

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

@@ -0,0 +1,2277 @@
+import * as rxjs from 'rxjs';
+import { Observable, BehaviorSubject, OperatorFunction, Subscription } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injector, OnDestroy, OnInit, EventEmitter, ModuleWithProviders } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { HttpClient, HttpHeaders, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as i16 from 'toast-message-display';
+import { ToastMessageDisplayService } from 'toast-message-display';
+import Dexie, { Table } from 'dexie';
+import * as i33 from '@ngx-translate/core';
+import { TranslateService } from '@ngx-translate/core';
+import * as _angular_forms from '@angular/forms';
+import { FormBuilder, FormArray, FormControl } from '@angular/forms';
+import { DataSource } from '@angular/cdk/collections';
+import * as http_request_manager from 'http-request-manager';
+import * as i4 from '@angular/common';
+import * as i7 from '@angular/material/button';
+import * as i19 from '@angular/material/tabs';
+import * as i20 from '@angular/material/select';
+import * as i21 from '@angular/material/chips';
+import * as i22 from '@angular/material/menu';
+import * as i5 from '@angular/material/icon';
+import * as i24 from '@angular/material/table';
+import * as i25 from '@angular/material/button-toggle';
+import * as i26 from '@angular/material/autocomplete';
+import * as i27 from '@angular/material/progress-bar';
+import * as i28 from '@angular/material/slide-toggle';
+import * as i29 from '@angular/material/divider';
+import * as i30 from '@angular/material/form-field';
+import * as i31 from '@angular/material/input';
+import * as i32 from '@angular/material/toolbar';
+import * as i34 from '@angular/material/sidenav';
+import * as i35 from '@angular/material/datepicker';
+import * as i36 from '@angular/material/core';
+import { ThemePalette } from '@angular/material/core';
+import * as i6 from '@angular/material/progress-spinner';
+import { ProgressSpinnerMode } from '@angular/material/progress-spinner';
+
+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;
+    options?: SettingOptions | undefined;
+    constructor(id?: string | undefined, name?: string, data?: any, 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;
+    constructor(id?: string | undefined, data?: any);
+    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 | undefined;
+    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[];
+    user?: any;
+    retry?: RetryOptions;
+}
+declare class WSOptions implements WSOptionsInterface {
+    id: string;
+    wsServer: string;
+    jwtToken: string;
+    permissions?: string[] | undefined;
+    channels?: string[] | undefined;
+    user?: any;
+    retry?: RetryOptions | undefined;
+    constructor(id?: string, wsServer?: string, jwtToken?: string, permissions?: string[] | undefined, channels?: string[] | undefined, user?: any, 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;
+    saveAs?: string;
+    fileContentHeader?: string;
+    ws?: WSOptions;
+}
+declare class ApiRequest implements ApiRequestInterface {
+    server: string;
+    path?: any[] | undefined;
+    headers?: any;
+    adapter?: any;
+    mapper?: any;
+    polling?: number | undefined;
+    retry?: RetryOptions | undefined;
+    stream?: boolean | undefined;
+    streamType?: StreamType | undefined;
+    displayError?: boolean | undefined;
+    saveAs?: string | undefined;
+    fileContentHeader?: string | undefined;
+    ws?: WSOptions | undefined;
+    constructor(server?: string, path?: any[] | undefined, headers?: any, adapter?: any, mapper?: any, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, streamType?: StreamType | undefined, displayError?: boolean | undefined, saveAs?: string | undefined, fileContentHeader?: string | undefined, ws?: WSOptions | undefined);
+    static adapt(item?: any): ApiRequest;
+}
+
+interface ChannelInfoInterface {
+    name: string;
+    canSubscribe: boolean;
+}
+declare class ChannelInfo implements ChannelInfoInterface {
+    name: string;
+    canSubscribe: boolean;
+    constructor(name?: string, canSubscribe?: boolean);
+    static adapt(item?: any): ChannelInfo;
+}
+
+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;
+}
+
+declare enum CommunicationType {
+    MESSAGE = 0,
+    ALERT = 1,
+    OTHER = 2
+}
+
+interface DatabaseStorageInterface {
+    table: string;
+    expiresIn: string;
+}
+declare class DatabaseStorage implements DatabaseStorageInterface {
+    table: string;
+    expiresIn: '';
+    constructor(table: string, expiresIn: '');
+    static adapt(item?: any): any;
+}
+
+interface RequestOptionsInterface {
+    path: any[];
+    headers: any;
+}
+declare class RequestOptions implements RequestOptionsInterface {
+    path: any[];
+    headers: {};
+    constructor(path?: any[], headers?: {});
+    static adapt(item?: any): RequestOptions;
+}
+
+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>;
+    protected DBOpened(): Promise<boolean>;
+    private getCurrentSchema;
+    protected cleanTableName(str: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbService>;
+}
+
+declare class DatabaseManagerService extends DbService {
+    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<{
+        [key: string]: any;
+    }[]>;
+    updateTableRecord(table: string, record: any): Observable<{
+        [key: string]: any;
+    } | null>;
+    updateTableRecords(table: string, records: any[]): Observable<{
+        [key: string]: any;
+    }[]>;
+    deleteTableRecord<T>(table: string, id: number): Observable<number | null>;
+    deleteTableRecords(table: string, ids: number[]): Observable<number[]>;
+    clearTable(table: string): Observable<unknown>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatabaseManagerService>;
+}
+
+interface ChannelMessageInterface {
+    sessionId: any;
+    content: any;
+}
+declare class ChannelMessage implements ChannelMessageInterface {
+    sessionId: any;
+    content: any;
+    constructor(sessionId?: any, content?: any);
+    static adapt(item?: any): ChannelMessage;
+}
+
+/**
+ * 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;
+    private database?;
+    httpManagerService: HTTPManagerService<any>;
+    dbManagerService: DatabaseManagerService;
+    localStorageManagerService: LocalStorageManagerService;
+    utils: UtilsService;
+    error$: Observable<boolean>;
+    isPending$: Observable<boolean>;
+    private page;
+    page$: Observable<number>;
+    private totalPages;
+    totalPages$: Observable<number>;
+    private percentage;
+    percentage$: Observable<number>;
+    private hasDatabase;
+    streamedResponse: never[];
+    private maxRetries;
+    private retryDelay;
+    private shouldRetry;
+    private databaseOptions?;
+    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>;
+    wsConnection: boolean;
+    wsOptions: WSOptions;
+    connectionStatus$: Observable<boolean>;
+    constructor(apiOptions: ApiRequest, dataType: DataType | undefined, database?: DatabaseStorage | undefined);
+    /**
+     * 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>) => rxjs.Subscription;
+    appendMessages(message: any): void;
+    latestMessage(): void;
+    clearMessages(): void;
+    get ApiRequestOptions(): ApiRequest;
+    readonly initDBStorage: (observableOrValue?: void | Observable<void> | undefined) => rxjs.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) => rxjs.Subscription;
+    readonly fetchRecords: (options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
+    private initDBStorageAsync;
+    readonly fetchRecord: (options: RequestOptions, method: string) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
+    readonly createRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
+    readonly updateRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
+    readonly deleteRecord: (options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
+    readonly createStream: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
+    readonly fetchStream: (options?: RequestOptions) => ((observableOrValue?: any) => rxjs.Subscription) | ((observableOrValue: any) => rxjs.Subscription);
+    private wsCommunication;
+    /**
+     * 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;
+    private isEmpty;
+    private updateRequestOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerStateService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerStateService<any>>;
+}
+
+declare class WebsocketService {
+    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;
+    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;
+    /**
+     * Get 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
+     */
+    subscribeToNotificationChannel(channel: string, options?: {
+        startEpoch?: number;
+        endEpoch?: number;
+    }, user?: any): void;
+    /**
+     * Unsubscribe from a notification channel
+     */
+    unsubscribeFromNotificationChannel(channel: string): void;
+    /**
+     * Send a notification to a channel
+     */
+    sendNotification(channel: string, content: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebsocketService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebsocketService>;
+}
+
+declare class RequestService extends WebsocketService {
+    private http;
+    private pathQueryService;
+    private headersService;
+    isPending: BehaviorSubject<boolean>;
+    isPending$: Observable<boolean>;
+    progress: BehaviorSubject<number>;
+    progress$: Observable<number>;
+    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>;
+    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;
+}
+
+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;
+}
+declare class ConfigHTTPOptions implements ConfigHTTPOptionsInterface {
+    server: string;
+    path?: any[] | undefined;
+    headers?: any;
+    polling?: number | undefined;
+    retry?: RetryOptions | undefined;
+    stream?: boolean | undefined;
+    displayError?: boolean | undefined;
+    constructor(server?: string, path?: any[] | undefined, headers?: any, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, displayError?: boolean | undefined);
+    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 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 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>;
+}
+
+declare class HTTPManagerService<T> extends RequestService {
+    private configOptions?;
+    toastMessage: ToastMessageDisplayService;
+    ng_injector: Injector;
+    objectMergerService: ObjectMergerService;
+    private countdown;
+    countdown$: Observable<number>;
+    private error;
+    error$: Observable<boolean>;
+    private data;
+    data$: Observable<any>;
+    private polling$;
+    config: ApiRequest;
+    constructor(configOptions?: ConfigOptions | undefined);
+    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>;
+    private createObservable;
+    private createRequest;
+    private prepareRequestData;
+    private handleError;
+    private handleErrorWithSnackBar;
+    private stopPolling;
+    private defineReqOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerService<any>, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerService<any>>;
+}
+
+declare class RequestSignalsService {
+    private http;
+    private pathQueryService;
+    private headersService;
+    isPending: i0.WritableSignal<boolean>;
+    progress: i0.WritableSignal<number>;
+    isIdle: i0.Signal<boolean>;
+    getRecordRequest<T>(options: ApiRequest): Observable<T>;
+    createRecordRequest<T>(options: ApiRequest, 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;
+    downloadFileRequest(options: ApiRequest): Observable<any>;
+    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;
+    countdown: i0.WritableSignal<number>;
+    error: i0.WritableSignal<string | boolean>;
+    data: i0.WritableSignal<any>;
+    private polling$;
+    config: ApiRequest;
+    constructor(configOptions?: ConfigOptions | undefined);
+    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>;
+    private createObservable;
+    private createRequest;
+    private prepareRequestData;
+    private handleError;
+    private handleErrorWithSnackBar;
+    private stopPolling;
+    private defineReqOptions;
+    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>;
+
+interface StreamConfig {
+    streamType: StreamType;
+}
+interface StreamEvent<T = any> {
+    type: 'progress' | 'complete' | 'data';
+    data: T;
+    metadata?: {
+        timestamp: Date;
+        streamType: StreamType;
+        contentLength?: number;
+    };
+}
+interface ParsingResult<T = any> {
+    success: boolean;
+    data?: T[];
+    error?: string;
+}
+/**
+ * COMPREHENSIVE REQUEST STREAMING OPERATOR - FULLY ABSTRACTED
+ * Refactored for better type safety and memory management
+ *
+ * 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?: StreamConfig): OperatorFunction<any, T[]>;
+/**
+ * Convenience functions for common use cases
+ */
+declare function streamJSON<T = any>(): OperatorFunction<any, T[]>;
+declare function streamNDJSON<T = any>(): OperatorFunction<any, T[]>;
+declare function streamAI<T = any>(): OperatorFunction<any, T[]>;
+declare function streamEvents<T = any>(): OperatorFunction<any, T[]>;
+declare function streamAuto<T = any>(): OperatorFunction<any, T[]>;
+
+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;
+    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;
+    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;
+    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 StateStoreManagerData<T> {
+}
+declare class StoreStateManagerService<T extends object = StateStoreManagerData<any>> extends ComponentStore<T> {
+    private options;
+    localStorageManagerService: LocalStorageManagerService;
+    subscriptions: Subscription;
+    settings: any;
+    private isRestoring;
+    constructor(options?: StateStorageOptions);
+    private static init;
+    init(options?: StateStorageOptions): void;
+    restoreState(): Subscription;
+    updateState(state: any): void;
+    readonly data$: rxjs.Observable<any>;
+    readonly updateData: (() => void) | ((observableOrValue: any) => Subscription);
+    static ɵfac: i0.ɵɵFactoryDeclaration<StoreStateManagerService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StoreStateManagerService<any>>;
+}
+
+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>;
+}
+
+declare class HttpRequestServicesDemoComponent implements OnInit {
+    private configOptions?;
+    wsServer: string;
+    jwtToken: string;
+    server: string;
+    user?: UserData;
+    path: string[];
+    wsChannel: 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;
+        divider: boolean;
+        disabled: boolean;
+        new?: 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; }; "wsChannel": { "alias": "wsChannel"; "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(): void;
+    createClient(data: any): void;
+    updateClient(data: ClientInfo$1): void;
+    deleteClient(data: ClientInfo$1): void;
+    streamRequest(): 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;
+    displayedColumns: string[];
+    getColumnsFromData(data: any[]): string[];
+    updateDisplayedColumns(data: any[]): void;
+    isObject(value: any): boolean;
+    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;
+    questionControl: _angular_forms.FormControl<string | null>;
+    requestType: string;
+    prompts: string[];
+    AIType: number;
+    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>;
+        }>;
+    }>;
+    get hasChanged(): boolean;
+    get dataType(): string | null | undefined;
+    get database(): {
+        table: string | null;
+        expiresIn: 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;
+    compileRequest(): {
+        apiOptions: ApiRequest;
+        path: string[];
+    };
+    onSetStateOptions(): void;
+    onClearRecords(): void;
+    onGetRequest(): void;
+    onCreateRequest(): void;
+    onUpdateRequest(): void;
+    onDeleteRequest(): void;
+    onStreamRequest(): void;
+    errorHandling(err: any, type: string): void;
+    onSelectAIType(type: number): void;
+    onClearHistory(): 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>;
+    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;
+    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
+     */
+    updateConnection(server: string, wsServer: string, jwtToken: string, user: any): 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<http_request_manager.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 {
+    httpManagerService: HTTPManagerService<any>;
+    stateService: StateServiceDemo;
+    fb: FormBuilder;
+    server: string;
+    wsServer: string;
+    jwtToken: string;
+    user: any;
+    path: string[];
+    wsChannel: string;
+    user$: rxjs.Observable<WSUser | null>;
+    attempts$: rxjs.Observable<number>;
+    nextRetry$: rxjs.Observable<number>;
+    connectionStatus$: rxjs.Observable<boolean>;
+    data$: rxjs.Observable<any>;
+    isPending$: rxjs.Observable<boolean>;
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestManagerWsDemoComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerWsDemoComponent, "app-request-manager-ws-demo", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; "wsChannel": { "alias": "wsChannel"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+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;
+    private destroy$;
+    dataToDisplay: TableRecord[];
+    dataSource: DatabaseDataSource;
+    displayedColumns: string[];
+    names: string[];
+    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>;
+    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[];
+    constructor();
+    updateConnection(server: string, wsServer: string, jwtToken: string, user: any, path?: string[], wsChannel?: string): 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 {
+    server: string;
+    wsServer: string;
+    jwtToken: string;
+    user: any;
+    path: string[];
+    wsChannel: string;
+    stateDataRequestService: StateDataRequestService;
+    user$: rxjs.Observable<http_request_manager.WSUser | null>;
+    users$: rxjs.Observable<any[]>;
+    userAction$: rxjs.Observable<any>;
+    data$: rxjs.Observable<any>;
+    isUser: (user: any, userItem: any) => boolean;
+    ngOnInit(): void;
+    onGetData(): void;
+    onAddData(): void;
+    onUpdateData(data: any[]): void;
+    onRemoveData(data: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WsDataControlComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WsDataControlComponent, "app-ws-data-control", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; "wsChannel": { "alias": "wsChannel"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+declare class WsMessagingComponent implements OnInit, OnDestroy {
+    server: string;
+    wsServer: string;
+    jwtToken: string;
+    user: any;
+    private destroy$;
+    fb: FormBuilder;
+    messageService: MessageServiceDemo;
+    stateService: StateServiceDemo;
+    toastService: ToastMessageDisplayService;
+    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(channel: string, event: any): void;
+    /**
+     * Check if currently subscribed to a channel
+     * Compares display names (without PUB- prefix)
+     */
+    isSubscribed(channel: string, subscribedChannels: string[]): boolean;
+    /**
+     * Handle chip click - toggle subscription state
+     */
+    onChipClick(channel: string, subscribedChannels: string[]): void;
+    onSendMessage(user: WSUser): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WsMessagingComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WsMessagingComponent, "app-ws-messaging", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; }, {}, never, never, false, never>;
+}
+
+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>;
+}
+
+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 HttpRequestServicesDemoComponent, typeof RequestManagerStateDemoComponent, typeof RequestManagerDemoComponent, typeof RequestSignalsManagerDemoComponent, typeof LocalStorageDemoComponent, typeof LocalStorageSignalsDemoComponent, typeof RequestManagerWsDemoComponent, typeof StoreStateManagerDemoComponent, typeof DatabaseDataDemoComponent, typeof WsDataControlComponent, typeof WsMessagingComponent, typeof WsNotificationsComponent, typeof WsAiMessagingComponent, typeof WsChatsComponent], [typeof i4.CommonModule, typeof i16.ToastMessageDisplayModule, typeof _angular_forms.FormsModule, typeof _angular_forms.ReactiveFormsModule, typeof i7.MatButtonModule, typeof i19.MatTabsModule, typeof i20.MatSelectModule, typeof i21.MatChipsModule, typeof i22.MatMenuModule, typeof i5.MatIconModule, typeof i24.MatTableModule, typeof i25.MatButtonToggleModule, typeof i26.MatAutocompleteModule, typeof i27.MatProgressBarModule, typeof i28.MatSlideToggleModule, typeof i29.MatDividerModule, typeof i30.MatFormFieldModule, typeof i31.MatInputModule, typeof i32.MatToolbarModule, typeof i28.MatSlideToggleModule, typeof i33.TranslateModule, typeof i34.MatSidenavModule, typeof i35.MatDatepickerModule, typeof i36.MatNativeDateModule, typeof FileDownloaderModule], [typeof HttpRequestServicesDemoComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HttpRequestManagerModule>;
+}
+
+export { ApiRequest, AppService, AsymmetricalEncryptionService, CONFIG_SETTINGS_TOKEN, ChannelInfo, ChannelType, CommunicationType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, ErrorDisplaySettings, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsManagerService, PathQueryService, Random, RandomHSLColor, RandomHexColor, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomPaletteColor, RandomSignature, RandomStr, RandomVisibleColor, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, StreamType, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UserData, UtilsService, WSOptions, WSUser, WebsocketService, WithCredentialsInterceptor, countdown, createChannelName, delayedRetry, requestPolling, requestStreaming, streamAI, streamAuto, streamEvents, streamJSON, streamNDJSON };
+export type { APIStateManagerData, ApiRequestInterface, ChannelInfoInterface, ConfigHTTPOptionsInterface, ConfigOptionsInterface, DatabaseStorageInterface, ErrorDisplaySettingsInterface, GlobalStoreOptionsInterface, LocalStorageOptionsInterface, ParsingResult, RequestOptionsInterface, RetryOptionsInterface, SettingOptionsInterface, State, StateStorageOptionsInterface, StateStoreManagerData, StorageDataInterface, StorageOptionInterface, StreamConfig, StreamEvent, TableRecord, TableSchemaDefInterface, UserDataInterface, WSOptionsInterface, WSUserInterface };