http-request-manager 15.0.26 → 18.0.1

package/lib/models/config-options.model.d.ts

@@ -0,0 +1,12 @@
+import { ConfigHTTPOptions } from "./config-http-options.model";
+import { LocalStorageOptions } from "./config-local-storage-options.model";
+export interface ConfigOptionsInterface {
+    httpRequestOptions?: ConfigHTTPOptions;
+    LocalStorageOptions?: LocalStorageOptions;
+}
+export declare class ConfigOptions implements ConfigOptionsInterface {
+    httpRequestOptions?: ConfigHTTPOptions | undefined;
+    LocalStorageOptions?: LocalStorageOptions | undefined;
+    constructor(httpRequestOptions?: ConfigHTTPOptions | undefined, LocalStorageOptions?: LocalStorageOptions | undefined);
+    static adapt(item?: any): ConfigOptions;
+}

package/{src/lib/models/config-token.model.ts → lib/models/config-token.model.d.ts}

@@ -1,9 +1,8 @@
 import { InjectionToken } from "@angular/core";
 import { ConfigOptions } from "./config-options.model";
-
 /**
  * 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.
  */
-export const CONFIG_SETTINGS_TOKEN = new InjectionToken<ConfigOptions>('http.config');
+export declare const CONFIG_SETTINGS_TOKEN: InjectionToken<ConfigOptions>;

package/lib/models/data-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum DataType {
+    ANY = 0,
+    ARRAY = 1,
+    OBJECT = 2
+}

package/lib/models/database-storage.model.d.ts

@@ -0,0 +1,10 @@
+export interface DatabaseStorageInterface {
+    table: string;
+    expiresIn: string;
+}
+export declare class DatabaseStorage implements DatabaseStorageInterface {
+    table: string;
+    expiresIn: '';
+    constructor(table: string, expiresIn: '');
+    static adapt(item?: any): DatabaseStorage;
+}

package/lib/models/index.d.ts

@@ -0,0 +1,6 @@
+export * from './database-storage.model';
+export * from './retry-options.model';
+export * from './data-type.enum';
+export * from './config-http-options.model';
+export * from './config-local-storage-options.model';
+export * from './config-options.model';

package/lib/models/retry-options.model.d.ts

@@ -0,0 +1,10 @@
+export interface RetryOptionsInterface {
+    times?: number;
+    delay?: number;
+}
+export declare class RetryOptions implements RetryOptionsInterface {
+    times: number;
+    delay: number;
+    constructor(times?: number, delay?: number);
+    static adapt(item?: any): RetryOptions;
+}

package/lib/services/database-manager-services/database.manager.service.d.ts

@@ -0,0 +1,31 @@
+import { DbService } from './db.storage.service';
+import { TableSchemaDef } from './models/table-schema';
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class DatabaseManagerService extends DbService {
+    constructor();
+    getDatabaseTables(): Observable<string[]>;
+    hasDatabaseTable(table: string): Observable<boolean>;
+    getDatabaseTable(table: string): Observable<any>;
+    getDatabaseTableSchema(table: string): Observable<string[]>;
+    createDatabaseTable(tableDef: TableSchemaDef): Observable<boolean>;
+    updateDatabaseTableSchema(tableDef: TableSchemaDef): void;
+    findTableRecords(table: string, column: string, value: any): void;
+    findTableRecord(table: string, column: string, value: any): void;
+    getTableRecords(table: string): void;
+    getTableRecord(table: string, id: number): void;
+    createTableRecord(table: string, record: any): Observable<any>;
+    createTableRecords(table: string, records: any[]): Observable<{
+        [key: string]: any;
+    }[]>;
+    updateTableRecord(table: string, record: any): Observable<{
+        [key: string]: any;
+    } | null>;
+    updateTableRecords(table: string, records: any[]): Observable<{
+        [key: string]: any;
+    }[]>;
+    deleteTableRecord<T>(table: string, id: number): void;
+    private clean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DatabaseManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DatabaseManagerService>;
+}

package/lib/services/database-manager-services/db.storage.service.d.ts

