nuxeo-development-framework 0.0.2 → 0.0.3-bos

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 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 type StringOrNumber = string | number;
+export type StrictOmit<K, T extends keyof K> = Omit<K, T>;
+export type LocalizedValue = {
+    ar: string;
+    en: string;
+};
+export type Prettify<T> = {
+    [k in keyof T]: T[k];
+} & {};
+export 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 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 { UserPreferencesService } from "../../../core/services/user/user-preferences.service";
+import { UtilityService } from "../../../core/utilities/utility.service";
+import { BaseCacheOptions } from "./models";
+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/config/index.d.ts

@@ -0,0 +1 @@
+export * from './default-ttl-config';

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<never>;
+    PREPARE_DATA: (result: Array<Record<string, any>>) => Array<Record<string, any>>;
+};

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

@@ -0,0 +1 @@
+export * from './default-cache-options';

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("nuxeo-development-framework").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,4 @@
+export * from './base.service';
+export * from './models/index';
+export * from './base-editor-config.service';
+export * from './cache-base.service';

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

@@ -0,0 +1,51 @@
+import { Observable, Subject } from 'rxjs';
+import { HttpOptions } from './http-options.model';
+import { QueryOptions } from './query-options.model';
+type RequestFunctionType = (...params: any[]) => Observable<any>;
+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 type CachedQueryOptions = {} & BaseOption & QueryOptions;
+export type CachedHttpOptions = {} & BaseOption & HttpOptions;
+export type CachedFullQueryOptions = {} & CachedQueryOptions & BaseCacheOptions;
+export type CachedFullHttpOptions = {} & CachedHttpOptions & BaseCacheOptions;
+export 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;
+}

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

@@ -0,0 +1,5 @@
+export * from './operation-options.model';
+export * from './request-options.model';
+export * from './query-options.model';
+export * from './http-options.model';
+export * from './cache-info-model';

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

@@ -0,0 +1,8 @@
+export interface OperationOptions {
+    operation: string;
+    input?: string;
+    params?: any;
+    context?: any;
+    headers?: any;
+    isCustomAutomation?: any;
+}

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

@@ -0,0 +1,5 @@
+export interface QueryOptions {
+    pageProvider: string;
+    params?: any;
+    headers: any;
+}

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

@@ -0,0 +1,7 @@
+export interface RequestOptions {
+    endpoint: string;
+    queryParams?: any;
+    headers?: any;
+    payload?: any;
+    type?: 'get' | 'post' | 'put';
+}

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

@@ -0,0 +1,13 @@
+import { Injector } from "@angular/core";
+import { Observable } from "rxjs";
+import { BaseService } from "../base";
+import * as i0 from "@angular/core";
+export declare class EncryptionService extends BaseService {
+    #private;
+    overrideToken?: string;
+    constructor(injector: Injector);
+    isEncryptionRequired(file: Record<string, any>): boolean;
+    fetchAndDecryptFile(file: Record<string, any>, renderAsPDF?: boolean): Observable<Blob>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EncryptionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EncryptionService>;
+}

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

@@ -0,0 +1,2 @@
+export * from "./base";
+export * from "./encryption/encryption.service";

package/lib/shared/utilities/departments.d.ts

@@ -0,0 +1 @@
+export declare function extractDepartmentCode(name: string, roles: Record<string, string>): string | null;

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

@@ -0,0 +1 @@
+export * from './departments';

package/lib/shared-services/apis-errors-messages.service.d.ts

@@ -0,0 +1,11 @@
+import { OperatorFunction } from 'rxjs';
+import * as i0 from "@angular/core";
+type errorHandlerFn = <T>() => OperatorFunction<T, T>;
+export declare class ApisErrorsMessagesService {
+    #private;
+    setErrorHandler(handler: errorHandlerFn): void;
+    handleErrorMessage<TResponse>(): OperatorFunction<TResponse, TResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ApisErrorsMessagesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ApisErrorsMessagesService>;
+}
+export {};

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

