nuxeo-development-framework 0.0.2 → 0.0.6

package/lib/components/dynamic-filter/dynamic-filter/dynamic-filter.component.d.ts

@@ -0,0 +1,45 @@
+import { EventEmitter, OnInit } from '@angular/core';
+import * as i0 from "@angular/core";
+/**
+ * Dyanamic filter is a component that leverages Nuxeo Elastic search aggregation buckets data to dynamically
+ * generate data filtering checkbox groups & emits checkbox selection for consumption
+ * @title
+ * Dynamic Filter
+ *
+ * @example
+ *
+ * <cts-dynamic-filter
+ *   [entityType]="entityType"
+ *   [filters]="aggregationBuckets"
+ *   [id]="aggregationId"
+ *   [selections]="aggregationSelection"
+ *   [title]="aggregationField"
+ *   [prefix]="'search'"
+ *   (onFilterSelected)="FilterSelected($event)">
+ * </cts-dynamic-filter>
+ */
+export declare class DynamicFilterComponent implements OnInit {
+    /** emits array of filters */
+    onFilterSelected: EventEmitter<any>;
+    _selections: any;
+    /** title of the filters group */
+    title: string;
+    /** filters group */
+    filters: any;
+    /** new filters coming from the backend based on the selection */
+    set selections(val: any);
+    /** Aggregation ID */
+    id: any;
+    entityType: any;
+    /** static  path for translation passed from out side according to each page translation path */
+    prefix: any;
+    /** special type for department */
+    department: boolean;
+    more: boolean;
+    constructor();
+    ngOnInit(): void;
+    onFilterSelect(committeeName: any, e: any): void;
+    EntityType(fetchedKey: any): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFilterComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFilterComponent, "cts-dynamic-filter", never, { "title": "title"; "filters": "filters"; "selections": "selections"; "id": "id"; "entityType": "entityType"; "prefix": "prefix"; "department": "department"; }, { "onFilterSelected": "onFilterSelected"; }, never, never>;
+}

package/lib/components/dynamic-filter/dynamic-filter.module.d.ts

@@ -0,0 +1,16 @@
+import * as i0 from "@angular/core";
+import * as i1 from "./dynamic-filter/dynamic-filter.component";
+import * as i2 from "@angular/common";
+import * as i3 from "../../pipes/pipes.module";
+import * as i4 from "@ngx-translate/core";
+import * as i5 from "@angular/material/checkbox";
+import * as i6 from "../dynamic-view/dynamic-view.module";
+/**
+ * @title
+ * Dynamic Filter Module
+ */
+export declare class DynamicFilterModule {
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFilterModule, never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<DynamicFilterModule, [typeof i1.DynamicFilterComponent], [typeof i2.CommonModule, typeof i3.PipesModule, typeof i4.TranslateModule, typeof i5.MatCheckboxModule, typeof i6.DynamicViewModule], [typeof i1.DynamicFilterComponent]>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<DynamicFilterModule>;
+}

package/lib/components/dynamic-form/components/department-form/department-form.component.d.ts