@@ -0,0 +1,26 @@
+import Dexie, { Table } from 'dexie';
+import * as i0 from "@angular/core";
+export declare class DbService extends Dexie {
+    storageDB: string;
+    db: Dexie;
+    get vr(): number;
+    get nextVr(): number;
+    get getTables(): string[];
+    hasDatabase(): Promise<boolean>;
+    getTable: (table: string) => Table<any, import("dexie").IndexableType> | undefined;
+    tableExists: (table: string) => boolean;
+    constructor();
+    protected updateTable(table: string, find: {
+        key: string;
+        value: string | number;
+    }, data: any): Promise<boolean>;
+    protected createNewDatabase(): Promise<void>;
+    protected createTable(table: string, schema: string): Promise<void>;
+    private create;
+    private updateObjectKeys;
+    protected DBOpened(): Promise<boolean>;
+    private normalizeString;
+    private cleanString;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DbService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DbService>;
+}

package/{src/lib/services/database-manager-services/index.ts → lib/services/database-manager-services/index.d.ts}

@@ -1,4 +1,3 @@
 export * from "./models/table-schema";
-
 export * from "./database.manager.service";
 export * from "./db.storage.service";

package/lib/services/database-manager-services/models/table-schema.d.ts

@@ -0,0 +1,11 @@
+export interface TableSchemaDefInterface {
+    table: string;
+    schema: string;
+}
+export declare class TableSchemaDef implements TableSchemaDefInterface {
+    table: string;
+    schema: string;
+    constructor(table?: string, schema?: string);
+    static adapt(item?: any): TableSchemaDef;
+    static cleanString(str: string): string;
+}

package/{src/lib/services/index.ts → lib/services/index.d.ts}

@@ -1,8 +1,4 @@
-
-// export * from "./database-manager-services/index";
 export * from "./local-storage-manager-service/index";
-
 export * from "./request-manager-services/index";
 export * from "./request-manager-state-service/index";
-
 export * from "./utils/index";

package/lib/services/local-storage-manager-service/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./models/index";
+export * from "./local-storage-manager.service";

package/lib/services/local-storage-manager-service/local-storage-manager.service.d.ts

@@ -0,0 +1,86 @@
+import { OnDestroy } from '@angular/core';
+import { ComponentStore } from '@ngrx/component-store';
+import { UtilsService } from '../utils/utils.service';
+import { SymmetricalEncryptionService } from '../utils/encryption/symmetrical-encryption.service';
+import { StorageOption } from './models';
+import { SettingOptions } from './models/setting-options.model';
+import { StorageData } from './models/storage-data.model';
+import { EncryptionTestService } from '../utils/encryption/encryption-test.service';
+import { AppService } from '../utils/app.service';
+import { ConfigOptions } from '../request-manager-services';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import * as i0 from "@angular/core";
+export interface State {
+    localStores: StorageData[];
+    sessionStores: StorageData[];
+    settings: StorageOption[];
+}
+export declare class LocalStorageManagerService extends ComponentStore<State> implements OnDestroy {
+    private configOptions?;
+    storageName: string;
+    storageSettingsName: string;
+    defaultOptions: SettingOptions;
+    stateRetrieved: boolean;
+    encrypted: boolean;
+    app: AppService;
+    utils: UtilsService;
+    objectMergerService: ObjectMergerService;
+    encryption: SymmetricalEncryptionService;
+    encryptionTest: EncryptionTestService;
+    private readonly data$;
+    readonly stores$: import("rxjs").Observable<StorageOption[]>;
+    readonly storeExists$: (store: string) => import("rxjs").Observable<boolean>;
+    readonly store$: (store: string) => import("rxjs").Observable<any>;
+    readonly settings$: import("rxjs").Observable<StorageOption[]>;
+    readonly setting$: (store: string) => import("rxjs").Observable<StorageOption | null>;
+    persistence$: import("rxjs").Subscription;
+    startTimer(): void;
+    private updateState;
+    constructor(configOptions?: ConfigOptions | undefined);
+    readonly setStore: (observableOrValue: {
+        id: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    } | import("rxjs").Observable<{
+        id: string;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }>) => import("rxjs").Subscription;
+    readonly createStore: (observableOrValue: {
+        id?: string | undefined;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    } | import("rxjs").Observable<{
+        id?: string | undefined;
+        name: string;
+        data: any;
+        options: SettingOptions;
+    }>) => import("rxjs").Subscription;
+    readonly updateStore: (observableOrValue: {
+        name: string;
+        data: any;
+    } | import("rxjs").Observable<{
+        name: string;
+        data: any;
+    }>) => import("rxjs").Subscription;
+    readonly deleteStore: (observableOrValue: {
+        name: string;
+    } | import("rxjs").Observable<{
+        name: string;
+    }>) => import("rxjs").Subscription;
+    resetStore(): void;
+    private persistState;
+    private expired;
+    retrieveState(): void;
+    private isObjectOrArray;
+    private isString;
+    private fixAndParseJSON;
+    private validStoreName;
+    private hasGlobalStorage;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStorageManagerService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStorageManagerService>;
+}