@@ -0,0 +1,24 @@
+import { MatDialog } from '@angular/material/dialog';
+import { Observable } from 'rxjs';
+import { AdapterService } from '../core/adapters/adapter.service';
+import { NuxeoService } from '../core/services/nuxeo/nuxeo.service';
+import { NuxeoDialogService } from '../shared/components/nuxeo-dialog/services/nuxeo-dialog.service';
+import * as i0 from "@angular/core";
+export declare class BaseSharedDocService {
+    private nuxeoService;
+    private dialog;
+    private adapter;
+    nuxeoDialogService: NuxeoDialogService;
+    constructor(nuxeoService: NuxeoService, dialog: MatDialog, adapter: AdapterService, nuxeoDialogService: NuxeoDialogService);
+    shareDocumentWithUser(context: any, DocId: any): Observable<any>;
+    removeAllSharesforDocs(DocId: any): Observable<any>;
+    getSharesWithMe(sortObj: any): Observable<any>;
+    getMyShares(headers?: Record<string, any>): Observable<any>;
+    removeCustomShare(context: any, DocId: any): Observable<any>;
+    canSeeSecretdocs(context: any): Observable<any>;
+    getSharesByMe(selectedItemId: any, getAllInfo?: any, options?: {
+        headers?: Record<string, any>;
+    }): Observable<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BaseSharedDocService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BaseSharedDocService>;
+}

package/lib/shared-services/dialog-mangment.service.d.ts

@@ -0,0 +1,28 @@
+import { TemplateRef, Type } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { DialogOptions } from '../shared/components/nuxeo-dialog';
+import { NuxeoDialogService } from '../shared/components/nuxeo-dialog/services/nuxeo-dialog.service';
+import * as i0 from "@angular/core";
+export declare class DialogMangmentService {
+    private dialog;
+    nuxeoDialogService: NuxeoDialogService;
+    minizedModal: boolean;
+    creationMode: string;
+    fileType: string;
+    addingFrom: string;
+    storedDynamicForm: string;
+    constructor(dialog: MatDialog, nuxeoDialogService: NuxeoDialogService);
+    open(config: {
+        type: string;
+        creationMode: string;
+        source: string;
+        component: Type<any> | TemplateRef<any>;
+        options: Omit<DialogOptions, 'component'>;
+    }): import("@angular/material/dialog").MatDialogRef<any, any>;
+    openModalV2(component: any, type: any, creationMode: any, source: any, width: any, height: any, data?: {}): void;
+    openMinimzedModalV2(component: any, width: any, height: any, data?: {}): void;
+    openModal(component: any, type: any, creationMode: any, source: any, width: any, height: any, data?: {}): void;
+    openMinimzedModal(component: any, width: any, height: any, data?: {}): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DialogMangmentService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DialogMangmentService>;
+}

package/lib/shared-services/dynamic-form.service.d.ts

