import { SymmetricalEncryptionService, EncryptionTestService } from 'encryption-helpers';
export * from 'encryption-helpers';
import * as i0 from '@angular/core';
import { Signal, InjectionToken, OnDestroy, Injector, OnInit, OnChanges, SimpleChanges, EventEmitter, ModuleWithProviders } from '@angular/core';
import * as rxjs from 'rxjs';
import { Observable, Subject, OperatorFunction, Subscription, BehaviorSubject } from 'rxjs';
import { HttpClient, HttpHeaders, HttpContextToken, HttpInterceptor, HttpRequest, HttpHandler, HttpEvent, HttpInterceptorFn } from '@angular/common/http';
import * as i18 from 'toast-message-display';
import { ToastMessageDisplayService } from 'toast-message-display';
import Dexie, { Table } from 'dexie';
import { AST } from 'node-sql-parser';
import * as _angular_forms from '@angular/forms';
import { FormBuilder, FormControl, FormArray } from '@angular/forms';
import { DataSource } from '@angular/cdk/collections';
import * as i26 from '@angular/material/list';
import { MatSelectionListChange } from '@angular/material/list';
import * as i4 from '@angular/common';
import * as i7 from '@angular/material/button';
import * as i21 from '@angular/material/tabs';
import * as i22 from '@angular/material/select';
import * as i23 from '@angular/material/chips';
import * as i24 from '@angular/material/menu';
import * as i5 from '@angular/material/icon';
import * as i27 from '@angular/material/table';
import * as i28 from '@angular/material/button-toggle';
import * as i29 from '@angular/material/autocomplete';
import * as i30 from '@angular/material/progress-bar';
import * as i6 from '@angular/material/progress-spinner';
import { ProgressSpinnerMode } from '@angular/material/progress-spinner';
import * as i32 from '@angular/material/slide-toggle';
import * as i33 from '@angular/material/divider';
import * as i34 from '@angular/material/form-field';
import * as i35 from '@angular/material/input';
import * as i36 from '@angular/material/toolbar';
import * as i37 from '@ngx-translate/core';
import * as i38 from '@angular/material/sidenav';
import * as i39 from '@angular/material/datepicker';
import * as i40 from '@angular/material/core';
import { ThemePalette } from '@angular/material/core';
import * as i41 from '@angular/material/card';

declare enum StorageType {
    GLOBAL = 0,
    SESSION = 1,
    DB = 2
}

interface SettingOptionsInterface {
    storage?: StorageType;
    expires?: number;
    expiresIn?: string;
    encrypted?: boolean;
}
declare class SettingOptions implements SettingOptionsInterface {
    storage?: StorageType | undefined;
    expires?: number | undefined;
    expiresIn?: string | undefined;
    encrypted?: boolean | undefined;
    constructor(storage?: StorageType | undefined, expires?: number | undefined, expiresIn?: string | undefined, encrypted?: boolean | undefined);
    static adapt(item?: any): SettingOptions;
}

interface StorageOptionInterface {
    id?: string;
    name: string;
    data?: any;
    options?: SettingOptions;
}
declare class StorageOption implements StorageOptionInterface {
    id?: string | undefined;
    name: string;
    data?: any | undefined;
    options?: SettingOptions | undefined;
    constructor(id?: string | undefined, name?: string, data?: any | undefined, options?: SettingOptions | undefined);
    static deriveStableId(name: string, storage?: StorageType): string;
    static adapt(item?: any): StorageOption;
}

interface GlobalStoreOptionsInterface {
    encryption?: boolean;
    expiresIn?: string;
    expires?: number;
    stores: StorageOption[] | null;
}
declare class GlobalStoreOptions implements GlobalStoreOptionsInterface {
    encryption: boolean;
    expiresIn?: string | undefined;
    expires?: number | undefined;
    stores: StorageOption[] | null;
    constructor(encryption?: boolean, expiresIn?: string | undefined, expires?: number | undefined, stores?: StorageOption[] | null);
    static adapt(item?: any): GlobalStoreOptions;
}

interface StorageDataInterface {
    id?: string;
    data?: any;
}
declare class StorageData implements StorageDataInterface {
    id?: string | undefined;
    data?: any | undefined;
    constructor(id?: string | undefined, data?: any | undefined);
    static adapt(item?: any): StorageData;
}

declare class UtilsService {
    http: HttpClient;
    constructor();
    isString(x: string | number): boolean;
    isObject(obj: any): boolean;
    JSONToString(value: any): any;
    stringToJSON(value: string): any;
    isJSON(str: any): boolean;
    getValueByProp(obj: any, prop: string): any;
    objectsEqual(x: any, y: any, seen?: Set<unknown>): 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>;
}

interface RetryOptionsInterface {
    times?: number;
    delay?: number;
}
declare class RetryOptions implements RetryOptionsInterface {
    times: number;
    delay: number;
    constructor(times?: number, delay?: number);
    static adapt(item?: any): RetryOptions;
}

interface ConfigHTTPOptionsInterface {
    server: string;
    path?: any[];
    headers?: any;
    polling?: number;
    retry?: RetryOptions;
    stream?: boolean;
    displayError?: boolean;
    displaySuccess?: boolean;
    selector?: string;
    suppressToastStatuses?: number[];
}
declare class ConfigHTTPOptions implements ConfigHTTPOptionsInterface {
    server: string;
    path?: any[] | undefined;
    headers?: any | undefined;
    polling?: number | undefined;
    retry?: RetryOptions | undefined;
    stream?: boolean | undefined;
    displayError?: boolean | undefined;
    displaySuccess?: boolean | undefined;
    selector?: string | undefined;
    suppressToastStatuses?: number[] | undefined;
    constructor(server?: string, path?: any[] | undefined, headers?: any | undefined, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, displayError?: boolean | undefined, displaySuccess?: boolean | undefined, selector?: string | undefined, suppressToastStatuses?: number[] | 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;
    appId?: string;
}
declare class ConfigOptions implements ConfigOptionsInterface {
    httpRequestOptions?: ConfigHTTPOptions | undefined;
    LocalStorageOptions?: LocalStorageOptions | undefined;
    appId?: string | undefined;
    constructor(httpRequestOptions?: ConfigHTTPOptions | undefined, LocalStorageOptions?: LocalStorageOptions | undefined, appId?: string | undefined);
    static adapt(item?: any): ConfigOptions;
}

interface WSOptionsInterface {
    id: string;
    wsServer: string;
    jwtToken: string;
    permissions?: string[];
    channels?: string[];
    wsUpdateChannels?: string[];
    user?: any;
    retry?: RetryOptions;
}
declare class WSOptions implements WSOptionsInterface {
    id: string;
    wsServer: string;
    jwtToken: string;
    permissions?: string[] | undefined;
    channels?: string[] | undefined;
    wsUpdateChannels?: string[] | undefined;
    user?: any | undefined;
    retry?: RetryOptions | undefined;
    constructor(id?: string, wsServer?: string, jwtToken?: string, permissions?: string[] | undefined, channels?: string[] | undefined, wsUpdateChannels?: string[] | undefined, user?: any | undefined, retry?: RetryOptions | undefined);
    static adapt(item?: any): WSOptions;
}

/**
 * Enum representing valid streaming format types
 *
 * This enum defines all supported streaming formats for HTTP requests.
 * Each enum value corresponds to a specific data format and parsing strategy.
 */
declare enum StreamType {
    JSON = "json",
    NDJSON = "ndjson",
    AI_STREAMING = "ai_streaming",
    EVENT_STREAM = "event_stream",
    AUTO = "auto"
}

interface ApiRequestInterface {
    server: string;
    path?: any[];
    headers?: any;
    adapter?: any;
    mapper?: any;
    polling?: number;
    retry?: RetryOptions;
    stream?: boolean;
    streamType?: StreamType;
    displayError?: boolean;
    displaySuccess?: boolean;
    successMessage?: string;
    errorMessage?: string;
    saveAs?: string;
    fileContentHeader?: string;
    ws?: WSOptions;
    env?: string;
    uploadFiles?: File | File[];
    uploadFieldName?: string;
    uploadHttpMethod?: 'POST' | 'PUT';
    allowedTypes?: string[];
    maxFileSize?: number;
    maxTotalSize?: number;
    selector?: string;
    suppressToastStatuses?: number[];
}
declare class ApiRequest implements ApiRequestInterface {
    server: string;
    path?: any[] | undefined;
    headers?: any | undefined;
    adapter?: any | undefined;
    mapper?: any | undefined;
    polling?: number | undefined;
    retry?: RetryOptions | undefined;
    stream?: boolean | undefined;
    streamType?: StreamType | undefined;
    displayError?: boolean | undefined;
    displaySuccess?: boolean | undefined;
    successMessage?: string | undefined;
    errorMessage?: string | undefined;
    saveAs?: string | undefined;
    fileContentHeader?: string | undefined;
    ws?: WSOptions | undefined;
    env?: string | undefined;
    uploadFiles?: (File | File[]) | undefined;
    uploadFieldName?: string | undefined;
    uploadHttpMethod?: "POST" | "PUT" | undefined;
    allowedTypes?: string[] | undefined;
    maxFileSize?: number | undefined;
    maxTotalSize?: number | undefined;
    selector?: string | undefined;
    suppressToastStatuses?: number[] | undefined;
    constructor(server?: string, path?: any[] | undefined, headers?: any | undefined, adapter?: any | undefined, mapper?: any | undefined, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, streamType?: StreamType | undefined, displayError?: boolean | undefined, displaySuccess?: boolean | undefined, successMessage?: string | undefined, errorMessage?: string | undefined, saveAs?: string | undefined, fileContentHeader?: string | undefined, ws?: WSOptions | undefined, env?: string | undefined, uploadFiles?: (File | File[]) | undefined, uploadFieldName?: string | undefined, uploadHttpMethod?: "POST" | "PUT" | undefined, allowedTypes?: string[] | undefined, maxFileSize?: number | undefined, maxTotalSize?: number | undefined, selector?: string | undefined, suppressToastStatuses?: number[] | undefined);
    static adapt(item?: any): ApiRequest;
}

interface RequestOptionsInterface {
    path: any[];
    headers: any;
    forceRefresh?: boolean;
    ignoreQueryParams?: string[];
    queryParamsExpiresIn?: string | number;
    selector?: string;
}
declare class RequestOptions implements RequestOptionsInterface {
    path: any[];
    headers: {};
    forceRefresh?: boolean | undefined;
    ignoreQueryParams?: string[] | undefined;
    queryParamsExpiresIn?: string | number | undefined;
    selector?: string | undefined;
    constructor(path?: any[], headers?: {}, forceRefresh?: boolean | undefined, ignoreQueryParams?: string[] | undefined, queryParamsExpiresIn?: string | number | undefined, selector?: string | undefined);
    static adapt(item?: any): RequestOptions;
}

interface OperationResultInterface {
    success: boolean;
    operation: 'CREATE' | 'UPDATE' | 'DELETE' | 'PATCH';
}
declare class OperationResultModel implements OperationResultInterface {
    success: boolean;
    operation: 'CREATE' | 'UPDATE' | 'DELETE' | 'PATCH';
    constructor(success?: boolean, operation?: 'CREATE' | 'UPDATE' | 'DELETE' | 'PATCH');
    static adapt(item?: any): OperationResultModel;
}

interface StreamConfigInterface {
    streamType: StreamType;
    totalHeader?: string;
}
declare class StreamConfigModel implements StreamConfigInterface {
    streamType: StreamType;
    totalHeader: string;
    constructor(streamType?: StreamType, totalHeader?: string);
    static adapt(item?: any): StreamConfigModel;
}

interface StreamProgressInterface {
    received: number;
    total?: number;
    percent: number;
    stage: 'connecting' | 'streaming' | 'complete' | 'error';
}
declare class StreamProgressModel implements StreamProgressInterface {
    received: number;
    total?: number | undefined;
    percent: number;
    stage: 'connecting' | 'streaming' | 'complete' | 'error';
    constructor(received?: number, total?: number | undefined, percent?: number, stage?: 'connecting' | 'streaming' | 'complete' | 'error');
    static adapt(item?: any): StreamProgressModel;
}

interface StreamOutputInterface<T = any> {
    data: T[];
    progress: StreamProgressModel;
    endpoint?: string;
}
declare class StreamOutputModel<T = any> implements StreamOutputInterface<T> {
    data: T[];
    progress: StreamProgressModel;
    endpoint?: string | undefined;
    constructor(data?: T[], progress?: StreamProgressModel, endpoint?: string | undefined);
    static adapt<T = any>(item?: any): StreamOutputModel<T>;
}

interface StreamEventMetadataInterface {
    timestamp: Date;
    streamType: StreamType;
    contentLength?: number;
}
declare class StreamEventMetadataModel implements StreamEventMetadataInterface {
    timestamp: Date;
    streamType: StreamType;
    contentLength?: number | undefined;
    constructor(timestamp?: Date, streamType?: StreamType, contentLength?: number | undefined);
    static adapt(item?: any): StreamEventMetadataModel;
}

interface StreamEventInterface<T = any> {
    type: 'progress' | 'complete' | 'data';
    data: T;
    metadata?: StreamEventMetadataModel;
}
declare class StreamEventModel<T = any> implements StreamEventInterface<T> {
    type: 'progress' | 'complete' | 'data';
    data: T;
    metadata?: StreamEventMetadataModel | undefined;
    constructor(type?: 'progress' | 'complete' | 'data', data?: T, metadata?: StreamEventMetadataModel | undefined);
    static adapt<T = any>(item?: any): StreamEventModel<T>;
}

interface ParsingResultInterface<T = any> {
    success: boolean;
    data?: T[];
    error?: string;
}
declare class ParsingResultModel<T = any> implements ParsingResultInterface<T> {
    success: boolean;
    data?: T[] | undefined;
    error?: string | undefined;
    constructor(success?: boolean, data?: T[] | undefined, error?: string | undefined);
    static adapt<T = any>(item?: any): ParsingResultModel<T>;
}

declare class ObjectMergerService {
    private configOptions?;
    utils: UtilsService;
    constructor(configOptions?: ConfigOptions | undefined);
    mergeOptions(options?: any, params?: any[]): ApiRequest;
    mergeStorageOptions(options?: SettingOptions): SettingOptions;
    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectMergerService, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectMergerService>;
}

interface State {
    localStores: StorageData[];
    sessionStores: StorageData[];
    settings: StorageOption[];
}
declare class LocalStorageManagerService {
    private configOptions?;
    storageName: string;
    storageSettingsName: string;
    defaultOptions: SettingOptions;
    stateRetrieved: boolean;
    encrypted: boolean;
    private readonly destroyRef;
    utils: UtilsService;
    objectMergerService: ObjectMergerService;
    encryption: SymmetricalEncryptionService;
    encryptionTest: EncryptionTestService;
    private readonly state;
    private readonly stateChanged$;
    readonly stores: Signal<StorageOption[]>;
    readonly storeExists: (store: string) => Signal<boolean>;
    readonly store: (store: string) => Signal<any>;
    readonly settings: Signal<StorageOption[]>;
    readonly setting: (store: string) => Signal<StorageOption | null>;
    private toSyncObservable;
    readonly stores$: Observable<StorageOption[]>;
    readonly storeExists$: (store: string) => Observable<boolean>;
    readonly store$: (store: string) => Observable<any>;
    readonly settings$: Observable<StorageOption[]>;
    readonly setting$: (store: string) => Observable<StorageOption | null>;
    constructor(configOptions?: ConfigOptions | undefined);
    /** Compat for existing test setup that seeds state directly. */
    setState(state: State): void;
    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;
        preserveRequestCache?: boolean;
    }): void;
    deleteStore(store: {
        name: string;
    }): void;
    resetStore(): void;
    private persistState;
    private expired;
    retrieveState(): void;
    private isObjectOrArray;
    private isString;
    private fixAndParseJSON;
    private validStoreName;
    private hasGlobalStorage;
    /**
     * Clears all stored data from localStorage and sessionStorage
     * Use this method to recover from corrupted data errors
     */
    clearAllStoredData(): void;
    /**
     * Checks if stored data appears to be corrupted
     * Returns true if data appears corrupted
     */
    checkForCorruptedData(): boolean;
    private tryParseSettingsArray;
    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageManagerService, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageManagerService>;
}

