nuxeo-development-framework 5.6.4 → 5.6.5

package/lib/shared/components/spinner/spinner.component.d.ts

@@ -0,0 +1,18 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Basic Loading spinner component to be used in lists when loading data
+ * @title
+ * Spinner Component
+ * @example
+ *
+ * <ng-container *ngIf="loading">
+ *   <cts-spinner></cts-spinner>
+ * </ng-container>
+ */
+export declare class SpinnerComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SpinnerComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<SpinnerComponent, "cts-spinner", never, {}, {}, never, never>;
+}

package/lib/shared/components/user-card/user-card.component.d.ts

@@ -0,0 +1,30 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * reusable user card component
+ * @title
+ * User Card
+ * @example
+ *
+ * <app-user-card [user]="NuxeoUserObject">
+ *   <div class="lineOne">
+ *     Content of card first line
+ *   </div>
+ *   <div class="lineOnePart2">
+ *     Content of card first line second part
+ *   </div>
+ *   <div class="lineTwo">
+ *     Content of card second line
+ *   </div>
+ * </app-user-card>
+ */
+export declare class UserCardComponent implements OnInit {
+    /** Nuxeo user object */
+    user: any;
+    /** @deprecated diameter of avatar */
+    diameter: any;
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserCardComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<UserCardComponent, "app-user-card", never, { "user": "user"; "diameter": "diameter"; }, {}, never, [".lineOne", ".lineOnePart2 ", ".lineTwo "]>;
+}

package/lib/shared/constants/editor-config-type.d.ts

@@ -0,0 +1,4 @@
+export declare const NDF_EDITOR_TYPE: {
+    readonly REPORTS: "report";
+    readonly TABLES: "table";
+};

package/lib/shared/constants/index.d.ts

@@ -0,0 +1 @@
+export * from './editor-config-type';

package/lib/shared/directives/copy-to-clipboard.directive.d.ts