package/lib/services/local-storage-manager-service/models/global-store-options.model.d.ts

@@ -0,0 +1,15 @@
+import { StorageOption } from "./storage-option.model";
+export interface GlobalStoreOptionsInterface {
+    encryption?: boolean;
+    expiresIn?: string;
+    expires?: number;
+    stores: StorageOption[] | null;
+}
+export 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;
+}

package/{src/lib/services/local-storage-manager-service/models/index.ts → lib/services/local-storage-manager-service/models/index.d.ts}

@@ -1,6 +1,5 @@
-export * from "./global-store-options.model"
+export * from "./global-store-options.model";
 export * from "./setting-options.model";
 export * from "./storage-data.model";
 export * from "./storage-option.model";
-
 export * from "./storage-type.enum";

package/lib/services/local-storage-manager-service/models/setting-options.model.d.ts

@@ -0,0 +1,15 @@
+import { StorageType } from "./storage-type.enum";
+export interface SettingOptionsInterface {
+    storage?: StorageType;
+    expires?: number;
+    expiresIn?: string;
+    encrypted?: boolean;
+}
+export 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;
+}

package/lib/services/local-storage-manager-service/models/storage-data.model.d.ts

@@ -0,0 +1,10 @@
+export interface StorageDataInterface {
+    id?: string;
+    data?: any;
+}
+export declare class StorageData implements StorageDataInterface {
+    id?: string | undefined;
+    data?: any;
+    constructor(id?: string | undefined, data?: any);
+    static adapt(item?: any): StorageData;
+}

package/lib/services/local-storage-manager-service/models/storage-option.model.d.ts

@@ -0,0 +1,13 @@
+import { SettingOptions } from "./setting-options.model";
+export interface StorageOptionInterface {
+    id?: string;
+    name: string;
+    options?: SettingOptions;
+}
+export declare class StorageOption implements StorageOptionInterface {
+    id?: string | undefined;
+    name: string;
+    options?: SettingOptions | undefined;
+    constructor(id?: string | undefined, name?: string, options?: SettingOptions | undefined);
+    static adapt(item?: any): StorageOption;
+}

package/lib/services/local-storage-manager-service/models/storage-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum StorageType {
+    GLOBAL = 0,
+    SESSION = 1,
+    DB = 2
+}

package/lib/services/request-manager-services/http-manager.service.d.ts