declare class RequestService {
    private http;
    private pathQueryService;
    private headersService;
    protected readonly stateChanged$: Subject<void>;
    isPending: i0.WritableSignal<boolean>;
    isPending$: Observable<boolean>;
    progress: i0.WritableSignal<number>;
    progress$: Observable<number>;
    streamProgress: i0.WritableSignal<StreamProgressModel>;
    streamProgress$: Observable<StreamProgressModel>;
    getRecordRequest<T>(options: ApiRequest): Observable<T>;
    getRecordRequest<T>(options: ApiRequest): Observable<T>;
    getRecordRequest<T>(options: ApiRequest & {
        stream: true;
    }): Observable<T[]>;
    createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
    createRecordRequest<T>(options: ApiRequest & {
        stream: true;
    }, data: any): Observable<T[]>;
    createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
    createRecordRequest<T>(options: ApiRequest & {
        stream: true;
    }, data: any): Observable<T[]>;
    updateRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
    patchRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
    deleteRecordRequest<T>(options: ApiRequest): Observable<T>;
    private buildUrlPath;
    private buildHeaders;
    private buildCombinedHeaders;
    private buildErrorDisplayContext;
    private resolveSelector;
    private request;
    private requestStreaming;
    downloadFileRequest(options: ApiRequest): Observable<any>;
    uploadFileRequest(options: ApiRequest): Observable<any>;
    private validateUploadFiles;
    private buildFormData;
    private handleFinalize;
    private handleStreamProgressFinalize;
    private downloadFile;
    private createFileType;
    private combineHeaders;
    static ɵfac: i0.ɵɵFactoryDeclaration<RequestService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<RequestService>;
}

interface DatabaseStorageInterface {
    table: string;
    expiresIn: string;
    deltaSync?: boolean;
    reconcile?: boolean;
    reconcileIntervalMs?: number;
}
declare class DatabaseStorage implements DatabaseStorageInterface {
    table: string;
    expiresIn: '';
    deltaSync: boolean;
    reconcile: boolean;
    reconcileIntervalMs: number;
    constructor(table: string | undefined, expiresIn: '', deltaSync?: boolean, reconcile?: boolean, reconcileIntervalMs?: number);
    static adapt(item?: any): any;
}

interface BatchOptionsInterface {
    mode?: 'sequential' | 'parallel';
    stopOnError?: boolean;
    concurrency?: number;
    ignoreErrors?: boolean;
    logErrors?: boolean;
    displaySuccess?: boolean;
    displayError?: boolean;
}
declare class BatchOptions implements BatchOptionsInterface {
    mode: 'sequential' | 'parallel';
    stopOnError: boolean;
    concurrency: number;
    ignoreErrors: boolean;
    logErrors: boolean;
    displaySuccess?: boolean | undefined;
    displayError?: boolean | undefined;
    constructor(mode?: 'sequential' | 'parallel', stopOnError?: boolean, concurrency?: number, ignoreErrors?: boolean, logErrors?: boolean, displaySuccess?: boolean | undefined, displayError?: boolean | undefined);
    static adapt(item?: any): BatchOptions;
}

interface BatchResultInterface<T = any> {
    request: any;
    success: boolean;
    data?: T;
    error?: any;
    index: number;
    timestamp: number;
}
declare class BatchResult<T = any> implements BatchResultInterface<T> {
    request: any;
    success: boolean;
    data?: T | undefined;
    error?: any | undefined;
    index: number;
    timestamp: number;
    constructor(request: any, success: boolean, data?: T | undefined, error?: any | undefined, index?: number, timestamp?: number);
    static adapt<T>(item?: any): BatchResult<T>;
}

type BatchRequestState<T> = BatchPendingState | BatchSuccessState<T> | BatchErrorState;
interface BatchPendingState {
    index: number;
    request: any;
    isPending: true;
    data?: undefined;
    error?: undefined;
}
interface BatchSuccessState<T> {
    index: number;
    request: any;
    isPending: false;
    data: T;
    error?: undefined;
}
interface BatchErrorState {
    index: number;
    request: any;
    isPending: false;
    data?: undefined;
    error: any;
}
declare function isPendingState<T>(state: BatchRequestState<T>): state is BatchPendingState;
declare function isSuccessState<T>(state: BatchRequestState<T>): state is BatchSuccessState<T>;
declare function isErrorState<T>(state: BatchRequestState<T>): state is BatchErrorState;

interface BatchProgress {
    total: number;
    pending: number;
    completed: number;
    failed: number;
    percent: number;
}
declare function calculateBatchProgress<T>(states: BatchRequestState<T>[]): BatchProgress;

declare enum DataType {
    ANY = 0,
    ARRAY = 1,
    OBJECT = 2
}

/**
 * An injection token that provides the configuration settings for the application.
 * This token can be used to inject the `ConfigSettings` instance into components or services
 * that require access to the application configuration.
 */
declare const CONFIG_SETTINGS_TOKEN: InjectionToken<ConfigOptions>;

interface InvalidFileInfoInterface {
    fileName: string;
    fileSize: number;
    fileType: string;
    errors: string[];
}
declare class InvalidFileInfoModel implements InvalidFileInfoInterface {
    fileName: string;
    fileSize: number;
    fileType: string;
    errors: string[];
    constructor(fileName?: string, fileSize?: number, fileType?: string, errors?: string[]);
    static adapt(item?: any): InvalidFileInfoModel;
}
interface UploadValidationErrorInterface {
    invalidFiles: InvalidFileInfoModel[];
    validFilesCount: number;
    totalFilesCount: number;
}
declare class UploadValidationErrorModel implements UploadValidationErrorInterface {
    invalidFiles: InvalidFileInfoModel[];
    validFilesCount: number;
    totalFilesCount: number;
    constructor(invalidFiles?: InvalidFileInfoModel[], validFilesCount?: number, totalFilesCount?: number);
    static adapt(item?: any): UploadValidationErrorModel;
}

interface WSUserInterface {
    id: string;
    ldap?: string;
    name?: string;
    email?: string;
    [key: string]: any;
}
declare class WSUser implements WSUserInterface {
    id: string;
    ldap: string;
    name: string;
    email: string;
    constructor(id?: string, ldap?: string, name?: string, email?: string);
    static adapt(item?: any): WSUser;
}

interface StateMessageInterface {
    sessionId: {
        id: string;
        ldap?: string;
        name?: string;
        email?: string;
    };
    content: any;
}
declare class StateMessage implements StateMessageInterface {
    sessionId: {
        id: string;
        ldap?: string;
        name?: string;
        email?: string;
    };
    content: any;
    constructor(sessionId?: {
        id: string;
        ldap?: string;
        name?: string;
        email?: string;
    }, content?: any);
    static adapt(item?: any): StateMessage;
}

interface PublicMessageInterface {
    sessionId: {
        id: string;
        ldap?: string;
        name?: string;
        email?: string;
    };
    content: {
        message: string;
        [key: string]: any;
    };
}
declare class PublicMessage implements PublicMessageInterface {
    sessionId: {
        id: string;
        ldap?: string;
        name?: string;
        email?: string;
    };
    content: {
        message: string;
        [key: string]: any;
    };
    constructor(sessionId?: {
        id: string;
        ldap?: string;
        name?: string;
        email?: string;
    }, content?: {
        message: string;
        [key: string]: any;
    });
    static adapt(item?: any): PublicMessage;
}

interface NotificationMessageInterface {
    sessionId: {
        id: string;
        ldap?: string;
        name?: string;
        email?: string;
        color?: string;
    };
    message: string;
    [key: string]: any;
}
declare class NotificationMessage implements NotificationMessageInterface {
    sessionId: {
        id: string;
        ldap?: string;
        name?: string;
        email?: string;
        color?: string;
    };
    message: string;
    [key: string]: any;
    constructor(sessionId?: {
        id: string;
        ldap?: string;
        name?: string;
        email?: string;
        color?: string;
    }, message?: string, additionalProperties?: any);
    static adapt(item?: any): NotificationMessage;
}

interface TableSchemaDefInterface {
    table: string;
    schema: string;
}
declare class TableSchemaDef implements TableSchemaDefInterface {
    table: string;
    schema: string;
    constructor(table?: string, schema?: string);
    static adapt(item?: any): TableSchemaDef;
    static cleanString(str: string): string;
}

declare class DbService extends Dexie {
    readonly storageDB = "global_storage_db";
    get db(): this;
    private dbReady;
    constructor();
    private init;
    protected createNewDatabase(): Promise<void>;
    get vr(): number;
    get nextVr(): number;
    get getTables(): string[];
    hasDatabase(): Promise<boolean>;
    getTable(tableName: string): Table<any, any> | undefined;
    tableExists(tableName: string): boolean;
    protected updateTable(tableName: string, find: {
        key: string;
        value: string | number;
    }, data: any): Promise<boolean>;
    protected createTable(tableName: string, schema: string): Promise<void>;
    private _doCreateTable;
    protected DBOpened(): Promise<boolean>;
    private getCurrentSchema;
    protected deleteAndReinitialize(): Observable<boolean>;
    protected cleanTableName(str: string): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<DbService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DbService>;
}

declare class DatabaseManagerService extends DbService {
    private localStorageManager;
    private readonly pendingCountSignal;
    private readonly tableNamesSignal;
    private readonly databaseReadySignal;
    readonly isPending: Signal<boolean>;
    readonly tableNames: Signal<string[]>;
    readonly databaseReady: Signal<boolean>;
    private readonly stateChanged$;
    private toSyncObservable;
    readonly isPending$: Observable<boolean>;
    readonly tableNames$: Observable<string[]>;
    readonly databaseReady$: Observable<boolean>;
    private trackPending;
    private refreshTableNames;
    constructor();
    getDatabaseTables(): Observable<any[]>;
    databaseExists(): Observable<boolean>;
    hasDatabaseTable(table: string): Observable<boolean>;
    getDatabaseTable(table: string): Observable<any>;
    getDatabaseTableSchema(table: string): Observable<string[]>;
    createDatabaseTable(tableDef: TableSchemaDef): Observable<boolean>;
    updateDatabaseTableSchema(tableDef: TableSchemaDef): Observable<any>;
    findTableRecords(table: string, column: string, value: any): Observable<unknown>;
    findTableRecord(table: string, column: string, value: any): Observable<any>;
    getTableRecords(table: string): Observable<unknown>;
    getTableRecord(table: string, id: number): Observable<any>;
    createTableRecord(table: string, record: any): Observable<any>;
    createTableRecords(table: string, records: any[]): Observable<any[]>;
    private inferSchemaFromRecords;
    private isMissingObjectStoreError;
    updateTableRecord(table: string, record: any): Observable<any>;
    updateTableRecords(table: string, records: any[]): Observable<any[]>;
    deleteTableRecord<T>(table: string, id: number): Observable<number | null>;
    deleteTableRecords(table: string, ids: number[]): Observable<number[]>;
    reconcileTableRecords(table: string, records: any[]): Observable<{
        records: any[];
        removedIds: any[];
    }>;
    clearTable(table: string): Observable<never[]>;
    clearDatabase(): void;
    resetDatabase(): Observable<boolean>;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DatabaseManagerService>;
}

interface ChannelMessageInterface {
    messageId?: number;
    channel?: string;
    isReplay?: boolean;
    sessionId: any;
    content: any;
    timestamp?: string;
}
declare class ChannelMessage implements ChannelMessageInterface {
    messageId?: number | undefined;
    channel?: string | undefined;
    isReplay?: boolean | undefined;
    sessionId: any;
    content: any;
    timestamp?: string | undefined;
    constructor(messageId?: number | undefined, channel?: string | undefined, isReplay?: boolean | undefined, sessionId?: any, content?: any, timestamp?: string | undefined);
    static adapt(item?: any): ChannelMessage;
}

/**
 * LoggerService for http-request-manager library
 *
 * Automatically enables debug logging in development mode,
 * disables it in production mode.
 *
 * Usage:
 * ```typescript
 * constructor(private logger: LoggerService) {}
 *
 * this.logger.debug('WebSocket', 'Connected successfully');
 * this.logger.info('HTTP', 'Request completed', { status: 200 });
 * this.logger.warn('State', 'Cache miss for key', { key: 'user' });
 * this.logger.error('Database', 'Connection failed', error);
 * ```
 */
declare class LoggerService {
    private static readonly DEBUG_FLAG_KEY;
    private debugMode;
    constructor();
    /**
     * Debug level logging - only shown in development mode
     * Use for: Detailed diagnostic information, state changes, connection events
     */
    debug(context: string, message: string, data?: any): void;
    /**
     * Info level logging - only shown in development mode
     * Use for: Important operational messages, successful operations
     */
    info(context: string, message: string, data?: any): void;
    /**
     * Warning level logging - only shown in development mode
     * Use for: Potential issues, deprecated usage, recoverable errors
     */
    warn(context: string, message: string, data?: any): void;
    /**
     * Error level logging - only shown in development mode
     * Use for: Actual errors, failures, exceptions
     */
    error(context: string, message: string, data?: any): void;
    /**
     * Check if debug mode is enabled (development mode)
     */
    isDebugEnabled(): boolean;
    private isDebugFlagEnabled;
    static ɵfac: i0.ɵɵFactoryDeclaration<LoggerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<LoggerService>;
}

