@smartbit4all/ng-client 1.2.1 → 2.0.0

package/fesm2020/smartbit4all-ng-client.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { InjectionToken, Injectable, Optional, Inject, PLATFORM_ID, NgModule, SkipSelf, Component, Pipe, CUSTOM_ELEMENTS_SCHEMA, ViewChild, Input } from '@angular/core';
+import { InjectionToken, Injectable, Optional, Inject, PLATFORM_ID, NgModule, SkipSelf, Component, Pipe, CUSTOM_ELEMENTS_SCHEMA, ViewChild, Input, ViewChildren } from '@angular/core';
 import { Subject, takeUntil, map, catchError, throwError, from } from 'rxjs';
 import { SmartSubject } from '@smartbit4all/subject';
 import * as i1 from '@angular/common/http';
@@ -28,15 +28,19 @@ import { catchError as catchError$1, switchMap } from 'rxjs/operators';
 import * as i4$4 from '@angular/material/snack-bar';
 import { MAT_SNACK_BAR_DATA, MatSnackBarModule } from '@angular/material/snack-bar';
 import { Validators } from '@angular/forms';
+import * as i5$1 from '@angular/material/menu';
+import { MatMenuTrigger, MatMenuModule } from '@angular/material/menu';
+import * as i1$2 from '@angular/material/tree';
+import { MatTreeNestedDataSource, MatTreeModule } from '@angular/material/tree';
+import { NestedTreeControl } from '@angular/cdk/tree';
 import { __decorate, __param } from 'tslib';
 import { SmartGridComponent } from '@smartbit4all/grid';
-import { SmarttreeGenericService } from '@smartbit4all/tree';
 
 /**
  * Custom HttpParameterCodec
  * Workaround for https://github.com/angular/angular/issues/18261
  */
-class CustomHttpParameterCodec$1 {
+class CustomHttpParameterCodec$2 {
     encodeKey(k) {
         return encodeURIComponent(k);
     }
@@ -51,15 +55,15 @@ class CustomHttpParameterCodec$1 {
     }
 }
 
-const BASE_PATH$1 = new InjectionToken('basePath');
-const COLLECTION_FORMATS$1 = {
+const BASE_PATH$2 = new InjectionToken('basePath');
+const COLLECTION_FORMATS$2 = {
     'csv': ',',
     'tsv': '   ',
     'ssv': ' ',
     'pipes': '|'
 };
 
-class Configuration$1 {
+class Configuration$2 {
     constructor(configurationParameters = {}) {
         this.apiKeys = configurationParameters.apiKeys;
         this.username = configurationParameters.username;
@@ -166,7 +170,7 @@ class SessionService {
         this.httpClient = httpClient;
         this.basePath = 'http://localhost';
         this.defaultHeaders = new HttpHeaders();
-        this.configuration = new Configuration$1();
+        this.configuration = new Configuration$2();
         if (configuration) {
             this.configuration = configuration;
         }
@@ -179,7 +183,7 @@ class SessionService {
             }
             this.configuration.basePath = basePath;
         }
-        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec$1();
+        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec$2();
     }
     // @ts-ignore
     addToHttpParams(httpParams, value, key) {
@@ -430,7 +434,7 @@ class SessionService {
         });
     }
 }
-SessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SessionService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH$1, optional: true }, { token: Configuration$1, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+SessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SessionService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH$2, optional: true }, { token: Configuration$2, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
 SessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SessionService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SessionService, decorators: [{
             type: Injectable,
@@ -441,8 +445,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
                     type: Optional
                 }, {
                     type: Inject,
-                    args: [BASE_PATH$1]
-                }] }, { type: Configuration$1, decorators: [{
+                    args: [BASE_PATH$2]
+                }] }, { type: Configuration$2, decorators: [{
                     type: Optional
                 }] }]; } });
 
@@ -951,7 +955,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
  * Custom HttpParameterCodec
  * Workaround for https://github.com/angular/angular/issues/18261
  */
