nuxeo-development-framework 5.6.4 → 5.6.5

package/lib/core/services/localStorag/local-storag.service.d.ts

@@ -0,0 +1,41 @@
+import * as i0 from "@angular/core";
+export declare class LocalStoragService {
+    private memoryStore;
+    private readonly useLocalStorage;
+    private _prefix;
+    get prefix(): string;
+    set prefix(prefix: string);
+    constructor();
+    /**
+     * Gets an item.
+     * @param key Key to identify the item
+     * @returns The item (if any) retrieved by the key
+     */
+    getItem(key: string): string | null;
+    /**
+     * Stores an item
+     * @param key Key to identify the item
+     * @param data Data to store
+     */
+    setItem(key: string, data: string): void;
+    /** Removes all currently stored items. */
+    clear(): void;
+    /**
+     * Removes a single item.
+     * @param key Key to identify the item
+     */
+    removeItem(key: string): void;
+    /**
+     * Is any item currently stored under `key`?
+     * @param key Key identifying item to check
+     * @returns True if key retrieves an item, false otherwise
+     */
+    hasItem(key: string): boolean;
+    private storageAvailable;
+    getLocal(key: string): any;
+    setLocal(key: string, value: any): void;
+    removeLocal(key: string): void;
+    removeAllLocals(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<LocalStoragService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<LocalStoragService>;
+}

package/lib/core/services/ndf-transform.service.d.ts

@@ -0,0 +1,61 @@
+import { Observable } from 'rxjs';
+import * as i0 from "@angular/core";
+export interface NdfTransformerDataModel {
+    id?: string;
+    code?: string;
+    arabicTitle: string;
+    englishTitle: string;
+}
+export declare type NdfTransformerFunction = (keys: string[]) => Observable<NdfTransformerDataModel[]>;
+export declare class NdfTransformService {
+    private readonly _transformations;
+    /**
+     * Registers one or multiple transformer functions.
+     *
+     * @param {Record<string, NdfTransformerFunction> | string} keys - A record of key-function pairs or a single key.
+     * @param {NdfTransformerFunction} [arg2] - A transformer function if registering a single key.
+     */
+    register(keys: Record<string, NdfTransformerFunction>): void;
+    register(key: string, fn: NdfTransformerFunction): void;
+    /**
+     * Retrieves a transformer function by its key.
+     *
+     * @param {string} key - The key of the transformer function.
+     * @returns {NdfTransformerFunction | undefined} - The transformer function or undefined if not found.
+     */
+    get(key: string): NdfTransformerFunction | undefined;
+    /**
+     * Retrieves all registered transformer functions.
+     *
+     * @returns {Map<string, NdfTransformerFunction>} - A map of all transformer functions.
+     */
+    getAll(): Map<string, NdfTransformerFunction>;
+    /**
+     * Clears all registered transformer functions.
+     */
+    clear(): void;
+    /**
+     * Checks if a transformer function is registered for a specific key.
+     *
+     * @param {string} key - The key to check.
+     * @returns {boolean} - True if the key exists, false otherwise.
+     */
+    has(key: string): boolean;
+    /**
+     * Removes a transformer function by its key.
+     *
+     * @param {string} key - The key of the transformer function to remove.
+     */
+    remove(key: string): void;
+    /**
+     * Executes a transformer function for a specific key with the provided input keys.
+     *
+     * @param {string} key - The key of the transformer function to execute.
+     * @param {string[]} keys - The input keys to pass to the transformer function.
+     * @throws {Error} - If no transformer function is registered for the key.
+     * @returns {Observable<NdfTransformerDataModel[]>} - The result of the transformer function.
+     */
+    transform(key: string, keys: string[]): Observable<NdfTransformerDataModel[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NdfTransformService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NdfTransformService>;
+}

package/lib/core/services/nuxeo/new-nuxeo-overide.d.ts

@@ -0,0 +1,14 @@
+import { CookieService } from "ngx-cookie-service";
+declare const Nuxeo: any;
+export declare class NewNuxeoOverride extends Nuxeo {
+    private environment;
+    private cookieService;
+    constructor(opts: {}, environment: any, cookieService: CookieService);
+    http(opts?: any): any;
+    refreshAccessToken(): Promise<any>;
+    login(): void;
+    logout(): void;
+    encriptFormating(cachable: any): string;
+    getAccessToken(baseURL: any, clientId: any, refreshToken: any, clientSecret: any): Promise<unknown>;
+}
+export {};

package/lib/core/services/nuxeo/nuxeo-override.d.ts

@@ -0,0 +1,8 @@
+import { KeycloakService } from "keycloak-angular";
+declare const Nuxeo: any;
+export declare class NuxeoOverride extends Nuxeo {
+    private keycloak;
+    constructor(opts: {}, keycloak: KeycloakService);
+    http(opts?: any): any;
+}
+export {};

package/lib/core/services/nuxeo/nuxeo.service.d.ts

@@ -0,0 +1,37 @@
+import { HttpClient } from '@angular/common/http';
+import { KeycloakService } from 'keycloak-angular';
+import { CookieService } from 'ngx-cookie-service';
+import { Observable } from 'rxjs';
+import { RolesService } from '../roles/roles.service';
+import * as i0 from "@angular/core";
+export declare class NuxeoService {
+    private http;
+    private keycloak;
+    private baseHref;
+    private environment;
+    private cookiesService;
+    private rolesService;
+    nuxeoClient: any;
+    excludedUrls: any[];
+    enableBearerInterceptor: boolean;
+    authenticated: boolean;
+    token: any;
+    tokenObservable: any;
+    constructor(http: HttpClient, keycloak: KeycloakService, baseHref: string, environment: any, cookiesService: CookieService, rolesService: RolesService);
+    init(): Promise<any>;
+    initWithNuxeoToken(token: any): Promise<unknown>;
+    createClientWithNuxeoToken(token: any): void;
+    createTokenClient(token: any): void;
+    getToken(): Promise<string>;
+    doLogout(): void;
+    isUserInRole(role: any, committeeCode?: any): Observable<any>;
+    createBlob(file: any): any;
+    getDuplicates(params?: {}, body?: {}): Observable<any>;
+    checkForRoles(): void;
+    ctsUser: boolean;
+    isCtsUser(): void;
+    ctsManger: boolean;
+    isCtsManger(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NuxeoService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NuxeoService>;
+}

package/lib/core/services/roles/roles.service.d.ts

@@ -0,0 +1,12 @@
+import * as i0 from "@angular/core";
+export declare class RolesService {
+    private environment;
+    constructor(environment: any);
+    getRoleName(role: any, code?: any): string;
+    isUserInRole(user: any, role: any, code?: any): boolean;
+    getUserRoleName(user: any, code: any, roleIncludes?: string): any;
+    isUserManagerInDepartment(user: any, code: any): boolean;
+    getUserDepartment(currentUser: any, prefix?: string, option?: any): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<RolesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<RolesService>;
+}

package/lib/core/services/translation/translate-loader.service.d.ts

@@ -0,0 +1,26 @@
+import { HttpClient } from '@angular/common/http';
+import { TranslateLoader } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { ComponentTranslationModel } from '../../models/component.model';
+import * as i0 from "@angular/core";
+export declare class TranslateLoaderService implements TranslateLoader {
+    private http;
+    private prefix;
+    private suffix;
+    private providers;
+    private queue;
+    private defaultLang;
+    constructor(http: HttpClient);
+    setDefaultLang(value: string): void;
+    registerProvider(name: string, path: string): void;
+    providerRegistered(name: string): boolean;
+    fetchLanguageFile(lang: string, component: ComponentTranslationModel, fallbackUrl?: string): Observable<void>;
+    getComponentToFetch(lang: string): Array<Observable<any>>;
+    init(lang: string): void;
+    isComponentInQueue(lang: string, name: string): boolean;
+    getFullTranslationJSON(lang: string): any;
+    getTranslation(lang: string): Observable<any>;
+    merge(...objects: any[]): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslateLoaderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslateLoaderService>;
+}

package/lib/core/services/translation/translation.service.d.ts

@@ -0,0 +1,76 @@
+import { InjectionToken, RendererFactory2 } from '@angular/core';
+import { TranslateService } from '@ngx-translate/core';
+import { BehaviorSubject, Observable } from 'rxjs';
+import { AppConfigService } from '../../../configuration/app-config.service';
+import { LocalStoragService } from '../localStorag/local-storag.service';
+import { NuxeoService } from '../nuxeo/nuxeo.service';
+import { UserPreferencesService } from '../user/user-preferences.service';
+import { TranslateLoaderService } from './translate-loader.service';
+import * as i0 from "@angular/core";
+export declare const TRANSLATION_PROVIDER: InjectionToken<unknown>;
+export interface TranslationProvider {
+    name: string;
+    source: string;
+}
+export declare class TranslationService {
+    #private;
+    translate: TranslateService;
+    private rendererFactory;
+    private localStorage;
+    private userPreferencesService;
+    private appConfig;
+    private nuxeoService;
+    private environment;
+    arabicFile: any;
+    englishFile: any;
+    defaultLang: string;
+    userLang: string;
+    customLoader: TranslateLoaderService;
+    lang: string;
+    private renderer;
+    isArabic: BehaviorSubject<boolean>;
+    isArabic$: Observable<boolean>;
+    translationApiName: any;
+    constructor(translate: TranslateService, rendererFactory: RendererFactory2, localStorage: LocalStoragService, userPreferencesService: UserPreferencesService, appConfig: AppConfigService, nuxeoService: NuxeoService, environment: any, providers: TranslationProvider[]);
+    /**
+     * Adds a new folder of translation source files.
+     * @param name Name for the translation provider
+     * @param path Path to the folder
+     */
+    addTranslationFolder(name?: string, path?: string): void;
+    /**
+     * Loads a translation file.
+     * @param lang Language code for the language to load
+     * @param fallback Language code to fall back to if the first one was unavailable
+     */
+    loadTranslation(lang: string, fallback?: string): void;
+    /**
+     * Triggers a notification callback when the translation language changes.
+     * @param lang The new language code
+     */
+    onTranslationChanged(lang: string): void;
+    /**
+     * Sets the target language for translations.
+     * @param lang Code name for the language
+     * @returns Translations available for the language
+     */
+    use(lang: string): Observable<any>;
+    /**
+     * Gets the translation for the supplied key.
+     * @param key Key to translate
+     * @param interpolateParams String(s) to be interpolated into the main message
+     * @returns Translated text
+     */
+    get(key: string | Array<string>, interpolateParams?: Object): Observable<string | any>;
+    /**
+     * Directly returns the translation for the supplied key.
+     * @param key Key to translate
+     * @param interpolateParams String(s) to be interpolated into the main message
+     * @returns Translated text
+     */
+    instant(key: string | Array<string>, interpolateParams?: Object): string | any;
+    getOrCreateTranslationFile(lang: any): Observable<unknown>;
+    updateTranslationFile(doc: any, params?: {}): Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<TranslationService, [null, null, null, null, null, null, null, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TranslationService>;
+}

package/lib/core/services/user/user-preferences.service.d.ts

@@ -0,0 +1,85 @@
+import { TranslateService } from '@ngx-translate/core';
+import { Observable } from 'rxjs';
+import { LocalStoragService } from '../localStorag/local-storag.service';
+import * as i0 from "@angular/core";
+export declare enum UserPreferenceValues {
+    Locale = "locale",
+    ExpandedSideNavStatus = "expandedSidenav"
+}
+export declare class UserPreferencesService {
+    #private;
+    translate: TranslateService;
+    private storage;
+    defaults: {
+        locale: string;
+        expandedSidenav: boolean;
+    };
+    private userPreferenceStatus;
+    private onChangeSubject;
+    onChange: Observable<any>;
+    clientCustomTranslateFiles: {
+        arFile: Observable<{}>;
+        enFile: Observable<{}>;
+    };
+    constructor(translate: TranslateService, storage: LocalStoragService);
+    private initUserPreferenceStatus;
+    private initUserLanguage;
+    /**
+     * Sets up a callback to notify when a property has changed.
+     * @param property The property to watch
+     * @returns Notification callback
+     */
+    select(property: string): Observable<any>;
+    /**
+     * Gets a preference property.
+     * @param property Name of the property
+     * @param defaultValue Default to return if the property is not found
+     * @returns Preference property
+     */
+    get(property: string, defaultValue?: string, withoutUser?: boolean): string;
+    /**
+     * Sets a preference property.
+     * @param property Name of the property
+     * @param value New value for the property
+     */
+    set(property: string, value: any, withoutUser?: boolean): void;
+    /**
+     * Sets a preference property.
+     * @param property Name of the property
+     * @param value New value for the property
+     */
+    setWithoutStore(property: string, value: any): void;
+    /**
+     * Check if an item is present in the storage
+     * @param property Name of the property
+     * @returns True if the item is present, false otherwise
+     */
+    hasItem(property: string, withoutUser?: boolean): boolean;
+    /**
+     * Gets the active storage prefix for preferences.
+     * @returns Storage prefix
+     */
+    getStoragePrefix(): string;
+    /**
+     * Sets the active storage prefix for preferences.
+     * @param value Name of the prefix
+     */
+    setStoragePrefix(value: string): void;
+    /**
+     * Gets the full property key with prefix.
+     * @param property The property name
+     * @returns Property key
+     */
+    getPropertyKey(property: string): string;
+    /** Current locale setting. */
+    get locale(): string;
+    set locale(value: string);
+    /**
+     * Gets the default locale.
+     * @returns Default locale language code
+     */
+    getDefaultLocale(): string;
+    private getLanguageByKey;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UserPreferencesService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UserPreferencesService>;
+}

package/lib/core/tokens/project.token.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken } from '@angular/core';
+export declare const PROJECT_BASE_HREF: InjectionToken<unknown>;

package/lib/core/utilities/moment-date-adapter.d.ts

@@ -0,0 +1,37 @@
+import { DateAdapter } from '@angular/material/core';
+import { Moment } from 'moment';
+import * as i0 from "@angular/core";
+export declare class MomentDateAdapter extends DateAdapter<Moment> {
+    private localeData;
+    overrideDisplayFormat: string;
+    getYear(date: Moment): number;
+    getMonth(date: Moment): number;
+    getDate(date: Moment): number;
+    getDayOfWeek(date: Moment): number;
+    getMonthNames(style: 'long' | 'short' | 'narrow'): string[];
+    getDateNames(): string[];
+    getDayOfWeekNames(style: 'long' | 'short' | 'narrow'): string[];
+    getYearName(date: Moment): string;
+    getFirstDayOfWeek(): number;
+    getNumDaysInMonth(date: Moment): number;
+    clone(date: Moment): Moment;
+    createDate(year: number, month: number, date: number): Moment;
+    today(): Moment;
+    parse(value: any, parseFormat: any): Moment;
+    format(date: Moment, displayFormat: any): string;
+    addCalendarYears(date: Moment, years: number): Moment;
+    addCalendarMonths(date: Moment, months: number): Moment;
+    addCalendarDays(date: Moment, days: number): Moment;
+    getISODateString(date: Moment): string;
+    setLocale(locale: any): void;
+    compareDate(first: Moment, second: Moment): number;
+    sameDate(first: any | Moment, second: any | Moment): boolean;
+    clampDate(date: Moment, min?: any | Moment, max?: any | Moment): Moment;
+    isDateInstance(date: any): boolean;
+    isValid(date: Moment): boolean;
+    toIso8601(date: Moment): string;
+    fromIso8601(iso8601String: string): Moment | null;
+    invalid(): Moment;
+    static ɵfac: i0.ɵɵFactoryDeclaration<MomentDateAdapter, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<MomentDateAdapter>;
+}

package/lib/core/utilities/utility.service.d.ts

@@ -0,0 +1,11 @@
+import * as i0 from "@angular/core";
+export declare class UtilityService {
+    constructor();
+    objectFlip(obj: any): object;
+    parseIfJson(str: any): any;
+    getValue(target: any, key: string): any;
+    merge(...objects: any[]): any;
+    getPlainText(description: string, maxLength?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<UtilityService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<UtilityService>;
+}

package/lib/directive/app-has-role/app-has-role.directive.d.ts

@@ -0,0 +1,18 @@
+import { OnChanges, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
+import { Subject } from 'rxjs';
+import { NuxeoService } from '../../core/services/nuxeo/nuxeo.service';
+import * as i0 from "@angular/core";
+export declare class AppHasRoleDirective implements OnInit, OnChanges {
+    private viewContainerRef;
+    private templateRef;
+    private nuxeoService;
+    /** the role the user must have */
+    appHasRole: any;
+    stop$: Subject<unknown>;
+    isVisible: boolean;
+    constructor(viewContainerRef: ViewContainerRef, templateRef: TemplateRef<any>, nuxeoService: NuxeoService);
+    ngOnInit(): void;
+    ngOnChanges(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<AppHasRoleDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<AppHasRoleDirective, "[appHasRole]", never, { "appHasRole": "appHasRole"; }, {}, never>;
+}

package/lib/directive/clickOutSide/click-outside.directive.d.ts

@@ -0,0 +1,11 @@
+import { ElementRef, EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+/** @ignore */
+export declare class ClickOutsideDirective {
+    private elementRef;
+    clickOutside: EventEmitter<void>;
+    constructor(elementRef: ElementRef);
+    onClick(target: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ClickOutsideDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<ClickOutsideDirective, "[clickOutside]", never, {}, { "clickOutside": "clickOutside"; }, never>;
+}

package/lib/directive/directive.module.d.ts

@@ -0,0 +1,17 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./clickOutSide/click-outside.directive";
+import * as i2 from "./rtl/set-rtl.directive";
+import * as i3 from "./permissions/permissions.directive";
+import * as i4 from "./rtl/set-dir-rtl.directive";
+import * as i5 from "./app-has-role/app-has-role.directive";
+import * as i6 from "./drag-and-drop/drag-and-drop.directive";
+import * as i7 from "@angular/common";
+/**
+ * @title
+ * Directives Module
+ */
+export declare class DirectiveModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DirectiveModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DirectiveModule, [typeof i1.ClickOutsideDirective, typeof i2.SetRtlDirective, typeof i3.PermissionsDirective, typeof i4.SetDirRtlDirective, typeof i5.AppHasRoleDirective, typeof i6.DragAndDropDirective], [typeof i7.CommonModule], [typeof i1.ClickOutsideDirective, typeof i2.SetRtlDirective, typeof i3.PermissionsDirective, typeof i4.SetDirRtlDirective, typeof i5.AppHasRoleDirective, typeof i6.DragAndDropDirective]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DirectiveModule>;
+}

package/lib/directive/drag-and-drop/drag-and-drop.directive.d.ts

@@ -0,0 +1,11 @@
+import { EventEmitter } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class DragAndDropDirective {
+    fileDroped: EventEmitter<any>;
+    constructor();
+    onDragOver(evt: any): void;
+    onDragLeave(evt: any): void;
+    onDrop(evt: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DragAndDropDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<DragAndDropDirective, "[appDragAndDrop]", never, {}, { "fileDroped": "fileDroped"; }, never>;
+}

package/lib/directive/permissions/evaluators.service.d.ts

@@ -0,0 +1,39 @@
+import { AppConfigService } from '../../configuration/app-config.service';
+import { NuxeoService } from '../../core/services/nuxeo/nuxeo.service';
+import * as i0 from "@angular/core";
+export declare class EvaluatorsService {
+    private nuxeoService;
+    private appConfigService;
+    context: {
+        entity: any;
+        getEvaluator: any;
+        user: any;
+    };
+    userEvaluators: Record<string, any>;
+    conditions: any;
+    constructor(nuxeoService: NuxeoService, appConfigService: AppConfigService);
+    asyncEvery: (arr: any, predicate: any) => Promise<boolean>;
+    asyncSome: (arr: any, predicate: any) => Promise<boolean>;
+    evaluators: {
+        AND: (context: any, args: any[]) => Promise<boolean>;
+        OR: (context: any, args: any[]) => Promise<boolean>;
+        isStatus: (context: any, args: any) => Promise<boolean>;
+        isCreator: (context: any, args: any) => Promise<boolean>;
+        isUserInrole: (context: any, args: any) => Promise<any>;
+    };
+    getEvaluator: (key: string) => Promise<any>;
+    setEvaluators(evaluators: any): void;
+    getEvaluators(): {
+        AND: (context: any, args: any[]) => Promise<boolean>;
+        OR: (context: any, args: any[]) => Promise<boolean>;
+        isStatus: (context: any, args: any) => Promise<boolean>;
+        isCreator: (context: any, args: any) => Promise<boolean>;
+        isUserInrole: (context: any, args: any) => Promise<any>;
+    };
+    getUserEvaluators(): Record<string, any>;
+    evaluateRule(ruleId: any, context?: any): Promise<boolean>;
+    getRuleById(id: string): any;
+    getAllRules(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<EvaluatorsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<EvaluatorsService>;
+}

package/lib/directive/permissions/permissions.directive.d.ts

@@ -0,0 +1,40 @@
+import { ChangeDetectorRef, TemplateRef, ViewContainerRef } from '@angular/core';
+import { NuxeoService } from '../../core/services/nuxeo/nuxeo.service';
+import { EvaluatorsService } from './evaluators.service';
+import * as i0 from "@angular/core";
+export declare type PermissionType = {
+    name?: string;
+    user?: Record<string, any>;
+    entity?: Record<string, any>;
+};
+/**
+ * Permission directive shows or hides an element,
+ * based on a predefined structured condition object in the [conditions.json]{@link ../additional-documentation/conditions-file.html} file.
+ * it will evaluate the rule and shows or hides an element based on the result.
+ * this directive can evaluate rules against a document object as well,
+ * check [conditions.json]{@link ../additional-documentation/conditions-file.html} for more information
+ * @example
+ * <div *permission="{ name: 'conditionKey', entity: nuxeoDocumentObject }">
+ *   Element with permissions
+ *  </duv>
+ *  <div *permission="{ name: 'conditionKey2' }">
+ *   Element with permissions 2
+ *  </duv>
+ * @title
+ * Permission
+ */
+export declare class PermissionsDirective {
+    private nuxeoService;
+    private viewContainerRef;
+    private templateRef;
+    private evaluatorsService;
+    private _cdr;
+    constructor(nuxeoService: NuxeoService, viewContainerRef: ViewContainerRef, templateRef: TemplateRef<any>, evaluatorsService: EvaluatorsService, _cdr: ChangeDetectorRef);
+    set permission(obj: PermissionType);
+    isVisible: boolean;
+    private _handleVisibleChange;
+    private showView;
+    private hideView;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionsDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<PermissionsDirective, "[permission]", never, { "permission": "permission"; }, {}, never>;
+}

package/lib/directive/rtl/set-dir-rtl.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef, Renderer2 } from '@angular/core';
+import { TranslationService } from '../../core/services/translation/translation.service';
+import * as i0 from "@angular/core";
+/** @ignore */
+export declare class SetDirRtlDirective {
+    private elRef;
+    private renderer;
+    private translation;
+    constructor(elRef: ElementRef, renderer: Renderer2, translation: TranslationService);
+    switchDirBasedOnLanguage(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SetDirRtlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SetDirRtlDirective, "[SetDirRtl]", never, {}, {}, never>;
+}

package/lib/directive/rtl/set-rtl.directive.d.ts

@@ -0,0 +1,13 @@
+import { ElementRef, Renderer2 } from '@angular/core';
+import { TranslationService } from '../../core/services/translation/translation.service';
+import * as i0 from "@angular/core";
+/** @ignore */
+export declare class SetRtlDirective {
+    private elRef;
+    private renderer;
+    private translation;
+    constructor(elRef: ElementRef, renderer: Renderer2, translation: TranslationService);
+    switchClassBasedOnLanguage(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SetRtlDirective, never>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<SetRtlDirective, "[SetRtl]", never, {}, {}, never>;
+}

package/lib/nuxeo-development-framework.component.d.ts

@@ -0,0 +1,8 @@
+import { OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+export declare class NuxeoDevelopmentFrameworkComponent implements OnInit {
+    constructor();
+    ngOnInit(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NuxeoDevelopmentFrameworkComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<NuxeoDevelopmentFrameworkComponent, "lib-nuxeo-development-framework", never, {}, {}, never, never>;
+}

package/lib/nuxeo-development-framework.module.d.ts

@@ -0,0 +1,9 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./nuxeo-development-framework.component";
+import * as i2 from "@angular/common";
+import * as i3 from "@angular/forms";
+export declare class NuxeoDevelopmentFrameworkModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<NuxeoDevelopmentFrameworkModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<NuxeoDevelopmentFrameworkModule, [typeof i1.NuxeoDevelopmentFrameworkComponent], [typeof i2.CommonModule, typeof i3.FormsModule, typeof i3.ReactiveFormsModule], [typeof i1.NuxeoDevelopmentFrameworkComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<NuxeoDevelopmentFrameworkModule>;
+}

package/lib/nuxeo-development-framework.service.d.ts

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

package/lib/pipes/file-size.pipe.d.ts

@@ -0,0 +1,34 @@
+import { PipeTransform } from '@angular/core';
+import { TranslationService } from '../core/services/translation/translation.service';
+import * as i0 from "@angular/core";
+/**
+ * transforms file size into translated appropriate units
+ *
+ * ### In template example:
+ * ~~~html
+ * <!-- in template -->
+ * <p>{{ file.sizeInBytes | FileSize}}</p>
+ * ~~~
+ * @title
+ * File Size
+ *
+ * @example
+ * ...
+ * constructor(...  private FileSizePipe: fileSizePiple ...){
+ *   const sizeString = this.fileSizePiple.transform(sizeInBytes);
+ * }
+ * ...
+ */
+export declare class FileSizePipe implements PipeTransform {
+    private translation;
+    constructor(translation: TranslationService);
+    /**
+     *
+     * @param paramByte Size in Bytes
+     * @optional @param  decimals Decimals to show
+     * @returns translated size string
+     */
+    transform(paramByte: any, decimals?: number): string;
+    static ɵfac: i0.ɵɵFactoryDeclaration<FileSizePipe, never>;
+    static ɵpipe: i0.ɵɵPipeDeclaration<FileSizePipe, "FileSize">;
+}