/**
 * Channel type enum for different communication purposes
 * - STATE: Private channels for state synchronization (SYS- prefix)
 * - MESSAGE: Public messaging/communication channels (PUB- prefix)
 * - NOTIFICATION: Notification channels with DB persistence (MES- prefix)
 */
declare enum ChannelType {
    STATE = "SYS",
    MESSAGE = "PUB",
    NOTIFICATION = "MES"
}
/**
 * Utility function to create prefixed channel name
 * @param channelType - The type of channel
 * @param channelName - The base channel name
 * @returns Prefixed channel name (e.g., 'SYS-USERS123')
 */
declare function createChannelName(channelType: ChannelType, channelName: string): string;
interface APIStateManagerData<T> {
    data: T[];
    dataObject: T | null;
}
declare class HTTPManagerStateService<T extends {
    id: number | string;
}> implements OnDestroy {
    private apiOptions;
    private dataType;
    httpManagerService: HTTPManagerService<any>;
    dbManagerService: DatabaseManagerService;
    localStorageManagerService: LocalStorageManagerService;
    utils: UtilsService;
    logger: LoggerService;
    private readonly subscriptions;
    private readonly stateSignal;
    private readonly stateChanged$;
    private toSyncObservable;
    private updateCoreState;
    private readonly pendingCountSignal;
    private readonly errorSignal;
    readonly isPending: Signal<boolean>;
    readonly error: Signal<boolean | string>;
    error$: Observable<string | boolean>;
    isPending$: Observable<boolean>;
    private beginPending;
    private endPending;
    private track;
    private readonly operationSuccessSignal;
    readonly operationSuccess: Signal<OperationResultModel | null>;
    operationSuccess$: Observable<OperationResultModel | null>;
    private emitOperationSuccess;
    private readonly pageSignal;
    readonly page: Signal<number>;
    page$: Observable<number>;
    private readonly totalPagesSignal;
    readonly totalPages: Signal<number>;
    totalPages$: Observable<number>;
    private readonly percentageSignal;
    readonly percentage: Signal<number>;
    percentage$: Observable<number>;
    private hasDatabase;
    private hasInitialFetch;
    streamedResponse: any[];
    private maxRetries;
    private retryDelay;
    private shouldRetry;
    private connectionStatusSubscription?;
    private hasConnectedOnce;
    private reconcileIntervalSubscription?;
    private lastFetchOptions?;
    private databaseOptions?;
    private readonly volatileHeaders;
    private requestSignatureCache;
    private inFlightRequestSignatures;
    private _requestCachePaths;
    private wsRetryAttempts;
    wsRetryAttempts$: Observable<number>;
    private wsNextRetry;
    wsNextRetry$: Observable<number>;
    private messages;
    messages$: Observable<any[]>;
    private userListByChannel;
    userListByChannel$: Observable<Map<string, any[]>>;
    getUsersForChannel$(channel: string): Observable<any[]>;
    private userList;
    userList$: Observable<any[]>;
    private user;
    user$: Observable<WSUser | null>;
    private channels;
    channels$: Observable<string[] | null>;
    private notificationChannels;
    notificationChannels$: Observable<string[]>;
    private todaysNotificationChannels;
    todaysNotificationChannels$: Observable<string[]>;
    private notificationMessages;
    notificationMessages$: Observable<any[]>;
    private latestNotification;
    latestNotification$: Observable<any>;
    private communicationMessages;
    communicationMessages$: Observable<any[]>;
    private latestCommunicationMessages;
    latestCommunicationMessages$: Observable<any>;
    private userAction;
    userAction$: Observable<any>;
    private static wsCommunicationQueue;
    private ownSessionId;
    wsOptions: WSOptions;
    connectionStatus$: Observable<boolean>;
    isConnecting$: Observable<boolean>;
    wsRetryCount$: Observable<number>;
    wsMaxRetries$: Observable<number>;
    connectionError$: Observable<string | null>;
    constructor(apiOptions: ApiRequest | undefined, dataType: DataType | undefined, database?: DatabaseStorage);
    ngOnDestroy(): void;
    /**
     * 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;
    private readonly wsOptionsTrigger$;
    readonly initWS: (wsOptions: WSOptions) => void;
    private static sameWsConnection;
    private readonly initWSSubscription;
    appendMessages(message: any, opts?: {
        silent?: boolean;
    }): void;
    latestMessage(): void;
    clearMessages(): void;
    get ApiRequestOptions(): ApiRequest;
    private readonly initDBStorageTrigger$;
    readonly initDBStorage: () => void;
    private readonly initDBStorageSubscription;
    initializeState(data: any): void;
    readonly data: Signal<T | T[] | null>;
    readonly data$: Observable<T | T[] | null>;
    readonly selectRecord: (id: number) => Signal<T | T[] | null>;
    readonly selectRecord$: (id: number) => Observable<T | T[] | null>;
    private setData$;
    private mergeDeltaData$;
    private updateArrayState;
    private addData$;
    private deleteData$;
    private updateData$;
    private readonly clearRecordsTrigger$;
    readonly clearRecords: (data?: any) => void;
    private readonly clearRecordsSubscription;
    fetchRecords(options?: RequestOptions): void;
    private initDBStorageAsync;
    private buildSchemaFromAdapter;
    private buildSchemaFromSample;
    private persistStreamDataToDb;
    private runGetDeltaOrFullFetch;
    private runStreamDeltaOrFullFetch;
    /**
     * Resolves the savedAt cursor for a specific query combination. Each query combo keeps
     * its OWN cursor (savedAtByQuery map), so switching views back and forth delta-fetches
     * against the correct per-combo cursor instead of full-fetching or reusing a cursor
     * that belongs to a different dataset.
     */
    private getSavedAtForCombo;
    /**
     * Deterministic, normalized query combination string for a request — same logic used by
     * checkTrackerAllowsRequest so cursor-query comparisons are consistent.
     */
    private buildQueryCombinationString;
    private deltaFetch;
    private static readonly inFlightFetchRecordRequests;
    fetchRecord(options: RequestOptions, method: string): void;
    reconcile(options?: RequestOptions): void;
    createRecord(data: any | null, options?: RequestOptions): void;
    updateRecord(data: any | null, options?: RequestOptions): void;
    patchRecord(data: any | null, options?: RequestOptions): void;
    deleteRecord(options?: RequestOptions): void;
    createStream(data: any | null, options?: RequestOptions): void;
    fetchStream(options?: RequestOptions): void;
    private wsCommunication;
    /**
     * Actually send the WebSocket message (called when connected or from queue)
     */
    private sendWsCommunication;
    /**
     * Send a message to channel(s)
     * @param message - The message content
     * @param channels - Optional array of channel names (passed as-is, caller should include prefix)
     *                   Use 'allChannels' to broadcast to all
     */
    wsMessaging(message: ChannelMessage, channels?: string[]): void;
    /**
     * Subscribe to a messaging channel
     * @param channel - Base channel name (MES- prefix added automatically)
     */
    subscribeToMessageChannel(channel: string): void;
    /**
     * Unsubscribe from a messaging channel
     * @param channel - Base channel name (MES- prefix added automatically)
     */
    unsubscribeFromMessageChannel(channel: string): void;
    /**
     * Subscribe to a single channel (no automatic prefix)
     * Use subscribeToMessageChannel() for MES- prefixed channels
     */
    subscribeToChannel(channel: string): void;
    /**
     * Subscribe to multiple channels at once
     */
    subscribeToChannels(channels: string[]): void;
    /**
     * Unsubscribe from a channel
     */
    unsubscribeFromChannel(channel: string): void;
    /**
     * Get observable of currently subscribed channels
     */
    get subscribedChannels$(): Observable<Set<string>>;
    /**
     * Get current subscribed channels synchronously
     */
    getSubscribedChannels(): Set<string>;
    /**
     * Create a new channel on the server
     */
    createChannel(channel: string): void;
    /**
     * Delete a channel from the server
     */
    deleteChannel(channel: string): void;
    /**
     * Request list of all channels from server
     */
    getAllChannels(): void;
    /**
     * Get users in a specific channel
     */
    getUsersInChannel(channel: string): void;
    /**
     * Create a notification channel on the server
     * @param channel - Base channel name (MES- prefix added automatically)
     */
    createNotificationChannel(channel: string): void;
    /**
     * Request list of all notification channels from server (in-memory)
     */
    getNotificationChannels(): void;
    /**
     * Request list of today's notification channels from database
     * Returns unique channels that have notifications posted today
     */
    getTodaysNotificationChannels(): void;
    /**
     * Subscribe to a notification channel with optional date filters
     * @param channel - Base channel name (MES- prefix added automatically)
     */
    subscribeToNotificationChannel(channel: string, options?: {
        startEpoch?: number;
        endEpoch?: number;
    }, user?: any): void;
    /**
     * Unsubscribe from a notification channel
     * @param channel - Base channel name (MES- prefix added automatically)
     */
    unsubscribeFromNotificationChannel(channel: string): void;
    /**
     * Send a notification to a channel
     * @param channel - Base channel name (MES- prefix added automatically)
     */
    sendNotification(channel: string, content: any): void;
    /**
     * Clear/flush all records from the database table
     * Does not clear localStorage metadata (expires info)
     * Does not re-fetch from API - leaves state empty for manual refresh
     */
    clearDatabase(): void;
    private isEmpty;
    private extractListPayload;
    private applyAdapter;
    private getSessionStoreName;
    private initSessionFlag;
    private setupReconciliation;
    private persistInitialFetch;
    private clearSessionFlag;
    /**
     * Update request options with provided headers
     */
    private updateRequestOptions;
    private normalizeObject;
    private filterHeaders;
    private resolvePath;
    private stripBasePathPrefix;
    private getEffectiveParams;
    private buildRequestSignature;
    private buildSchemaSignature;
    private setCachedRequestSignature;
    private tryBeginInFlightRequest;
    private endInFlightRequest;
    private getRequestCacheMetadata;
    private getStoredSchemaSignature;
    private saveSchemaSignature;
    private saveRequestCacheMetadata;
    private clearRequestCacheMetadata;
    private clearRequestCacheMetadataAsync;
    private trackerNormalizePath;
    private trackerParsePathSegment;
    private trackerSafeDecode;
    private trackerNormalizePathSegments;
    private trackerNormalizeParamKey;
    private trackerNormalizeParamValue;
    private trackerFilterQuery;
    private checkTrackerAllowsRequest;
    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerStateService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerStateService<any>>;
}

/**
 * WebSocketManagerService - Singleton WebSocket connection manager
 *
 * This service ensures only ONE WebSocket connection exists across ALL instances
 * of HTTPManagerStateService. It uses static properties to track connection state
 * globally, preventing duplicate connections when multiple state services are created.
 *
 * Usage:
 * - Inject into HTTPManagerService (or directly into state services)
 * - Call connect() with WSOptions - only the first call establishes connection
 * - Subsequent calls detect existing connection and skip reconnection
 * - All instances share the same connectionStatus$ and messages$ observables
 */
declare class WebSocketManagerService {
    private static socket;
    private static isConnectingSubject;
    isConnecting$: Observable<boolean>;
    private static connectionInitialized;
    private static shouldRetry;
    private static lastOptions;
    private static lastJwtToken;
    private static retryCount;
    private static retryDelay;
    private static retrySubscription;
    private static maxRetries;
    private static connectionReadyNotified;
    private static retryCountSubject;
    retryCount$: Observable<number>;
    private static maxRetriesSubject;
    maxRetries$: Observable<number>;
    private static messages;
    messages$: Observable<any>;
    private static connectionStatus;
    connectionStatus$: Observable<boolean>;
    private static connectionError;
    connectionError$: Observable<string | null>;
    private static isSubscribed;
    private static subscribedChannels;
    subscribedChannels$: Observable<Set<string>>;
    private static pendingSubscriptions;
    static getSubscribedChannels(): Set<string>;
    static addSubscribedChannel(channelName: string): void;
    private static onReconnect;
    onReconnect$: Observable<void>;
    private getSessionId;
    /**
     * Connect to WebSocket server
     *
     * IMPORTANT: Only the first call across ALL instances will establish a connection.
     * Subsequent calls will detect the existing connection and return immediately.
     *
     * @param options - WebSocket configuration options
     * @param jwtToken - Optional JWT token for authentication
     */
    connect(options: WSOptions, jwtToken: string): void;
    /**
     * Disconnect from WebSocket server
     */
    disconnect(): void;
    /**
     * Clear a stale connectionError without triggering a connection attempt.
     * Used when no wsServer is configured so the UI shows clean "Disconnected" state.
     */
    clearConnectionError(): void;
    private sendSubscribe;
    /**
     * Send subscribe with lastSeenId for message sync support
     * @param channelName - Channel name to subscribe to
     * @param user - User data
     * @param lastSeenId - Last message ID seen (for replay)
     */
    sendSubscribeWithLastSeen(channelName: string, user: any, lastSeenId: number): void;
    /**
     * Subscribe to a channel
     * @param channelName - Channel name to subscribe to
     */
    subscribeToChannel(channelName: string): void;
    /**
     * Subscribe to multiple channels
     * @param channelNames - Array of channel names to subscribe to
     */
    subscribeToChannels(channelNames: string[]): void;
    /**
     * Unsubscribe from a channel
     * @param channel - Channel name to unsubscribe from
     */
    unsubscribeFromChannel(channel: string): void;
    /**
     * Get currently subscribed channels
     * @returns Set of subscribed channel names
     */
    getSubscribedChannels(): Set<string>;
    /**
     * Generic send method for message tracking (acks, gap requests, etc.)
     * @param message - Message object to send
     */
    send(message: any): void;
    /**
     * Send broadcast message
     * @param content - Message content to broadcast
     */
    sendBroadcast(content: any): void;
    /**
     * Send message in channel (state manager message)
     * @param channel - Channel name
     * @param content - Message content
     */
    sendMessageInChannel(channel: string, content: any): void;
    /**
     * Send channel message (broadcasts to all subscribers in the channel)
     * @param channel - Channel name
     * @param content - Message content
     */
    sendChannelMessage(channel: string, content: any): void;
    /**
     * Send message to multiple channels at once (batch)
     * @param channels - Array of channel names
     * @param content - Message content
     */
    sendChannelMessageToChannels(channels: string[], content: any): void;
    /**
     * Send message to specific user
     * @param user - User identifier
     * @param content - Message content
     */
    sendMessageToUser(user: string, content: any): void;
    /**
     * Request list of all channels from server
     */
    getAllChannels(): void;
    /**
     * Create a new channel on server
     * @param channel - Channel name to create
     */
    createChannel(channel: string): void;
    /**
     * Delete a channel from server
     * @param channel - Channel name to delete
     */
    deleteChannel(channel: string): void;
    /**
     * Get users in a specific channel
     * @param channel - Channel name
     */
    getUsersInChannel(channel: string): void;
    /**
     * Create a notification channel
     * @param channel - Channel name (should include MES- prefix)
     */
    createNotificationChannel(channel: string): void;
    /**
     * Get all notification channels (in-memory)
     */
    getNotificationChannels(): void;
    /**
     * Get today's notification channels from database
     */
    getTodaysNotificationChannels(): void;
    /**
     * Subscribe to a notification channel with optional date filters
     * @param channel - Channel name
     * @param options - Optional start/end epoch filters
     * @param user - User information
     */
    subscribeToNotificationChannel(channel: string, options?: {
        startEpoch?: number;
        endEpoch?: number;
    }, user?: any): void;
    /**
     * Unsubscribe from a notification channel
     * @param channel - Channel name
     */
    unsubscribeFromNotificationChannel(channel: string): void;
    /**
     * Send notification to channel
     * @param channel - Channel name (should include MES- prefix)
     * @param content - Notification content
     */
    sendNotification(channel: string, content: any): void;
    /**
     * Check if WebSocket connection is currently open
     * @returns true if connected, false otherwise
     */
    static isConnected(): boolean;
    /**
     * Check if connection has been initialized (attempted at least once)
     * @returns true if connection was initialized, false otherwise
     */
    static isInitialized(): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<WebSocketManagerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WebSocketManagerService>;
}