-class CustomHttpParameterCodec {
+class CustomHttpParameterCodec$1 {
     encodeKey(k) {
         return encodeURIComponent(k);
     }
@@ -966,15 +970,15 @@ class CustomHttpParameterCodec {
     }
 }
 
-const BASE_PATH = new InjectionToken('basePath');
-const COLLECTION_FORMATS = {
+const BASE_PATH$1 = new InjectionToken('basePath');
+const COLLECTION_FORMATS$1 = {
     'csv': ',',
     'tsv': '   ',
     'ssv': ' ',
     'pipes': '|'
 };
 
-class Configuration {
+class Configuration$1 {
     constructor(configurationParameters = {}) {
         this.apiKeys = configurationParameters.apiKeys;
         this.username = configurationParameters.username;
@@ -1081,7 +1085,7 @@ class ViewService {
         this.httpClient = httpClient;
         this.basePath = 'http://localhost';
         this.defaultHeaders = new HttpHeaders();
-        this.configuration = new Configuration();
+        this.configuration = new Configuration$1();
         if (configuration) {
             this.configuration = configuration;
         }
@@ -1094,7 +1098,7 @@ class ViewService {
             }
             this.configuration.basePath = basePath;
         }
-        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();
+        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec$1();
     }
     /**
      * @param consumes string[] mime-types
@@ -1871,7 +1875,7 @@ class ViewService {
                 });
             }
             else {
-                localVarFormParams = localVarFormParams.append('contents', [...contents].join(COLLECTION_FORMATS['csv'])) || localVarFormParams;
+                localVarFormParams = localVarFormParams.append('contents', [...contents].join(COLLECTION_FORMATS$1['csv'])) || localVarFormParams;
             }
         }
         let responseType_ = 'json';
@@ -1898,7 +1902,7 @@ class ViewService {
         });
     }
 }
-ViewService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ViewService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ViewService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ViewService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH$1, optional: true }, { token: Configuration$1, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
 ViewService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ViewService, providedIn: 'root' });
 i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: ViewService, decorators: [{
             type: Injectable,
@@ -1909,8 +1913,8 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
                     type: Optional
                 }, {
                     type: Inject,
-                    args: [BASE_PATH]
-                }] }, { type: Configuration, decorators: [{
+                    args: [BASE_PATH$1]
+                }] }, { type: Configuration$1, decorators: [{
                     type: Optional
                 }] }]; } });
 
@@ -2213,7 +2217,7 @@ class ApiModule {
     static forRoot(configurationFactory) {
         return {
             ngModule: ApiModule,
-            providers: [{ provide: Configuration, useFactory: configurationFactory }]
+            providers: [{ provide: Configuration$1, useFactory: configurationFactory }]
         };
     }
 }
@@ -4466,56 +4470,1362 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
                 type: Input
             }] } });
 
-class SmartNgClientModule {
-}
-SmartNgClientModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartNgClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-SmartNgClientModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartNgClientModule, declarations: [SmartFileUploaderComponent], imports: [BrowserModule,
-        MatCommonModule,
-        SmartSessionModule,
-        SmartViewContextModule,
-        SmartformModule,
-        SmartExpandableSectionModule], exports: [SmartSessionModule, SmartViewContextModule, SmartFileUploaderComponent] });
-SmartNgClientModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartNgClientModule, providers: [SmartNgClientService], imports: [[
-            BrowserModule,
-            MatCommonModule,
-            SmartSessionModule,
-            SmartViewContextModule,
-            SmartformModule,
-            SmartExpandableSectionModule,
-        ], SmartSessionModule, SmartViewContextModule] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartNgClientModule, decorators: [{
-            type: NgModule,
-            args: [{
-                    declarations: [SmartFileUploaderComponent],
-                    imports: [
-                        BrowserModule,
-                        MatCommonModule,
-                        SmartSessionModule,
-                        SmartViewContextModule,
-                        SmartformModule,
-                        SmartExpandableSectionModule,
-                    ],
-                    exports: [SmartSessionModule, SmartViewContextModule, SmartFileUploaderComponent],
-                    providers: [SmartNgClientService],
-                }]
-        }] });
+/**
+ * Custom HttpParameterCodec
+ * Workaround for https://github.com/angular/angular/issues/18261
+ */
+class CustomHttpParameterCodec {
+    encodeKey(k) {
+        return encodeURIComponent(k);
+    }
+    encodeValue(v) {
+        return encodeURIComponent(v);
+    }
+    decodeKey(k) {
+        return decodeURIComponent(k);
+    }
+    decodeValue(v) {
+        return decodeURIComponent(v);
+    }
+}
 
-class SmartAuthService {
-    constructor() {
-        this.bffApisHaveBeenSetUp = false;
-        this._destroy$ = new Subject();
-        this.headersUpdated = new SmartSubject(this._destroy$);
+const BASE_PATH = new InjectionToken('basePath');
+const COLLECTION_FORMATS = {
+    'csv': ',',
+    'tsv': '   ',
+    'ssv': ' ',
+    'pipes': '|'
+};
+
+class Configuration {
+    constructor(configurationParameters = {}) {
+        this.apiKeys = configurationParameters.apiKeys;
+        this.username = configurationParameters.username;
+        this.password = configurationParameters.password;
+        this.accessToken = configurationParameters.accessToken;
+        this.basePath = configurationParameters.basePath;
+        this.withCredentials = configurationParameters.withCredentials;
+        this.encoder = configurationParameters.encoder;
+        if (configurationParameters.encodeParam) {
+            this.encodeParam = configurationParameters.encodeParam;
+        }
+        else {
+            this.encodeParam = param => this.defaultEncodeParam(param);
+        }
+        if (configurationParameters.credentials) {
+            this.credentials = configurationParameters.credentials;
+        }
+        else {
+            this.credentials = {};
+        }
     }
-    ngOnDestroy() {
-        this._destroy$.next();
-        this._destroy$.complete();
+    /**
+     * Select the correct content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param contentTypes - the array of content types that are available for selection
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderContentType(contentTypes) {
+        if (contentTypes.length === 0) {
+            return undefined;
+        }
+        const type = contentTypes.find((x) => this.isJsonMime(x));
+        if (type === undefined) {
+            return contentTypes[0];
+        }
+        return type;
     }
-}
-SmartAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartAuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-SmartAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartAuthService });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartAuthService, decorators: [{
-            type: Injectable
-        }] });
+    /**
+     * Select the correct accept content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param accepts - the array of content types that are available for selection.
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderAccept(accepts) {
+        if (accepts.length === 0) {
+            return undefined;
+        }
+        const type = accepts.find((x) => this.isJsonMime(x));
+        if (type === undefined) {
+            return accepts[0];
+        }
+        return type;
+    }
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime) {
+        const jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
+    }
+    lookupCredential(key) {
+        const value = this.credentials[key];
+        return typeof value === 'function'
+            ? value()
+            : value;
+    }
+    defaultEncodeParam(param) {
+        // This implementation exists as fallback for missing configuration
+        // and for backwards compatibility to older typescript-angular generator versions.
+        // It only works for the 'simple' parameter style.
+        // Date-handling only works for the 'date-time' format.
+        // All other styles and Date-formats are probably handled incorrectly.
+        //
+        // But: if that's all you need (i.e.: the most common use-case): no need for customization!
+        const value = param.dataFormat === 'date-time'
+            ? param.value.toISOString()
+            : param.value;
+        return encodeURIComponent(String(value));
+    }
+}
+
+/**
+ * UiTree domain objects
+ * Tree domain objects
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: info@it4all.hu
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+class TreeService {
+    constructor(httpClient, basePath, configuration) {
+        this.httpClient = httpClient;
+        this.basePath = 'http://localhost';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (configuration) {
+            this.configuration = configuration;
+        }
+        if (typeof this.configuration.basePath !== 'string') {
+            if (Array.isArray(basePath) && basePath.length > 0) {
+                basePath = basePath[0];
+            }
+            if (typeof basePath !== 'string') {
+                basePath = this.basePath;
+            }
+            this.configuration.basePath = basePath;
+        }
+        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();
+    }
+    // @ts-ignore
+    addToHttpParams(httpParams, value, key) {
+        if (typeof value === 'object' && value instanceof Date === false) {
+            httpParams = this.addToHttpParamsRecursive(httpParams, value);
+        }
+        else {
+            httpParams = this.addToHttpParamsRecursive(httpParams, value, key);
+        }
+        return httpParams;
+    }
+    addToHttpParamsRecursive(httpParams, value, key) {
+        if (value == null) {
+            return httpParams;
+        }
+        if (typeof value === 'object') {
+            if (Array.isArray(value)) {
+                value.forEach((elem) => (httpParams = this.addToHttpParamsRecursive(httpParams, elem, key)));
+            }
+            else if (value instanceof Date) {
+                if (key != null) {
+                    httpParams = httpParams.append(key, value.toISOString().substr(0, 10));
+                }
+                else {
+                    throw Error('key may not be null if value is Date');
+                }
+            }
+            else {
+                Object.keys(value).forEach((k) => (httpParams = this.addToHttpParamsRecursive(httpParams, value[k], key != null ? `${key}.${k}` : k)));
+            }
+        }
+        else if (key != null) {
+            httpParams = httpParams.append(key, value);
+        }
+        else {
+            throw Error('key may not be null if value is not object or array');
+        }
+        return httpParams;
+    }
+    collapseNode(viewUuid, treeId, nodeId, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling collapseNode.');
+        }
+        if (treeId === null || treeId === undefined) {
+            throw new Error('Required parameter treeId was null or undefined when calling collapseNode.');
+        }
+        if (nodeId === null || nodeId === undefined) {
+            throw new Error('Required parameter nodeId was null or undefined when calling collapseNode.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/tree/${this.configuration.encodeParam({
+            name: 'viewUuid',
+            value: viewUuid,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: 'uuid',
+        })}/${this.configuration.encodeParam({
+            name: 'treeId',
+            value: treeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/${this.configuration.encodeParam({
+            name: 'nodeId',
+            value: nodeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/collapse`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    expandNode(viewUuid, treeId, nodeId, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling expandNode.');
+        }
+        if (treeId === null || treeId === undefined) {
+            throw new Error('Required parameter treeId was null or undefined when calling expandNode.');
+        }
+        if (nodeId === null || nodeId === undefined) {
+            throw new Error('Required parameter nodeId was null or undefined when calling expandNode.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/tree/${this.configuration.encodeParam({
+            name: 'viewUuid',
+            value: viewUuid,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: 'uuid',
+        })}/${this.configuration.encodeParam({
+            name: 'treeId',
+            value: treeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/${this.configuration.encodeParam({
+            name: 'nodeId',
+            value: nodeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/expand`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    getChildrenNodes(viewUuid, treeId, nodeId, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling getChildrenNodes.');
+        }
+        if (treeId === null || treeId === undefined) {
+            throw new Error('Required parameter treeId was null or undefined when calling getChildrenNodes.');
+        }
+        if (nodeId === null || nodeId === undefined) {
+            throw new Error('Required parameter nodeId was null or undefined when calling getChildrenNodes.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/tree/${this.configuration.encodeParam({
+            name: 'viewUuid',
+            value: viewUuid,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: 'uuid',
+        })}/${this.configuration.encodeParam({
+            name: 'treeId',
+            value: treeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/${this.configuration.encodeParam({
+            name: 'nodeId',
+            value: nodeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    getMainActions(viewUuid, treeId, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling getMainActions.');
+        }
+        if (treeId === null || treeId === undefined) {
+            throw new Error('Required parameter treeId was null or undefined when calling getMainActions.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/tree/${this.configuration.encodeParam({
+            name: 'viewUuid',
+            value: viewUuid,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: 'uuid',
+        })}/${this.configuration.encodeParam({
+            name: 'treeId',
+            value: treeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/action`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    getRootNodes(viewUuid, treeId, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling getRootNodes.');
+        }
+        if (treeId === null || treeId === undefined) {
+            throw new Error('Required parameter treeId was null or undefined when calling getRootNodes.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/tree/${this.configuration.encodeParam({
+            name: 'viewUuid',
+            value: viewUuid,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: 'uuid',
+        })}/${this.configuration.encodeParam({
+            name: 'treeId',
+            value: treeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    performAction(viewUuid, treeId, nodeId, body, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling performAction.');
+        }
+        if (treeId === null || treeId === undefined) {
+            throw new Error('Required parameter treeId was null or undefined when calling performAction.');
+        }
+        if (nodeId === null || nodeId === undefined) {
+            throw new Error('Required parameter nodeId was null or undefined when calling performAction.');
+        }
+        if (body === null || body === undefined) {
+            throw new Error('Required parameter body was null or undefined when calling performAction.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        // to determine the Content-Type header
+        const consumes = ['application/json'];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/tree/${this.configuration.encodeParam({
+            name: 'viewUuid',
+            value: viewUuid,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: 'uuid',
+        })}/${this.configuration.encodeParam({
+            name: 'treeId',
+            value: treeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/${this.configuration.encodeParam({
+            name: 'nodeId',
+            value: nodeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/action`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            body: body,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    performMainAction(viewUuid, treeId, body, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling performMainAction.');
+        }
+        if (treeId === null || treeId === undefined) {
+            throw new Error('Required parameter treeId was null or undefined when calling performMainAction.');
+        }
+        if (body === null || body === undefined) {
+            throw new Error('Required parameter body was null or undefined when calling performMainAction.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        // to determine the Content-Type header
+        const consumes = ['application/json'];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/tree/${this.configuration.encodeParam({
+            name: 'viewUuid',
+            value: viewUuid,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: 'uuid',
+        })}/${this.configuration.encodeParam({
+            name: 'treeId',
+            value: treeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/action`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            body: body,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+    selectNode(viewUuid, treeId, nodeId, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling selectNode.');
+        }
+        if (treeId === null || treeId === undefined) {
+            throw new Error('Required parameter treeId was null or undefined when calling selectNode.');
+        }
+        if (nodeId === null || nodeId === undefined) {
+            throw new Error('Required parameter nodeId was null or undefined when calling selectNode.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = ['application/json'];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        let localVarPath = `/tree/${this.configuration.encodeParam({
+            name: 'viewUuid',
+            value: viewUuid,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: 'uuid',
+        })}/${this.configuration.encodeParam({
+            name: 'treeId',
+            value: treeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/${this.configuration.encodeParam({
+            name: 'nodeId',
+            value: nodeId,
+            in: 'path',
+            style: 'simple',
+            explode: false,
+            dataType: 'string',
+            dataFormat: undefined,
+        })}/select`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress,
+        });
+    }
+}
+TreeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TreeService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+TreeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TreeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: TreeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [BASE_PATH]
+                }] }, { type: Configuration, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+var SmartTreeNodeButtonType;
+(function (SmartTreeNodeButtonType) {
+    SmartTreeNodeButtonType["MENU"] = "MENU";
+    SmartTreeNodeButtonType["ICON"] = "ICON";
+    SmartTreeNodeButtonType["NORMAL"] = "NORMAL";
+})(SmartTreeNodeButtonType || (SmartTreeNodeButtonType = {}));
+
+class SmarttreeService {
+    constructor() {
+        this.errorMessage = 'The tree is currently unavailable';
+        this.smartTreeModelChanged = new Subject();
+        this.uiActionModelsChanged = new Subject();
+    }
+    get uiActionModels() {
+        return this._uiActionModels;
+    }
+    set uiActionModels(uiActionModels) {
+        this._uiActionModels = uiActionModels;
+        this.uiActionModelsChanged.next();
+    }
+    async initialize() {
+        await this.downloadTree().then((rootNodes) => {
+            this.treeFromBackend = rootNodes;
+            this.syncTree();
+        });
+    }
+    async downloadTree() {
+        throw new Error('downloadTree method not implemented.');
+    }
+    async downloadChildren(parentNode) {
+        throw new Error('downloadChildren method not implemented.');
+    }
+    onTreeNodeClick(treeNode) {
+        throw new Error('onTreeNodeClick method not implemented.');
+    }
+    onTreeNodeOpen(treeNode) {
+        throw new Error('onTreeNodeOpen method not implemented.');
+    }
+    syncTree() {
+        throw new Error('syncTree method not implemented.');
+    }
+}
+SmarttreeService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SmarttreeService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return []; } });
+
+class SmarttreeGenericService extends SmarttreeService {
+    constructor(inject, pageName, treeId) {
+        super();
+        this.pageName = pageName;
+        this.treeId = treeId;
+        // UseUiAction properties
+        this.submit = new Subject();
+        this.reSubscribeToChange = new Subject();
+        this.uiActionDescriptors = new Map();
+        this.viewContextName = 'viewContextUuid';
+        this.configureTree({
+            pageName: this.pageName,
+            treeid: this.treeId,
+            viewContextName: this.viewContextName,
+        });
+        this.viewContext = inject.get(SmartViewContextService);
+        this.service = inject.get(TreeService);
+        this.uiActionService = inject.get(UiActionService);
+        this.uiActionDescriptorService = inject.get(UiActionDescriptorService);
+        this.initialize();
+    }
+    constructUiActionModels(uiActions) {
+        this.uiActionModels = uiActions.map((uiAction) => {
+            return {
+                serviceToUse: this,
+                uiAction,
+            };
+        });
+    }
+    configureTree(configuration) {
+        this.treeId = configuration.treeid;
+        this.viewContextName = configuration.viewContextName;
+        this.pageName = configuration.pageName;
+    }
+    async initialize() {
+        if (sessionStorage.getItem(this.viewContextName)) {
+            await this.downloadTree().then((rootNodes) => {
+                this.treeFromBackend = rootNodes;
+                this.syncTree();
+            });
+        }
+    }
+    async downloadTree() {
+        let uuid = this.viewContext.getUuidOfPage(this.pageName);
+        const rootNodes = await this.service.getRootNodes(uuid, this.treeId).toPromise();
+        const uiActions = await this.service.getMainActions(uuid, this.treeId).toPromise();
+        if (uiActions) {
+            this.constructUiActionModels(uiActions);
+        }
+        if (!rootNodes) {
+            throw new Error('RootNodes are undefined!');
+        }
+        return rootNodes;
+    }
+    async downloadChildren(parentNode) {
+        let uuid = this.viewContext.getUuidOfPage(this.pageName);
+        const children = await this.service
+            .getChildrenNodes(uuid, this.treeId, parentNode.identifier)
+            .toPromise();
+        if (!children) {
+            throw new Error(`Node with identifier ${parentNode.identifier} does not have children.`);
+        }
+        return children;
+    }
+    async onTreeNodeOpen(treeNode) {
+        let viewUuid = this.viewContext.getUuidOfPage(this.pageName);
+        if (treeNode?.expanded) {
+            let tempTreeNode = await this.service
+                .collapseNode(viewUuid, this.treeId, treeNode.identifier)
+                .toPromise();
+            treeNode = tempTreeNode;
+        }
+        else if (!treeNode?.expanded) {
+            let tempTreeNode = await this.service
+                .expandNode(viewUuid, this.treeId, treeNode?.identifier)
+                .toPromise();
+            treeNode = tempTreeNode;
+        }
+        let node = this.deepSearchTreeNode(treeNode?.identifier, this.treeFromBackend);
+        node.expanded = treeNode?.expanded;
+        node.childrenNodes = treeNode?.childrenNodes;
+        this.syncTree();
+    }
+    onTreeNodeClick(treeNode) {
+        this.selectFolder(treeNode.identifier, treeNode);
+    }
+    async selectFolder(folderUri, treeNode) {
+        let viewUuid = this.viewContext.getUuidOfPage(this.pageName);
+        await this.service
+            .selectNode(viewUuid, this.treeId, treeNode.identifier)
+            .toPromise()
+            .then((updatedTreeNode) => {
+            if (this.selectedNode) {
+                this.selectedNode.selected = false;
+            }
+            this.selectedNode = updatedTreeNode;
+            let node = this.deepSearchTreeNode(updatedTreeNode?.identifier, this.treeFromBackend);
+            if (!node) {
+                throw Error('Tree node does not exist');
+            }
+            node.expanded = updatedTreeNode?.expanded;
+            node.childrenNodes = updatedTreeNode?.childrenNodes;
+            node.selected = updatedTreeNode?.selected;
+            treeNode = updatedTreeNode;
+            this.syncTree();
+            this.viewContext.getAndSyncViewContext(this.viewContext.getUuidOfPage(this.viewContextName));
+        });
+    }
+    async updateTreeOnTheFly() {
+        await this.initialize();
+    }
+    async syncTree() {
+        await this.cacheActionDesciptors(this.getAllNodes(this.treeFromBackend));
+        if (!this.treeFromBackend) {
+            throw new Error('There is no treeFromBackend available!');
+        }
+        if (!this.smartTreeModel) {
+            this.smartTreeModel = {
+                rootNodes: [],
+            };
+        }
+        let smartTreeNodes = this.createButtonsForTreeNodes(this.treeFromBackend);
+        this.smartTreeModel = undefined;
+        this.smartTreeModel = {
+            rootNodes: [],
+        };
+        this.smartTreeModelChanged.next(this.smartTreeModel);
+        this.smartTreeModel.rootNodes = smartTreeNodes;
+        this.findSelected(this.smartTreeModel.rootNodes);
+        this.smartTreeModelChanged.next(this.smartTreeModel);
+    }
+    deepSearchTreeNode(identifier, nodes) {
+        let treeNode;
+        for (let index = 0; index < nodes.length; index++) {
+            const node = nodes[index];
+            if (node.identifier === identifier) {
+                treeNode = node;
+                break;
+            }
+            if (node.childrenNodes && node.childrenNodes.length) {
+                treeNode = this.deepSearchTreeNode(identifier, node.childrenNodes);
+                if (treeNode) {
+                    break;
+                }
+            }
+        }
+        return treeNode;
+    }
+    findSelected(nodes) {
+        return nodes.forEach((node) => {
+            if (node.selected) {
+                this.selectedNode = node;
+                return;
+            }
+            else if (node.childrenNodes && node.childrenNodes.length) {
+                return this.findSelected(node.childrenNodes);
+            }
+        });
+    }
+    createButtonsForTreeNodes(nodes) {
+        nodes.map((node) => {
+            node.button = node.actions?.length
+                ? {
+                    type: SmartTreeNodeButtonType.MENU,
+                    icon: 'more_vert',
+                    menuItemButtons: node.actions.map((action) => {
+                        return {
+                            type: SmartTreeNodeButtonType.NORMAL,
+                            label: this.getLabelByAction(action),
+                            callback: this.doAction.bind(this),
+                            args: [action, node.identifier],
+                        };
+                    }),
+                }
+                : undefined;
+            node.icon = 'Folders';
+            if (node.childrenNodes) {
+                node.childrenNodes = this.createButtonsForTreeNodes(node.childrenNodes);
+            }
+        });
+        return nodes;
+    }
+    async doAction(args) {
+        let uiAction = args[0];
+        let nodeUuid = args[1];
+        if (uiAction.params) {
+            uiAction.params['nodeUuid'] = nodeUuid;
+        }
+        else {
+            uiAction.params = {
+                nodeUuid: nodeUuid,
+            };
+        }
+        let uiActionModel = {
+            serviceToUse: this,
+            uiAction,
+        };
+        this.uiActionService.uiActionModel = uiActionModel;
+        this.uiActionService.execute(uiAction);
+    }
+    getAllNodes(nodes) {
+        return nodes.flatMap((n) => [n, ...this.getAllNodes(n.childrenNodes)]);
+    }
+    async cacheActionDesciptors(nodes) {
+        await Promise.all(nodes.map(async (node) => {
+            let newUiActions = node.actions?.filter((uiAction) => !this.uiActionDescriptors.get(uiAction.code));
+            if (!newUiActions) {
+                return;
+            }
+            await Promise.all(newUiActions.map(async (uiAction) => {
+                if (!this.uiActionDescriptors.get(uiAction.code)) {
+                    let descriptor = await this.uiActionDescriptorService.getActionDescriptor(uiAction);
+                    this.uiActionDescriptors.set(uiAction.code, descriptor);
+                }
+            }));
+        }));
+    }
+    getLabelByAction(action) {
+        let desc = this.uiActionDescriptors.get(action.code);
+        return desc.title;
+    }
+    // #region UseUiAction
+    getAdditionalParams(uiAction) {
+        if (uiAction.params && uiAction.params['nodeUuid']) {
+            let nodeUuid = uiAction.params['nodeUuid'];
+            let nodeName;
+            if (uiAction.code === 'RENAME') {
+                nodeName = this.deepSearchTreeNode(nodeUuid, this.treeFromBackend)?.caption;
+            }
+            return {
+                forTextArea: '',
+                forTextField: nodeName ? nodeName : '',
+            };
+        }
+        return {
+            forTextArea: '',
+            forTextField: '',
+        };
+    }
+    getModel() {
+        return {};
+    }
+    async performUiActionRequest(uiActionRequest) {
+        if (uiActionRequest.params['nodeUuid']) {
+            await this.performNodeUiActionRequest(uiActionRequest);
+        }
+        else {
+            await this.performMainUiActionRequest(uiActionRequest);
+        }
+        await this.viewContext.getAndSyncViewContext();
+        this.syncTree();
+    }
+    async performNodeUiActionRequest(uiActionRequest) {
+        let nodeId = uiActionRequest.params['nodeUuid'];
+        delete uiActionRequest.params['nodeUuid'];
+        let viewUuid = this.viewContext.getUuidOfPage(this.pageName);
+        this.treeFromBackend = await this.service
+            .performAction(viewUuid, this.treeId, nodeId, uiActionRequest)
+            .toPromise();
+    }
+    async performMainUiActionRequest(uiActionRequest) {
+        let viewUuid = this.viewContext.getUuidOfPage(this.pageName);
+        this.treeFromBackend = await this.service
+            .performMainAction(viewUuid, this.treeId, uiActionRequest)
+            .toPromise();
+    }
+    handleSpecificDemandsAsynchronously(uiAction, uiActionRequest) {
+        throw new Error('Method not implemented.');
+    }
+}
+SmarttreeGenericService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeGenericService, deps: [{ token: i0.Injector }, { token: 'pageName' }, { token: 'treeId' }], target: i0.ɵɵFactoryTarget.Injectable });
+SmarttreeGenericService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeGenericService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeGenericService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['pageName']
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: ['treeId']
+                }] }]; } });
+
+class SmartTreeComponent {
+    constructor(cdr) {
+        this.cdr = cdr;
+        this._destroy$ = new Subject();
+        this.treeControl = new NestedTreeControl((node) => node.childrenNodes);
+        this.dataSource = new MatTreeNestedDataSource();
+        this.smartTreeNodeButtonType = SmartTreeNodeButtonType;
+        this.uiActionModels = [];
+        this.hasChild = (_, node) => node.hasChildren;
+    }
+    ngOnInit() {
+        if (!this.treeService) {
+            throw new Error('TreeService has not been given!');
+        }
+        this.errorMessage = this.treeService.errorMessage;
+        this.treeService.smartTreeModelChanged.subscribe((newSmartTree) => {
+            this.treeData = newSmartTree;
+            this.dataSource.data = this.treeData.rootNodes;
+            this.expandTreeNodes();
+        });
+        this.treeService.uiActionModelsChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            if (this.treeService.uiActionModels) {
+                this.uiActionModels = this.treeService.uiActionModels;
+            }
+        });
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    getIfExpanded(node) {
+        return this.treeControl.isExpanded(node);
+    }
+    expandTreeNodes() {
+        this.expandTreeNodesDeeply(this.dataSource.data);
+    }
+    expandTreeNodesDeeply(nodes) {
+        nodes.forEach((node) => {
+            if (node.expanded) {
+                this.treeControl.expand(node);
+                this.cdr.markForCheck();
+                if (node.childrenNodes && node.childrenNodes.length) {
+                    this.expandTreeNodesDeeply(node.childrenNodes);
+                }
+            }
+            else {
+                this.treeControl.collapse(node);
+            }
+        });
+    }
+    onNodeClick(event, node) {
+        event.stopPropagation();
+        if (this.tempActiveNode)
+            this.tempActiveNode.selected = false;
+        node.selected = true;
+        this.tempActiveNode = node;
+        this.treeService.onTreeNodeClick(node);
+    }
+    onOpenNode(event, node) {
+        event.stopPropagation();
+        this.treeService.onTreeNodeOpen(node);
+    }
+    getNodeStyle(node) {
+        if (this.treeStyle) {
+            var style = node.selected
+                ? {
+                    background: this.treeStyle.activeStyle?.backgroundColor,
+                    color: this.treeStyle.activeStyle?.color,
+                }
+                : {
+                    background: this.treeStyle.levelBackgroundColor[node.level],
+                    color: this.treeStyle.color,
+                };
+            return style;
+        }
+        return {};
+    }
+    getNodePadding(node) {
+        if (this.treeStyle) {
+            var style = node.selected
+                ? {
+                    'padding-left': 15 * node.level + 'px',
+                }
+                : {
+                    'padding-left': 15 * node.level + 'px',
+                };
+            return style;
+        }
+        return {};
+    }
+    customButtonClicked(event, button, close) {
+        event.stopPropagation();
+        if (button.type === SmartTreeNodeButtonType.MENU) {
+            return;
+        }
+        if (!button.callback) {
+            throw new Error(`Button with name ${button.label || button.icon} does not have a callback!`);
+        }
+        button.callback(button.args);
+        if (close) {
+            let openMenus = this.trigger.filter((matMenuTrigger) => matMenuTrigger.menuOpen);
+            openMenus.forEach((matMenuTrigger) => {
+                matMenuTrigger.closeMenu();
+            });
+        }
+    }
+    getClassesForTreeNode(node) {
+        let classes = [];
+        if (node.expanded) {
+            classes.push(this.getCustomClass('expanded', node.level));
+        }
+        else {
+            classes.push(this.getCustomClass('collapsed', node.level));
+        }
+        if (node.selected) {
+            classes.push(this.getCustomClass('selected', node.level));
+        }
+        else {
+            classes.push(this.getCustomClass('unselected', node.level));
+        }
+        if (node.level !== 0) {
+            classes.push(this.getCustomClass('child', node.level));
+        }
+        return classes;
+    }
+    getInnerClassesForTreeNode(node) {
+        let classes = [];
+        if (node.expanded) {
+            classes.push(this.getCustomClass('inner-expanded', node.level));
+        }
+        else {
+            classes.push(this.getCustomClass('inner-collapsed', node.level));
+        }
+        if (node.selected) {
+            classes.push(this.getCustomClass('inner-selected', node.level));
+        }
+        else {
+            classes.push(this.getCustomClass('inner-unselected', node.level));
+        }
+        return classes;
+    }
+    getClassesForTreeNodeChildren(node) {
+        let classes = [];
+        classes.push(this.getCustomClass('group', node.level));
+        return classes;
+    }
+    getCustomClass(cssClass, plusProperty) {
+        return `${cssClass}-${plusProperty}`;
+    }
+}
+SmartTreeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartTreeComponent, deps: [{ token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+SmartTreeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.4.0", type: SmartTreeComponent, selector: "smart-tree", inputs: { treeStyle: "treeStyle", treeService: "treeService" }, viewQueries: [{ propertyName: "tree", first: true, predicate: ["tree"], descendants: true }, { propertyName: "trigger", predicate: MatMenuTrigger, descendants: true }], ngImport: i0, template: "<div class=\"smartTreeContainer\">\r\n  <smart-ui-action-toolbar\r\n    *ngIf=\"uiActionModels.length\"\r\n    [uiActionModels]=\"uiActionModels\"\r\n  ></smart-ui-action-toolbar>\r\n  <mat-tree\r\n    #tree\r\n    *ngIf=\"treeData\"\r\n    [dataSource]=\"dataSource\"\r\n    [treeControl]=\"treeControl\"\r\n    class=\"sm-tree\"\r\n  >\r\n    <mat-nested-tree-node\r\n      *matTreeNodeDef=\"let node; when: hasChild\"\r\n      matTreeNodeToggle=\"{{ getIfExpanded(node) }}\"\r\n      [ngClass]=\"getClassesForTreeNode(node)\"\r\n      [ngStyle]=\"getNodeStyle(node)\"\r\n    >\r\n      <div\r\n        [ngStyle]=\"getNodePadding(node)\"\r\n        [ngClass]=\"getInnerClassesForTreeNode(node)\"\r\n        class=\"mat-tree-node sm-tree-node\"\r\n        (click)=\"onNodeClick($event, node)\"\r\n      >\r\n        <button mat-icon-button [attr.aria-label]=\"'Toggle ' + node.name\">\r\n          <mat-icon\r\n            class=\"mat-icon-rtl-mirror\"\r\n            matTreeNodeToggle\r\n            (click)=\"onOpenNode($event, node)\"\r\n          >\r\n            <div *ngIf=\"hasChild(node.level, node)\">\r\n              {{ treeControl.isExpanded(node) ? 'expand_more' : 'chevron_right' }}\r\n            </div>\r\n          </mat-icon>\r\n        </button>\r\n        <smart-icon [icon]=\"node.icon\"> </smart-icon>\r\n        <div class=\"sm-tree-row\" [ngClass]=\"node.classes\">\r\n          <div class=\"sm-tree-row-caption\">\r\n            {{ node.caption }}\r\n          </div>\r\n          <div class=\"sm-shortDescription-spacer\"></div>\r\n          <div class=\"sm-tree-row-shortDescription\">\r\n            {{ node.shortDescription }}\r\n          </div>\r\n          <div class=\"sm-shortDescription-button-spacer\"></div>\r\n          <div *ngIf=\"node.button\" class=\"sm-tree-node-button\" [ngSwitch]=\"node.button.type\">\r\n            <button\r\n              (click)=\"customButtonClicked($event, node.button)\"\r\n              *ngSwitchCase=\"smartTreeNodeButtonType.ICON\"\r\n              mat-icon-button\r\n            >\r\n              <smart-icon title=\"{{ node.button.icon }}\" [icon]=\"node.button.icon\"></smart-icon>\r\n            </button>\r\n            <div *ngSwitchCase=\"smartTreeNodeButtonType.MENU\">\r\n              <button\r\n                mat-button\r\n                [matMenuTriggerFor]=\"menu\"\r\n                (click)=\"customButtonClicked($event, node.button, true)\"\r\n              >\r\n                <smart-icon *ngIf=\"node.button.icon\" [icon]=\"node.button.icon\"></smart-icon\r\n                >{{ node.button.label }}\r\n              </button>\r\n              <mat-menu #menu=\"matMenu\">\r\n                <button\r\n                  *ngFor=\"let button of node.button.menuItemButtons\"\r\n                  (click)=\"customButtonClicked($event, button, true)\"\r\n                  mat-menu-item\r\n                >\r\n                  <smart-icon *ngIf=\"button.icon\" [icon]=\"button.icon\"></smart-icon\r\n                  >{{ button.label }}\r\n                </button>\r\n              </mat-menu>\r\n            </div>\r\n            <button\r\n              (click)=\"customButtonClicked($event, node.button)\"\r\n              *ngSwitchCase=\"smartTreeNodeButtonType.NORMAL\"\r\n              mat-raised-button\r\n            >\r\n              <smart-icon *ngIf=\"node.button.icon\" [icon]=\"node.button.icon\"></smart-icon>\r\n              {{ node.button.icon }}\r\n            </button>\r\n          </div>\r\n        </div>\r\n      </div>\r\n      <div\r\n        [class.sm-tree-invisible]=\"!treeControl.isExpanded(node)\"\r\n        [ngClass]=\"getClassesForTreeNodeChildren(node)\"\r\n        role=\"group\"\r\n      >\r\n        <ng-container matTreeNodeOutlet></ng-container>\r\n      </div>\r\n    </mat-nested-tree-node>\r\n  </mat-tree>\r\n  <div *ngIf=\"!treeData\">\r\n    <h3>\r\n      {{ errorMessage }}\r\n    </h3>\r\n  </div>\r\n</div>\r\n", styles: [".smartTreeContainer{display:flex;flex-direction:column;gap:.5rem}.sm-tree-invisible{display:none}.sm-tree ul,.sm-tree li{margin-top:0;margin-bottom:0;list-style-type:none}.sm-tree div[role=group]>.mat-tree-node{padding-left:40px}.sm-tee-node{padding-left:40px}.sm-tree-node-name{padding-left:15px;padding-top:15px;display:flex;flex-direction:column}.sm-tree-node-name-row{padding-left:15px;padding-top:15px;display:flex;flex-direction:row;justify-content:space-between}.sm-tree-node-name-col{padding-left:15px;padding-top:15px;display:flex;flex-direction:column}.sm-tee-node-id{font-weight:lighter}.mat-tree-node:hover{cursor:pointer}::ng-deep .mat-icon-rtl-mirror{display:flex;flex-direction:row}.sm-tree-row{display:flex;flex-direction:row;flex:1;align-items:center}.sm-shortDescription-spacer{flex:1}\n"], components: [{ type: i1$2.MatTree, selector: "mat-tree", exportAs: ["matTree"] }, { type: i2.MatButton, selector: "button[mat-button], button[mat-raised-button], button[mat-icon-button],             button[mat-fab], button[mat-mini-fab], button[mat-stroked-button],             button[mat-flat-button]", inputs: ["disabled", "disableRipple", "color"], exportAs: ["matButton"] }, { type: i3.MatIcon, selector: "mat-icon", inputs: ["color", "inline", "svgIcon", "fontSet", "fontIcon"], exportAs: ["matIcon"] }, { type: i4$2.SmartIconComponent, selector: "smart-icon", inputs: ["icon", "color"] }, { type: i5$1.MatMenu, selector: "mat-menu", exportAs: ["matMenu"] }, { type: i5$1.MatMenuItem, selector: "[mat-menu-item]", inputs: ["disabled", "disableRipple", "role"], exportAs: ["matMenuItem"] }], directives: [{ type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i1$2.MatTreeNodeDef, selector: "[matTreeNodeDef]", inputs: ["matTreeNodeDefWhen", "matTreeNode"] }, { type: i1$2.MatNestedTreeNode, selector: "mat-nested-tree-node", inputs: ["role", "disabled", "tabIndex", "matNestedTreeNode"], exportAs: ["matNestedTreeNode"] }, { type: i1$2.MatTreeNodeToggle, selector: "[matTreeNodeToggle]", inputs: ["matTreeNodeToggleRecursive"] }, { type: i4.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i4.NgStyle, selector: "[ngStyle]", inputs: ["ngStyle"] }, { type: i4.NgSwitch, selector: "[ngSwitch]", inputs: ["ngSwitch"] }, { type: i4.NgSwitchCase, selector: "[ngSwitchCase]", inputs: ["ngSwitchCase"] }, { type: i5$1.MatMenuTrigger, selector: "[mat-menu-trigger-for], [matMenuTriggerFor]", exportAs: ["matMenuTrigger"] }, { type: i4.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i1$2.MatTreeNodeOutlet, selector: "[matTreeNodeOutlet]" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartTreeComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'smart-tree', template: "<div class=\"smartTreeContainer\">\r\n  <smart-ui-action-toolbar\r\n    *ngIf=\"uiActionModels.length\"\r\n    [uiActionModels]=\"uiActionModels\"\r\n  ></smart-ui-action-toolbar>\r\n  <mat-tree\r\n    #tree\r\n    *ngIf=\"treeData\"\r\n    [dataSource]=\"dataSource\"\r\n    [treeControl]=\"treeControl\"\r\n    class=\"sm-tree\"\r\n  >\r\n    <mat-nested-tree-node\r\n      *matTreeNodeDef=\"let node; when: hasChild\"\r\n      matTreeNodeToggle=\"{{ getIfExpanded(node) }}\"\r\n      [ngClass]=\"getClassesForTreeNode(node)\"\r\n      [ngStyle]=\"getNodeStyle(node)\"\r\n    >\r\n      <div\r\n        [ngStyle]=\"getNodePadding(node)\"\r\n        [ngClass]=\"getInnerClassesForTreeNode(node)\"\r\n        class=\"mat-tree-node sm-tree-node\"\r\n        (click)=\"onNodeClick($event, node)\"\r\n      >\r\n        <button mat-icon-button [attr.aria-label]=\"'Toggle ' + node.name\">\r\n          <mat-icon\r\n            class=\"mat-icon-rtl-mirror\"\r\n            matTreeNodeToggle\r\n            (click)=\"onOpenNode($event, node)\"\r\n          >\r\n            <div *ngIf=\"hasChild(node.level, node)\">\r\n              {{ treeControl.isExpanded(node) ? 'expand_more' : 'chevron_right' }}\r\n            </div>\r\n          </mat-icon>\r\n        </button>\r\n        <smart-icon [icon]=\"node.icon\"> </smart-icon>\r\n        <div class=\"sm-tree-row\" [ngClass]=\"node.classes\">\r\n          <div class=\"sm-tree-row-caption\">\r\n            {{ node.caption }}\r\n          </div>\r\n          <div class=\"sm-shortDescription-spacer\"></div>\r\n          <div class=\"sm-tree-row-shortDescription\">\r\n            {{ node.shortDescription }}\r\n          </div>\r\n          <div class=\"sm-shortDescription-button-spacer\"></div>\r\n          <div *ngIf=\"node.button\" class=\"sm-tree-node-button\" [ngSwitch]=\"node.button.type\">\r\n            <button\r\n              (click)=\"customButtonClicked($event, node.button)\"\r\n              *ngSwitchCase=\"smartTreeNodeButtonType.ICON\"\r\n              mat-icon-button\r\n            >\r\n              <smart-icon title=\"{{ node.button.icon }}\" [icon]=\"node.button.icon\"></smart-icon>\r\n            </button>\r\n            <div *ngSwitchCase=\"smartTreeNodeButtonType.MENU\">\r\n              <button\r\n                mat-button\r\n                [matMenuTriggerFor]=\"menu\"\r\n                (click)=\"customButtonClicked($event, node.button, true)\"\r\n              >\r\n                <smart-icon *ngIf=\"node.button.icon\" [icon]=\"node.button.icon\"></smart-icon\r\n                >{{ node.button.label }}\r\n              </button>\r\n              <mat-menu #menu=\"matMenu\">\r\n                <button\r\n                  *ngFor=\"let button of node.button.menuItemButtons\"\r\n                  (click)=\"customButtonClicked($event, button, true)\"\r\n                  mat-menu-item\r\n                >\r\n                  <smart-icon *ngIf=\"button.icon\" [icon]=\"button.icon\"></smart-icon\r\n                  >{{ button.label }}\r\n                </button>\r\n              </mat-menu>\r\n            </div>\r\n            <button\r\n              (click)=\"customButtonClicked($event, node.button)\"\r\n              *ngSwitchCase=\"smartTreeNodeButtonType.NORMAL\"\r\n              mat-raised-button\r\n            >\r\n              <smart-icon *ngIf=\"node.button.icon\" [icon]=\"node.button.icon\"></smart-icon>\r\n              {{ node.button.icon }}\r\n            </button>\r\n          </div>\r\n        </div>\r\n      </div>\r\n      <div\r\n        [class.sm-tree-invisible]=\"!treeControl.isExpanded(node)\"\r\n        [ngClass]=\"getClassesForTreeNodeChildren(node)\"\r\n        role=\"group\"\r\n      >\r\n        <ng-container matTreeNodeOutlet></ng-container>\r\n      </div>\r\n    </mat-nested-tree-node>\r\n  </mat-tree>\r\n  <div *ngIf=\"!treeData\">\r\n    <h3>\r\n      {{ errorMessage }}\r\n    </h3>\r\n  </div>\r\n</div>\r\n", styles: [".smartTreeContainer{display:flex;flex-direction:column;gap:.5rem}.sm-tree-invisible{display:none}.sm-tree ul,.sm-tree li{margin-top:0;margin-bottom:0;list-style-type:none}.sm-tree div[role=group]>.mat-tree-node{padding-left:40px}.sm-tee-node{padding-left:40px}.sm-tree-node-name{padding-left:15px;padding-top:15px;display:flex;flex-direction:column}.sm-tree-node-name-row{padding-left:15px;padding-top:15px;display:flex;flex-direction:row;justify-content:space-between}.sm-tree-node-name-col{padding-left:15px;padding-top:15px;display:flex;flex-direction:column}.sm-tee-node-id{font-weight:lighter}.mat-tree-node:hover{cursor:pointer}::ng-deep .mat-icon-rtl-mirror{display:flex;flex-direction:row}.sm-tree-row{display:flex;flex-direction:row;flex:1;align-items:center}.sm-shortDescription-spacer{flex:1}\n"] }]
+        }], ctorParameters: function () { return [{ type: i0.ChangeDetectorRef }]; }, propDecorators: { trigger: [{
+                type: ViewChildren,
+                args: [MatMenuTrigger]
+            }], tree: [{
+                type: ViewChild,
+                args: ['tree']
+            }], treeStyle: [{
+                type: Input
+            }], treeService: [{
+                type: Input
+            }] } });
+
+class SmarttreeModule {
+}
+SmarttreeModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SmarttreeModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeModule, declarations: [SmartTreeComponent], imports: [BrowserModule,
+        MatCommonModule,
+        MatButtonModule,
+        MatIconModule,
+        MatTreeModule,
+        MatMenuModule,
+        SmartIconModule], exports: [SmartTreeComponent] });
+SmarttreeModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeModule, providers: [SmarttreeService, SmarttreeGenericService], imports: [[
+            BrowserModule,
+            MatCommonModule,
+            MatButtonModule,
+            MatIconModule,
+            MatTreeModule,
+            MatMenuModule,
+            SmartIconModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmarttreeModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SmartTreeComponent],
+                    imports: [
+                        BrowserModule,
+                        MatCommonModule,
+                        MatButtonModule,
+                        MatIconModule,
+                        MatTreeModule,
+                        MatMenuModule,
+                        SmartIconModule,
+                    ],
+                    exports: [SmartTreeComponent],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    providers: [SmarttreeService, SmarttreeGenericService],
+                }]
+        }] });
+
+class SmartNgClientModule {
+}
+SmartNgClientModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartNgClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SmartNgClientModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartNgClientModule, declarations: [SmartFileUploaderComponent], imports: [BrowserModule,
+        MatCommonModule,
+        SmartSessionModule,
+        SmartViewContextModule,
+        SmartformModule,
+        SmartExpandableSectionModule], exports: [SmartSessionModule,
+        SmartViewContextModule,
+        SmartFileUploaderComponent,
+        SmarttreeModule] });
+SmartNgClientModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartNgClientModule, providers: [SmartNgClientService], imports: [[
+            BrowserModule,
+            MatCommonModule,
+            SmartSessionModule,
+            SmartViewContextModule,
+            SmartformModule,
+            SmartExpandableSectionModule,
+        ], SmartSessionModule,
+        SmartViewContextModule,
+        SmarttreeModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartNgClientModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [SmartFileUploaderComponent],
+                    imports: [
+                        BrowserModule,
+                        MatCommonModule,
+                        SmartSessionModule,
+                        SmartViewContextModule,
+                        SmartformModule,
+                        SmartExpandableSectionModule,
+                    ],
+                    exports: [
+                        SmartSessionModule,
+                        SmartViewContextModule,
+                        SmartFileUploaderComponent,
+                        SmarttreeModule,
+                    ],
+                    providers: [SmartNgClientService],
+                }]
+        }] });
+
+class SmartAuthService {
+    constructor() {
+        this.bffApisHaveBeenSetUp = false;
+        this._destroy$ = new Subject();
+        this.headersUpdated = new SmartSubject(this._destroy$);
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+}
+SmartAuthService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartAuthService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+SmartAuthService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartAuthService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImport: i0, type: SmartAuthService, decorators: [{
+            type: Injectable
+        }] });
+
+/*
+ * Public API Surface of smarttree
+ */
 
 let SmartComponentApiClient = class SmartComponentApiClient {
     constructor(inject, auth, pageName) {
@@ -4939,5 +6249,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.4.0", ngImpor
  * Generated bundle index. Do not edit.
  */
 
-export { APIS, ApiModule, ApiQueueService, BASE_PATH, COLLECTION_FORMATS, CloseResult, Configuration, DataChangeKind, IS_ASYNC_PARAM_NAME, MessageOptionType, MessageType, SessionAPIS, SessionErrorBehaviour, SessionService, SmartAuthService, SmartComponent, SmartComponentApiClient, SmartDevToolDatePipe, SmartDevToolFloatingButtonComponent, SmartDevToolService, SmartFileUploaderComponent, SmartLinkChannelVariableInPath, SmartLinkUuidVariableInPath, SmartNgClientModule, SmartNgClientService, SmartService, SmartSessionModule, SmartSessionService, SmartSessionTimerComponent, SmartSessionTimerService, SmartViewContextErrorDialogButtonLabel, SmartViewContextErrorDialogMessage, SmartViewContextErrorDialogTitle, SmartViewContextModule, SmartViewContextService, SmartViewRedirect, UiActionButtonIconPos, UiActionButtonType, UiActionConfirmDialogComponent, UiActionConfirmDialogService, UiActionDescriptorService, UiActionDialogType, UiActionFeedbackType, UiActionInputDialogComponent, UiActionInputDialogService, UiActionInputType, UiActionService, UiActionToolbarComponent, ViewEventHandler, ViewService, ViewState, ViewType, WidgetMap };
+export { APIS, ApiModule, ApiQueueService, BASE_PATH$1 as BASE_PATH, COLLECTION_FORMATS$1 as COLLECTION_FORMATS, CloseResult, Configuration$1 as Configuration, DataChangeKind, IS_ASYNC_PARAM_NAME, MessageOptionType, MessageType, SessionAPIS, SessionErrorBehaviour, SessionService, SmartAuthService, SmartComponent, SmartComponentApiClient, SmartDevToolDatePipe, SmartDevToolFloatingButtonComponent, SmartDevToolService, SmartFileUploaderComponent, SmartLinkChannelVariableInPath, SmartLinkUuidVariableInPath, SmartNgClientModule, SmartNgClientService, SmartService, SmartSessionModule, SmartSessionService, SmartSessionTimerComponent, SmartSessionTimerService, SmartTreeComponent, SmartTreeNodeButtonType, SmartViewContextErrorDialogButtonLabel, SmartViewContextErrorDialogMessage, SmartViewContextErrorDialogTitle, SmartViewContextModule, SmartViewContextService, SmartViewRedirect, SmarttreeGenericService, SmarttreeModule, SmarttreeService, UiActionButtonIconPos, UiActionButtonType, UiActionConfirmDialogComponent, UiActionConfirmDialogService, UiActionDescriptorService, UiActionDialogType, UiActionFeedbackType, UiActionInputDialogComponent, UiActionInputDialogService, UiActionInputType, UiActionService, UiActionToolbarComponent, ViewEventHandler, ViewService, ViewState, ViewType, WidgetMap };
 //# sourceMappingURL=smartbit4all-ng-client.mjs.map