@@ -0,0 +1,24 @@
+import { Observable } from 'rxjs';
+import { NuxeoService } from '../core/services/nuxeo/nuxeo.service';
+import { AppConfigService } from '../configuration/app-config.service';
+import * as i0 from "@angular/core";
+export declare class DynamicFormService {
+    private nuxeoService;
+    private environment;
+    private configService;
+    myPrefix: {};
+    dynamicFieldsOperations: any;
+    excludedSchemas: string[];
+    controlsTypes: string[];
+    constructor(nuxeoService: NuxeoService, environment: any, configService: AppConfigService);
+    getSchemaComponents(type: any): Observable<any>;
+    getSchemaComponentsFromFacets(schemaId: any): Observable<any>;
+    getDynamicForm(type: any): Observable<any>;
+    createFormJson(type: any, jsonObject: any): Observable<unknown>;
+    adapt(fields: any): any;
+    constructDynamicFormPayload(data: any, dynamicForm: any): {};
+    getUserSelectorValue(value: any): any;
+    removeNullValues(data: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DynamicFormService>;
+}

package/lib/shared-services/file-manager.adapter.d.ts

@@ -0,0 +1,46 @@
+import { IconService } from '../components/display-suitable-icon/display-suitable-icon/icon.service';
+import * as i0 from "@angular/core";
+export declare class FileManagerAdapter {
+    private iconService;
+    constructor(iconService: IconService);
+    adapt(item: any): {
+        id: any;
+        name: any;
+        isFavorite: any;
+        extension: any;
+        isDirectory: boolean;
+        size: any;
+        creator: string;
+        modified: string;
+        lastContributor: string;
+        items: boolean | any[];
+        entity: any;
+    };
+    treeViewAdapt(item: any, parent?: boolean, pageConfigurations?: {}): {
+        id: any;
+        name: any;
+        parentId: any;
+        icon: string;
+        isExpanded: any;
+        entity: any;
+    };
+    dropDownTreeViewAdapt(item: any, parent?: boolean): {
+        id: any;
+        name: any;
+        parentId: any;
+        icon: string;
+        isExpanded: any;
+        entity: any;
+    };
+    fulltreeViewAdapt(item: any, parent?: boolean): {
+        id: any;
+        name: any;
+        parentId: any;
+        icon: string;
+        isExpanded: boolean;
+        entity: any;
+    };
+    checkIfExpanded(document: any): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileManagerAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileManagerAdapter>;
+}

package/lib/shared-services/file-manager.service.d.ts

@@ -0,0 +1,102 @@
+import { HttpClient } from '@angular/common/http';
+import { EventEmitter, OnDestroy } from '@angular/core';
+import { MatDialog } from '@angular/material/dialog';
+import { Router } from '@angular/router';
+import { Observable, Subject, Subscriber, Subscription } from 'rxjs';
+import { CustomToastrService } from '../components/custom-toastr/services/custom-toastr.service';
+import { FileManagerPaginationData, PaginationPayload } from '../components/file-manger/models';
+import { AppConfigService } from '../configuration/app-config.service';
+import { AdapterService } from '../core/adapters/adapter.service';
+import { CallApiService } from '../core/services/callApi/call-api.service';
+import { NuxeoService } from '../core/services/nuxeo/nuxeo.service';
+import { TranslationService } from '../core/services/translation/translation.service';
+import { EvaluatorsService } from '../directive/permissions/evaluators.service';
+import { FileManagerAdapter } from './file-manager.adapter';
+import { MainfolderService } from './mainfolder.service';
+import { RecentlyViewedService } from './recently-viewed.service';
+import * as i0 from "@angular/core";
+export declare class FileManagerService implements OnDestroy {
+    #private;
+    private callApi;
+    private adapter;
+    private environment;
+    private fileManagerAdapter;
+    private appConfService;
+    private nuxeoService;
+    private permissionEvaluatorService;
+    private mainFolderService;
+    private http;
+    private translationService;
+    private toaster;
+    private dialog;
+    private router;
+    private recentlyViewedService;
+    pageProvider: any;
+    headers: any;
+    fields: any;
+    allFilesConfig: any;
+    selectedFolderId: any;
+    onRefreshingFileManger: Subject<void>;
+    onRefreshClipboard: EventEmitter<any>;
+    permissionsList: string[];
+    userPermittedTypes: any[];
+    userPermittedTypesTotalSize: number;
+    userPermittedFilesOnly: any[];
+    sharedFiles: any;
+    isArabic: boolean;
+    langSubscription: Subscription;
+    clipboardPermissionList: string[];
+    customEvent: EventEmitter<any>;
+    static PaginationConfig: {
+        enable: boolean;
+        pageSize: number;
+    };
+    constructor(callApi: CallApiService, adapter: AdapterService, environment: any, fileManagerAdapter: FileManagerAdapter, appConfService: AppConfigService, nuxeoService: NuxeoService, permissionEvaluatorService: EvaluatorsService, mainFolderService: MainfolderService, http: HttpClient, translationService: TranslationService, toaster: CustomToastrService, dialog: MatDialog, router: Router, recentlyViewedService: RecentlyViewedService);
+    ngOnDestroy(): void;
+    setMyTableConfiguration(): void;
+    getClipboardAcceptedTypes(id: any): Observable<any>;
+    getClipboardDocuments(docIds: any, sortObj?: any): Observable<any>;
+    sortingTypes(types: any): any;
+    CreateLoanRequest(input: any, context: any, params?: {}): Observable<any>;
+    CreateTransferRequest(input: any, context: any, params?: {}): Observable<any>;
+    subscribe_OR_unSubscribeToItem(item: any, isUserSubscriberToFile: any): Observable<unknown>;
+    openFile(Data: any, fileId: any, dynaimcFormType?: '', searchString?: string): void;
+    registerAuditLog(docId: any, eventType: any): void;
+    subscribeOrUnsubscribeUserToItem(itemId: any, ToDo: any): Observable<unknown>;
+    getUserAcceptedTypes(contentTypee?: any): Observable<any[]>;
+    fetchUserPermittedTypesRecursively(offset: any, pageSize: any, op: Subscriber<any[]>, contentTypee?: any): void;
+    refreshUserAcceptedTypes(): void;
+    checkIfDocumentIsFile(document: any): "Folder" | "File";
+    getChildren(id: any, payload?: PaginationPayload, loadFolders?: boolean): Observable<any[] | FileManagerPaginationData<any>>;
+    getChildrenForSharedDocumentRoot(id: any, payload?: PaginationPayload, loadFolders?: boolean): Observable<any[] | FileManagerPaginationData<any>>;
+    refreshData(id: any, payload?: PaginationPayload, loadFolders?: boolean): Observable<any[] | FileManagerPaginationData<any>>;
+    getFolders(id: any, pageProvider?: string): Observable<any[]>;
+    getMapedFolder(uid: string): Observable<any>;
+    createFolder(params: any, id: any): Observable<any>;
+    createDirectory(params: any, id: any): Observable<any>;
+    UpdateFolder(params: any, id: any): Observable<any>;
+    deleteFolder(folderId: any): Observable<unknown>;
+    addToCollection(id: string, collectionId: string, operation?: string): Observable<any>;
+    renameFolder(body: any, id: any): Observable<any>;
+    createFile(payload: any, id: any, customApi?: any): Observable<any>;
+    createNewCollection(name: string, operation?: string): Observable<any>;
+    copyTo(destination: any, id: any): Observable<any>;
+    moveTo(destination: any, id: any): Observable<any>;
+    getCollectionSuggestion(term: string, operation?: string): Observable<any>;
+    getCollectionFromPP(searchTerm: string, pp?: string, queryParams?: Record<string, any>): Observable<any>;
+    setSync(id: any): Observable<any>;
+    unSetSync(id: any): Observable<any>;
+    addToFavorites(id: string, operation?: string): Observable<any>;
+    defineNewPerson(title: any, titleEn: any, ids: any): Observable<unknown>;
+    addToQuickAccess(id: string, operation?: string): Observable<any>;
+    removeFromQuickAccess(id: string, operation?: string): Observable<any>;
+    removeFromFavorites(id: string, operation?: string): Observable<any>;
+    getFolder<D = any>(uid: string, headers?: Record<string, any>): Observable<D>;
+    getLogs(id: any, pageIndex?: number, pageSize?: number): Observable<unknown>;
+    getFileSchemas(type: any): Observable<any>;
+    downloadAsZip(selectedItems: any, fileTitle: any): Subscription;
+    parseNodeChildren: (observable: any, pageConfigurations: any, parent?: boolean) => any;
+    createTreeNodeChildren(parent: any): Promise<any[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileManagerService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FileManagerService>;
+}