/**
 * Message Tracker Service - Guaranteed Message Delivery
 *
 * Tracks message IDs, detects gaps, manages acknowledgments, and handles sync.
 * Ensures frontend clients never miss messages even during disconnections.
 *
 * Features:
 * - Per-channel message sequence tracking
 * - Automatic gap detection and recovery
 * - Batch acknowledgments (configurable interval)
 * - Reconnection sync with last-seen tracking
 * - Gap threshold alerting (10 messages before UI notification)
 */
declare class MessageTrackerService implements OnDestroy {
    private wsManager;
    /** Batch acknowledgment interval in milliseconds */
    private readonly BATCH_ACK_INTERVAL_MS;
    /** Maximum gap before alerting UI */
    private readonly GAP_THRESHOLD;
    /** Maximum messages to store in pending acks before forcing batch */
    private readonly MAX_PENDING_ACKS;
    /**
     * Track last seen message ID per channel
     * Map<channelName, lastMessageId>
     */
    private lastSeen;
    /**
     * Expected next message ID per channel (for gap detection)
     * Map<channelName, nextExpectedId>
     */
    private expectedSequence;
    /**
     * Pending acknowledgments per channel
     * Map<channelName, Set<messageId>>
     */
    private pendingAcks;
    /**
     * Gap count per channel (for threshold alerting)
     * Map<channelName, gapCount>
     */
    private gapCounts;
    /**
     * Replay mode tracking (per channel)
     * Used to distinguish replay vs live messages
     */
    private inReplayMode;
    /**
     * Gap retry count (for retry logic)
     * Map<channel, retryCount>
     */
    private gapRetryCount;
    /** Subscription to WebSocket messages */
    private messagesSubscription;
    /** Subject to signal destroy for takeUntil */
    private destroy$;
    /**
     * Track channels we want to be subscribed to (survives disconnect/reconnect)
     * This is separate from WebSocketManagerService.subscribedChannels which tracks
     * actual active subscriptions
     */
    private intendedChannels;
    /** Observable to emit processed messages to UI components */
    private messagesSubject;
    messages$: Observable<any>;
    constructor(wsManager: WebSocketManagerService);
    ngOnDestroy(): void;
    /**
     * Process incoming message
     * Tracks ID, detects gaps, queues acknowledgment
     */
    private onMessage;
    /**
     * Track message ID and detect gaps
     */
    private trackMessage;
    /**
     * Queue message for batch acknowledgment
     */
    private queueAck;
    /**
     * Send batch acknowledgments for all channels with pending acks
     */
    private sendAllBatchAcks;
    /**
     * Send batch acknowledgment for a specific channel
     */
    private sendBatchAck;
    /**
     * Request missing messages from server
     */
    private requestGapFill;
    /**
     * Handle gap threshold exceeded (optional: alert UI)
     */
    private onGapThresholdExceeded;
    /**
     * Subscribe to channel with sync support
     * Automatically includes lastSeenId for replay
     */
    subscribeToChannel(channel: string, userData?: any): void;
    /**
     * Re-subscribe to all previously subscribed channels after reconnect
     * Includes lastSeenId for each channel to trigger message replay
     */
    private reSubscribeAllChannels;
    /**
     * Persist lastSeen to sessionStorage (survives page reload)
     */
    private persistLastSeen;
    /**
     * Restore lastSeen from sessionStorage
     */
    private restoreLastSeen;
    /**
     * Persist intendedChannels to sessionStorage
     */
    private persistIntendedChannels;
    /**
     * Restore intendedChannels from sessionStorage
     */
    private restoreIntendedChannels;
    /**
     * Get last seen message ID for a channel
     */
    getLastSeenId(channel: string): number;
    /**
     * Get expected next message ID for a channel
     */
    getExpectedNextId(channel: string): number;
    /**
     * Check if currently in replay mode for a channel
     */
    isInReplayMode(channel: string): boolean;
    /**
     * Get gap count for a channel
     */
    getGapCount(channel: string): number;
    /**
     * Get skipped IDs between expected and received (for detailed gap reporting)
     */
    private getSkippedIds;
    /**
     * Clear all tracking state (useful for debugging or manual reset)
     */
    clearState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageTrackerService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MessageTrackerService>;
}

declare class HTTPManagerService<T> extends RequestService {
    private configOptions?;
    toastMessage: ToastMessageDisplayService;
    ng_injector: Injector;
    objectMergerService: ObjectMergerService;
    wsManager: WebSocketManagerService;
    messageTracker: MessageTrackerService;
    connectionStatus$: Observable<boolean>;
    messages$: Observable<any>;
    subscribedChannels$: Observable<Set<string>>;
    isConnecting$: Observable<boolean>;
    retryCount$: Observable<number>;
    maxRetries$: Observable<number>;
    connectionError$: Observable<string | null>;
    countdown: i0.WritableSignal<number>;
    countdown$: Observable<number>;
    error: i0.WritableSignal<boolean>;
    error$: Observable<boolean>;
    data: i0.WritableSignal<any>;
    data$: Observable<any>;
    isBatchPending: i0.WritableSignal<boolean>;
    isBatchPending$: Observable<boolean>;
    batchResults: i0.WritableSignal<any[] | null>;
    batchResults$: Observable<any[] | null>;
    batchError: i0.WritableSignal<any>;
    batchError$: Observable<any>;
    batchStates: i0.WritableSignal<BatchRequestState<any>[]>;
    batchStates$: Observable<BatchRequestState<any>[]>;
    batchProgress: i0.Signal<BatchProgress>;
    batchProgress$: Observable<BatchProgress>;
    private polling$;
    config: ApiRequest;
    constructor(configOptions?: ConfigOptions | undefined);
    /**
     * Connect to WebSocket server
     * Only the first call across ALL instances will establish a connection
     */
    connect(options: any, jwtToken: string): void;
    /**
     * Disconnect from WebSocket server
     */
    disconnect(): void;
    /**
     * Clear any stale connection error without triggering a connection attempt
     */
    clearConnectionError(): void;
    /**
     * Subscribe to a channel
     */
    subscribeToChannel(channel: string, userData?: any): void;
    /**
     * Subscribe to multiple channels
     */
    subscribeToChannels(channels: string[], userData?: any): void;
    /**
     * Unsubscribe from a channel
     */
    unsubscribeFromChannel(channel: string): void;
    /**
     * Get currently subscribed channels
     */
    getSubscribedChannels(): Set<string>;
    /**
     * Send broadcast message
     */
    sendBroadcast(content: any): void;
    /**
     * Send message in channel (state manager message)
     */
    sendMessageInChannel(channel: string, content: any): void;
    /**
     * Send channel message
     */
    sendChannelMessage(channel: string, content: any): void;
    /**
     * Send message to multiple channels
     */
    sendChannelMessageToChannels(channels: string[], content: any): void;
    /**
     * Send message to user
     */
    sendMessageToUser(user: string, content: any): void;
    /**
     * Get all channels
     */
    getAllChannels(): void;
    /**
     * Create channel
     */
    createChannel(channel: string): void;
    /**
     * Delete channel
     */
    deleteChannel(channel: string): void;
    /**
     * Get users in channel
     */
    getUsersInChannel(channel: string): void;
    /**
     * Create notification channel
     */
    createNotificationChannel(channel: string): void;
    /**
     * Get notification channels
     */
    getNotificationChannels(): void;
    /**
     * Get today's notification channels
     */
    getTodaysNotificationChannels(): void;
    /**
     * Subscribe to notification channel
     */
    subscribeToNotificationChannel(channel: string, options?: any, user?: any): void;
    /**
     * Unsubscribe from notification channel
     */
    unsubscribeFromNotificationChannel(channel: string): void;
    /**
     * Send notification to channel
     */
    sendNotification(channel: string, content: any): void;
    getRequest<T>(options?: ApiRequest, params?: any[]): Observable<T>;
    postRequest<T extends {
        id?: number | string;
    }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
    putRequest<T extends {
        id?: number | string;
    }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
    patchRequest<T extends {
        id?: number | string;
    }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
    deleteRequest<T>(options: ApiRequest, params?: any[]): Observable<T>;
    downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string): Observable<T>;
    uploadRequest<T>(files: File | File[], options: ApiRequest, params?: any[]): Observable<T>;
    private createObservable;
    private createRequest;
    private prepareRequestData;
    private handleError;
    private handleErrorWithSnackBar;
    private handleSuccessWithSnackBar;
    private stopPolling;
    private defineReqOptions;
    /**
     * Execute multiple HTTP requests with configurable execution strategy
     * @param requests Array of ApiRequest configurations
     * @param options Optional batch configuration (all properties optional)
     * @returns Observable emitting array of data in the order of requests provided
     */
    getBatchRequests<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<U[]>;
    /**
     * Execute requests sequentially (one at a time, in order)
     * @param requests Array of ApiRequest configurations
     * @param options Optional batch configuration
     * @returns Observable emitting array of data when all requests complete
     */
    getSequentialRequest<U = T>(requests: ApiRequest[], options?: BatchOptions, successMessage?: string, errorMessage?: string): Observable<U[]>;
    /**
     * Execute requests in parallel with concurrency control
     * @param requests Array of ApiRequest configurations
     * @param options Optional batch configuration with concurrency limit
     * @returns Observable emitting array of data when all requests complete
     */
    getParallelRequest<U = T>(requests: ApiRequest[], options?: BatchOptions, successMessage?: string, errorMessage?: string): Observable<U[]>;
    /**
     * Execute multiple HTTP requests and emit individual state changes in real-time
     * @param requests Array of ApiRequest configurations
     * @param options Optional batch configuration (all properties optional)
     * @returns Observable stream of individual request states
     */
    getBatchRequestsStream<U = T>(requests: ApiRequest[], options?: BatchOptions): Observable<BatchRequestState<U>>;
    /**
     * Execute requests sequentially and emit state changes
     */
    private getSequentialStream;
    /**
     * Execute requests in parallel and emit state changes
     */
    private getParallelStream;
    private handleSequentialError;
    private handleParallelError;
    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerService<any>, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerService<any>>;
}

declare function countdown(duration: number): Observable<number>;

declare function delayedRetry<T>(delayMs: number, maxRetry?: number): (src: Observable<T>) => Observable<T>;

declare function requestPolling<T>(pollInterval: number, stopCondition$: Observable<any>, isPending$: any): (source: Observable<T>) => Observable<T>;

/**
 * COMPREHENSIVE REQUEST STREAMING OPERATOR - FULLY ABSTRACTED
 * Refactored for better type safety and memory management
 *
 * Single function that handles ALL streaming formats without hardcoded assumptions:
 * - JSON format (Individual JSON objects)
 * - NDJSON format (Newline delimited JSON)
 * - AI streaming format (Real-time AI responses)
 * - Server-Sent Events format
 * - Auto-detection mode
 *
 * Usage:
 *   this.http.get(url, options).pipe(requestStreaming()).subscribe(data => {...})
 *   this.http.get(url, options).pipe(requestStreaming({ streamType: StreamType.NDJSON })).subscribe(data => {...})
 */
declare function requestStreaming<T = any>(config?: StreamConfigModel): OperatorFunction<any, StreamOutputModel<T>>;
/**
 * Convenience functions for common use cases
 */
declare function streamJSON<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;
declare function streamNDJSON<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;
declare function streamAI<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;
declare function streamEvents<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;
declare function streamAuto<T = any>(): OperatorFunction<any, StreamOutputModel<T>>;

/**
 * WebSocketMessageService - Unified service for sending WebSocket messages
 *
 * Provides type-safe methods for sending messages with automatic prefix management.
 * Supports three message types: State (SYS-), Public (PUB-), and Notification (MES-).
 *
 * Features:
 * - Type-safe message models
 * - Automatic prefix management
 * - Runtime validation
 * - Boolean return values for success/failure
 * - Silent failure with console errors
 */
