http-request-manager 18.4.4 → 18.4.7

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

@@ -0,0 +1,1731 @@
+import * as rxjs from 'rxjs';
+import { Observable, Subscription, BehaviorSubject, OperatorFunction } from 'rxjs';
+import * as i0 from '@angular/core';
+import { InjectionToken, Injector, OnDestroy, OnInit, EventEmitter, ModuleWithProviders } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { HttpClient, HttpHeaders, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent } from '@angular/common/http';
+import * as i15 from 'toast-message-display';
+import { ToastMessageDisplayService } from 'toast-message-display';
+import Dexie, { Table } from 'dexie';
+import * as i32 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 i4 from '@angular/common';
+import * as i7 from '@angular/material/button';
+import * as i18 from '@angular/material/tabs';
+import * as i19 from '@angular/material/select';
+import * as i20 from '@angular/material/chips';
+import * as i21 from '@angular/material/menu';
+import * as i5 from '@angular/material/icon';
+import * as i23 from '@angular/material/table';
+import * as i24 from '@angular/material/button-toggle';
+import * as i25 from '@angular/material/autocomplete';
+import * as i26 from '@angular/material/progress-bar';
+import * as i27 from '@angular/material/slide-toggle';
+import * as i28 from '@angular/material/divider';
+import * as i29 from '@angular/material/form-field';
+import * as i30 from '@angular/material/input';
+import * as i31 from '@angular/material/toolbar';
+import * as i33 from '@angular/material/sidenav';
+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;
+}
+
+interface ApiRequestInterface {
+    server: string;
+    path?: any[];
+    headers?: any;
+    adapter?: any;
+    mapper?: any;
+    polling?: number;
+    retry?: RetryOptions;
+    stream?: boolean;
+    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;
+    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, 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;
+}
+
+declare enum CommunicationType {
+    MESSAGE = 0,
+    ALERT = 1,
+    OTHER = 2
+}
+
+interface ChannelMessageInterface {
+    fromUser: string | null;
+    toUser: string | null;
+    content: string | null;
+    issued: Date;
+    type: CommunicationType;
+}
+declare class ChannelMessage implements ChannelMessageInterface {
+    fromUser: string | null;
+    toUser: string | null;
+    content: string | null;
+    issued: Date;
+    type: CommunicationType;
+    constructor(fromUser?: string | null, toUser?: string | null, content?: string | null, issued?: Date, type?: CommunicationType);
+    static adapt(item?: any): ChannelMessage;
+}
+
+interface UserMessageInterface {
+    fromUser: any;
+    toUser?: any;
+    content?: string;
+    issued?: Date;
+}
+declare class UserMessage implements UserMessageInterface {
+    fromUser: any;
+    toUser?: any;
+    content?: string | undefined;
+    issued?: Date | undefined;
+    constructor(fromUser: any, toUser?: any, content?: string | undefined, issued?: Date | undefined);
+    static adapt(item?: any): UserMessage;
+}
+
+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 WSUserInterface {
+    id: string;
+    adapter?: Function;
+}
+declare class WSUser implements WSUserInterface {
+    id: string;
+    adapter?: Function | undefined;
+    constructor(id?: string, adapter?: Function | undefined);
+    static adapt(item?: any): WSUser;
+}
+
+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 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 wsRetryAttempts;
+    wsRetryAttempts$: Observable<number>;
+    private wsNextRetry;
+    wsNextRetry$: Observable<number>;
+    messages$: Subscription | null;
+    connectionStatus$: Subscription | null;
+    private userList;
+    userList$: Observable<any[]>;
+    private user;
+    user$: Observable<any>;
+    private communicationMessages;
+    communicationMessages$: Observable<UserMessage[]>;
+    private latestCommunicationMessages;
+    latestCommunicationMessages$: Observable<UserMessage | null>;
+    private userAction;
+    userAction$: Observable<any>;
+    channels: ChannelInfo[];
+    channelList: string[];
+    messages: any[];
+    wsConnection: boolean;
+    wsOptions: WSOptions;
+    status$: Observable<boolean>;
+    constructor(apiOptions: ApiRequest, dataType: DataType | undefined, database?: DatabaseStorage | undefined);
+    setApiRequestOptions(apiOptions?: ApiRequest, dataType?: DataType, database?: DatabaseStorage): void;
+    private setupConnectionStatus;
+    readonly initWS: (observableOrValue: WSOptions | Observable<WSOptions>) => Subscription;
+    appendMessages(message: UserMessage): 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;
+    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;
+    wsMessaging(message: ChannelMessage, channel?: string): 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 getSessionId;
+    private sendSubscribe;
+    connect(options: WSOptions, jwtToken: string): void;
+    disconnect(): void;
+    subscribeToChannel(channelName: string): void;
+    unsubscribeToChannel(channel: string): void;
+    sendBroadcast(content: any): void;
+    sendMessageInChannel(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;
+    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>;
+    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<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>;
+
+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>;
+
+declare function requestStreaming(): OperatorFunction<any, any>;
+
+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>;
+}
+
+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 UserDataInterface {
+    ldap: string;
+    name: string;
+    email: string;
+}
+declare class UserData implements UserDataInterface {
+    ldap: string;
+    name: string;
+    email: string;
+    constructor(ldap?: string, name?: string, email?: string);
+    static adapt(item?: any): UserData;
+}
+
+declare class HttpRequestServicesDemoComponent implements OnInit {
+    private configOptions?;
+    wsServer: string;
+    jwtToken: string;
+    server: string;
+    user?: UserData;
+    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; }; "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[];
+    selectedRecord$?: Observable<ClientInfo$1 | null>;
+    fb: FormBuilder;
+    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;
+    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[];
+    private fb;
+    private toastMessage;
+    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_AI$?: Observable<any>;
+    STREAM$?: Observable<any>;
+    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$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;
+    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>;
+}
+
+declare class StateRequestServiceDemo extends HTTPManagerStateService<any> {
+    attempts$: rxjs.Observable<number>;
+    nextRetry$: rxjs.Observable<number>;
+    constructor();
+    updateConnection(server: string, wsServer: string, jwtToken: string, user: any): void;
+    sendMessage(data: ChannelMessage): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<StateRequestServiceDemo, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<StateRequestServiceDemo>;
+}
+
+declare class RequestManagerWsDemoComponent implements OnInit {
+    httpManagerService: HTTPManagerService<any>;
+    stateRequestServiceDemo: StateRequestServiceDemo;
+    fb: FormBuilder;
+    server: string;
+    wsServer: string;
+    jwtToken: string;
+    user: any;
+    user$: Observable<any>;
+    users$: Observable<any[]>;
+    attempts$: Observable<number>;
+    nextRetry$: Observable<number>;
+    connectionStatus$: Observable<boolean>;
+    messages: _angular_forms.FormGroup<{
+        [x: string]: FormControl<unknown>;
+    }>;
+    get toUser(): FormControl;
+    get content(): FormControl;
+    get isValid(): boolean;
+    data$: Observable<any>;
+    isPending$: Observable<boolean>;
+    fromMe: (user: string, fromUser: string) => boolean;
+    communicationMessages$: Observable<UserMessage[]>;
+    latestCommunicationMessages$: Observable<UserMessage | null>;
+    chat$: Observable<{
+        user: any;
+        messages: any[];
+    } | any>;
+    ngOnInit(): void;
+    onSendMessage(): void;
+    onSendAlert(): 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; }; }, {}, 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>;
+    constructor();
+    updateConnection(server: string, wsServer: string, jwtToken: string, user: any): 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;
+    stateDataRequestService: StateDataRequestService;
+    user$: rxjs.Observable<any>;
+    users$: rxjs.Observable<any[]>;
+    data$: rxjs.Observable<any>;
+    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; }; }, {}, never, never, false, never>;
+}
+
+declare class WsMessagingComponent implements OnInit {
+    server: string;
+    wsServer: string;
+    jwtToken: string;
+    user: any;
+    fb: FormBuilder;
+    stateRequestServiceDemo: StateRequestServiceDemo;
+    user$: Observable<any>;
+    users$: Observable<any[]>;
+    data$: Observable<any>;
+    messages: _angular_forms.FormGroup<{
+        [x: string]: FormControl<unknown>;
+    }>;
+    get toUser(): FormControl;
+    get content(): FormControl;
+    get isValid(): boolean;
+    communicationMessages$: Observable<UserMessage[]>;
+    latestCommunicationMessages$: Observable<UserMessage | null>;
+    chat$: Observable<{
+        user: any;
+        messages: any[];
+    } | any>;
+    ngOnInit(): void;
+    onSendMessage(): void;
+    onSendAlert(): 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 {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WsNotificationsComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<WsNotificationsComponent, "app-ws-notifications", never, {}, {}, 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 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 i4.CommonModule, typeof i15.ToastMessageDisplayModule, typeof _angular_forms.FormsModule, typeof _angular_forms.ReactiveFormsModule, typeof i7.MatButtonModule, typeof i18.MatTabsModule, typeof i19.MatSelectModule, typeof i20.MatChipsModule, typeof i21.MatMenuModule, typeof i5.MatIconModule, typeof i23.MatTableModule, typeof i24.MatButtonToggleModule, typeof i25.MatAutocompleteModule, typeof i26.MatProgressBarModule, typeof i27.MatSlideToggleModule, typeof i28.MatDividerModule, typeof i29.MatFormFieldModule, typeof i30.MatInputModule, typeof i31.MatToolbarModule, typeof i27.MatSlideToggleModule, typeof i32.TranslateModule, typeof i33.MatSidenavModule, typeof FileDownloaderModule], [typeof HttpRequestServicesDemoComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<HttpRequestManagerModule>;
+}
+
+export { ApiRequest, AppService, AsymmetricalEncryptionService, CONFIG_SETTINGS_TOKEN, ChannelInfo, ChannelMessage, CommunicationType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, ErrorDisplaySettings, GlobalStoreOptions, HTTPManagerService, HTTPManagerSignalsService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LocalStorageSignalsManagerService, PathQueryService, Random, RandomNumber, RandomNumbers, RandomNumbersUnique, RandomSignature, RandomStr, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RequestSignalsService, RetryOptions, SettingOptions, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, SymmetricalEncryptionService, TableSchemaDef, UUID, UUID_STR, UserMessage, UtilsService, WSOptions, WSUser, WebsocketService, WithCredentialsInterceptor, countdown, delayedRetry, requestPolling, requestStreaming };
+export type { APIStateManagerData, ApiRequestInterface, ChannelInfoInterface, ChannelMessageInterface, ConfigHTTPOptionsInterface, ConfigOptionsInterface, DatabaseStorageInterface, ErrorDisplaySettingsInterface, GlobalStoreOptionsInterface, LocalStorageOptionsInterface, RequestOptionsInterface, RetryOptionsInterface, SettingOptionsInterface, State, StateStorageOptionsInterface, StateStoreManagerData, StorageDataInterface, StorageOptionInterface, TableRecord, TableSchemaDefInterface, UserMessageInterface, WSOptionsInterface, WSUserInterface };