@@ -0,0 +1,15 @@
+import { Clipboard } from '@angular/cdk/clipboard';
+import * as i0 from "@angular/core";
+export declare class CopyToClipboardDirective {
+    private clipboard;
+    textToCopy: string;
+    constructor(clipboard: Clipboard);
+    onClick(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopyToClipboardDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<CopyToClipboardDirective, "[appCopyToClipboard]", never, { "textToCopy": "appCopyToClipboard"; }, {}, never>;
+}
+export declare class CopyToClipboardModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<CopyToClipboardModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CopyToClipboardModule, [typeof CopyToClipboardDirective], never, [typeof CopyToClipboardDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<CopyToClipboardModule>;
+}

package/lib/shared/directives/element-height.directive.d.ts

@@ -0,0 +1,28 @@
+import { AfterViewInit, ElementRef, NgZone, OnDestroy, Renderer2 } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export declare class ElementHeightDirective implements AfterViewInit, OnDestroy {
+    private renderer;
+    private elementRef;
+    private ngZone;
+    cssVar: string;
+    calculate: boolean;
+    private _inlineStyle;
+    get inlineStyle(): boolean;
+    set inlineStyle(value: boolean);
+    private _domElement;
+    private _resizeListener;
+    constructor(renderer: Renderer2, elementRef: ElementRef, ngZone: NgZone);
+    ngAfterViewInit(): void;
+    private onResize;
+    private setHeight;
+    static ngAcceptInputType_inlineStyle: BooleanInput;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementHeightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ElementHeightDirective, "[appItemHeight]", ["appItemHeight"], { "cssVar": "cssVar"; "calculate": "calculate"; "inlineStyle": "inlineStyle"; }, {}, never>;
+}
+export declare class ElementHeightModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<ElementHeightModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<ElementHeightModule, [typeof ElementHeightDirective], never, [typeof ElementHeightDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<ElementHeightModule>;
+}

package/lib/shared/directives/fluid-height.directive.d.ts

@@ -0,0 +1,37 @@
+import { AfterViewInit, ElementRef, NgZone, OnDestroy, Renderer2 } from '@angular/core';
+import { BooleanInput } from '@angular/cdk/coercion';
+import * as i0 from "@angular/core";
+export declare class FluidHeightDirective implements AfterViewInit, OnDestroy {
+    private renderer;
+    private elementRef;
+    private ngZone;
+    minHeight: number;
+    topOffset: number;
+    subtractItems: string[];
+    decrease: number;
+    delay: number;
+    cssVar: string;
+    calculate: boolean;
+    private _inlineStyle;
+    get inlineStyle(): boolean;
+    set inlineStyle(value: boolean);
+    private _domElement;
+    private _animationId?;
+    private _resizeListener;
+    constructor(renderer: Renderer2, elementRef: ElementRef, ngZone: NgZone);
+    ngAfterViewInit(): void;
+    scheduleSetHeight(delay?: number): void;
+    private onResize;
+    private setHeight;
+    private _getSelectorHeight;
+    private _calcTopOffset;
+    static ngAcceptInputType_inlineStyle: BooleanInput;
+    ngOnDestroy(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FluidHeightDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<FluidHeightDirective, "[ndfFluidHeight]", ["ndfFluidHeight"], { "minHeight": "minHeight"; "topOffset": "ndfFluidHeight"; "subtractItems": "subtractItems"; "decrease": "decrease"; "delay": "delay"; "cssVar": "cssVar"; "calculate": "calculate"; "inlineStyle": "inlineStyle"; }, {}, never>;
+}
+export declare class FluidHeightModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<FluidHeightModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<FluidHeightModule, [typeof FluidHeightDirective], never, [typeof FluidHeightDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<FluidHeightModule>;
+}

package/lib/shared/evaluator/evaluator.d.ts

@@ -0,0 +1,79 @@
+import { EvaluatorOptions, TemplateSettings } from './types';
+/**
+ * A utility class for evaluating expressions, interpolating strings, and working with templates.
+ * This class provides static methods for dynamic evaluation of code, string interpolation,
+ * and template processing with caching capabilities.
+ */
+export declare class Evaluator {
+    /**
+     * Cache for storing compiled template functions to improve performance.
+     * Keys are string hashes of the template, values are the compiled functions.
+     */
+    static cache: Record<string, Function>;
+    /**
+     * Settings for template processing, defining regex patterns for different template operations.
+     * - interpolate: Pattern for variable interpolation ({{ variable }})
+     * - evaluate: Pattern for code evaluation ({% code %})
+     * - escape: Pattern for HTML escaping ({{{ variable }}})
+     */
+    static templateSettings: TemplateSettings;
+    /**
+     * Creates a function from a string or returns the function if already provided.
+     * Uses a secure context to prevent access to the window object by default.
+     * @param {string|Function} func - The function or string to convert to a function.
+     * @param {...any} params - The parameters to pass to the function.
+     * @param {EvaluatorOptions} [options={}] - Optional configuration for the evaluation.
+     * @returns {Function} - The resulting function.
+     */
+    static evaluator(func: string | Function, ...params: any[]): Function;
+    /**
+     * Replaces template expressions in a string with values from data.
+     * Supports function calls within templates and fallback values using || syntax.
+     * By default, ensures evaluation happens in a secure context to prevent access to window object.
+     * @param {string} rawTemplate - The template string containing expressions to interpolate.
+     * @param {Record<string, any>} data - The data object containing values to use for interpolation.
+     * @param {EvaluatorOptions} [options={}] - Optional configuration for the interpolation process.
+     * @returns {string} - The interpolated string with all expressions replaced with actual values.
+     */
+    static interpolateString(rawTemplate: string, data: Record<string, any>, options?: EvaluatorOptions): string;
+    /**
+     * Performs an evaluation using the evaluation context of this component.
+     * By default, ensures evaluation happens in a secure context to prevent access to window object.
+     * @param {string|Function|object} func - The function or string to evaluate.
+     * @param {object} args - The arguments to pass to the evaluation.
+     * @param {string} ret - The name of the variable within the evaluation context to return.
+     * @param {boolean} interpolate - Determines if it should replace all {{ }} token references with actual data.
+     * @param {object} context -   - The evaluation context.
+     * @param {EvaluatorOptions } options - The options to pass to the evaluation.
+     * @returns {*} - The result of the evaluation.
+     */
+    static evaluate(func: any, args?: Record<string, any>, ret?: string, interpolate?: boolean, context?: Record<string, any>, options?: EvaluatorOptions): any;
+    /**
+     * Executes a function with provided arguments and context.
+     * By default, ensures execution happens in a secure context to prevent access to window object.
+     * @param {Function} func - The function to execute.
+     * @param {any[]|Record<string, any>} args - The arguments to pass to the function, either as an array or object.
+     * @param {Record<string, any>} [context={}] - The context (this) to use when executing the function.
+     * @param {EvaluatorOptions} [options={}] - Optional configuration for the execution.
+     * @returns {any} - The result of the function execution.
+     */
+    static execute(func: Function, args: any[] | Record<string, any>, context?: Record<string, any>, options?: EvaluatorOptions): any;
+    /**
+     * Creates a template function from a string with caching for performance.
+     * By default, ensures the template function executes in a secure context.
+     * @param {string} template - The template string to compile into a function.
+     * @param {string} [hash] - Optional hash to use as cache key. If not provided, a hash will be generated from the template.
+     * @param {EvaluatorOptions} [options={}] - Optional configuration for the template.
+     * @returns {Function|undefined} - The compiled template function, or undefined if compilation fails.
+     */
+    static template(template: string, hash?: string, options?: EvaluatorOptions): Function | undefined;
+    /**
+     * Interpolates a template with data, handling both function templates and string templates.
+     * By default, ensures interpolation happens in a secure context to prevent access to window object.
+     * @param {string|Function} rawTemplate - The template to interpolate, either as a string or a function.
+     * @param {Record<string, any>} data - The data object to use for interpolation.
+     * @param {EvaluatorOptions} options - Options for the interpolation process.
+     * @returns {string|any} - The result of the interpolation, typically a string but could be any type depending on the template.
+     */
+    static interpolate(rawTemplate: string | Function, data: Record<string, any>, options?: EvaluatorOptions): string | any;
+}

package/lib/shared/evaluator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './evaluator';
+export * from './types';

package/lib/shared/evaluator/types.d.ts

@@ -0,0 +1,18 @@
+export declare type EvaluatorOptions = {
+    data?: Record<string, any>;
+    /**
+     * Controls the security level of evaluation.
+     * - 'secure' (default): Prevents access to window object and other global objects
+     * - 'unsafe': Allows access to all global objects (use with caution)
+     */
+    securityMode?: 'secure' | 'unsafe';
+};
+export declare type TemplateSettings = {
+    interpolate: RegExp;
+    evaluate: RegExp;
+    escape: RegExp;
+};
+export declare type InterpolateString = `${string}{{${string | number}}}${string}`;
+export declare type EvaluatedString<VAR extends string = 'show'> = `${string}${VAR}${Whitespace}=${Whitespace}${string}`;
+declare type Whitespace = '' | ' ' | `${any}`;
+export {};

package/lib/shared/index.d.ts

@@ -0,0 +1,7 @@
+export * from './directives';
+export * from './services';
+export * from './components';
+export * from './models';
+export * from './libraryShared.module';
+export * from './evaluator';
+export * from './constants';

package/lib/shared/libraryShared.module.d.ts

@@ -0,0 +1,29 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./components/read-more/read-more.component";
+import * as i2 from "./components/user-card/user-card.component";
+import * as i3 from "./components/button/button.component";
+import * as i4 from "./components/no-data/no-data.component";
+import * as i5 from "./components/spinner/spinner.component";
+import * as i6 from "./components/item-list/item-list.component";
+import * as i7 from "../components/avatar/avatar.module";
+import * as i8 from "@angular/common";
+import * as i9 from "@angular/router";
+import * as i10 from "@ngx-translate/core";
+import * as i11 from "@angular/material/progress-spinner";
+import * as i12 from "@angular/material/icon";
+import * as i13 from "@angular/material/list";
+import * as i14 from "@angular/material/menu";
+import * as i15 from "angular-ng-autocomplete";
+import * as i16 from "../directive/directive.module";
+import * as i17 from "@angular/material/tooltip";
+import * as i18 from "./directives/fluid-height.directive";
+import * as i19 from "./directives/element-height.directive";
+/**
+ * @title
+ * Shared UI Components
+ */
+export declare class LibrarySharedModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<LibrarySharedModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LibrarySharedModule, [typeof i1.ReadMoreComponent, typeof i2.UserCardComponent, typeof i3.ButtonComponent, typeof i4.NoDataComponent, typeof i5.SpinnerComponent, typeof i6.ItemListComponent], [typeof i7.AvatarModule, typeof i8.CommonModule, typeof i9.RouterModule, typeof i10.TranslateModule, typeof i11.MatProgressSpinnerModule, typeof i12.MatIconModule, typeof i13.MatListModule, typeof i14.MatMenuModule, typeof i15.AutocompleteLibModule, typeof i16.DirectiveModule, typeof i17.MatTooltipModule, typeof i18.FluidHeightModule, typeof i19.ElementHeightModule], [typeof i2.UserCardComponent, typeof i1.ReadMoreComponent, typeof i10.TranslateModule, typeof i3.ButtonComponent, typeof i4.NoDataComponent, typeof i5.SpinnerComponent, typeof i6.ItemListComponent, typeof i18.FluidHeightModule, typeof i19.ElementHeightModule]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LibrarySharedModule>;
+}

package/lib/shared/models/index.d.ts

@@ -0,0 +1,5 @@
+export * from './mapper/index';
+export * from './nuxeo-response.model';
+export * from './task.model';
+export * from './ndf-request.model';
+export * from './type-helpers';

package/lib/shared/models/mapper/nuxeo-mapper.d.ts

@@ -0,0 +1,8 @@
+export declare class NuxeoMapper {
+    static schemaToModel<Schemas extends Record<string, any>>(properties: Record<string, any>): {
+        [K in keyof Schemas]: Schemas[K];
+    };
+    static modelToSchema<Schemas extends Record<string, any>>(model: {
+        [K in keyof Schemas]: Schemas[K];
+    }): Record<string, any>;
+}

package/lib/shared/models/ndf-request.model.d.ts

@@ -0,0 +1,7 @@
+export declare type NdfRequestModel = {
+    method: 'post' | 'get' | 'put' | 'delete';
+    url: string;
+    payload?: Record<string, any>;
+    params?: Record<string, any>;
+    headers?: Record<string, any>;
+};

package/lib/shared/models/nuxeo-response.model.d.ts

@@ -0,0 +1,61 @@
+export declare const ENTITY_TYPE = "entity-type";
+export interface NuxeoQuickFilter {
+    name: string;
+    active: boolean;
+}
+export interface NuxeoPagination<T> {
+    [ENTITY_TYPE]: string;
+    isPaginable: boolean;
+    resultsCount: number;
+    pageSize: number;
+    maxPageSize: number;
+    resultsCountLimit: number;
+    currentPageSize: number;
+    currentPageIndex: number;
+    currentPageOffset: number;
+    numberOfPages: number;
+    isPreviousPageAvailable: boolean;
+    isNextPageAvailable: boolean;
+    isLastPageAvailable: boolean;
+    isSortable: boolean;
+    hasError: boolean;
+    errorMessage: string | null;
+    totalSize: number;
+    pageIndex: number;
+    pageCount: number;
+    quickFilters: NuxeoQuickFilter[];
+    aggregations?: Record<string, any>;
+    entries: T[];
+}
+export interface NuxeoResponse {
+    [ENTITY_TYPE]: string;
+    entries: Entity[];
+}
+export declare type Entity = {
+    [ENTITY_TYPE]: string;
+    repository?: string;
+    uid?: string;
+    path?: string;
+    type?: string;
+    state?: string;
+    parentRef?: string | null;
+    isCheckedOut?: boolean;
+    isRecord?: boolean;
+    retainUntil?: string | null;
+    hasLegalHold?: boolean;
+    isUnderRetentionOrLegalHold?: boolean;
+    isVersion?: boolean;
+    isProxy?: boolean;
+    changeToken?: string;
+    contextParameters?: Record<string, any>;
+    isTrashed?: boolean;
+    title?: string;
+    lastModified?: string;
+    properties?: Record<string, any>;
+    facets?: string[];
+    schemas?: Schema[];
+};
+export interface Schema {
+    name: string;
+    prefix: string;
+}

package/lib/shared/models/task.model.d.ts

@@ -0,0 +1,71 @@
+import { Entity, ENTITY_TYPE } from './nuxeo-response.model';
+export interface Task {
+    [ENTITY_TYPE]?: string;
+    id?: string;
+    name?: string;
+    workflowInstanceId?: string;
+    workflowModelName?: string;
+    workflowInitiator?: string;
+    workflowTitle?: string;
+    workflowLifeCycleState?: string;
+    graphResource?: string;
+    state?: string;
+    directive?: any;
+    created?: string;
+    dueDate?: string;
+    nodeName?: string;
+    targetDocumentIds?: Entity[];
+    actors?: Actor[];
+    delegatedActors?: any[];
+    comments?: any[];
+    variables?: Record<string, any>;
+    taskInfo?: TaskInfo;
+    workflowInitiatorDetails?: WorkflowInitiatorDetails;
+    actorsDetails?: Record<string, any>[];
+    customTaskVariables?: Record<string, any>;
+    workflowVariables?: Record<string, any>;
+}
+export interface Actor {
+    id?: string;
+    [ENTITY_TYPE]?: string;
+    properties?: BaseProperties;
+    extendedGroups?: any[];
+    isPartial?: boolean;
+    isAdministrator?: boolean;
+    isAnonymous?: boolean;
+    birthdate?: any;
+    phonenumber?: any;
+    avatar?: any;
+    userGroups?: BaseModel[];
+    fullName?: string;
+}
+export interface WorkflowInitiatorDetails {
+    properties?: BaseProperties;
+    fullName?: string;
+    birthdate?: any;
+    phonenumber?: any;
+    avatar?: any;
+}
+export interface TaskInfo {
+    allowTaskReassignment?: boolean;
+    taskActions?: BaseModel[];
+    layoutResource?: BaseModel;
+    schemas?: BaseModel[];
+}
+interface BaseModel {
+    name?: string;
+    url?: string;
+    label?: string;
+    validate?: boolean;
+}
+interface BaseProperties {
+    firstName?: string;
+    lastName?: string;
+    jobTitle?: any;
+    tenantId?: any;
+    groups?: string[];
+    company?: any;
+    email?: string;
+    username?: string;
+}
+export {};

package/lib/shared/models/type-helpers.d.ts

@@ -0,0 +1,10 @@
+export declare type StringOrNumber = string | number;
+export declare type StrictOmit<K, T extends keyof K> = Omit<K, T>;
+export declare type LocalizedValue = {
+    ar: string;
+    en: string;
+};
+export declare type Prettify<T> = {
+    [k in keyof T]: T[k];
+} & {};
+export declare type TranslateKey = string;

package/lib/shared/services/base/base-editor-config.service.d.ts

@@ -0,0 +1,33 @@
+import { BaseService } from './base.service';
+import { AppConfigService } from '../../../configuration/app-config.service';
+import { Observable } from 'rxjs';
+import { Injector } from '@angular/core';
+import { NDF_EDITOR_TYPE } from '../../constants';
+import * as i0 from "@angular/core";
+export declare type ConfigType = (typeof NDF_EDITOR_TYPE)[keyof typeof NDF_EDITOR_TYPE];
+export interface ConfigResponseModel {
+    submitted: boolean;
+    uid?: string;
+    data: {
+        key: string;
+        type: string;
+        app?: string;
+        config: Record<string, any>;
+    };
+}
+export interface ConfigRequestModel {
+    key: string;
+    type: ConfigType;
+    app?: string;
+    localPath?: string;
+}
+export declare class BaseEditorConfigService extends BaseService {
+    injector: Injector;
+    protected appConfigService: AppConfigService;
+    constructor(injector: Injector);
+    fetchData({ key, type, app, localPath, }: ConfigRequestModel): Observable<ConfigResponseModel>;
+    private _getDataFromLocal;
+    private _parseData;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseEditorConfigService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseEditorConfigService>;
+}

package/lib/shared/services/base/base.service.d.ts

@@ -0,0 +1,30 @@
+import { Injector } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { CachedFullHttpOptions, CachedFullQueryOptions, CachedHttpOptions, CachedQueryOptions, OperationOptions, QueryOptions, RequestOptions } from './models';
+import { HttpBaseService } from './http-base.service';
+import { AdapterService } from '../../../core/adapters/adapter.service';
+import * as i0 from "@angular/core";
+export declare abstract class BaseService extends HttpBaseService {
+    #private;
+    protected adapterService: AdapterService;
+    protected translateService: TranslateService;
+    get user(): any;
+    get userName(): any;
+    constructor(injector: Injector);
+    protected automation<TResponse = unknown>(operationOrOptions: string | OperationOptions, input?: string, params?: any, context?: any, headers?: any, isCustomAutomation?: boolean): Observable<TResponse>;
+    protected customAutomation<TResponse = unknown>(operationOrOptions: string | OperationOptions, input?: string, params?: any, context?: any, headers?: any): Observable<TResponse>;
+    protected request<TResponse>(endpointOrOptions: string | RequestOptions, queryParams?: any, headers?: any, payload?: any, type?: string): Observable<TResponse>;
+    protected query<TResponse>(pageProviderOrOptions: string | QueryOptions, params?: any, headers?: any): Observable<TResponse>;
+    protected hasItemInCache(key: string): boolean;
+    protected validateTTLForKey(firstFetchingDate: string): boolean;
+    protected cachedQuery<TResponse>(options: CachedQueryOptions | CachedFullQueryOptions): Observable<TResponse>;
+    protected cachedGet<TResponse>(options: CachedHttpOptions | CachedFullHttpOptions): Observable<TResponse>;
+    protected fetch<TResponse>(path: string, headers?: any): Observable<TResponse>;
+    token(): Promise<string>;
+    isUserInRole(role: string): Observable<any>;
+    doLogout(): void;
+    getDuplicates(params?: {}, body?: {}): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseService>;
+}

package/lib/shared/services/base/cache-base.service.d.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import { BaseCacheOptions } from './models';
+import { UserPreferencesService } from '../../../core/services/user/user-preferences.service';
+import { UtilityService } from '../../../core/utilities/utility.service';
+import * as i0 from "@angular/core";
+export declare class CacheBaseService {
+    #private;
+    private userPreferencesService;
+    private utilityService;
+    constructor(userPreferencesService: UserPreferencesService, utilityService: UtilityService);
+    hasItem(cacheKey: string): boolean;
+    clearAll(userName: string): void;
+    validateTTL(userName: string): void;
+    startFetchingItems(options: BaseCacheOptions): Observable<any>;
+    validateTTLForKey(firstFetchingDate: string): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CacheBaseService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CacheBaseService>;
+}

package/lib/shared/services/base/config/default-ttl-config.d.ts

@@ -0,0 +1,9 @@
+import { CachingExpiryUnit } from '../models';
+export declare const DEFAULT_TTL_CONFIG: {
+    TTL: number;
+    UNIT: CachingExpiryUnit;
+    AUTO_CHECK: boolean;
+    RETRY: number;
+    QUICK_REFRESH: number;
+    QUICK_REFRESH_UNIT: CachingExpiryUnit;
+};

package/lib/shared/services/base/constants/default-cache-options.d.ts

@@ -0,0 +1,17 @@
+export declare const DEFAULT_CACHE_OPTIONS: {
+    PREFIX: string;
+    PAGE_KEY: string;
+    TOTAL_PAGE_KEY: string;
+    RESULTS_COUNT_KEY: string;
+    MAPPED_DATA_KEY: string;
+    UNIQUE_COMPARE_KEY: string;
+    MIN_COMPARE_DATE_KEY: string;
+    LAST_MODIFIED_KEY: string;
+    LAST_MODIFIED_PATH: string;
+    EXCLUDE_KEYS_WHEN_UPDATE: string[];
+    CHILDREN_PATH: string;
+    PARENT_KEY: string;
+    ENABLE_QUICK_REFRESH: boolean;
+    REQUEST: () => import("rxjs").Observable<unknown>;
+    PREPARE_DATA: (result: Array<Record<string, any>>) => Array<Record<string, any>>;
+};

package/lib/shared/services/base/http-base.service.d.ts

@@ -0,0 +1,17 @@
+import { HttpRequest } from '@angular/common/http';
+import { Injector } from '@angular/core';
+import { Observable, OperatorFunction } from 'rxjs';
+import { HttpOptions } from './models';
+export declare abstract class HttpBaseService {
+    #private;
+    get environment(): import("../../../core/env/env-manager").Environment;
+    constructor(injector: Injector);
+    protected httpRequest<TBody, TResponse>(req: HttpRequest<TBody>): Observable<import("@angular/common/http").HttpEvent<TResponse>>;
+    protected get<TResponse>(endpointOrOptions: string | HttpOptions, params?: any, headers?: any, responseType?: any): Observable<TResponse>;
+    protected post<TResponse>(endpointOrOptions: string | HttpOptions, payload?: any, params?: any, headers?: any, responseType?: any): Observable<TResponse>;
+    protected put<TResponse>(endpointOrOptions: string | HttpOptions, payload?: any, params?: any, headers?: any, responseType?: any): Observable<TResponse>;
+    protected patch<TResponse>(endpointOrOptions: string | HttpOptions, payload?: any, params?: any, headers?: any, responseType?: any): Observable<TResponse>;
+    protected delete<TResponse>(endpointOrOptions: string | HttpOptions, params?: any, headers?: any, responseType?: any): Observable<TResponse>;
+    protected httpAutomation<TResponse = unknown>(endpoint: string, payload?: any, responseType?: any): Observable<TResponse>;
+    protected catchErrors<TResponse>(): OperatorFunction<TResponse, TResponse>;
+}

package/lib/shared/services/base/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base.service';
+export * from './models/index';
+export * from './base-editor-config.service';

package/lib/shared/services/base/models/cache-info-model.d.ts

@@ -0,0 +1,50 @@
+import { Observable, Subject } from 'rxjs';
+import { HttpOptions, QueryOptions } from '../..';
+declare type RequestFunctionType = (...params: any[]) => Observable<any>;
+declare type PrepareDataBeforeCachingType = (result: Array<Record<string, any>>) => Array<Record<string, any>>;
+export declare enum CachingExpiryUnit {
+    YEARS = "years",
+    MONTHS = "months",
+    WEEKS = "weeks",
+    DAYS = "days",
+    HOURS = "hours",
+    MINUTES = "minutes",
+    SECONDS = "seconds",
+    MILLI_SECONDS = "milliseconds"
+}
+interface BaseOption {
+    cacheKey: string;
+    prepareDataBeforeCaching: PrepareDataBeforeCachingType;
+    inMemory?: boolean;
+    enableQuickRefresh?: boolean;
+}
+export declare type CachedQueryOptions = {} & BaseOption & QueryOptions;
+export declare type CachedHttpOptions = {} & BaseOption & HttpOptions;
+export declare type CachedFullQueryOptions = {} & CachedQueryOptions & BaseCacheOptions;
+export declare type CachedFullHttpOptions = {} & CachedHttpOptions & BaseCacheOptions;
+export declare type BaseCacheOptions = {
+    userName: string;
+    request: RequestFunctionType;
+    pageKey?: string;
+    totalPageKey?: string;
+    resultsCount?: string;
+    mappedDataKey?: string;
+    uniqueCompareKey?: string;
+    minCompareDateKey?: string;
+    lastModifiedDateKey?: string;
+    lastModifiedDatePath?: string;
+    excludeKeysWhenUpdate?: string[];
+    childrenPath?: string;
+    parentKey?: string;
+} & BaseOption;
+export interface CacheInfo {
+    data: Array<Record<string, any>>;
+    firstFetchingDate: string;
+    lastModifiedDate: string;
+    resultsCount: number;
+    fetchingItemsFromTheServer: boolean;
+    onFinishFetching: Subject<any>;
+    request?: RequestFunctionType;
+    params?: Record<string, any>;
+}
+export {};

package/lib/shared/services/base/models/http-options.model.d.ts

@@ -0,0 +1,7 @@
+export interface HttpOptions {
+    endpoint: string;
+    payload?: any;
+    params?: any;
+    headers?: any;
+    responseType?: any;
+}