declare class WebSocketMessageService {
    private wsManagerService;
    private logger;
    /**
     * Send state message (SYS- prefix)
     * Used for CRUD operations and state synchronization
     *
     * @param path - Path array (e.g., ['ai', 'tests'])
     * @param payload - StateMessage with sessionId and content
     * @returns true if sent successfully, false otherwise
     */
    sendStateMessage(path: (string | number)[], payload: StateMessage): boolean;
    /**
     * Send public message (PUB- prefix)
     * Used for chat, broadcast, general messaging
     *
     * @param channel - Channel name (without prefix)
     * @param payload - PublicMessage with sessionId and content.message
     * @returns true if sent successfully, false otherwise
     */
    sendPublicMessage(channel: string, payload: PublicMessage): boolean;
    /**
     * Send notification (MES- prefix)
     * Used for persistent notifications with history
     *
     * @param channel - Channel name (without prefix)
     * @param payload - NotificationMessage with sessionId and message
     * @returns true if sent successfully, false otherwise
     */
    sendNotification(channel: string, payload: NotificationMessage): boolean;
    /**
     * Send to custom channel (no prefix)
     * User provides full channel name
     *
     * @param channel - Full channel name
     * @param payload - Any message payload
     * @returns true if sent successfully, false otherwise
     */
    sendToCustomChannel(channel: string, payload: any): boolean;
    static ɵfac: i0.ɵɵFactoryDeclaration<WebSocketMessageService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<WebSocketMessageService>;
}

interface StateStorageOptionsInterface {
    store?: string;
    options?: SettingOptions;
    model?: (state: any) => any;
}
declare class StateStorageOptions implements StateStorageOptionsInterface {
    store?: string | undefined;
    options?: SettingOptions | undefined;
    model?: ((state: any) => any) | undefined;
    constructor(store?: string | undefined, options?: SettingOptions | undefined, model?: ((state: any) => any) | undefined);
    static adapt(item?: any): StateStorageOptions;
}

interface StateOperationResultInterface {
    success: boolean;
    operation: 'CREATE' | 'UPDATE' | 'DELETE';
    key?: string;
    value?: any;
    timestamp: number;
    error?: string;
}
declare class StateOperationResult implements StateOperationResultInterface {
    success: boolean;
    operation: 'CREATE' | 'UPDATE' | 'DELETE';
    key?: string | undefined;
    value?: any | undefined;
    timestamp: number;
    error?: string | undefined;
    constructor(success?: boolean, operation?: 'CREATE' | 'UPDATE' | 'DELETE', key?: string | undefined, value?: any | undefined, timestamp?: number, error?: string | undefined);
    static adapt(item?: any): StateOperationResult;
}