@@ -0,0 +1,28 @@
+import { OnInit } from '@angular/core';
+import { FormGroup } from '@angular/forms';
+import { MatDialogRef } from '@angular/material/dialog';
+import { TreeviewItem } from 'ngx-treeview';
+import { CustomToastrService } from '../../../custom-toastr/services/custom-toastr.service';
+import { DepartmentApiService } from '../dynamic-form-department/services/department-api.service';
+import * as i0 from "@angular/core";
+export declare class DepartmentFormComponent implements OnInit {
+    data: any;
+    dialogRef: MatDialogRef<DepartmentFormComponent>;
+    private toastr;
+    private departmentManagementService;
+    loading: boolean;
+    depId: any;
+    updateMode: boolean;
+    depCode: any;
+    item: TreeviewItem;
+    constructor(data: any, dialogRef: MatDialogRef<DepartmentFormComponent>, toastr: CustomToastrService, departmentManagementService: DepartmentApiService);
+    departmentForm: FormGroup;
+    ngOnInit(): void;
+    filterNullValues(formValue: any): {};
+    save(): void;
+    departmentFormPopulate(department: any): void;
+    getDepartment(): void;
+    update(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DepartmentFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DepartmentFormComponent, "cts-department-form", never, {}, {}, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form/dynamic-form.component.d.ts

@@ -0,0 +1,26 @@
+import { EventEmitter, OnChanges, OnDestroy, OnInit } from '@angular/core';
+import { FormBuilderService } from './form-builder.service';
+import { TranslateService } from '@ngx-translate/core';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+/** @ignore */
+export declare class DynamicFormComponent implements OnChanges, OnInit, OnDestroy {
+    private formBuilderServic;
+    translate: TranslateService;
+    form: any;
+    data: any;
+    readOnly: boolean;
+    change: EventEmitter<any>;
+    submission: {};
+    translations: {};
+    renderOptions: {};
+    refresher: EventEmitter<any>;
+    langSubscription: Subscription;
+    constructor(formBuilderServic: FormBuilderService, translate: TranslateService);
+    ngOnInit(): void;
+    ngOnChanges(changes: any): void;
+    ngOnDestroy(): void;
+    excuteFunction(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormComponent, "app-dynamic-form", never, { "form": "form"; "data": "data"; "readOnly": "readOnly"; }, { "change": "change"; }, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form/fields.adapter.d.ts

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

package/lib/components/dynamic-form/components/dynamic-form/form-builder.service.d.ts

@@ -0,0 +1,21 @@
+import { Observable } from 'rxjs';
+import { AppConfigService } from '../../../../configuration/app-config.service';
+import { NuxeoService } from '../../../../Core/services/nuxeo/nuxeo.service';
+import { FieldsAdapterService } from './fields.adapter';
+import * as i0 from "@angular/core";
+export declare class FormBuilderService {
+    private nuxeoService;
+    private configService;
+    private fieldsAdapter;
+    private environment;
+    dynamicFieldsOperations: any;
+    myPrefix: string;
+    constructor(nuxeoService: NuxeoService, configService: AppConfigService, fieldsAdapter: FieldsAdapterService, environment: any);
+    getSchemaComponents(type: any): Observable<any>;
+    createFormJson(type: any, jsonObject: any): Observable<unknown>;
+    getDynamicForm(type: any): Observable<any>;
+    adaptOutDynamicFields(data: any): {};
+    adaptInDynamicFields(data: any): {};
+    static ɵfac: i0.ɵɵFactoryDeclaration<FormBuilderService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<FormBuilderService>;
+}

package/lib/components/dynamic-form/components/dynamic-form-boolitem/dynamic-form-boolitem.component.d.ts

@@ -0,0 +1,17 @@
+import { MatCheckboxChange } from '@angular/material/checkbox';
+import { DynamicFormUpdateService } from '../../services/dynamic-form-update.service';
+import { DynamicFormBoolItemModel } from '../../models/dynamic-form.models';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+/** @ignore */
+export declare class DynamicFormBoolItemComponent {
+    private dynamicFormUpdateService;
+    translate: TranslateService;
+    property: DynamicFormBoolItemModel;
+    editable: boolean;
+    constructor(dynamicFormUpdateService: DynamicFormUpdateService, translate: TranslateService);
+    isEditable(): boolean;
+    changed(change: MatCheckboxChange): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormBoolItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormBoolItemComponent, "app-dynamic-form-boolitem", never, { "property": "property"; "editable": "editable"; }, {}, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form-builder/dynamic-form-builder.component.d.ts

@@ -0,0 +1,57 @@
+import { ElementRef, EventEmitter, OnChanges, OnInit } from '@angular/core';
+import { FormBuilderComponent } from 'angular-formio';
+import * as i0 from "@angular/core";
+export declare class DynamicFormBuilderComponent implements OnChanges, OnInit {
+    jsonElement?: ElementRef;
+    form: any;
+    builder: any;
+    builderComponents: {};
+    formUpdated: EventEmitter<any>;
+    saving: boolean;
+    FormBuilderComponent: FormBuilderComponent;
+    builderOptions: {
+        noDefaultSubmitButton: boolean;
+        builder: {
+            basic: boolean;
+            advanced: boolean;
+            data: boolean;
+            premium: boolean;
+            layout: {
+                components: {
+                    htmlelement: boolean;
+                    content: boolean;
+                };
+            };
+            customBasic: {
+                title: string;
+                default: boolean;
+                weight: number;
+                components: {};
+            };
+        };
+        editForm: {
+            textfield: {
+                key: string;
+                ignore: boolean;
+            }[];
+            number: ({
+                key: string;
+                ignore?: undefined;
+            } | {
+                key: string;
+                ignore: boolean;
+            })[];
+        };
+    };
+    refresher: EventEmitter<any>;
+    deletedComponents: {};
+    private _form;
+    constructor();
+    ngOnInit(): void;
+    ngOnChanges(changes: any): void;
+    save(): void;
+    onChange(event: any): void;
+    handleComponentChange(component: any, eventType: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormBuilderComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormBuilderComponent, "app-dynamic-form-builder", never, { "form": "form"; "builder": "builder"; "builderComponents": "builderComponents"; }, { "formUpdated": "formUpdated"; }, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form-checkbox-item/dynamic-form-checkbox-item.component.d.ts

@@ -0,0 +1,35 @@
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+/**
+ * A checkbox input that can be used inside reactive or template driven forms
+ * @title
+ * Checkbox
+ * @example
+ *   <cts-dynamic-form-checkbox-item
+ *     [label]="'test slide'"
+ *     formControlName="checkbox"
+ * ></cts-dynamic-form-checkbox-item>
+ */
+export declare class DynamicFormCheckboxItemComponent implements ControlValueAccessor {
+    translate: TranslateService;
+    private control;
+    value: any;
+    /** Input Label */
+    label: any;
+    /** set input to disabled */
+    disabled: boolean;
+    /** is checkbox checked */
+    checked: boolean;
+    onChange: any;
+    onTouched: any;
+    constructor(translate: TranslateService, control: NgControl);
+    writeValue(obj: boolean): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    isRequired(): any;
+    setValue(event: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormCheckboxItemComponent, [null, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormCheckboxItemComponent, "cts-dynamic-form-checkbox-item", never, { "label": "label"; "disabled": "disabled"; "checked": "checked"; }, {}, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form-dateitem/dynamic-form-dateitem.component.d.ts

@@ -0,0 +1,70 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { DateAdapter } from '@angular/material/core';
+import { MatDatetimepicker } from '@mat-datetimepicker/core';
+import { TranslateService } from '@ngx-translate/core';
+import { Moment } from 'moment';
+import { UserPreferencesService } from '../../../../Core/services/user/user-preferences.service';
+import { DynamicFormDateItemModel } from '../../models/dynamic-form.models';
+import { DynamicFormUpdateService } from '../../services/dynamic-form-update.service';
+import * as i0 from "@angular/core";
+export declare const MY_MOMENT_FORMATS: {
+    parseInput: string;
+    fullPickerInput: string;
+    datePickerInput: string;
+    timePickerInput: string;
+    monthYearLabel: string;
+    dateA11yLabel: string;
+    monthYearA11yLabel: string;
+};
+/** @ignore */
+export declare class DynamicFormDateItemComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    private dynamicFormUpdateService;
+    private dateAdapter;
+    private userPreferencesService;
+    translate: TranslateService;
+    control: NgControl;
+    label: any;
+    disabled: boolean;
+    inEdit: boolean;
+    editedValue: string;
+    errorMessages: string[];
+    valueSeparator: string;
+    property: DynamicFormDateItemModel;
+    editable: boolean;
+    displayEmpty: boolean;
+    min: any;
+    max: any;
+    startAt: any;
+    displayClearAction: boolean;
+    pickerType: string;
+    selectMode: string;
+    datepicker: MatDatetimepicker<any>;
+    valueDate: any;
+    dateFormat: string;
+    isfilter: boolean;
+    placeholder: string;
+    private onDestroy$;
+    constructor(dynamicFormUpdateService: DynamicFormUpdateService, dateAdapter: DateAdapter<Moment>, userPreferencesService: UserPreferencesService, translate: TranslateService, control: NgControl);
+    onChange: any;
+    onTouched: any;
+    isRequired(): any;
+    writeValue(obj: any): void;
+    get invalid(): boolean;
+    get showError(): boolean;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    hasErrors(): boolean;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    showProperty(): boolean;
+    showClearAction(): boolean;
+    isEditable(): boolean;
+    isDisabled(): boolean;
+    showDatePicker(): void;
+    onDateChanged(newDateValue: any): void;
+    onDateClear(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormDateItemComponent, [null, null, null, null, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormDateItemComponent, "app-dynamic-form-dateitem", never, { "label": "label"; "disabled": "disabled"; "property": "property"; "editable": "editable"; "displayEmpty": "displayEmpty"; "min": "min"; "max": "max"; "startAt": "startAt"; "displayClearAction": "displayClearAction"; "pickerType": "pickerType"; "selectMode": "selectMode"; "isfilter": "isfilter"; "placeholder": "placeholder"; }, {}, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form-dateitem/owlDateTimeIntl.d.ts

@@ -0,0 +1,52 @@
+import { DateTimeAdapter, OwlDateTimeIntl } from '@busacca/ng-pick-datetime';
+import { TranslateService } from '@ngx-translate/core';
+import { UserPreferencesService } from '../../../../Core/services/user/user-preferences.service';
+import * as i0 from "@angular/core";
+export declare class owlDateTimeIntl extends OwlDateTimeIntl {
+    private translate;
+    private userPreference;
+    private dateTimeAdapter;
+    cancelBtnLabel: string;
+    setBtnLabel: string;
+    private currentLang;
+    /** A label for the up second button (used by screen readers).  */
+    upSecondLabel: string;
+    /** A label for the down second button (used by screen readers).  */
+    downSecondLabel: string;
+    /** A label for the up minute button (used by screen readers).  */
+    upMinuteLabel: string;
+    /** A label for the down minute button (used by screen readers).  */
+    downMinuteLabel: string;
+    /** A label for the up hour button (used by screen readers).  */
+    upHourLabel: string;
+    /** A label for the down hour button (used by screen readers).  */
+    downHourLabel: string;
+    /** A label for the previous month button (used by screen readers). */
+    prevMonthLabel: string;
+    /** A label for the next month button (used by screen readers). */
+    nextMonthLabel: string;
+    /** A label for the previous year button (used by screen readers). */
+    prevYearLabel: string;
+    /** A label for the next year button (used by screen readers). */
+    nextYearLabel: string;
+    /** A label for the previous multi-year button (used by screen readers). */
+    prevMultiYearLabel: string;
+    /** A label for the next multi-year button (used by screen readers). */
+    nextMultiYearLabel: string;
+    /** A label for the 'switch to month view' button (used by screen readers). */
+    switchToMonthViewLabel: string;
+    /** A label for the 'switch to year view' button (used by screen readers). */
+    switchToMultiYearViewLabel: string;
+    /** A label for the range 'from' in picker info */
+    rangeFromLabel: string;
+    /** A label for the range 'to' in picker info */
+    rangeToLabel: string;
+    /** A label for the hour12 button (AM) */
+    hour12AMLabel: string;
+    /** A label for the hour12 button (PM) */
+    hour12PMLabel: string;
+    constructor(translate: TranslateService, userPreference: UserPreferencesService, dateTimeAdapter: DateTimeAdapter<any>);
+    getLang(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<owlDateTimeIntl, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<owlDateTimeIntl>;
+}

package/lib/components/dynamic-form/components/dynamic-form-department/constants/department.d.ts

@@ -0,0 +1,12 @@
+export declare class DepartmentConstants {
+    static fields: {
+        title: string;
+        description: string;
+        agencyCode: string;
+        arabicName: string;
+        englishName: string;
+        deptTypee: string;
+        isAllowRecExternal: string;
+        manager: string;
+    };
+}

package/lib/components/dynamic-form/components/dynamic-form-department/dynamic-form-department.component.d.ts

@@ -0,0 +1,65 @@
+import { EventEmitter, OnDestroy, OnInit } from '@angular/core';
+import { ControlValueAccessor, FormControl, NgControl } from '@angular/forms';
+import { TreeviewItem } from 'ngx-treeview';
+import { Subscription } from 'rxjs';
+import { TranslationService } from '../../../../Core/services/translation/translation.service';
+import { DepartmentApiService } from './services/department-api.service';
+import * as i0 from "@angular/core";
+/**
+ * A department tree dropdown input already with departments backend,
+ *  that can be used inside reactive or template driven forms
+ * @title
+ * Department tree dropdown
+ * @example
+ *   <app-dynamic-form-department
+ *       label="Field Label"
+ *       placeholder="Placeholder text"
+ *       formControlName="controlName"
+ *     >
+ *   </app-dynamic-form-department>
+ */
+export declare class DynamicFormDepartmentComponent implements ControlValueAccessor, OnInit, OnDestroy {
+    private translation;
+    private departmentApi;
+    control: NgControl;
+    data: any[];
+    /** is tree View or dropdown view */
+    treeview: boolean;
+    /** use tree view inside form */
+    treeViewAsFormControl: boolean;
+    /** Placeholder text */
+    placeholder: any;
+    /** Can select multiple */
+    multiple: boolean;
+    /** is tree searchable */
+    searchable: boolean;
+    /** Input Field label */
+    label: any;
+    /** emitted when item is selected */
+    onSelecting: EventEmitter<any>;
+    /** emitted when action is clicked */
+    actionClicked: EventEmitter<any>;
+    loading: boolean;
+    selection: any;
+    arabic: boolean;
+    languageSubscription: Subscription;
+    propagateChange: any;
+    validateFn: any;
+    onTouched: any;
+    get invalid(): boolean;
+    get showError(): boolean;
+    constructor(translation: TranslationService, departmentApi: DepartmentApiService, control: NgControl);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    recursiveFill(entries: any, level?: number): Promise<TreeviewItem[]>;
+    getLisOfOptions(): Promise<void>;
+    getSelecteditems(selectedItems: any): void;
+    writeValue(value: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    validate(c: FormControl): any;
+    isRequired(): boolean;
+    hasErrors(): boolean;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormDepartmentComponent, [null, null, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormDepartmentComponent, "app-dynamic-form-department", never, { "treeview": "treeview"; "treeViewAsFormControl": "treeViewAsFormControl"; "placeholder": "placeholder"; "multiple": "multiple"; "searchable": "searchable"; "label": "label"; }, { "onSelecting": "onSelecting"; "actionClicked": "actionClicked"; }, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form-department/services/department-api.service.d.ts

@@ -0,0 +1,29 @@
+import { TreeviewItem } from 'ngx-treeview';
+import { Observable, Subject } from 'rxjs';
+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 * as i0 from "@angular/core";
+export declare const departmentCacheBuster$: Subject<void>;
+export declare const minute = 60000;
+/** @ignore */
+export declare class DepartmentApiService {
+    private CallApiService;
+    private translation;
+    private nuxeoService;
+    private adapter;
+    private environment;
+    arabic: any;
+    constructor(CallApiService: CallApiService, translation: TranslationService, nuxeoService: NuxeoService, adapter: AdapterService, environment: any);
+    getDepartmentTree(): Observable<any>;
+    getDepartmentDetails(code: any): Observable<any>;
+    getDepartmentNestedTree(code: any): Observable<any>;
+    getDepartment(uid: any): Observable<any>;
+    createDepartment(Department: any, parentId: any): Observable<unknown>;
+    createDepartmentInRoot(Department: any): Observable<unknown>;
+    updateDepartment(Department: any, departmentId: any): Observable<unknown>;
+    recursiveFill(entries: any, level?: number, treeview?: boolean, collapsed?: boolean): TreeviewItem[];
+    static ɵfac: i0.ɵɵFactoryDeclaration<DepartmentApiService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DepartmentApiService>;
+}

package/lib/components/dynamic-form/components/dynamic-form-department/services/department-management.service.d.ts

@@ -0,0 +1,21 @@
+import { MatDialog } from '@angular/material/dialog';
+import { TreeviewItem } from 'ngx-treeview';
+import { AppConfigService } from '../../../../../configuration/app-config.service';
+import { AdapterService } from '../../../../../Core/adapters/adapter.service';
+import { NuxeoService } from '../../../../../Core/services/nuxeo/nuxeo.service';
+import * as i0 from "@angular/core";
+export declare class DepartmentManagementService {
+    private nuxeoService;
+    private adapter;
+    private myConfigService;
+    private dialog;
+    private environment;
+    constructor(nuxeoService: NuxeoService, adapter: AdapterService, myConfigService: AppConfigService, dialog: MatDialog, environment: any);
+    createDepartment(Department: any, parentId: any): import("rxjs").Observable<unknown>;
+    createDepartmentInRoot(Department: any): import("rxjs").Observable<unknown>;
+    updateDepartment(Department: any, departmentId: any): import("rxjs").Observable<unknown>;
+    getDepartment(uid: any): import("rxjs").Observable<any>;
+    openFormDialog(e?: string, update?: boolean, depCode?: any, item?: TreeviewItem): import("rxjs").Observable<any>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DepartmentManagementService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DepartmentManagementService>;
+}

package/lib/components/dynamic-form/components/dynamic-form-field/dynamic-form-field.component.d.ts

@@ -0,0 +1,30 @@
+import { OnDestroy, OnInit } from '@angular/core';
+import { AbstractControl, ControlValueAccessor, NgControl } from '@angular/forms';
+import { TranslateService } from '@ngx-translate/core';
+import * as i0 from "@angular/core";
+export declare class DynamicFormFieldComponent implements OnInit, OnDestroy, ControlValueAccessor {
+    translate: TranslateService;
+    private control;
+    disabled: boolean;
+    field: any;
+    value: any;
+    private onDestroy$;
+    constructor(translate: TranslateService, control: NgControl);
+    onChange: any;
+    onTouched: any;
+    get invalid(): boolean;
+    get showError(): boolean;
+    Validator: (control: AbstractControl) => {
+        [key: string]: boolean;
+    };
+    isRequired(): boolean;
+    writeValue(value: any): void;
+    ngOnInit(): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    ngOnDestroy(): void;
+    onChanged(value: any): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormFieldComponent, [null, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormFieldComponent, "cts-dynamic-form-field", never, { "disabled": "disabled"; "field": "field"; }, {}, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form-hijri-dateitem/dynamic-form-hijri-dateitem.component.d.ts

@@ -0,0 +1,61 @@
+import { OnInit, EventEmitter } from '@angular/core';
+import { NgbDate } from '@ng-bootstrap/ng-bootstrap';
+import { ControlValueAccessor, NgControl } from '@angular/forms';
+import { DateFormatterService } from '../../../hijri-gregorian-datepicker/services/date-formatter.service';
+import * as i0 from "@angular/core";
+/**
+ * A Hijri and gregorian datepicker
+ *  that can be used inside reactive or template driven forms
+ * @title
+ * Hijri Gregorian Datepicker
+ *
+ * @example
+ * <cts-dynamic-form-hijri-dateitem
+ *     formControlName="controlName"
+ *     label="PATH.TO.LABEL.TRANSLATION"
+ *     [minGreg]="maxDate"
+ *   >
+ *   </cts-dynamic-form-hijri-dateitem>
+ */
+export declare class DynamicFormHijriDateitemComponent implements OnInit, ControlValueAccessor {
+    private dateFormatterService;
+    private control;
+    /** Minimum Hijri Date */
+    minHijri: NgbDate;
+    /** Max Hijri Date */
+    maxHijri: NgbDate;
+    /** Minimum Gregorian Date */
+    minGreg: NgbDate;
+    /** Max Gregorian Date */
+    maxGreg: NgbDate;
+    /** Field Label */
+    label: any;
+    /** Is input disabled */
+    isDisabled: boolean;
+    /** is input a range picker */
+    range: boolean;
+    /** list inputs vertically (for range only) */
+    vertical: boolean;
+    /** Sets picker to readonly mode */
+    isReadOnly: boolean;
+    /** Emitted when the value changes */
+    valueChanged: EventEmitter<any>;
+    date: any;
+    dateString: string;
+    selectedDateType: number;
+    onChange: any;
+    onTouched: any;
+    startDatePicker: any;
+    constructor(dateFormatterService: DateFormatterService, control: NgControl);
+    writeValue(obj: any): void;
+    registerOnChange(fn: any): void;
+    registerOnTouched(fn: any): void;
+    setDisabledState?(isDisabled: boolean): void;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    removelable(): void;
+    setValue(event: any): void;
+    isRequired(): any;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormHijriDateitemComponent, [null, { optional: true; self: true; }]>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormHijriDateitemComponent, "cts-dynamic-form-hijri-dateitem", never, { "minHijri": "minHijri"; "maxHijri": "maxHijri"; "minGreg": "minGreg"; "maxGreg": "maxGreg"; "label": "label"; "isDisabled": "isDisabled"; "range": "range"; "vertical": "vertical"; "isReadOnly": "isReadOnly"; }, { "valueChanged": "valueChanged"; }, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form-item-dispatcher/dynamic-form-item-dispatcher.component.d.ts

@@ -0,0 +1,25 @@
+import { ComponentFactoryResolver, OnChanges, SimpleChanges } from '@angular/core';
+import { CardItemTypeService } from '../../services/card-item-types.service';
+import { DynamicFormItem } from '../../interfaces/dynamic-form-item.interface';
+import * as i0 from "@angular/core";
+/** @ignore */
+export declare class DynamicFormItemDispatcherComponent implements OnChanges {
+    private cardItemTypeService;
+    private resolver;
+    property: DynamicFormItem;
+    editable: boolean;
+    displayEmpty: boolean;
+    displayNoneOption: boolean;
+    displayClearAction: boolean;
+    private content;
+    private loaded;
+    private componentReference;
+    ngOnInit: any;
+    ngDoCheck: any;
+    constructor(cardItemTypeService: CardItemTypeService, resolver: ComponentFactoryResolver);
+    ngOnChanges(changes: SimpleChanges): void;
+    private loadComponent;
+    private proxy;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormItemDispatcherComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormItemDispatcherComponent, "app-dynamic-form-item-dispatcher", never, { "property": "property"; "editable": "editable"; "displayEmpty": "displayEmpty"; "displayNoneOption": "displayNoneOption"; "displayClearAction": "displayClearAction"; }, {}, never, never>;
+}

package/lib/components/dynamic-form/components/dynamic-form-mapitem/dynamic-form-mapitem.component.d.ts

@@ -0,0 +1,15 @@
+import { DynamicFormUpdateService } from '../../services/dynamic-form-update.service';
+import { DynamicFormMapItemModel } from '../../models/dynamic-form.models';
+import * as i0 from "@angular/core";
+/** @ignore */
+export declare class DynamicFormMapItemComponent {
+    private dynamicFormUpdateService;
+    property: DynamicFormMapItemModel;
+    displayEmpty: boolean;
+    constructor(dynamicFormUpdateService: DynamicFormUpdateService);
+    showProperty(): boolean;
+    isClickable(): boolean;
+    clicked(): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DynamicFormMapItemComponent, never>;
+    static ɵcmp: i0.ɵɵComponentDeclaration<DynamicFormMapItemComponent, "app-dynamic-form-mapitem", never, { "property": "property"; "displayEmpty": "displayEmpty"; }, {}, never, never>;
+}