@@ -0,0 +1,41 @@
+import { Injector } from '@angular/core';
+import { Observable } from 'rxjs';
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import { RequestService } from './request.service';
+import { ToastMessageDisplayService } from 'toast-message-display';
+import { ConfigOptions } from '../../models';
+import { ObjectMergerService } from '../utils/object-merger.service';
+import * as i0 from "@angular/core";
+export declare class HTTPManagerService<T> extends RequestService {
+    private configOptions?;
+    toastMessage: ToastMessageDisplayService;
+    ng_injector: Injector;
+    objectMergerService: ObjectMergerService;
+    private countdown;
+    countdown$: Observable<number>;
+    private error;
+    error$: Observable<boolean>;
+    private data;
+    data$: Observable<any>;
+    private polling$;
+    config: ApiRequest;
+    constructor(configOptions?: ConfigOptions | undefined);
+    getRequest<T>(options?: ApiRequest, params?: any[]): Observable<T>;
+    postRequest<T extends {
+        id?: number | string;
+    }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
+    putRequest<T extends {
+        id?: number | string;
+    }>(data: T, options: ApiRequest, params?: any[]): Observable<T>;
+    deleteRequest<T>(options: ApiRequest, params?: any[]): Observable<T>;
+    downloadRequest<T>(options: ApiRequest, params?: any[], saveAs?: string): Observable<T>;
+    private createObservable;
+    private createRequest;
+    private prepareRequestData;
+    private handleError;
+    private handleErrorWithSnackBar;
+    private stopPolling;
+    private defineReqOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerService<any>, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerService<any>>;
+}

package/{src/lib/services/request-manager-services/index.ts → lib/services/request-manager-services/index.d.ts}

@@ -1,5 +1,3 @@
 export * from "./http-manager.service";
-// export * from './request.service';
-
 export * from "../../models/index";
 export * from "./rxjs-operators/index";

package/lib/services/request-manager-services/request.service.d.ts

@@ -0,0 +1,27 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { ApiRequest } from '../request-manager-state-service/models/api-request.model';
+import * as i0 from "@angular/core";
+export declare class RequestService {
+    private http;
+    private pathQueryService;
+    private headersService;
+    isPending: BehaviorSubject<boolean>;
+    isPending$: Observable<boolean>;
+    progress: BehaviorSubject<number>;
+    progress$: Observable<number>;
+    getRecordRequest<T>(options: ApiRequest): Observable<T>;
+    createRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+    updateRecordRequest<T>(options: ApiRequest, data: any): Observable<T>;
+    deleteRecordRequest<T>(options: ApiRequest): Observable<T>;
+    private buildUrlPath;
+    private buildHeaders;
+    private buildCombinedHeaders;
+    private request;
+    downloadFileRequest(options: ApiRequest): Observable<any>;
+    private handleFinalize;
+    private downloadFile;
+    private createFileType;
+    private combineHeaders;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RequestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RequestService>;
+}

package/lib/services/request-manager-services/rxjs-operators/countdown.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function countdown(duration: number): Observable<number>;

package/lib/services/request-manager-services/rxjs-operators/delay-retry.d.ts

@@ -0,0 +1,2 @@
+import { Observable } from 'rxjs';
+export declare function delayedRetry<T>(delayMs: number, maxRetry?: number): (src: Observable<T>) => Observable<T>;

package/lib/services/request-manager-services/rxjs-operators/request-polling.d.ts

@@ -0,0 +1,7 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+/**
+ * @param pollInterval
+ * @param stopCondition$
+ * @param isPending$
+ */
+export declare function requestPolling<T>(pollInterval: number, stopCondition$: Observable<any>, isPending$: BehaviorSubject<boolean>): (source: Observable<T>) => Observable<T>;

package/lib/services/request-manager-services/rxjs-operators/request-streaming.d.ts

@@ -0,0 +1,2 @@
+import { OperatorFunction } from 'rxjs';
+export declare function requestStreaming(): OperatorFunction<any, any>;

package/lib/services/request-manager-state-service/http-manager-state.store.d.ts