interface StateStoreManagerData<T> {
}
declare class StoreStateManagerService<T extends object = StateStoreManagerData<any>> {
    private readonly localStorageManagerService;
    private readonly injector;
    private readonly settings;
    private isRestoring;
    private readonly stateSignal;
    private readonly operationResultSignal;
    private readonly stateChanged$;
    /** Untransformed state, exactly as held internally. */
    readonly rawData: Signal<T>;
    /**
     * State passed through the store's configured model. A model is free to ignore its
     * argument (as `StoreStateSignalsDemoComponent`'s does) — in that case this stays
     * fixed at the model's default even as `rawData` changes; use `rawData` for a value
     * that always reflects the latest state.
     */
    readonly data: Signal<any>;
    readonly operationResult: Signal<StateOperationResult | null>;
    private toSyncObservable;
    readonly rawData$: Observable<T>;
    readonly data$: Observable<any>;
    readonly operationResult$: Observable<StateOperationResult | null>;
    constructor(options?: StateStorageOptions);
    restoreState(): void;
    updateState(state: Partial<T>): void;
    updateData(data: Partial<T>): void;
    createRecord(key: string, value: any): void;
    updateRecord(key: string, value: any): void;
    deleteRecord(key: string): void;
    resetState(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StoreStateManagerService<any>, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StoreStateManagerService<any>>;
}

interface DexieSqlOptions {
    strict?: boolean;
}

declare class DexieSqlService {
    private readonly _parser;
    private readonly _validator;
    private readonly _planner;
    private readonly _executor;
    /**
     * Execute a MySQL-syntax SQL SELECT string against the DexieJS IndexedDB database.
     * Returns an Observable that emits the result array and completes, or errors with
     * SqlParseError / SqlValidationError if the query is invalid.
     */
    query(sql: string, options?: DexieSqlOptions): Observable<any[]>;
    private _run;
    static ɵfac: i0.ɵɵFactoryDeclaration<DexieSqlService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<DexieSqlService>;
}

declare class SqlParseError extends Error {
    name: string;
    constructor(message: string);
}
declare class SqlValidationError extends Error {
    name: string;
    constructor(message: string);
}

declare enum ExecutionPlanType {
    SIMPLE = "SIMPLE",
    AND_BOUNDED = "AND_BOUNDED",
    AND_COMPOUND = "AND_COMPOUND",
    OR_MERGE = "OR_MERGE",
    JOIN_HASH = "JOIN_HASH"
}
type DexieOp = 'equals' | 'notEqual' | 'above' | 'aboveOrEqual' | 'below' | 'belowOrEqual' | 'between' | 'anyOf' | 'noneOf' | 'startsWith';
interface PlanStep {
    col: string;
    op: DexieOp;
    val: any;
}
interface JoinInfo {
    leftTable: string;
    rightTable: string;
    leftKey: string;
    rightKey: string;
    joinType: 'inner' | 'left';
}
interface ExecutionPlan {
    type: ExecutionPlanType;
    table: string;
    primaryStep: PlanStep | null;
    boundedFilters: PlanStep[];
    compoundIndex?: string;
    compoundValues?: any[];
    compoundWarnCols?: string[];
    orBranches?: PlanStep[];
    joinInfo?: JoinInfo;
    orderBy?: {
        col: string;
        dir: 'asc' | 'desc';
    } | null;
    limit?: number | null;
    offset?: number | null;
    projection?: string[] | null;
    aggregate?: 'count' | null;
    distinct?: boolean;
    dedupeKey?: string;
}

interface ParseResult {
    ast: AST;
    tableList: string[];
    columnList: string[];
}

interface TableSchemaInfo {
    pk: string;
    simpleIndexes: string[];
    compoundIndexes: string[][];
}
interface ValidatedQuery {
    ast: any;
    schemas: Record<string, TableSchemaInfo>;
    aliases: Record<string, string>;
}

declare class HeadersService {
    headers: {};
    generateHeaders(headers?: Record<string, string>): {
        headers: HttpHeaders;
    };
    static ɵfac: i0.ɵɵFactoryDeclaration<HeadersService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<HeadersService>;
}

declare class PathQueryService {
    buildAPIPath(server: string | string[], params?: any[] | any): string;
    private buildRestPath;
    private buildQueryPath;
    private cleanUrlPath;
    private isObject;
    private removeEmptyParams;
    static ɵfac: i0.ɵɵFactoryDeclaration<PathQueryService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<PathQueryService>;
}

/**
 * Generate a random hex color code
 * @returns A random hex color string (e.g., "#FF5733")
 */
declare const RandomHexColor: () => string;
/**
 * Generate a random hex color with constraints to ensure good visibility
 * @param options Optional constraints for color generation
 * @returns A random hex color string with good contrast
 */
declare const RandomVisibleColor: (options?: {
    minBrightness?: number;
    maxBrightness?: number;
}) => string;
/**
 * Generate a random color from a predefined palette
 * @returns A hex color from a set of visually distinct colors
 */
declare const RandomPaletteColor: () => string;
/**
 * Generate a random HSL color
 * @param options Optional constraints for HSL generation
 * @returns A random HSL color string (e.g., "hsl(120, 100%, 50%)")
 */
declare const RandomHSLColor: (options?: {
    saturation?: [number, number];
    lightness?: [number, number];
}) => string;

declare function toSyncObservable<T>(sig: Signal<T>, changed$: Observable<void>): Observable<T>;

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 const OWNS_ERROR_DISPLAY: HttpContextToken<boolean>;

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();
    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 const PROXY_CONFIG: InjectionToken<Record<string, any>>;
declare class ProxyDebuggerInterceptor implements HttpInterceptor {
    private proxyConfig;
    constructor(proxyConfig: Record<string, any>);
    intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>>;
    static ɵfac: i0.ɵɵFactoryDeclaration<ProxyDebuggerInterceptor, [{ optional: true; }]>;
    static ɵprov: i0.ɵɵInjectableDeclaration<ProxyDebuggerInterceptor>;
}

declare const withCredentialsInterceptorFn: HttpInterceptorFn;
declare const requestHeadersInterceptorFn: HttpInterceptorFn;
declare const proxyDebuggerInterceptorFn: HttpInterceptorFn;
declare const requestErrorInterceptorFn: HttpInterceptorFn;
declare const httpRequestManagerInterceptors: HttpInterceptorFn[];

interface TestAllResultModel {
    name: string;
    status: 'pending' | 'success' | 'error';
    detail?: any;
    error?: string;
}
declare class RequestManagerBasicDemoComponent implements OnInit {
    server: string;
    displayedColumns: string[];
    getColumnsFromData(data: any[]): string[];
    updateDisplayedColumns(data: any[]): void;
    isObject(value: any): boolean;
    httpManagerService: HTTPManagerService<any>;
    isPending$: Observable<boolean>;
    countdown$: Observable<number>;
    GET_error$: BehaviorSubject<string>;
    GET_FAILURE_error$: BehaviorSubject<string>;
    POST_error$: BehaviorSubject<string>;
    PUT_error$: BehaviorSubject<string>;
    PATCH_error$: BehaviorSubject<string>;
    DELETE_error$: BehaviorSubject<string>;
    STREAM_error$: BehaviorSubject<string>;
    testAllResults$: BehaviorSubject<TestAllResultModel[]>;
    testAllRunning$: BehaviorSubject<boolean>;
    GET$?: Observable<any>;
    GET_FAILURE$?: Observable<any>;
    POST$?: Observable<any>;
    PUT$?: Observable<any>;
    PATCH$?: Observable<any>;
    DELETE$?: Observable<any>;
    STREAM$?: Observable<any>;
    lastRecordId: number | null;
    requestParams: {
        GET: ApiRequest;
        GET_FAILURE: ApiRequest;
        POST: ApiRequest;
        PUT: ApiRequest;
        PATCH: ApiRequest;
        DELETE: ApiRequest;
        STREAM: ApiRequest;
    };
    streamTypes: {
        id: string;
        value: string;
    }[];
    streamType: string;
    getStreamPath(type: string): string[];
    sampleClientData: {
        id: number;
        name: string;
        domain: string;
        service: string;
        spiffe: string;
        secret: string;
        created: number;
        modified: number;
        icon: string;
        imageFile: string;
        email: string;
    };
    constructor();
    ngOnInit(): void;
    onStreamType(type: string): void;
    private captureRecordId;
    onGetRequest(): void;
    onGetFailureRequest(): void;
    onCreateRequest(): void;
    onUpdateRequest(): void;
    onPatchRequest(): void;
    onDeleteRequest(): void;
    onStreamRequest(): void;
    errorHandling(err: any, type: string): void;
    onTestAll(): Promise<void>;
    static ɵfac: i0.ɵɵFactoryDeclaration<RequestManagerBasicDemoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerBasicDemoComponent, "app-request-manager-basic-demo", never, {}, {}, never, never, false, never>;
}

interface UserDataInterface {
    ldap: string;
    name: string;
    email: string;
    color: string;
}
declare class UserData implements UserDataInterface {
    ldap: string;
    name: string;
    email: string;
    color: string;
    constructor(ldap?: string, name?: string, email?: string, color?: string);
    static adapt(item?: any): UserData;
}

declare class HttpRequestServicesDemoComponent implements OnInit {
    private configOptions?;
    wsServer: string;
    jwtToken: string;
    server: string;
    user?: UserData;
    path: string[];
    requestManagerDemoServer: string;
    adapter?: Function;
    mapper?: Function;
    requestTypes: ({
        name: string;
        value: string;
        new?: undefined;
        divider?: undefined;
        disabled?: undefined;
    } | {
        name: string;
        value: string;
        new: boolean;
        divider?: undefined;
        disabled?: undefined;
    } | {
        name: string;
        value: string;
        new: boolean;
        divider: boolean;
        disabled?: undefined;
    } | {
        name: string;
        value: string;
        divider: boolean;
        disabled: boolean;
        new?: undefined;
    } | {
        name: string;
        value: string;
        divider: boolean;
        new?: undefined;
        disabled?: undefined;
    })[];
    selectedService: string;
    injectionOptions?: ConfigOptions;
    constructor(configOptions?: ConfigOptions | undefined);
    ngOnInit(): void;
    onSelected(type: number): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestServicesDemoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<HttpRequestServicesDemoComponent, "app-http-request-services-demo", never, { "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "server": { "alias": "server"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; "adapter": { "alias": "adapter"; "required": false; }; "mapper": { "alias": "mapper"; "required": false; }; }, {}, never, never, false, never>;
}

interface ClientInfoInterface$1 {
    domain: string;
    service: string;
    id: number;
    name: string;
}
declare class ClientInfo$1 implements ClientInfoInterface$1 {
    domain: string;
    service: string;
    id: number;
    name: string;
    constructor(domain?: string, service?: string, id?: number, name?: string);
    static adapt(item?: any): ClientInfo$1;
}

declare class StateManagerDemoService extends HTTPManagerStateService<any> {
    constructor();
    setAPIOptions(apiOptions: ApiRequest, dataType: DataType, database?: DatabaseStorage): void;
    getClients(options?: RequestOptions): void;
    createClient(data: any): void;
    updateClient(data: ClientInfo$1): void;
    patchClient(data: ClientInfo$1): void;
    deleteClient(data: ClientInfo$1): void;
    streamRequest(options?: RequestOptions): void;
    sendWsMessage(channel: string, method: string, path: (string | number)[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StateManagerDemoService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StateManagerDemoService>;
}

interface ClientInfoMapperInterface$1 {
    id: number;
    first_name: string;
    last_name: string;
    email: string;
}
declare class ClientInfoMapper$1 implements ClientInfoMapperInterface$1 {
    id: number;
    first_name: string;
    last_name: string;
    email: string;
    constructor(id?: number, first_name?: string, last_name?: string, email?: string);
    static adapt(item?: any): ClientInfoMapper$1;
}

interface AIPromptInterface$1 {
    response: string;
}
declare class AIPrompt$1 implements AIPromptInterface$1 {
    response: string;
    constructor(response?: string);
    static adapt(item?: any): AIPrompt$1;
}

declare class RequestManagerStateDemoComponent implements OnInit {
    server: string;
    adapter?: Function;
    mapper?: Function;
    stateManagerDemoService: StateManagerDemoService;
    databaseManagerService: DatabaseManagerService;
    displayedColumns: string[];
    getColumnsFromData(data: any[]): string[];
    updateDisplayedColumns(data: any[]): void;
    isObject(value: any): boolean;
    getRecordLabel(item: any): string;
    private normalizeLabelValue;
    getDataLength(data: any): number;
    selectedRecord$?: Observable<ClientInfo$1 | null>;
    fb: FormBuilder;
    streamTypes: {
        id: string;
        value: string;
    }[];
    streamType: string;
    httpManagerService: HTTPManagerService<any>;
    isPending$: Observable<boolean>;
    error$: Observable<string | boolean>;
    countdown$: Observable<number>;
    GET_error$: BehaviorSubject<string>;
    POST_error$: BehaviorSubject<string>;
    PUT_error$: BehaviorSubject<string>;
    PATCH_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>;
    PATCH$: BehaviorSubject<null>;
    DELETE$: BehaviorSubject<null>;
    STREAM: BehaviorSubject<null>;
    STREAM$: Observable<null>;
    STREAM_AI: BehaviorSubject<{
        response: string;
    }[]>;
    STREAM_AI$: Observable<any>;
    failedState: any;
    pollingState: any;
    DBState: any;
    questionControl: FormControl<string | null>;
    requestType: string;
    prompts: string[];
    AIType: number;
    wsMessageForm: _angular_forms.FormGroup<{
        channel: FormControl<string | null>;
        method: FormControl<string | null>;
        path: FormControl<string | null>;
    }>;
    get dataObservable$(): BehaviorSubject<any> | BehaviorSubject<null> | BehaviorSubject<{
        response: string;
    }[]>;
    sampleClientData: {
        id: number;
        name: string;
        domain: string;
        service: string;
        spiffe: string;
        secret: string;
        created: number;
        modified: number;
        icon: string;
        imageFile: string;
    };
    selectedRecord: FormControl<null>;
    requestForm: _angular_forms.FormGroup<{
        datatype: FormControl<string | null>;
        path: FormControl<string | null>;
        headers: FormArray<FormControl<unknown>>;
        adapter: FormControl<null>;
        mapper: FormControl<null>;
        selector: FormControl<string | null>;
        retry: _angular_forms.FormGroup<{
            times: FormControl<number | null>;
            delay: FormControl<number | null>;
        }>;
        polling: FormControl<number | null>;
        database: _angular_forms.FormGroup<{
            table: FormControl<string | null>;
            expiresIn: FormControl<string | null>;
            ignoreQueryParams: FormControl<string | null>;
            queryParamsExpiresIn: FormControl<string | null>;
            deltaSync: FormControl<boolean | null>;
        }>;
    }>;
    get hasChanged(): boolean;
    get dataType(): string | null | undefined;
    get database(): {
        table: string | null;
        expiresIn: string | null;
        ignoreQueryParams: string | null;
        queryParamsExpiresIn: string | null;
        deltaSync: boolean | null;
    } | undefined;
    get deltaSyncControl(): FormControl;
    get retry(): {
        times: number | null;
        delay: number | null;
    } | undefined;
    sampleAdaptors: ({
        label: string;
        value: typeof ClientInfo$1.adapt;
    } | {
        label: string;
        value: typeof AIPrompt$1.adapt;
    })[];
    sampleMappers: ({
        label: string;
        value: typeof ClientInfoMapper$1.adapt;
    } | {
        label: string;
        value: typeof AIPrompt$1.adapt;
    })[];
    get headers(): FormArray;
    get isValid(): boolean;
    arrayObjectsToObjects: (arr: any[]) => any;
    props: (adapter: any) => any;
    constructor();
    ngOnInit(): void;
    onStreamType(type: string): void;
    addHeader(): void;
    removeHeader(index: number): void;
    private parsePathInput;
    private normalizeQueryValue;
    compileRequest(): {
        apiOptions: ApiRequest;
        path: any[];
    };
    private parseIgnoreParams;
    private buildDemoRequestOptions;
    onSetStateOptions(): void;
    onClearRecords(): void;
    deleteDatabase(): void;
    onGetRequest(): void;
    onCreateRequest(): void;
    onUpdateRequest(): void;
    onPatchRequest(): void;
    onDeleteRequest(): void;
    onStreamRequest(): void;
    errorHandling(err: any, type: string): void;
    onSelectAIType(type: number): void;
    onClearHistory(): void;
    onSendWsMessage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RequestManagerStateDemoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerStateDemoComponent, "app-request-manager-state-demo", never, { "server": { "alias": "server"; "required": false; }; "adapter": { "alias": "adapter"; "required": false; }; "mapper": { "alias": "mapper"; "required": false; }; }, {}, never, never, false, never>;
}

declare class RequestManagerDemoComponent implements OnInit {
    server: string;
    adapter?: Function;
    mapper?: Function;
    streamTestServer: string;
    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>;
    PATCH_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>;
    PATCH$?: Observable<any>;
    DELETE$?: Observable<any>;
    STREAM$?: Observable<any>;
    STREAM_AI$?: Observable<any>;
    parallelBatch$?: Observable<any[]>;
    sequentialBatch$?: Observable<any[]>;
    parallelExecutionTime?: number;
    sequentialExecutionTime?: number;
    parallelResults?: any[];
    sequentialResults?: any[];
    isParallelLoading: boolean;
    isSequentialLoading: boolean;
    parallelError?: string;
    sequentialError?: string;
    parallelBatchStates: (BatchRequestState<any> | undefined)[];
    sequentialBatchStates: (BatchRequestState<any> | undefined)[];
    streamBatchStates: (BatchRequestState<any> | undefined)[];
    streamProgress?: BatchProgress;
    streamExecutionTime?: number;
    isStreamLoading: boolean;
    streamError?: string;
    get filteredParallelStates(): BatchRequestState<any>[];
    get filteredSequentialStates(): BatchRequestState<any>[];
    get filteredStreamStates(): BatchRequestState<any>[];
    requestParams: {
        GET: ApiRequest;
        POST: ApiRequest;
        PUT: ApiRequest;
        PATCH: 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;
    };
    sampleClientPatchData: {
        name: string;
        modified: number;
    };
    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>;
        selector: _angular_forms.FormControl<string | 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;
    onPatchRequest(): void;
    onDeleteRequest(): void;
    onStreamPostRequest(): void;
    onStreamRequest(): void;
    onDownloadCompleted(): void;
    onDownloadFailed(err: string): void;
    errorHandling(err: any, type: string): void;
    onSelectAIType(type: number): void;
    /**
     * Execute parallel batch request - fetch 5 users from JSONPlaceholder with individual states
     */
    onExecuteParallelBatch(): void;
    /**
     * Execute sequential batch request - fetch 5 todos from JSONPlaceholder with individual states
     */
    onExecuteSequentialBatch(): void;
    /**
     * Execute stream batch request - fetch 5 posts with real-time state updates
     */
    onExecuteStreamBatch(): void;
    /**
     * Type guard for pending state
     */
    isPendingState(state: BatchRequestState<any>): boolean;
    /**
     * Type guard for success state
     */
    isSuccessState(state: BatchRequestState<any>): boolean;
    /**
     * Type guard for error state
     */
    isErrorState(state: BatchRequestState<any>): boolean;
    /**
     * Helper to create batch requests from IDs
     */
    private createBatchRequests;
    /**
     * Check if result is successful (not undefined)
     */
    isSuccess(result: any): boolean;
    /**
     * Format execution time for display
     */
    formatTime(ms: number): string;
    /**
     * Get success count from results array
     */
    getSuccessCount(results?: any[]): number;
    /**
     * Get failure count from results array
     */
    getFailureCount(results?: any[]): number;
    static ɵfac: i0.ɵɵFactoryDeclaration<RequestManagerDemoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerDemoComponent, "app-request-manager-demo", never, { "server": { "alias": "server"; "required": false; }; "adapter": { "alias": "adapter"; "required": false; }; "mapper": { "alias": "mapper"; "required": false; }; }, {}, never, never, false, never>;
}

interface ClientInfoInterface {
    domain: string;
    service: string;
    id: number;
    name: string;
}
declare class ClientInfo implements ClientInfoInterface {
    domain: string;
    service: string;
    id: number;
    name: string;
    constructor(domain?: string, service?: string, id?: number, name?: string);
    static adapt(item?: any): ClientInfo;
}

interface ClientInfoMapperInterface {
    id: number;
    first_name: string;
    last_name: string;
    email: string;
}
declare class ClientInfoMapper implements ClientInfoMapperInterface {
    id: number;
    first_name: string;
    last_name: string;
    email: string;
    constructor(id?: number, first_name?: string, last_name?: string, email?: string);
    static adapt(item?: any): ClientInfoMapper;
}

interface AIPromptInterface {
    response: string;
}
declare class AIPrompt implements AIPromptInterface {
    response: string;
    constructor(response?: string);
    static adapt(item?: any): AIPrompt;
}

declare class RequestSignalsManagerDemoComponent implements OnInit {
    displayedColumns: string[];
    private fb;
    private toastMessage;
    httpManagerService: HTTPManagerService<any>;
    isPending: i0.WritableSignal<boolean>;
    countdown: i0.WritableSignal<number>;
    GET_result: any;
    POST_result: any;
    PUT_result: any;
    PATCH_result: any;
    DELETE_result: any;
    STREAM_result: any;
    STREAM_AI_result: any;
    GET_error: string;
    POST_error: string;
    PUT_error: string;
    PATCH_error: string;
    DELETE_error: string;
    STREAM_error: string;
    STREAM_AI_error: string;
    requestParams: {
        GET: ApiRequest;
        POST: ApiRequest;
        PUT: ApiRequest;
        PATCH: 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>;
        selector: _angular_forms.FormControl<string | 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;
    onPatchRequest(): 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>;
}

/**
 * StateServiceDemo - Core state management and WebSocket connection service
 *
 * Handles:
 * - WebSocket connection setup
 * - Base HTTP state management
 * - Connection status and retry logic
 */
declare class StateServiceDemo extends HTTPManagerStateService<any> {
    attempts$: rxjs.Observable<number>;
    nextRetry$: rxjs.Observable<number>;
    constructor();
    /**
     * Initialize WebSocket connection with server configuration
     * @param server - Backend server URL
     * @param wsServer - WebSocket server URL
     * @param jwtToken - JWT authentication token
     * @param user - User information
     * @param path - Path for constructing channel name (e.g., ['items'])
     */
    updateConnection(server: string, wsServer: string, jwtToken: string, user: any, path?: (string | number)[]): void;
    /**
     * Get all available channels
     */
    getAllChannels(): void;
    /**
     * Subscribe to a channel
     */
    subscribeToChannel(channel: string): void;
    /**
     * Unsubscribe from a channel
     */
    unsubscribeFromChannel(channel: string): void;
    /**
     * Create a notification channel (MES- prefix)
     */
    createNotificationChannel(channel: string): void;
    /**
     * Get all notification channels list (in-memory)
     */
    getNotificationChannels(): void;
    /**
     * Get today's notification channels from database
     * Returns unique channels that have notifications posted today
     */
    getTodaysNotificationChannels(): void;
    /**
     * Define and load previous day's notification channels from database
     * Creates channels in memory and broadcasts updated list
     */
    definePreviousNotificationChannels(): void;
    /**
     * Subscribe to notification channel with optional date filters
     */
    subscribeToNotificationChannel(channel: string, options?: {
        startEpoch?: number;
        endEpoch?: number;
    }, user?: any): void;
    /**
     * Unsubscribe from notification channel
     */
    unsubscribeFromNotificationChannel(channel: string): void;
    /**
     * Send a notification to a channel
     */
    sendNotification(channel: string, content: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StateServiceDemo, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StateServiceDemo>;
}

/**
 * MessageServiceDemo - Channel messaging service (PUB- prefix channels)
 *
 * Handles:
 * - Sending messages to channels
 * - Channel subscription for messaging
 * - Real-time message broadcast
 */
declare class MessageServiceDemo {
    private stateService;
    channels$: rxjs.Observable<string[] | null>;
    subscribedChannels$: rxjs.Observable<Set<string>>;
    communicationMessages$: rxjs.Observable<any[]>;
    latestCommunicationMessages$: rxjs.Observable<any>;
    connectionStatus$: rxjs.Observable<boolean>;
    user$: rxjs.Observable<WSUser | null>;
    data$: rxjs.Observable<any>;
    /**
     * Helper to ensure channel has PUB- prefix
     */
    private toPublicChannel;
    /**
     * Helper to strip PUB- prefix for display
     */
    private fromPublicChannel;
    /**
     * Create a new public channel
     */
    createChannel(channel: string): void;
    /**
     * Get all available channels
     */
    getAllChannels(): void;
    /**
     * Subscribe to a channel to receive messages
     */
    subscribeToChannel(channel: string): void;
    /**
     * Unsubscribe from a channel
     */
    unsubscribeFromChannel(channel: string): void;
    /**
     * Send a message to one or more channels
     */
    sendMessage(data: ChannelMessage, channels?: string[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageServiceDemo, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MessageServiceDemo>;
}

/**
 * NotificationServiceDemo - Notification channel service (MES- prefix channels)
 *
 * Handles:
 * - Creating notification channels
 * - Subscribing to notifications with date filters
 * - Sending notifications (persisted to database)
 * - Receiving real-time and historical notifications
 */
declare class NotificationServiceDemo {
    private stateService;
    notificationChannels$: rxjs.Observable<string[]>;
    todaysNotificationChannels$: rxjs.Observable<string[]>;
    private subscribedNotificationChannelsSubject;
    subscribedNotificationChannels$: rxjs.Observable<Set<string>>;
    notificationMessages$: rxjs.Observable<any[]>;
    latestNotification$: rxjs.Observable<any>;
    connectionStatus$: rxjs.Observable<boolean>;
    /**
     * Create a notification channel
     * NOTE: MES- prefix is added automatically by HTTPManagerStateService
     */
    createNotificationChannel(channel: string): void;
    /**
     * Get all notification channels (in-memory)
     */
    getNotificationChannels(): void;
    /**
     * Get today's notification channels from database
     * Returns unique channels that have notifications posted today
     */
    getTodaysNotificationChannels(): void;
    /**
     * Define and load previous day's notification channels from database
     * Creates channels in memory and broadcasts updated list
     */
    definePreviousNotificationChannels(): void;
    /**
     * Subscribe to a notification channel with optional date filter
     * NOTE: MES- prefix is added automatically by HTTPManagerStateService
     * @param channel Base channel name (without MES- prefix)
     * @param options { startEpoch?, endEpoch? }
     * @param user User info for subscription
     */
    subscribeToNotificationChannel(channel: string, options?: {
        startEpoch?: number;
        endEpoch?: number;
    }, user?: any): void;
    /**
     * Unsubscribe from a notification channel
     * NOTE: MES- prefix is added automatically by HTTPManagerStateService
     */
    unsubscribeFromNotificationChannel(channel: string): void;
    /**
     * Send a notification to a channel
     * NOTE: MES- prefix is added automatically by HTTPManagerStateService
     */
    sendNotification(channel: string, content: any, user?: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<NotificationServiceDemo, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<NotificationServiceDemo>;
}

declare class RequestManagerWsDemoComponent implements OnInit, OnChanges {
    httpManagerService: HTTPManagerService<any>;
    stateService: StateServiceDemo;
    fb: FormBuilder;
    server: string;
    wsServer: string;
    jwtToken: string;
    user: any;
    path: string[];
    retryCount$: rxjs.Observable<number>;
    maxRetries$: rxjs.Observable<number>;
    connectionStatus$: rxjs.Observable<boolean>;
    isConnecting$: rxjs.Observable<boolean>;
    connectionError$: rxjs.Observable<string | null>;
    data$: rxjs.Observable<any>;
    isPending$: rxjs.Observable<boolean>;
    users$: rxjs.Observable<any[]>;
    user$: rxjs.Observable<WSUser | null>;
    wsServerControl: FormControl<string | null>;
    isUser: (user: any, userItem: any) => boolean;
    getUserLabel: (user: any) => any;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onConnect(): void;
    onDisconnect(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<RequestManagerWsDemoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<RequestManagerWsDemoComponent, "app-request-manager-ws-demo", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; }, {}, never, never, false, never>;
}

declare class SettingsStateService extends StoreStateManagerService {
    constructor();
    updateEnum_1(value: any): void;
    updateEnum_2(value: any): void;
    getEnum(key: string): rxjs.Observable<any>;
    getEnum_1(): rxjs.Observable<any>;
    static ɵfac: i0.ɵɵFactoryDeclaration<SettingsStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<SettingsStateService>;
}

interface CounterStateInterface {
    count: number;
}
declare class CounterState implements CounterStateInterface {
    count: number;
    constructor(count?: number);
    static adapt(item?: any): CounterState;
}

declare class CounterStateService extends StoreStateManagerService<CounterState> {
    constructor();
    increment(): void;
    decrement(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<CounterStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<CounterStateService>;
}

interface TodoListStateInterface {
    items: string[];
}
declare class TodoListState implements TodoListStateInterface {
    items: string[];
    constructor(items?: string[]);
    static adapt(item?: any): TodoListState;
}

declare class TodoListStateService extends StoreStateManagerService<TodoListState> {
    constructor();
    addItem(item: string): void;
    clear(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<TodoListStateService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<TodoListStateService>;
}

declare class StoreStateManagerDemoComponent implements OnInit {
    settingsStateService: SettingsStateService;
    dataState$: rxjs.Observable<any>;
    dataEnum$: rxjs.Observable<any>;
    counterStateService: CounterStateService;
    counterState$: rxjs.Observable<any>;
    todoListStateService: TodoListStateService;
    todoListState$: rxjs.Observable<any>;
    ngOnInit(): void;
    onUpdateEnum_1(): void;
    onUpdateEnum_2(): void;
    onGetEnum_1(): void;
    onIncrement(): void;
    onDecrement(): void;
    onResetCounter(): void;
    onAddTodoItem(item: string): void;
    onClearTodoList(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StoreStateManagerDemoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<StoreStateManagerDemoComponent, "app-store-state-manager-demo", never, {}, {}, never, never, false, never>;
}

interface TableRecord {
    id: number;
    last_name: string;
    age: number;
    amount: number;
}
declare class DatabaseDataDemoComponent implements OnInit, OnDestroy {
    db: DatabaseManagerService;
    sql: DexieSqlService;
    private destroy$;
    dataToDisplay: TableRecord[];
    dataSource: DatabaseDataSource;
    displayedColumns: string[];
    names: string[];
    sqlQuery: string;
    sqlResults: any[];
    sqlResultCols: string[];
    sqlError: string | null;
    sqlLoading: boolean;
    constructor();
    ngOnDestroy(): void;
    addData(): void;
    removeData(): void;
    updateData(): void;
    clearAllData(): void;
    private refreshData;
    ngOnInit(): void;
    createTable(tableDef: TableSchemaDef): Observable<boolean>;
    findTableRecords(table: string, column: string, value: any): Observable<any>;
    findTableRecord(table: string, column: string, value: any): Observable<any>;
    getTableRecords(table: string): Observable<any>;
    getTableRecord(table: string, id: number): Observable<any>;
    createTableRecord<T>(table: string, record: T): Observable<any>;
    updateTableRecord<T>(table: string, record: T): Observable<any>;
    deleteTableRecord<T>(table: string, id: number): Observable<any>;
    runSqlQuery(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseDataDemoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DatabaseDataDemoComponent, "app-database-data-demo", never, {}, {}, never, never, false, never>;
}
declare class DatabaseDataSource extends DataSource<TableRecord> {
    private _dataStream;
    constructor(initialData: TableRecord[]);
    connect(): Observable<TableRecord[]>;
    disconnect(): void;
    setData(data: TableRecord[]): void;
}

declare class StateDataRequestService extends HTTPManagerStateService<any> {
    attempts$: rxjs.Observable<number>;
    nextRetry$: rxjs.Observable<number>;
    path: (string | number)[];
    constructor();
    updateConnection(server: string, wsServer: string, jwtToken: string, user: any, path?: (string | number)[]): void;
    addData(): void;
    sendMessage(data: ChannelMessage): void;
    getData(): void;
    updateData(data: any): void;
    deleteData(data: any): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<StateDataRequestService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<StateDataRequestService>;
}

declare class WsDataControlComponent implements OnInit, OnChanges {
    server: string;
    wsServer: string;
    jwtToken: string;
    user: any;
    path: (string | number)[];
    stateDataRequestService: StateDataRequestService;
    webSocketMessageService: WebSocketMessageService;
    userAction$: rxjs.Observable<any>;
    data$: rxjs.Observable<any>;
    ngOnInit(): void;
    ngOnChanges(changes: SimpleChanges): void;
    onGetData(): void;
    onAddData(): void;
    onUpdateData(data: any[]): void;
    onRemoveData(data: any): void;
    /**
     * Test direct state message via WebSocketMessageService
     * Sends an UPDATE message that should trigger fetchRecord() in the state manager
     *
     * @param recordId - The record ID to update (default: 63)
     * @param useFakeSessionId - If true, uses a fake sessionId to avoid filtering (default: true)
     * @param customSessionId - Optional custom sessionId (overrides useFakeSessionId if provided)
     */
    onTestDirectStateMessage(recordId?: number, useFakeSessionId?: boolean, customSessionId?: string): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsDataControlComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WsDataControlComponent, "app-ws-data-control", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; }, {}, never, never, false, never>;
}

interface SlideInterface {
    title: string;
    message: string;
    image?: string;
    icon?: string;
}
declare class Slide implements SlideInterface {
    title: string;
    message: string;
    image?: string | undefined;
    icon?: string | undefined;
    constructor(title?: string, message?: string, image?: string | undefined, icon?: string | undefined);
    static adapt(item?: any): Slide;
}

interface ActionInterface {
    label: string;
    action: 'close' | 'navigate' | 'callback' | 'custom';
    target?: string;
    callback?: string;
    primary?: boolean;
}
declare class Action implements ActionInterface {
    label: string;
    action: 'close' | 'navigate' | 'callback' | 'custom';
    target?: string | undefined;
    callback?: string | undefined;
    primary?: boolean | undefined;
    constructor(label?: string, action?: 'close' | 'navigate' | 'callback' | 'custom', target?: string | undefined, callback?: string | undefined, primary?: boolean | undefined);
    static adapt(item?: any): Action;
}

type DisplayType = 'snackbar' | 'dialog' | 'carousel' | 'banner' | 'inline';
interface DisplayConfigInterface {
    type: DisplayType;
    supportsMarkdown?: boolean;
    stackable?: boolean;
    queueBehavior?: 'replace' | 'queue' | 'ignore';
    autoDismiss?: number;
    width?: string;
    height?: string;
}
declare class DisplayConfig implements DisplayConfigInterface {
    type: DisplayType;
    supportsMarkdown?: boolean | undefined;
    stackable?: boolean | undefined;
    queueBehavior?: "replace" | "queue" | "ignore" | undefined;
    autoDismiss?: number | undefined;
    width?: string | undefined;
    height?: string | undefined;
    constructor(type?: DisplayType, supportsMarkdown?: boolean | undefined, stackable?: boolean | undefined, queueBehavior?: "replace" | "queue" | "ignore" | undefined, autoDismiss?: number | undefined, width?: string | undefined, height?: string | undefined);
    static adapt(item?: any): DisplayConfig;
}

interface MessageContentInterface {
    displayConfig?: DisplayConfig;
    title?: string;
    message: string;
    slides?: Slide[];
    image?: string;
    images?: string[];
    actions?: Action[];
    messageType?: string;
    icon?: string;
    data?: any;
}
declare class MessageContent implements MessageContentInterface {
    displayConfig?: DisplayConfig | undefined;
    title?: string | undefined;
    message: string;
    slides?: Slide[] | undefined;
    image?: string | undefined;
    images?: string[] | undefined;
    actions?: Action[] | undefined;
    messageType?: string | undefined;
    icon?: string | undefined;
    data?: any | undefined;
    constructor(displayConfig?: DisplayConfig | undefined, title?: string | undefined, message?: string, slides?: Slide[] | undefined, image?: string | undefined, images?: string[] | undefined, actions?: Action[] | undefined, messageType?: string | undefined, icon?: string | undefined, data?: any | undefined);
    static adapt(item?: any): MessageContent;
}
interface CommunicationMessageInterface {
    type: string;
    messageId?: number;
    channel?: string;
    sessionId?: {
        id: string;
    };
    timestamp?: string;
    content: MessageContent;
}
declare class CommunicationMessage implements CommunicationMessageInterface {
    type: string;
    messageId?: number | undefined;
    channel?: string | undefined;
    sessionId?: {
        id: string;
    } | undefined;
    timestamp?: string | undefined;
    content: MessageContent;
    constructor(type?: string, messageId?: number | undefined, channel?: string | undefined, sessionId?: {
        id: string;
    } | undefined, timestamp?: string | undefined, content?: MessageContent);
    static adapt(item?: any): CommunicationMessage;
}

interface IDisplayStrategy {
    name: string;
    canHandle(message: CommunicationMessage): boolean;
    display(message: CommunicationMessage, config: DisplayConfig): void;
}

interface DisplayRuleInterface {
    id: string;
    name?: string;
    match: (message: CommunicationMessage) => boolean;
    display: DisplayConfig;
}
declare class DisplayRule implements DisplayRuleInterface {
    id: string;
    name?: string | undefined;
    match: (message: CommunicationMessage) => boolean;
    display: DisplayConfig;
    constructor(id?: string, name?: string | undefined, match?: (message: CommunicationMessage) => boolean, display?: DisplayConfig);
    static adapt(item?: any): DisplayRule;
}

declare class MessageDisplayRouterService {
    private snackbarStrategy;
    private strategies;
    private rules;
    display(message: CommunicationMessage): void;
    registerStrategies(strategies: IDisplayStrategy[]): void;
    setRules(rules: DisplayRule[]): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<MessageDisplayRouterService, never>;
    static ɵprov: i0.ɵɵInjectableDeclaration<MessageDisplayRouterService>;
}

declare class WsMessagingComponent implements OnInit, OnDestroy {
    server: string;
    wsServer: string;
    jwtToken: string;
    user: any;
    path: (string | number)[];
    private destroy$;
    fb: FormBuilder;
    messageService: MessageServiceDemo;
    stateService: StateServiceDemo;
    messageDisplayService: MessageDisplayRouterService;
    channels$: Observable<string[]>;
    subscribedChannels$: Observable<string[]>;
    user$: Observable<WSUser | null>;
    data$: Observable<any>;
    connectionStatus$: Observable<boolean>;
    newChannelName: FormControl<string | null>;
    messages: _angular_forms.FormGroup<{
        selectedChannels: FormControl<string[] | null>;
        content: FormControl<string | null>;
    }>;
    get selectedChannels(): FormControl;
    get content(): FormControl;
    communicationMessages$: Observable<any[]>;
    latestCommunicationMessages$: Observable<any>;
    chat$: Observable<{
        user: any;
        messages: any[];
    } | any>;
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Create a new public channel without auto-subscribing
     * NOTE: PUB- prefix is added by messageService.createChannel
     */
    onCreateChannel(): void;
    /**
     * Subscribe to a channel to receive messages
     * NOTE: PUB- prefix is added by messageService.subscribeToChannel
     */
    onSubscribeToChannel(channel: string): void;
    /**
     * Unsubscribe from a channel
     * NOTE: PUB- prefix is added by messageService.unsubscribeFromChannel
     */
    onUnsubscribeFromChannel(channel: string): void;
    /**
     * Channels the user has clicked but whose subscribe/unsubscribe confirmation
     * hasn't arrived yet, keyed by channel with the intended (optimistic) selected
     * state. Lets isSubscribed() reflect a click immediately instead of the stale
     * subscribedChannels$ value a change-detection cycle would otherwise re-assert
     * during the server round-trip, which is what caused the chip to visibly
     * flicker back and require repeated clicks.
     */
    private pendingChipSelections;
    /**
     * Handle chip toggle for subscribe/unsubscribe
     */
    onChipToggle(event: any, channel: string): void;
    /**
     * Check if currently subscribed to a channel
     * Compares display names (without PUB- prefix)
     */
    isSubscribed(channel: string, subscribedChannels: string[]): boolean;
    onSendMessage(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsMessagingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WsMessagingComponent, "app-ws-messaging", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; "path": { "alias": "path"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WsNotificationsComponent implements OnInit, OnDestroy {
    server: string;
    wsServer: string;
    jwtToken: string;
    user: any;
    private destroy$;
    fb: FormBuilder;
    notificationService: NotificationServiceDemo;
    stateService: StateServiceDemo;
    todaysNotificationChannels$: rxjs.Observable<string[]>;
    subscribedNotificationChannels$: rxjs.Observable<string[]>;
    notificationMessages$: rxjs.Observable<any[]>;
    connectionStatus$: rxjs.Observable<boolean>;
    /**
     * Helper to ensure channel has MES- prefix for outgoing communication
     */
    private toNotificationChannel;
    newChannelName: FormControl<string | null>;
    selectedConnectionChannel: FormControl<string | null>;
    connectedChannel: string | null;
    displayedColumns: string[];
    dateFilter: _angular_forms.FormGroup<{
        startDate: FormControl<Date | null>;
        endDate: FormControl<Date | null>;
    }>;
    notificationForm: _angular_forms.FormGroup<{
        content: FormControl<string | null>;
    }>;
    get content(): FormControl;
    /**
     * Check if currently connected to a channel
     */
    isChannelConnected(subscribedChannels: string[]): boolean;
    /**
     * Connect to the selected channel
     */
    onConnectToChannel(): void;
    /**
     * Disconnect from the current channel
     */
    onDisconnectFromChannel(): void;
    ngOnInit(): void;
    ngOnDestroy(): void;
    /**
     * Create a new notification channel
     */
    onCreateChannel(): void;
    /**
     * Define and load previous channels
     */
    onDefinePreviousChannels(): void;
    /**
     * Subscribe to a notification channel with optional date filter
     */
    onSubscribeToChannel(channel: string): void;
    /**
     * Unsubscribe from a notification channel
     */
    onUnsubscribeFromChannel(channel: string): void;
    /**
     * Check if currently subscribed to a channel
     */
    isSubscribed(channel: string, subscribedChannels: string[]): boolean;
    /**
     * Handle chip click - toggle subscription state
     */
    onChipClick(channel: string, subscribedChannels: string[]): void;
    /**
     * Send a notification
     */
    onSendNotification(): void;
    /**
     * Format epoch timestamp to readable date/time
     */
    formatTimestamp(epoch: number): string;
    /**
     * Get today's date in YYYY-MM-DD format for date input default
     */
    getTodayDate(): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsNotificationsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WsNotificationsComponent, "app-ws-notifications", never, { "server": { "alias": "server"; "required": false; }; "wsServer": { "alias": "wsServer"; "required": false; }; "jwtToken": { "alias": "jwtToken"; "required": false; }; "user": { "alias": "user"; "required": false; }; }, {}, never, never, false, never>;
}

declare class WsAiMessagingComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsAiMessagingComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WsAiMessagingComponent, "app-ws-ai-messaging", never, {}, {}, never, never, false, never>;
}

declare class WsChatsComponent implements OnInit {
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<WsChatsComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<WsChatsComponent, "app-ws-chats", never, {}, {}, never, never, false, never>;
}

declare class UploadStateModel {
    private readonly stateChanged$;
    private readonly _selectedFiles;
    private readonly _isUploading;
    private readonly _progress;
    private readonly _currentFile;
    private readonly _errorMessage;
    private readonly _successMessage;
    readonly selectedFiles: Signal<File[]>;
    readonly isUploading: Signal<boolean>;
    readonly progress: Signal<number>;
    readonly currentFile: Signal<string | null>;
    readonly errorMessage: Signal<string | null>;
    readonly successMessage: Signal<string | null>;
    readonly selectedFiles$: Observable<File[]>;
    readonly isUploading$: Observable<boolean>;
    readonly progress$: Observable<number>;
    readonly currentFile$: Observable<string | null>;
    readonly errorMessage$: Observable<string | null>;
    readonly successMessage$: Observable<string | null>;
    constructor(selectedFiles?: File[], isUploading?: boolean, progress?: number, currentFile?: string | null, errorMessage?: string | null, successMessage?: string | null);
    static adapt(item?: any): UploadStateModel;
    private toSyncObservable;
    setSelectedFiles(files: File[]): void;
    setUploading(isUploading: boolean): void;
    setProgress(progress: number): void;
    setCurrentFile(currentFile: string | null): void;
    setError(errorMessage: string | null): void;
    setSuccess(successMessage: string | null): void;
    clear(): void;
}

interface FileTypeOptionInterface {
    id: string;
    value: string;
}

declare class UploadDemoComponent implements OnInit, OnDestroy {
    private httpManager;
    uploadState: UploadStateModel;
    fileTypeOptions: FileTypeOptionInterface[];
    acceptedTypeIds: string[];
    maxFileSize: number;
    uploadMode: 'single' | 'multiple';
    ngOnInit(): void;
    ngOnDestroy(): void;
    onUploadModeChange(mode: 'single' | 'multiple'): void;
    onFileSelected(event: Event): void;
    onFileTypesChanged(event: MatSelectionListChange): void;
    validateFile(file: File): string | null;
    getAcceptedTypeLabels(): string;
    clearSelection(): void;
    startUpload(): void;
    getFileSizeString(size: number): string;
    static ɵfac: i0.ɵɵFactoryDeclaration<UploadDemoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<UploadDemoComponent, "lib-upload-demo", never, {}, {}, never, never, false, never>;
}

type DownloadQueueStatus = 'pending' | 'downloading' | 'done' | 'error';
interface DownloadQueueItemInterface {
    url: string;
    fileName: string;
    status: DownloadQueueStatus;
}
declare class DownloadQueueItemModel implements DownloadQueueItemInterface {
    url: string;
    fileName: string;
    status: DownloadQueueStatus;
    constructor(url?: string, fileName?: string, status?: DownloadQueueStatus);
    static adapt(item?: any): DownloadQueueItemModel;
}

declare class DownloadDemoComponent {
    private http;
    singleDownloadRequest: ApiRequest;
    downloadUrls: string[];
    downloadQueue: DownloadQueueItemModel[];
    isDownloadingAll: boolean;
    downloadAllAsZip(): void;
    private fetchQueuedFile;
    private buildZip;
    private saveBlob;
    static ɵfac: i0.ɵɵFactoryDeclaration<DownloadDemoComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DownloadDemoComponent, "lib-download-demo", never, {}, {}, never, never, false, never>;
}

declare class SpinnerComponent implements OnInit {
    color: ThemePalette;
    diameter?: number;
    display?: string | number;
    mode?: ProgressSpinnerMode;
    strokeWidth?: number;
    value: number;
    constructor();
    ngOnInit(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerComponent, "app-spinner", never, { "color": { "alias": "color"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "display": { "alias": "display"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "strokeWidth": { "alias": "strokeWidth"; "required": false; }; "value": { "alias": "value"; "required": false; }; }, {}, never, never, false, never>;
}

declare class DownloadFileComponent implements OnInit {
    private subscriptions;
    event?: Function;
    displayError: number;
    diameter: number;
    mode: ProgressSpinnerMode;
    isPending: boolean;
    active: boolean;
    disabled: boolean;
    error: EventEmitter<void>;
    private _progress;
    set progress(value: any);
    get progress(): any;
    private _hasError;
    private errorTimerActive;
    set hasError(value: boolean | any);
    get hasError(): boolean | any;
    ngOnInit(): void;
    onAction(): void;
    ngOnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<DownloadFileComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<DownloadFileComponent, "app-download-file", never, { "event": { "alias": "event"; "required": false; }; "displayError": { "alias": "displayError"; "required": false; }; "diameter": { "alias": "diameter"; "required": false; }; "mode": { "alias": "mode"; "required": false; }; "isPending": { "alias": "isPending"; "required": false; }; "active": { "alias": "active"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; "progress": { "alias": "progress"; "required": false; }; "hasError": { "alias": "hasError"; "required": false; }; }, { "error": "error"; }, never, never, false, never>;
}

interface DownloadLabelsInterface {
    error: string;
    action: string;
    icon: string;
}
declare class DownloadLabels implements DownloadLabelsInterface {
    error: string;
    action: string;
    icon: string;
    constructor(error?: string, action?: string, icon?: string);
    static adapt(item?: any): DownloadLabelsInterface;
}

declare class FileDownloaderComponent extends HTTPManagerService<any> implements OnInit {
    delayError: number;
    apiRequest: ApiRequest;
    displayErrorMessage: boolean;
    saveFileAs?: string;
    _labels: DownloadLabelsInterface;
    set labels(value: DownloadLabels);
    active: boolean;
    subscription: Subscription;
    get labels(): DownloadLabels;
    completed: EventEmitter<void>;
    failed: EventEmitter<string>;
    disabled: boolean;
    constructor();
    ngOnInit(): void;
    onDownloadStreaming(): Subscription | undefined;
    onError(message: string): void;
    OnDestroy(): void;
    static ɵfac: i0.ɵɵFactoryDeclaration<FileDownloaderComponent, never>;
    static ɵcmp: i0.ɵɵComponentDeclaration<FileDownloaderComponent, "app-file-downloader", never, { "delayError": { "alias": "delayError"; "required": false; }; "apiRequest": { "alias": "apiRequest"; "required": false; }; "displayErrorMessage": { "alias": "displayErrorMessage"; "required": false; }; "saveFileAs": { "alias": "saveFileAs"; "required": false; }; "labels": { "alias": "labels"; "required": false; }; "disabled": { "alias": "disabled"; "required": false; }; }, { "completed": "completed"; "failed": "failed"; }, never, never, false, never>;
}

declare class FileDownloaderModule {
    static ɵfac: i0.ɵɵFactoryDeclaration<FileDownloaderModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<FileDownloaderModule, [typeof SpinnerComponent, typeof DownloadFileComponent, typeof FileDownloaderComponent], [typeof i4.CommonModule, typeof i5.MatIconModule, typeof i6.MatProgressSpinnerModule, typeof i7.MatButtonModule], [typeof FileDownloaderComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<FileDownloaderModule>;
}

declare class HttpRequestManagerModule {
    static forRoot(config?: ConfigOptions): ModuleWithProviders<HttpRequestManagerModule>;
    static ɵfac: i0.ɵɵFactoryDeclaration<HttpRequestManagerModule, never>;
    static ɵmod: i0.ɵɵNgModuleDeclaration<HttpRequestManagerModule, [typeof RequestManagerBasicDemoComponent, typeof HttpRequestServicesDemoComponent, typeof RequestManagerStateDemoComponent, typeof RequestManagerDemoComponent, typeof RequestSignalsManagerDemoComponent, typeof LocalStorageDemoComponent, typeof RequestManagerWsDemoComponent, typeof StoreStateManagerDemoComponent, typeof DatabaseDataDemoComponent, typeof WsDataControlComponent, typeof WsMessagingComponent, typeof WsNotificationsComponent, typeof WsAiMessagingComponent, typeof WsChatsComponent, typeof UploadDemoComponent, typeof DownloadDemoComponent], [typeof i4.CommonModule, typeof i18.ToastMessageDisplayModule, typeof _angular_forms.FormsModule, typeof _angular_forms.ReactiveFormsModule, typeof i7.MatButtonModule, typeof i21.MatTabsModule, typeof i22.MatSelectModule, typeof i23.MatChipsModule, typeof i24.MatMenuModule, typeof i5.MatIconModule, typeof i26.MatListModule, typeof i27.MatTableModule, typeof i28.MatButtonToggleModule, typeof i29.MatAutocompleteModule, typeof i30.MatProgressBarModule, typeof i6.MatProgressSpinnerModule, typeof i32.MatSlideToggleModule, typeof i33.MatDividerModule, typeof i34.MatFormFieldModule, typeof i35.MatInputModule, typeof i36.MatToolbarModule, typeof i32.MatSlideToggleModule, typeof i37.TranslateModule, typeof i38.MatSidenavModule, typeof i39.MatDatepickerModule, typeof i40.MatNativeDateModule, typeof i41.MatCardModule, typeof FileDownloaderModule], [typeof HttpRequestServicesDemoComponent, typeof UploadDemoComponent, typeof DownloadDemoComponent]>;
    static ɵinj: i0.ɵɵInjectorDeclaration<HttpRequestManagerModule>;
}

export { ApiRequest, BatchOptions, BatchResult, CONFIG_SETTINGS_TOKEN, ChannelType, ConfigHTTPOptions, ConfigOptions, DataType, DatabaseDataDemoComponent, DatabaseManagerService, DatabaseStorage, DbService, DexieSqlService, DownloadDemoComponent, ErrorDisplaySettings, ExecutionPlanType, GlobalStoreOptions, HTTPManagerService, HTTPManagerStateService, HeadersService, HttpRequestManagerModule, HttpRequestServicesDemoComponent, InvalidFileInfoModel, LocalStorageDemoComponent, LocalStorageManagerService, LocalStorageOptions, LoggerService, NotificationMessage, OWNS_ERROR_DISPLAY, ObjectMergerService, OperationResultModel, PROXY_CONFIG, ParsingResultModel, PathQueryService, ProxyDebuggerInterceptor, PublicMessage, RandomHSLColor, RandomHexColor, RandomPaletteColor, RandomVisibleColor, RequestErrorInterceptor, RequestHeadersInterceptor, RequestManagerDemoComponent, RequestManagerStateDemoComponent, RequestOptions, RequestService, RetryOptions, SettingOptions, SqlParseError, SqlValidationError, StateMessage, StateOperationResult, StateStorageOptions, StorageData, StorageOption, StorageType, StoreStateManagerService, StreamConfigModel, StreamEventMetadataModel, StreamEventModel, StreamOutputModel, StreamProgressModel, StreamType, TableSchemaDef, UploadDemoComponent, UploadValidationErrorModel, UserData, UtilsService, WSOptions, WebSocketMessageService, WithCredentialsInterceptor, calculateBatchProgress, countdown, createChannelName, delayedRetry, httpRequestManagerInterceptors, isErrorState, isPendingState, isSuccessState, proxyDebuggerInterceptorFn, requestErrorInterceptorFn, requestHeadersInterceptorFn, requestPolling, requestStreaming, streamAI, streamAuto, streamEvents, streamJSON, streamNDJSON, toSyncObservable, withCredentialsInterceptorFn };
export type { APIStateManagerData, ApiRequestInterface, BatchErrorState, BatchOptionsInterface, BatchPendingState, BatchProgress, BatchRequestState, BatchResultInterface, BatchSuccessState, ConfigHTTPOptionsInterface, ConfigOptionsInterface, DatabaseStorageInterface, DexieOp, DexieSqlOptions, ErrorDisplaySettingsInterface, ExecutionPlan, GlobalStoreOptionsInterface, InvalidFileInfoInterface, JoinInfo, LocalStorageOptionsInterface, NotificationMessageInterface, OperationResultInterface, ParseResult, ParsingResultInterface, PlanStep, PublicMessageInterface, RequestOptionsInterface, RetryOptionsInterface, SettingOptionsInterface, State, StateMessageInterface, StateOperationResultInterface, StateStorageOptionsInterface, StateStoreManagerData, StorageDataInterface, StorageOptionInterface, StreamConfigInterface, StreamEventInterface, StreamEventMetadataInterface, StreamOutputInterface, StreamProgressInterface, TableRecord, TableSchemaDefInterface, TableSchemaInfo, UploadValidationErrorInterface, UserDataInterface, ValidatedQuery, WSOptionsInterface };