@@ -0,0 +1,51 @@
+import { ComponentStore } from '@ngrx/component-store';
+import { DatabaseStorage } from '../../models/database-storage.model';
+import { HTTPManagerService, DataType } from '../request-manager-services';
+import { ApiRequest, RequestOptions } from './models';
+import * as i0 from "@angular/core";
+export interface APIStateManagerData<T> {
+    data: T[];
+    dataObject: T | null;
+}
+export declare class HTTPManagerStateService<T extends {
+    id: number;
+}> extends ComponentStore<APIStateManagerData<T>> {
+    private apiOptions;
+    private dataType;
+    private database?;
+    httpManagerService: HTTPManagerService<any>;
+    error$: import("rxjs").Observable<boolean>;
+    isPending$: import("rxjs").Observable<boolean>;
+    private page;
+    page$: import("rxjs").Observable<number>;
+    private totalPages;
+    totalPages$: import("rxjs").Observable<number>;
+    private percentage;
+    percentage$: import("rxjs").Observable<number>;
+    private hasDatabase;
+    streamedResponse: never[];
+    constructor(apiOptions: ApiRequest, dataType: DataType | undefined, database?: DatabaseStorage | undefined);
+    setApiRequestOptions(apiOptions?: ApiRequest, dataType?: DataType, database?: DatabaseStorage): void;
+    get ApiRequestOptions(): ApiRequest;
+    initStorage(): void;
+    initializeState(data: any): void;
+    readonly data$: import("rxjs").Observable<T | T[] | null>;
+    readonly selectRecord$: (id: number) => import("rxjs").Observable<T | T[] | null>;
+    private readonly setData$;
+    private updateArrayState;
+    private readonly addData$;
+    private readonly deleteData$;
+    private readonly updateData$;
+    readonly clearRecords: (observableOrValue?: void | import("rxjs").Observable<void> | undefined) => import("rxjs").Subscription;
+    readonly refreshData: (observableOrValue?: void | import("rxjs").Observable<void> | undefined) => import("rxjs").Subscription;
+    readonly fetchRecords: (options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly createRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly updateRecord: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly deleteRecord: (options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly createStream: (data: any | null, options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    readonly fetchStream: (options?: RequestOptions) => ((observableOrValue?: any) => import("rxjs").Subscription) | ((observableOrValue: any) => import("rxjs").Subscription);
+    private isEmpty;
+    private updateRequestOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<HTTPManagerStateService<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HTTPManagerStateService<any>>;
+}

package/{src/lib/services/request-manager-state-service/index.ts → lib/services/request-manager-state-service/index.d.ts}

@@ -1,3 +1,2 @@
 export * from "./http-manager-state.store";
-
 export * from "./models/index";

package/lib/services/request-manager-state-service/models/api-request.model.d.ts

@@ -0,0 +1,27 @@
+import { RetryOptions } from "../../request-manager-services";
+export interface ApiRequestInterface {
+    server: string;
+    path?: any[];
+    headers?: any;
+    adapter?: any;
+    mapper?: any;
+    polling?: number;
+    retry?: RetryOptions;
+    stream?: boolean;
+    displayError?: boolean;
+    saveAs?: string;
+}
+export declare class ApiRequest implements ApiRequestInterface {
+    server: string;
+    path?: any[] | undefined;
+    headers?: any;
+    adapter?: any;
+    mapper?: any;
+    polling?: number | undefined;
+    retry?: RetryOptions | undefined;
+    stream?: boolean | undefined;
+    displayError?: boolean | undefined;
+    saveAs?: string | undefined;
+    constructor(server?: string, path?: any[] | undefined, headers?: any, adapter?: any, mapper?: any, polling?: number | undefined, retry?: RetryOptions | undefined, stream?: boolean | undefined, displayError?: boolean | undefined, saveAs?: string | undefined);
+    static adapt(item?: any): ApiRequest;
+}

package/{src/lib/services/request-manager-state-service/models/index.ts → lib/services/request-manager-state-service/models/index.d.ts}

@@ -1,3 +1,2 @@
 export * from "./api-request.model";
 export * from "./request-options.model";
-

package/lib/services/request-manager-state-service/models/request-options.model.d.ts

@@ -0,0 +1,10 @@
+export interface RequestOptionsInterface {
+    path: any[];
+    headers: any;
+}
+export declare class RequestOptions implements RequestOptionsInterface {
+    path: any[];
+    headers: {};
+    constructor(path?: any[], headers?: {});
+    static adapt(item?: any): RequestOptions;
+}

package/lib/services/utils/app.service.d.ts

@@ -0,0 +1,8 @@
+import * as i0 from "@angular/core";
+export declare class AppService {
+    private id;
+    appID: string;
+    constructor(id: string);
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AppService>;
+}

package/lib/services/utils/encryption/asymmetrical-encryption.service.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export declare class AsymmetricalEncryptionService {
+    constructor();
+    generateKeyPair(modulusLength?: number): Observable<CryptoKeyPair>;
+    encryptData(publicKey: CryptoKey, data: string): Observable<string>;
+    decryptData(privateKey: CryptoKey, encryptedData: string): Observable<string>;
+    pemToArrayBuffer(pem: string): ArrayBuffer;
+    base64ToArrayBuffer(base64: string): ArrayBuffer;
+    arrayBufferToBase64(buffer: ArrayBuffer): string;
+    base64ToPEM(base64Key: string, publicKey?: boolean): string;
+    pemToCryptoKey(pem: string, algorithm: RsaHashedKeyGenParams, extractable: boolean, keyUsages: KeyUsage[], format?: any): Observable<CryptoKey>;
+    testGenerateKeys(): Observable<string>;
+    testDecryptionWithKeys(): Observable<string>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AsymmetricalEncryptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<AsymmetricalEncryptionService>;
+}

package/lib/services/utils/encryption/encryption-test.service.d.ts

@@ -0,0 +1,10 @@
+import * as i0 from "@angular/core";
+export declare class EncryptionTestService {
+    constructor();
+    private isBase64;
+    private isHexadecimal;
+    private hasHighEntropy;
+    isEncrypted(str: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EncryptionTestService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EncryptionTestService>;
+}

package/{src/lib/services/utils/encryption/index.ts → lib/services/utils/encryption/index.d.ts}

@@ -1,5 +1,3 @@
 export * from "./asymmetrical-encryption.service";
 export * from './symmetrical-encryption.service';
-
 export * from './random';
-

package/lib/services/utils/encryption/random.d.ts

@@ -0,0 +1,7 @@
+export declare const Random: () => number;
+export declare const RandomNumber: (min: number, max: number) => number;
+export declare const RandomNumbers: (min: number, max: number, length: number) => number[];
+export declare const RandomNumbersUnique: (min: number, max: number, length: number) => number[];
+export declare const RandomStr: () => string;
+export declare const RandomSignature: () => number;
+export declare const UUID: () => `${string}-${string}-${string}-${string}-${string}`;

package/lib/services/utils/encryption/symmetrical-encryption.service.d.ts

@@ -0,0 +1,14 @@
+import * as i0 from "@angular/core";
+export declare class SymmetricalEncryptionService {
+    appID: string;
+    private appService;
+    constructor();
+    generateCipherKey(): string;
+    encrypt(str: any, key?: string): string | undefined;
+    decrypt(str: string, key?: string): string | undefined;
+    createSignature(url: string, len?: number): string;
+    normalizeURL(url: string): string;
+    generateSignature(url: string): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SymmetricalEncryptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SymmetricalEncryptionService>;
+}

package/lib/services/utils/headers.service.d.ts

@@ -0,0 +1,10 @@
+import { HttpHeaders } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class HeadersService {
+    headers: {};
+    generateHeaders(headers?: Record<string, string>): {
+        headers: HttpHeaders;
+    };
+    static ɵfac: i0.ɵɵFactoryDeclaration<HeadersService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<HeadersService>;
+}

package/{src/lib/services/utils/index.ts → lib/services/utils/index.d.ts}

@@ -2,6 +2,4 @@ export * from './app.service';
 export * from './headers.service';
 export * from './path-query.service';
 export * from './utils.service';
-
 export * from './encryption/index';
-

package/lib/services/utils/object-merger.service.d.ts

@@ -0,0 +1,12 @@
+import { ApiRequest } from '../request-manager-state-service/models';
+import { SettingOptions } from '../local-storage-manager-service';
+import { ConfigOptions } from '../request-manager-services';
+import * as i0 from "@angular/core";
+export declare class ObjectMergerService {
+    private configOptions?;
+    constructor(configOptions?: ConfigOptions | undefined);
+    mergeOptions(options?: ApiRequest): ApiRequest;
+    mergeStorageOptions(options?: SettingOptions): SettingOptions;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ObjectMergerService, [{ optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ObjectMergerService>;
+}

package/lib/services/utils/path-query.service.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export 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>;
+}