@smartbit4all/ng-client 1.0.0

package/fesm2020/smartbit4all-ng-client.mjs

@@ -0,0 +1,3423 @@
+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 { Subject, takeUntil, map, catchError, throwError, from } from 'rxjs';
+import * as i1 from '@angular/common/http';
+import { HttpHeaders, HttpContext, HttpEventType, HTTP_INTERCEPTORS, HttpClientModule } from '@angular/common/http';
+import * as i5 from '@angular/common';
+import { isPlatformBrowser, DOCUMENT, DatePipe, CommonModule } from '@angular/common';
+import * as i2 from '@angular/material/button';
+import { MatButtonModule } from '@angular/material/button';
+import * as i3 from '@angular/material/icon';
+import { MatIconModule } from '@angular/material/icon';
+import * as i3$1 from '@smartbit4all/navigation';
+import * as i4 from '@smartbit4all/dialog';
+import { SmartdialogService, SmartdialogModule } from '@smartbit4all/dialog';
+import { MatCommonModule } from '@angular/material/core';
+import * as i4$2 from '@angular/material/expansion';
+import { MatExpansionModule } from '@angular/material/expansion';
+import { BrowserModule } from '@angular/platform-browser';
+import * as i4$1 from '@smartbit4all/icon';
+import { SmartIconModule } from '@smartbit4all/icon';
+import * as i1$1 from '@angular/material/dialog';
+import * as i2$1 from '@angular/router';
+import { catchError as catchError$1, switchMap } from 'rxjs/operators';
+import * as i3$2 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 '@smartbit4all/form';
+import { SmartFormWidgetType, SmartFormWidgetDirection, SmartValidatorName, SmartformModule } from '@smartbit4all/form';
+
+/**
+ * Custom HttpParameterCodec
+ * Workaround for https://github.com/angular/angular/issues/18261
+ */
+class CustomHttpParameterCodec$1 {
+    encodeKey(k) {
+        return encodeURIComponent(k);
+    }
+    encodeValue(v) {
+        return encodeURIComponent(v);
+    }
+    decodeKey(k) {
+        return decodeURIComponent(k);
+    }
+    decodeValue(v) {
+        return decodeURIComponent(v);
+    }
+}
+
+const BASE_PATH$1 = new InjectionToken('basePath');
+const COLLECTION_FORMATS$1 = {
+    'csv': ',',
+    'tsv': '   ',
+    'ssv': ' ',
+    'pipes': '|'
+};
+
+class Configuration$1 {
+    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 = {};
+        }
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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));
+    }
+}
+
+/**
+ * Session api
+ * Session api...
+ *
+ * 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 SessionService {
+    constructor(httpClient, basePath, configuration) {
+        this.httpClient = httpClient;
+        this.basePath = 'http://localhost';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration$1();
+        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$1();
+    }
+    // @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;
+    }
+    getAuthenticationProviders(observe = 'body', reportProgress = false, options) {
+        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 = `/authenticationProviders`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    getSession(observe = 'body', reportProgress = false, options) {
+        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 = `/session`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    refreshSession(refreshSessionRequest, observe = 'body', reportProgress = false, options) {
+        if (refreshSessionRequest === null || refreshSessionRequest === undefined) {
+            throw new Error('Required parameter refreshSessionRequest was null or undefined when calling refreshSession.');
+        }
+        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 = `/refresh`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            body: refreshSessionRequest,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    setLocale(locale, observe = 'body', reportProgress = false, options) {
+        if (locale === null || locale === undefined) {
+            throw new Error('Required parameter locale was null or undefined when calling setLocale.');
+        }
+        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 = `/locale/${this.configuration.encodeParam({ name: "locale", value: locale, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: undefined })}`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    startSession(observe = 'body', reportProgress = false, options) {
+        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 = `/session`;
+        return this.httpClient.request('put', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+}
+SessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SessionService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH$1, optional: true }, { token: Configuration$1, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+SessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SessionService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [BASE_PATH$1]
+                }] }, { type: Configuration$1, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+const SessionAPIS = [SessionService];
+
+/**
+ * Session api
+ * Session api...
+ *
+ * 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.
+ */
+
+/**
+ * Session api
+ * Session api...
+ *
+ * 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.
+ */
+
+/**
+ * Session api
+ * Session api...
+ *
+ * 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.
+ */
+
+/**
+ * Session api
+ * Session api...
+ *
+ * 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.
+ */
+
+/**
+ * Session api
+ * Session api...
+ *
+ * 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.
+ */
+
+// This service is based on the `ng2-cookies` package which sadly is not a service and does
+class SmartCookieService {
+    constructor(document, 
+    // Get the `PLATFORM_ID` so we can check if we're in a browser.
+    platformId) {
+        this.document = document;
+        this.platformId = platformId;
+        this.documentIsAccessible = isPlatformBrowser(this.platformId);
+    }
+    /**
+     * Get cookie Regular Expression
+     *
+     * @param name Cookie name
+     * @returns property RegExp
+     *
+     * @author: Stepan Suvorov
+     * @since: 1.0.0
+     */
+    static getCookieRegExp(name) {
+        const escapedName = name.replace(/([\[\]\{\}\(\)\|\=\;\+\?\,\.\*\^\$])/gi, "\\$1");
+        return new RegExp("(?:^" + escapedName + "|;\\s*" + escapedName + ")=(.*?)(?:;|$)", "g");
+    }
+    /**
+     * Gets the unencoded version of an encoded component of a Uniform Resource Identifier (URI).
+     *
+     * @param encodedURIComponent A value representing an encoded URI component.
+     *
+     * @returns The unencoded version of an encoded component of a Uniform Resource Identifier (URI).
+     *
+     * @author: Stepan Suvorov
+     * @since: 1.0.0
+     */
+    static safeDecodeURIComponent(encodedURIComponent) {
+        try {
+            return decodeURIComponent(encodedURIComponent);
+        }
+        catch {
+            // probably it is not uri encoded. return as is
+            return encodedURIComponent;
+        }
+    }
+    /**
+     * Return `true` if {@link Document} is accessible, otherwise return `false`
+     *
+     * @param name Cookie name
+     * @returns boolean - whether cookie with specified name exists
+     *
+     * @author: Stepan Suvorov
+     * @since: 1.0.0
+     */
+    check(name) {
+        if (!this.documentIsAccessible) {
+            return false;
+        }
+        name = encodeURIComponent(name);
+        const regExp = SmartCookieService.getCookieRegExp(name);
+        return regExp.test(this.document.cookie);
+    }
+    /**
+     * Get cookies by name
+     *
+     * @param name Cookie name
+     * @returns property value
+     *
+     * @author: Stepan Suvorov
+     * @since: 1.0.0
+     */
+    get(name) {
+        if (this.documentIsAccessible && this.check(name)) {
+            name = encodeURIComponent(name);
+            const regExp = SmartCookieService.getCookieRegExp(name);
+            const result = regExp.exec(this.document.cookie);
+            let results = result.input.split(";");
+            let value;
+            results.forEach((r) => {
+                let values = r.split(`${name}=`);
+                if (values[1] !== "null") {
+                    value = values[1];
+                }
+            });
+            return value ?? "";
+        }
+        else {
+            return "";
+        }
+    }
+    /**
+     * Get all cookies in JSON format
+     *
+     * @returns all the cookies in json
+     *
+     * @author: Stepan Suvorov
+     * @since: 1.0.0
+     */
+    getAll() {
+        if (!this.documentIsAccessible) {
+            return {};
+        }
+        const cookies = {};
+        const document = this.document;
+        if (document.cookie && document.cookie !== "") {
+            document.cookie.split(";").forEach((currentCookie) => {
+                const [cookieName, cookieValue] = currentCookie.split("=");
+                cookies[SmartCookieService.safeDecodeURIComponent(cookieName.replace(/^ /, ""))] =
+                    SmartCookieService.safeDecodeURIComponent(cookieValue);
+            });
+        }
+        return cookies;
+    }
+    set(name, value, expiresOrOptions, path, domain, secure, sameSite) {
+        if (!this.documentIsAccessible) {
+            return;
+        }
+        if (typeof expiresOrOptions === "number" ||
+            expiresOrOptions instanceof Date ||
+            path ||
+            domain ||
+            secure ||
+            sameSite) {
+            const optionsBody = {
+                expires: expiresOrOptions,
+                path,
+                domain,
+                secure,
+                sameSite: sameSite ? sameSite : "Lax",
+            };
+            this.set(name, value, optionsBody);
+            return;
+        }
+        let cookieString = encodeURIComponent(name) + "=" + encodeURIComponent(value) + ";";
+        const options = expiresOrOptions ? expiresOrOptions : {};
+        if (options.expires) {
+            if (typeof options.expires === "number") {
+                const dateExpires = new Date(new Date().getTime() + options.expires * 1000 * 60 * 60 * 24);
+                cookieString += "expires=" + dateExpires.toUTCString() + ";";
+            }
+            else {
+                cookieString += "expires=" + options.expires.toUTCString() + ";";
+            }
+        }
+        if (options.path) {
+            cookieString += "path=" + options.path + ";";
+        }
+        else {
+            cookieString += "path=/;";
+        }
+        if (options.domain) {
+            cookieString += "domain=" + options.domain + ";";
+        }
+        if (options.secure === false && options.sameSite === "None") {
+            options.secure = true;
+            console.warn(`[ngx-cookie-service] Cookie ${name} was forced with secure flag because sameSite=None.` +
+                `More details : https://github.com/stevermeister/ngx-cookie-service/issues/86#issuecomment-597720130`);
+        }
+        if (options.secure) {
+            cookieString += "secure;";
+        }
+        if (!options.sameSite) {
+            options.sameSite = "Lax";
+        }
+        cookieString += "sameSite=" + options.sameSite + ";";
+        this.document.cookie = cookieString;
+    }
+    /**
+     * Delete cookie by name
+     *
+     * @param name   Cookie name
+     * @param path   Cookie path
+     * @param domain Cookie domain
+     * @param secure Cookie secure flag
+     * @param sameSite Cookie sameSite flag - https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Set-Cookie/SameSite
+     *
+     * @author: Stepan Suvorov
+     * @since: 1.0.0
+     */
+    delete(name, path, domain, secure, sameSite = "Lax") {
+        if (!this.documentIsAccessible) {
+            return;
+        }
+        const expiresDate = new Date("Thu, 01 Jan 1970 00:00:01 GMT");
+        this.set(name, "", { expires: expiresDate, path, domain, secure, sameSite });
+    }
+    /**
+     * Delete all cookies
+     *
+     * @param path   Cookie path
+     * @param domain Cookie domain
+     * @param secure Is the Cookie secure
+     * @param sameSite Is the cookie same site
+     *
+     * @author: Stepan Suvorov
+     * @since: 1.0.0
+     */
+    deleteAll(path, domain, secure, sameSite = "Lax") {
+        if (!this.documentIsAccessible) {
+            return;
+        }
+        const cookies = this.getAll();
+        for (const cookieName in cookies) {
+            if (cookies.hasOwnProperty(cookieName)) {
+                this.delete(cookieName, path, domain, secure, sameSite);
+            }
+        }
+    }
+}
+SmartCookieService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartCookieService, deps: [{ token: DOCUMENT }, { token: PLATFORM_ID }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartCookieService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartCookieService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartCookieService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: Document, decorators: [{
+                    type: Inject,
+                    args: [DOCUMENT]
+                }] }, { type: undefined, decorators: [{
+                    type: Inject,
+                    args: [PLATFORM_ID]
+                }] }]; } });
+
+class SmartSessionService {
+    constructor(apiService, cookieService) {
+        this.apiService = apiService;
+        this.cookieService = cookieService;
+        this.isAuthenticated = false;
+        this.authenticationStateChanged = new Subject();
+        this.headerParams = new Array();
+        this.headersUpdated = new Subject();
+        // Locale
+        this.localStorageLocaleName = "locale";
+        this.localeChanged = new Subject();
+        this.sessionExpiracyChanged = new Subject();
+    }
+    get sessionInfoData() {
+        return this._sessionInfoData;
+    }
+    set sessionInfoData(sessionInfoData) {
+        let expiracyChanged = this.sessionInfoData?.expiration !== sessionInfoData?.expiration;
+        this._sessionInfoData = sessionInfoData;
+        if (expiracyChanged) {
+            this.sessionExpiracyChanged.next();
+        }
+    }
+    setSessionHandlerService(smartSessionHandlerService) {
+        this.sessionHandlerService = smartSessionHandlerService;
+    }
+    async handleSessionError(sessionError) {
+        if (this.sessionHandlerService) {
+            await this.sessionHandlerService.handleSessionError(sessionError);
+        }
+        throw new Error(`sessionHandlerService was not initialized. Error: ${sessionError.code}`);
+    }
+    addHeaderParam(headerParam) {
+        this.headerParams.push(headerParam);
+        this.headersUpdated.next();
+    }
+    setUpTokenForSessionService() {
+        if (this.headerParams.find((header) => header.headerName === "Authorization")) {
+            let index = this.headerParams.findIndex((header) => header.headerName === "Authorization");
+            this.headerParams[index].value = `Bearer ${this.token}`;
+        }
+        else {
+            this.addHeaderParam({ headerName: "Authorization", value: `Bearer ${this.token}` });
+        }
+    }
+    setUrl(url) {
+        this.basePath = url;
+    }
+    getBasePath() {
+        if (!this.basePath) {
+            throw new Error("BasePath has not been set in SmartSessionService!");
+        }
+        return this.basePath;
+    }
+    setCookieName(name) {
+        this.cookieName = name;
+    }
+    saveTokenToLocalStorage() {
+        if (this.sessionInfoData && this.cookieName) {
+            localStorage.setItem("token", this.sessionInfoData.sid);
+            if (this.sessionInfoData.refreshToken &&
+                this.sessionInfoData.refreshToken !== localStorage.getItem("refreshToken")) {
+                localStorage.setItem("refreshToken", this.sessionInfoData.refreshToken);
+            }
+            this.cookieService.set(this.cookieName, this.token);
+        }
+    }
+    setAuthenticationStatus() {
+        if (this.sessionInfoData && this.sessionInfoData.authentications) {
+            this.isAuthenticated = this.sessionInfoData.authentications.length > 0;
+        }
+        this.authenticationStateChanged.next(this.isAuthenticated);
+    }
+    checkStatements() {
+        if (!this.basePath) {
+            throw new Error("The url of the backend api has not been set!");
+        }
+        else if (!this.cookieName) {
+            throw new Error("The name of the cookie required by the backend has not been set!");
+        }
+    }
+    async initialize() {
+        this.checkStatements();
+        let tokenFromLocalStorage = localStorage.getItem("token");
+        let tokenFromCookies = this.cookieService.get(this.cookieName);
+        if (tokenFromLocalStorage &&
+            tokenFromCookies &&
+            tokenFromLocalStorage === tokenFromCookies) {
+            this.token = tokenFromLocalStorage;
+            this.setUpTokenForSessionService();
+            try {
+                await this.getSession();
+            }
+            catch (err) {
+                await this.startSession();
+            }
+        }
+        else {
+            await this.clearAndStartNewSession();
+        }
+        if (this.sessionInfoData && this.sessionInfoData.locale) {
+            localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);
+            this.localeChanged.next();
+        }
+    }
+    async startSession() {
+        let sessionInfo = await this.apiService.startSession().toPromise();
+        if (sessionInfo) {
+            this.sessionInfoData = sessionInfo;
+            this.token = sessionInfo.sid;
+            this.saveTokenToLocalStorage();
+            this.setAuthenticationStatus();
+            this.setUpTokenForSessionService();
+        }
+        return this.sessionInfoData;
+    }
+    async getSession() {
+        let sessionInfo = await this.apiService.getSession().toPromise();
+        if (sessionInfo) {
+            this.sessionInfoData = sessionInfo;
+            this.token = sessionInfo.sid;
+            this.saveTokenToLocalStorage();
+            this.setAuthenticationStatus();
+        }
+        return this.sessionInfoData;
+    }
+    async refreshSession() {
+        let refreshToken = localStorage.getItem("refreshToken");
+        if (!refreshToken) {
+            return await this.startSession();
+        }
+        let sessionInfo = await this.apiService
+            .refreshSession({
+            refreshToken,
+        })
+            .toPromise()
+            .catch(async (error) => {
+            if (error.error &&
+                error.error.code &&
+                error.error.code === "session.refreshtoken.invalid") {
+                await this.startSession();
+            }
+        });
+        if (sessionInfo) {
+            this.sessionInfoData = sessionInfo;
+            this.token = sessionInfo.sid;
+            this.saveTokenToLocalStorage();
+            this.setAuthenticationStatus();
+            this.setUpTokenForSessionService();
+        }
+        return this.sessionInfoData;
+    }
+    async getAuthenticationProviders() {
+        let providers = await this.apiService
+            .getAuthenticationProviders()
+            .toPromise();
+        this.providers = providers?.authenticationProviders;
+        return this.providers;
+    }
+    async getIsAuthenticated() {
+        if (this.sessionInfoData) {
+            return this.isAuthenticated;
+        }
+        await this.getSession();
+        return this.isAuthenticated;
+    }
+    async clearAndStartNewSession() {
+        sessionStorage.clear();
+        localStorage.clear();
+        this.headerParams = [];
+        this.cookieService.delete(this.cookieName);
+        await this.startSession();
+    }
+    getLocale() {
+        if (this.sessionInfoData && this.sessionInfoData.locale) {
+            if (localStorage.getItem(this.localStorageLocaleName) !== this.sessionInfoData.locale) {
+                localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);
+            }
+            return this.sessionInfoData.locale;
+        }
+        throw new Error("There is no SessionInfoData or locale is undefined.");
+    }
+    async changeLocale(locale) {
+        this.sessionInfoData = await this.apiService.setLocale(locale).toPromise();
+        if (this.sessionInfoData && this.sessionInfoData.locale) {
+            localStorage.setItem(this.localStorageLocaleName, this.sessionInfoData.locale);
+            this.localeChanged.next();
+        }
+    }
+}
+SmartSessionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionService, deps: [{ token: SessionService }, { token: SmartCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartSessionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: SessionService }, { type: SmartCookieService }]; } });
+
+/**
+ * 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);
+    }
+}
+
+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 = {};
+        }
+    }
+    /**
+     * 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;
+    }
+    /**
+     * 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));
+    }
+}
+
+/**
+ * View API
+ * View API
+ *
+ * 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 ViewService {
+    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;
+    }
+    createViewContext(observe = 'body', reportProgress = false, options) {
+        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 = `/context`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    downloadItem(uuid, item, observe = 'body', reportProgress = false, options) {
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling downloadItem.');
+        }
+        if (item === null || item === undefined) {
+            throw new Error('Required parameter item was null or undefined when calling downloadItem.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [
+                'application/octet-stream'
+            ];
+            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 localVarPath = `/view/${this.configuration.encodeParam({ name: "uuid", value: uuid, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: "uuid" })}/download/${this.configuration.encodeParam({ name: "item", value: item, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: undefined })}`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: "blob",
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    getViewConstraint(uuid, observe = 'body', reportProgress = false, options) {
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling getViewConstraint.');
+        }
+        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 = `/view/${this.configuration.encodeParam({ name: "uuid", value: uuid, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: "uuid" })}/constraint`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    getViewContext(uuid, observe = 'body', reportProgress = false, options) {
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling getViewContext.');
+        }
+        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 = `/context/${this.configuration.encodeParam({ name: "uuid", value: uuid, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: "uuid" })}`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    message(viewUuid, messageUuid, messageResult, observe = 'body', reportProgress = false, options) {
+        if (viewUuid === null || viewUuid === undefined) {
+            throw new Error('Required parameter viewUuid was null or undefined when calling message.');
+        }
+        if (messageUuid === null || messageUuid === undefined) {
+            throw new Error('Required parameter messageUuid was null or undefined when calling message.');
+        }
+        if (messageResult === null || messageResult === undefined) {
+            throw new Error('Required parameter messageResult was null or undefined when calling message.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [];
+            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 = `/message/${this.configuration.encodeParam({ name: "viewUuid", value: viewUuid, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: "uuid" })}/${this.configuration.encodeParam({ name: "messageUuid", value: messageUuid, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: "uuid" })}`;
+        return this.httpClient.request('post', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            body: messageResult,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    showPublishedView(channel, uuid, observe = 'body', reportProgress = false, options) {
+        if (channel === null || channel === undefined) {
+            throw new Error('Required parameter channel was null or undefined when calling showPublishedView.');
+        }
+        if (uuid === null || uuid === undefined) {
+            throw new Error('Required parameter uuid was null or undefined when calling showPublishedView.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [];
+            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 = `/smartlink/${this.configuration.encodeParam({ name: "channel", value: channel, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: undefined })}/${this.configuration.encodeParam({ name: "uuid", value: uuid, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: "uuid" })}`;
+        return this.httpClient.request('put', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    updateViewContext(viewContextUpdate, observe = 'body', reportProgress = false, options) {
+        if (viewContextUpdate === null || viewContextUpdate === undefined) {
+            throw new Error('Required parameter viewContextUpdate was null or undefined when calling updateViewContext.');
+        }
+        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 = `/context`;
+        return this.httpClient.request('put', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            body: viewContextUpdate,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+}
+ViewService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ViewService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+ViewService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ViewService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ViewService, 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
+                }] }]; } });
+
+const APIS = [ViewService];
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+const CloseResult = {
+    Approved: 'approved',
+    Pending: 'pending',
+    Rejected: 'rejected'
+};
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+const MessageOptionType = {
+    Confirm: 'confirm',
+    Reject: 'reject',
+    Cancel: 'cancel'
+};
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+const MessageType = {
+    Info: 'info',
+    Question: 'question',
+    Warning: 'warning',
+    Error: 'error'
+};
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+const UiActionButtonIconPos = {
+    Pre: 'PRE',
+    Post: 'POST'
+};
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+const UiActionButtonType = {
+    Normal: 'NORMAL',
+    Flat: 'FLAT',
+    Stroked: 'STROKED',
+    Raised: 'RAISED',
+    Icon: 'ICON',
+    MiniFab: 'MINI_FAB',
+    Fab: 'FAB'
+};
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+const UiActionFeedbackType = {
+    None: 'NONE',
+    Snackbar: 'SNACKBAR'
+};
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+const UiActionInputType = {
+    None: 'none',
+    Textfield: 'textfield',
+    Textarea: 'textarea',
+    UserSelect: 'user_select'
+};
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+const ViewState = {
+    OpenPending: 'open_pending',
+    ToOpen: 'to_open',
+    Opened: 'opened',
+    ClosePending: 'close_pending',
+    CloseApproved: 'close_approved',
+    ToClose: 'to_close',
+    Closed: 'closed'
+};
+
+/**
+ * View API
+ * View API
+ *
+ * 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.
+ */
+const ViewType = {
+    Normal: 'normal',
+    Dialog: 'dialog',
+    Embedded: 'embedded'
+};
+
+class ViewContextApiModule {
+    constructor(parentModule, http) {
+        if (parentModule) {
+            throw new Error("ApiModule is already loaded. Import in your base AppModule only.");
+        }
+        if (!http) {
+            throw new Error("You need to import the HttpClientModule in your AppModule! \n" +
+                "See also https://github.com/angular/angular/issues/20575");
+        }
+    }
+    static forRoot(configurationFactory) {
+        return {
+            ngModule: ViewContextApiModule,
+            providers: [{ provide: Configuration, useFactory: configurationFactory }],
+        };
+    }
+}
+ViewContextApiModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ViewContextApiModule, deps: [{ token: ViewContextApiModule, optional: true, skipSelf: true }, { token: i1.HttpClient, optional: true }], target: i0.ɵɵFactoryTarget.NgModule });
+ViewContextApiModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ViewContextApiModule });
+ViewContextApiModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ViewContextApiModule, providers: [], imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: ViewContextApiModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [],
+                    exports: [],
+                    providers: [],
+                }]
+        }], ctorParameters: function () { return [{ type: ViewContextApiModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i1.HttpClient, decorators: [{
+                    type: Optional
+                }] }]; } });
+
+class MessageDialogComponent {
+    constructor(viewContext) {
+        this.viewContext = viewContext;
+    }
+    ngOnInit() {
+        this.getMessageData();
+    }
+    ngOnDestroy() {
+        if (!this.messageData.options || !this.messageData.options.length) {
+            this.viewContext.message(this.messageData, {
+                selectedOption: {
+                    code: MessageOptionType.Cancel,
+                    label: "",
+                },
+            });
+        }
+    }
+    async getMessageData() {
+        let messageDialogName = this.viewContext.messageDialogname;
+        let viewData = await this.viewContext.getViewContextDataByPageName(messageDialogName);
+        this.messageData = viewData.message;
+    }
+    getColor(option) {
+        switch (option.type) {
+            case MessageOptionType.Cancel:
+                return "accent";
+            case MessageOptionType.Confirm:
+                return "primary";
+            case MessageOptionType.Reject:
+                return "warn";
+            default:
+                return "accent";
+        }
+    }
+    getType(option) {
+        switch (option.type) {
+            case MessageOptionType.Confirm:
+            case MessageOptionType.Reject:
+                return "mat-raised-button";
+            default:
+                return "mat-button";
+        }
+    }
+    onClick(selectedOption) {
+        this.viewContext.message(this.messageData, {
+            selectedOption,
+        });
+    }
+}
+MessageDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: MessageDialogComponent, deps: [{ token: SmartViewContextService }], target: i0.ɵɵFactoryTarget.Component });
+MessageDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: MessageDialogComponent, selector: "app-message-dialog", ngImport: i0, template: "<div class=\"taskDialogContainer\" *ngIf=\"messageData\">\n\t<h2>\n\t\t{{ messageData.header }}\n\t</h2>\n\t<p>{{ messageData.text }}</p>\n\t<div class=\"buttonsContainer\">\n\t\t<button\n\t\t\t*ngFor=\"let option of messageData.options\"\n\t\t\tmat-button\n\t\t\tclass=\"taskDialogButton\"\n\t\t\t[ngClass]=\"getType(option)\"\n\t\t\tcolor=\"{{ getColor(option) }}\"\n\t\t\t(click)=\"onClick(option)\"\n\t\t>\n\t\t\t<mat-icon *ngIf=\"option.icon\">\n\t\t\t\t{{ option.icon }}\n\t\t\t</mat-icon>\n\t\t\t{{ option.label }}\n\t\t</button>\n\t</div>\n</div>\n", styles: [".taskDialogContainer{width:400px;display:flex;flex-direction:column;gap:.5rem}.spacer{flex:1}.buttonsContainer{display:flex;flex-direction:row;gap:.5rem;justify-content:flex-end}.taskDialogButton{min-width:100px}h2,p{margin:0!important}\n"], components: [{ 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"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: MessageDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "app-message-dialog", template: "<div class=\"taskDialogContainer\" *ngIf=\"messageData\">\n\t<h2>\n\t\t{{ messageData.header }}\n\t</h2>\n\t<p>{{ messageData.text }}</p>\n\t<div class=\"buttonsContainer\">\n\t\t<button\n\t\t\t*ngFor=\"let option of messageData.options\"\n\t\t\tmat-button\n\t\t\tclass=\"taskDialogButton\"\n\t\t\t[ngClass]=\"getType(option)\"\n\t\t\tcolor=\"{{ getColor(option) }}\"\n\t\t\t(click)=\"onClick(option)\"\n\t\t>\n\t\t\t<mat-icon *ngIf=\"option.icon\">\n\t\t\t\t{{ option.icon }}\n\t\t\t</mat-icon>\n\t\t\t{{ option.label }}\n\t\t</button>\n\t</div>\n</div>\n", styles: [".taskDialogContainer{width:400px;display:flex;flex-direction:column;gap:.5rem}.spacer{flex:1}.buttonsContainer{display:flex;flex-direction:row;gap:.5rem;justify-content:flex-end}.taskDialogButton{min-width:100px}h2,p{margin:0!important}\n"] }]
+        }], ctorParameters: function () { return [{ type: SmartViewContextService }]; } });
+
+class SmartViewContextService {
+    constructor(view, session, navigation, dialog) {
+        this.view = view;
+        this.session = session;
+        this.navigation = navigation;
+        this.dialog = dialog;
+        this.tabIdName = "viewContextUuid";
+        this.tabIdhttpHeaderName = "viewContextUuid";
+        this.viewHandlers = new Array();
+        this.openedViewUuids = new Array();
+        this.uuidOfPageHasBeenChanged = new Subject();
+        this.viewContextHasBeenSynced = new Subject();
+        this.openSmartLink = new Subject();
+        this.isOpeningSmartLink = false;
+        this.dialogRefs = [];
+        this.translateServiceChanged = new Subject();
+    }
+    set translateService(translateService) {
+        this._translateService = translateService;
+        this.translateServiceChanged.next();
+        this.translateServiceChanged.complete();
+    }
+    get translateService() {
+        if (this._translateService) {
+            return this._translateService;
+        }
+        return undefined;
+    }
+    setActionDescriptors(actionDescriptors) {
+        this.actionDescriptors = actionDescriptors;
+    }
+    getActionDescriptors() {
+        if (!this.actionDescriptors) {
+            console.error("No action descriptors has been set to ViewContext.");
+        }
+        return this.actionDescriptors;
+    }
+    setViewHandlers(viewHandlers) {
+        this.viewHandlers = viewHandlers;
+    }
+    setViewApiErrors(viewApiErrors) {
+        this.smartViewContextApiErrors = viewApiErrors;
+    }
+    setMessageDialogName(messageDialogName) {
+        this.messageDialogname = messageDialogName;
+        this.viewHandlers.push({
+            name: messageDialogName,
+            component: MessageDialogComponent,
+        });
+    }
+    setUpUrlForViewService() {
+        this.view.configuration.basePath = this.url;
+    }
+    setUrl(url) {
+        this.url = url + "/view";
+        this.setUpUrlForViewService();
+    }
+    async getAndSyncViewContext(uuid) {
+        if (!uuid) {
+            uuid = this.getUuidOfPage(this.tabIdName);
+        }
+        await this.getViewContext(uuid).then(() => {
+            this.syncView();
+        });
+    }
+    async getViewContext(uuid) {
+        this.viewContext = await this.view.getViewContext(uuid).toPromise();
+        if (!this.viewContext) {
+            throw new Error("ViewContext does not exist with the given uuid.");
+        }
+        return this.viewContext;
+    }
+    async getViewContextDataByPageName(pageName) {
+        if (!this.viewContext) {
+            let viewContextUuid = sessionStorage.getItem(this.tabIdName);
+            if (!viewContextUuid) {
+                throw new Error("View context is not initialized!");
+            }
+            await this.getViewContext(viewContextUuid);
+        }
+        let pageUuid = this.getUuidOfPage(pageName);
+        let viewContextByPageName = this.viewContext?.views.find((view) => view.uuid === pageUuid);
+        if (!viewContextByPageName) {
+            throw new Error(`The ViewData of ${pageName} is not found!`);
+        }
+        return viewContextByPageName;
+    }
+    async updateViewContext(viewContextUpdate) {
+        this.viewContext = await this.view.updateViewContext(viewContextUpdate).toPromise();
+        return this.viewContext;
+    }
+    clearSessionStorage() {
+        sessionStorage.clear();
+    }
+    setTabId(tabId) {
+        sessionStorage.setItem(this.tabIdName, tabId);
+        this.session.addHeaderParam({ headerName: this.tabIdhttpHeaderName, value: tabId });
+    }
+    async startViewContext() {
+        this.clearSessionStorage();
+        let newViewContext = await this.view
+            .createViewContext()
+            .toPromise();
+        if (!newViewContext) {
+            throw new Error("No ViewContext was created");
+        }
+        this.viewContext = newViewContext;
+        this.setTabId(newViewContext.uuid);
+        return this.viewContext;
+    }
+    async initialize(uuid) {
+        if (this.viewHandlers.length === 0) {
+            throw new Error("There aren't any viewHandlers in SmartViewContextService! Provide some to use its functions.");
+        }
+        if (!this.messageDialogname) {
+            throw new Error("The messageDialogName provided by the backend has not been set.");
+        }
+        if (uuid) {
+            let subscription = this.session.headersUpdated.subscribe(async () => {
+                subscription.unsubscribe();
+                try {
+                    await this.getViewContext(uuid);
+                    this.setTabId(uuid);
+                }
+                catch (err) {
+                    await this.startViewContext();
+                }
+            });
+            this.setTabId(uuid);
+        }
+        else {
+            await this.startViewContext();
+        }
+        return this.viewContext;
+    }
+    openView(view) {
+        let viewHandler = this.viewHandlers.find((handler) => handler.name === view.viewName);
+        if (!viewHandler) {
+            throw new Error(`SmartViewHandlerModel was not found by view name: ${view.viewName}`);
+        }
+        if (view.type === ViewType.Dialog) {
+            if (!viewHandler.component) {
+                throw new Error(`Component is undefined in SmartViewHandlerModel with name: ${view.viewName}`);
+            }
+            let dialogRef = this.dialog.openComponentAsDialog(viewHandler.component, viewHandler.name);
+            if (view.viewName === this.messageDialogname) {
+                if (view.message?.options && view.message.options.length) {
+                    dialogRef.disableClose = true;
+                }
+            }
+            this.dialogRefs.push({
+                uuid: view.uuid,
+                dialogRef,
+            });
+        }
+        else if (view.type === ViewType.Normal) {
+            if (viewHandler.route === undefined) {
+                throw new Error(`Route is undefined in SmartViewHandlerModel with name: ${view.viewName}`);
+            }
+            this.navigation.navigateTo(viewHandler.route.split("/"));
+        }
+        else {
+            throw new Error("The type of the view and its viewHandler is not the same!");
+        }
+        view.state = ViewState.Opened;
+        this.openedViewUuids.push(view.uuid);
+        sessionStorage.setItem(view.viewName, view.uuid);
+        this.uuidOfPageHasBeenChanged.next(view.viewName);
+        this.updateViewContext({
+            updates: [
+                {
+                    state: ViewState.Opened,
+                    uuid: view.uuid,
+                },
+            ],
+            uuid: this.viewContext?.uuid,
+        });
+    }
+    closeView(view) {
+        let viewHandler = this.viewHandlers.find((handler) => handler.name === view.viewName);
+        if (!viewHandler) {
+            throw new Error(`SmartViewHandlerModel was not found by view name: ${view.viewName}`);
+        }
+        if (view.type === ViewType.Dialog) {
+            let dialogRef = this.dialogRefs.find((dialogRef) => dialogRef.uuid === view.uuid);
+            if (dialogRef) {
+                dialogRef.dialogRef.close();
+                let index = this.dialogRefs.indexOf(dialogRef);
+                this.dialogRefs.splice(index, 1);
+            }
+            else {
+                throw new Error("DialogRef is not found by uuid.");
+            }
+        }
+        else if (view.type === ViewType.Normal) {
+            // TODO: close normal page???
+            // this.navigation.navigateTo(viewHandler.route.split("/"));
+        }
+        else {
+            throw new Error("The type of the view and its viewHandler is not the same!");
+        }
+        view.state = ViewState.Closed;
+        this.openedViewUuids.slice(this.openedViewUuids.indexOf(view.uuid), 1);
+        sessionStorage.removeItem(view.viewName);
+        this.updateViewContext({
+            updates: [
+                {
+                    state: ViewState.Closed,
+                    uuid: view.uuid,
+                },
+            ],
+            uuid: this.viewContext?.uuid,
+        });
+    }
+    async restoreViews(uuid) {
+        if (!this.viewContext) {
+            await this.getViewContext(uuid);
+        }
+        this.viewContext.views.map((view) => {
+            this.openView(view);
+        });
+    }
+    syncView() {
+        this.viewContext?.views.map((view) => {
+            switch (view.state) {
+                case ViewState.ToOpen:
+                    this.openView(view);
+                    break;
+                case ViewState.ToClose:
+                    this.closeView(view);
+                    break;
+            }
+        });
+        this.viewContextHasBeenSynced.next();
+    }
+    getUuidOfPage(pageName) {
+        let uuid = sessionStorage.getItem(pageName);
+        if (!uuid) {
+            throw new Error(`The uuid of ${pageName} is not available.`);
+        }
+        return uuid;
+    }
+    async message(messageData, messageResult) {
+        await this.view
+            .message(messageData.viewUuid ?? "", messageData.uuid, messageResult)
+            .toPromise();
+        await this.getAndSyncViewContext();
+    }
+    getSmartViewContextApiErrorByCode(code) {
+        if (!this.smartViewContextApiErrors) {
+            return {
+                code,
+                message: "An error has occured.",
+                buttonLabel: "Ok",
+                dialogTitle: "Hiba",
+            };
+        }
+        let apiErrorsWithCode = this.smartViewContextApiErrors.viewContextApiErrors.filter((apiError) => {
+            return apiError.code === code;
+        });
+        if (!apiErrorsWithCode || (apiErrorsWithCode && !apiErrorsWithCode.length)) {
+            console.error(`SmartViewContextApiError with code ${code} could not be found.`);
+            return {
+                code,
+                message: "An error has occured.",
+                buttonLabel: "Ok",
+                dialogTitle: "Hiba",
+            };
+        }
+        return apiErrorsWithCode[0];
+    }
+    async getViewConstraint(uuid) {
+        let viewConstraintResponse = await this.view.getViewConstraint(uuid).toPromise();
+        if (!viewConstraintResponse)
+            throw new Error("Could not get ViewConstraint with the given uuid.");
+        return viewConstraintResponse;
+    }
+    async showPublishedView(channel, uuid) {
+        await this.session.initialize();
+        // TODO init view context automatically
+        // await this.initialize();
+        this.isOpeningSmartLink = true;
+        this.openSmartLink.next();
+        await this.openSmartLink.toPromise();
+        await this.view.showPublishedView(channel, uuid).toPromise();
+        await this.getAndSyncViewContext();
+        this.isOpeningSmartLink = false;
+    }
+    async downloadResource(uuid, item) {
+        return await this.view.downloadItem(uuid, item).toPromise();
+    }
+}
+SmartViewContextService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextService, deps: [{ token: ViewService }, { token: SmartSessionService }, { token: i3$1.SmartNavigationService }, { token: i4.SmartdialogService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartViewContextService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: ViewService }, { type: SmartSessionService }, { type: i3$1.SmartNavigationService }, { type: i4.SmartdialogService }]; } });
+
+class SmartNgClientService {
+    constructor(session, viewContext) {
+        this.session = session;
+        this.viewContext = viewContext;
+    }
+}
+SmartNgClientService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientService, deps: [{ token: SmartSessionService }, { token: SmartViewContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartNgClientService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: SmartSessionService }, { type: SmartViewContextService }]; } });
+
+class SmartDevToolService {
+    constructor(cookieService) {
+        this.cookieService = cookieService;
+        this.smartDevToolName = "smartDevTool";
+        this.isSmartDevToolActiveName = "smartDevToolActive";
+        this.isActive = false;
+        this.smartDevToolHoursName = "smartDevToolHours";
+        this.smartDevToolMaxName = "smartDevToolMaxCalls";
+        this.hoursToSave = 1;
+        this.maxNumOfSavedCalls = 50;
+        this.descriptorChanged = new Subject();
+        this.newErrorsCount = 0;
+        this.newErrorsCountChanged = new Subject();
+        this.setUpLocalStorage();
+        let apiCallsFromLocalStorage = localStorage.getItem(this.smartDevToolName);
+        if (apiCallsFromLocalStorage) {
+            this.descriptor = JSON.parse(apiCallsFromLocalStorage);
+        }
+        else {
+            this.descriptor = { apiCalls: [] };
+            this.save();
+        }
+        window.addEventListener("storage", (event) => {
+            if (event.storageArea === localStorage) {
+                this.isActive = localStorage.getItem(this.isSmartDevToolActiveName) === "true";
+                let hoursToSaveString = localStorage.getItem(this.smartDevToolHoursName);
+                if (hoursToSaveString) {
+                    this.hoursToSave = Number.parseInt(hoursToSaveString);
+                }
+                let maxNumOfSavedCalls = localStorage.getItem(this.smartDevToolMaxName);
+                if (maxNumOfSavedCalls) {
+                    this.maxNumOfSavedCalls = Number.parseInt(maxNumOfSavedCalls);
+                }
+            }
+        });
+    }
+    setUpLocalStorage() {
+        let keysOfLocalStorage = Object.keys(localStorage);
+        if (!keysOfLocalStorage.includes(this.isSmartDevToolActiveName)) {
+            localStorage.setItem(this.isSmartDevToolActiveName, "true");
+        }
+    }
+    writeResponse(request, response, requestDate, responseDate) {
+        this.sanitizeByLength();
+        this.sanitizeByTime();
+        let requestHeader = this.createObject(request.headers.keys(), request.headers, false);
+        let responseHeader = this.createObject(response.headers.keys(), response.headers, false);
+        let _localStorage = this.createObject(Object.keys(localStorage).filter((key) => key !== this.smartDevToolName), localStorage, true);
+        let _sessionStorage = this.createObject(Object.keys(sessionStorage), sessionStorage, true);
+        let _cookies = this.cookieService.getAll();
+        this.descriptor.apiCalls = [
+            {
+                url: response.url,
+                requestBody: request.body,
+                requestHeader,
+                requestDate,
+                requestMethod: request.method,
+                responseBody: response.body ?? null,
+                responseHeader,
+                responseStatus: response.status,
+                responseStatusText: response.statusText,
+                responseDate,
+                localStorage: _localStorage,
+                sessionStorage: _sessionStorage,
+                cookies: _cookies,
+            },
+            ...this.descriptor.apiCalls,
+        ];
+        if (response.status !== 200) {
+            this.newErrorsCount++;
+            this.newErrorsCountChanged.next();
+        }
+        this.save();
+    }
+    clearErrors() {
+        this.newErrorsCount = 0;
+        this.newErrorsCountChanged.next();
+    }
+    createObject(keys, mapWithValues, useGetItem) {
+        let newObject = {};
+        keys.forEach((key) => {
+            if (useGetItem) {
+                newObject[key] = mapWithValues.getItem(key);
+            }
+            else {
+                newObject[key] = mapWithValues.get(key);
+            }
+        });
+        return newObject;
+    }
+    sanitizeByTime() {
+        let now = new Date();
+        this.descriptor.apiCalls = this.descriptor.apiCalls.filter((apiCall) => {
+            let hoursBetween;
+            if (typeof apiCall.requestDate === "string") {
+                hoursBetween = Math.floor(Math.abs(now.getMilliseconds() - new Date(apiCall.requestDate).getMilliseconds()) / 36e5);
+            }
+            else {
+                hoursBetween = Math.floor(Math.abs(now.getMilliseconds() - apiCall.requestDate.getMilliseconds()) /
+                    36e5);
+            }
+            return hoursBetween < this.hoursToSave;
+        });
+    }
+    sanitizeByLength() {
+        if (this.descriptor?.apiCalls &&
+            this.descriptor.apiCalls.length > this.maxNumOfSavedCalls) {
+            let length = this.descriptor.apiCalls.length;
+            this.descriptor.apiCalls.splice(this.maxNumOfSavedCalls - 1, length - this.maxNumOfSavedCalls);
+        }
+    }
+    save() {
+        try {
+            localStorage.setItem(this.smartDevToolName, JSON.stringify(this.descriptor));
+            this.descriptorChanged.next();
+        }
+        catch (error) {
+            // localStorage.setItem() throws a "QuotaExceededError" DOMException exception if the new value
+            // couldn't be set. (Setting could fail if, e.g., the user has disabled storage for the site,
+            // or if the quota has been exceeded.)
+            this.sanitizeByLength();
+            this.save();
+        }
+    }
+    clear() {
+        this.descriptor = {
+            apiCalls: [],
+        };
+        this.save();
+    }
+    getPureString() {
+        return localStorage.getItem(this.smartDevToolName);
+    }
+}
+SmartDevToolService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolService, deps: [{ token: SmartCookieService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartDevToolService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: SmartCookieService }]; } });
+class SmartDevToolDatePipe extends DatePipe {
+    transform(value, format = "yyyy.MM.dd. H:mm:ss") {
+        return super.transform(value, format);
+    }
+}
+SmartDevToolDatePipe.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDatePipe, deps: null, target: i0.ɵɵFactoryTarget.Pipe });
+SmartDevToolDatePipe.ɵpipe = i0.ɵɵngDeclarePipe({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDatePipe, name: "smartDevToolDatePipe" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDatePipe, decorators: [{
+            type: Pipe,
+            args: [{
+                    name: "smartDevToolDatePipe",
+                }]
+        }] });
+
+class SmartDevToolDialogService extends SmartdialogService {
+    constructor(dialog, router, service) {
+        super(dialog, router);
+        this.service = service;
+        this.update = this.service.descriptorChanged;
+    }
+    handleAfterClosed(result) { }
+    openDialog() {
+        const dialogData = {
+            content: {
+                title: ''
+            },
+            size: {},
+            customComponent: SmartDevToolDialogComponent
+        };
+        this.createDialog(dialogData, SmartDevToolDialogComponent);
+    }
+    getData() {
+        return this.service.descriptor;
+    }
+    getPureString() {
+        return this.service.getPureString();
+    }
+    clear() {
+        this.service.clear();
+    }
+}
+SmartDevToolDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDialogService, deps: [{ token: i1$1.MatDialog }, { token: i2$1.Router }, { token: SmartDevToolService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartDevToolDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDialogService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.MatDialog }, { type: i2$1.Router }, { type: SmartDevToolService }]; } });
+
+class SmartDevToolDialogComponent {
+    constructor(service) {
+        this.service = service;
+        this._destroy$ = new Subject();
+        this.descriptor = this.service.getData();
+        this.service.update.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this.descriptor = this.service.getData();
+        });
+        this.service.service.clearErrors();
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    clear() {
+        this.service.clear();
+    }
+    getBody(inp) {
+        return this.syntaxHighlight(inp);
+    }
+    syntaxHighlight(json) {
+        if (typeof json != 'string') {
+            json = JSON.stringify(json, undefined, 2);
+        }
+        json = json.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+        return json.replace(/("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?)/g, function (match) {
+            var cls = 'number';
+            if (/^"/.test(match)) {
+                if (/:$/.test(match)) {
+                    cls = 'key';
+                }
+                else {
+                    cls = 'string';
+                }
+            }
+            else if (/true|false/.test(match)) {
+                cls = 'boolean';
+            }
+            else if (/null/.test(match)) {
+                cls = 'null';
+            }
+            return '<span class="' + cls + '">' + match + '</span>';
+        });
+    }
+    copy() {
+        copyToClipboard({
+            value: this.service.getPureString()
+        });
+    }
+    close() {
+        this.service.closeDialog();
+    }
+}
+SmartDevToolDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDialogComponent, deps: [{ token: SmartDevToolDialogService }], target: i0.ɵɵFactoryTarget.Component });
+SmartDevToolDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: SmartDevToolDialogComponent, selector: "app-smart-dev-tool-dialog", ngImport: i0, template: "<div class=\"smartDevToolDialogContainer\">\n    <div class=\"header\">\n        <h2>Developer tool</h2>\n        <button mat-icon-button title=\"close\" (click)=\"close()\">\n            <smart-icon icon=\"close\"></smart-icon>\n        </button>\n    </div>\n    <div class=\"requestsContainer\">\n        <mat-accordion multi>\n            <mat-expansion-panel\n                class=\"requestCard\"\n                [ngClass]=\"apiCall.responseStatus === 200 ? '' : 'hasError'\"\n                *ngFor=\"let apiCall of descriptor?.apiCalls; let i = index\"\n            >\n                <mat-expansion-panel-header>\n                    <mat-panel-title>\n                        <div class=\"titlePanel\">\n                            <span class=\"date\">\n                                {{ apiCall.responseDate | smartDevToolDatePipe }}\n                            </span>\n                            <span class=\"urlText\">\n                                {{ apiCall.url }}\n                            </span>\n                            <div [ngClass]=\"apiCall.requestMethod\">\n                                {{ apiCall.requestMethod }}\n                            </div>\n                            <div [ngClass]=\"'statusCode-' + apiCall.responseStatus.toString()[0]\">\n                                {{ apiCall.responseStatus }}\n                            </div>\n                        </div>\n                    </mat-panel-title>\n                </mat-expansion-panel-header>\n\n                <div>\n                    <div class=\"table\">\n                        <div class=\"row\">\n                            <div class=\"mainCol heading\">Request</div>\n                            <div class=\"mainCol heading\">Response</div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Date</div>\n                                <div class=\"data\">\n                                    {{ apiCall.requestDate | smartDevToolDatePipe }}\n                                </div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Date</div>\n                                <div class=\"data\">\n                                    {{ apiCall.responseDate | smartDevToolDatePipe }}\n                                </div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Headers</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Headers</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.requestHeader\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.requestHeader)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.requestHeader\" class=\"data\">null</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.responseHeader\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.responseHeader)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.responseHeader\" class=\"data\">null</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\"></div>\n                                <div class=\"data\"></div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Status</div>\n                                <div class=\"data\">\n                                    {{ apiCall.responseStatus }}\n                                </div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\"></div>\n                                <div class=\"data\"></div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Status text</div>\n                                <div class=\"data\">\n                                    {{ apiCall.responseStatusText }}\n                                </div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Body</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Body</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.requestBody\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.requestBody)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.requestBody\" class=\"data\">null</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.responseBody\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.responseBody)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.responseBody\" class=\"data\">null</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Session Storage</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Local Storage</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Cookies</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.sessionStorage\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.sessionStorage)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.sessionStorage\" class=\"data\">null</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.localStorage\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.localStorage)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.localStorage\" class=\"data\">null</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.cookies\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.cookies)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.cookies\" class=\"data\">null</div>\n                            </div>\n                        </div>\n                    </div>\n                </div>\n            </mat-expansion-panel>\n        </mat-accordion>\n    </div>\n    <div class=\"buttonsContainer\">\n        <button color=\"primary\" mat-raised-button (click)=\"copy()\">Copy</button>\n        <button color=\"warn\" mat-raised-button (click)=\"clear()\">Clear</button>\n    </div>\n</div>\n", styles: [".smartDevToolDialogContainer{display:flex;flex-direction:column;gap:1rem;width:78vw;height:90vh}.header{display:flex;flex-direction:row;justify-content:space-between}.requestsContainer{display:flex;flex-direction:column;gap:1rem;flex:1;overflow:auto}.requestCard{background-color:var(--primary-lighter-color);padding:.5rem;border-radius:.5rem;display:flex;flex-direction:column}.table{display:flex;flex-direction:column;gap:.25rem}.row{display:flex;flex-direction:row;gap:1rem}.mainCol{flex:1;display:flex;flex-direction:row;gap:.5rem;overflow:auto}.heading{font-weight:700}.data{word-wrap:break-word}.buttonsContainer{display:flex;flex-direction:row;justify-content:space-between}pre{outline:1px solid #000;padding:5px;margin:5px}.string{color:green}.number{color:#ff8c00}.boolean{color:#00f}.null{color:#f0f}.key{color:red}@media only screen and (max-width: 1000px){.row{flex-direction:column;gap:.5rem}.mainCol{flex-direction:column;overflow-x:auto;overflow-y:visible;flex:auto}.requestCard h4{font-size:small;overflow:auto}.smartDevToolDialogContainer{width:calc(80vw - 3rem)}}.hasError{background-color:var(--warn-lighter-color)}.titlePanel{flex:1;display:flex;flex-direction:row;gap:1rem}.urlText{flex:1;text-decoration:underline}.PATCH{color:#d38042}.DELETE{color:#a41e22}.GET{color:#0f6ab4}.POST{color:#10a54a}.PUT{color:#c5862b}.HEAD{color:#ffd20f}.statusCode-2{color:#5fb442}.statusCode-3{color:#5970f6}.statusCode-4{color:#ec6762}.statusCode-5{color:#f2a63b}\n"], components: [{ 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: i4$1.SmartIconComponent, selector: "smart-icon", inputs: ["icon", "color"] }, { type: i4$2.MatExpansionPanel, selector: "mat-expansion-panel", inputs: ["disabled", "expanded", "hideToggle", "togglePosition"], outputs: ["opened", "closed", "expandedChange", "afterExpand", "afterCollapse"], exportAs: ["matExpansionPanel"] }, { type: i4$2.MatExpansionPanelHeader, selector: "mat-expansion-panel-header", inputs: ["tabIndex", "expandedHeight", "collapsedHeight"] }], directives: [{ type: i4$2.MatAccordion, selector: "mat-accordion", inputs: ["multi", "hideToggle", "displayMode", "togglePosition"], exportAs: ["matAccordion"] }, { type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i4$2.MatExpansionPanelTitle, selector: "mat-panel-title" }, { type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }], pipes: { "smartDevToolDatePipe": SmartDevToolDatePipe } });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'app-smart-dev-tool-dialog', template: "<div class=\"smartDevToolDialogContainer\">\n    <div class=\"header\">\n        <h2>Developer tool</h2>\n        <button mat-icon-button title=\"close\" (click)=\"close()\">\n            <smart-icon icon=\"close\"></smart-icon>\n        </button>\n    </div>\n    <div class=\"requestsContainer\">\n        <mat-accordion multi>\n            <mat-expansion-panel\n                class=\"requestCard\"\n                [ngClass]=\"apiCall.responseStatus === 200 ? '' : 'hasError'\"\n                *ngFor=\"let apiCall of descriptor?.apiCalls; let i = index\"\n            >\n                <mat-expansion-panel-header>\n                    <mat-panel-title>\n                        <div class=\"titlePanel\">\n                            <span class=\"date\">\n                                {{ apiCall.responseDate | smartDevToolDatePipe }}\n                            </span>\n                            <span class=\"urlText\">\n                                {{ apiCall.url }}\n                            </span>\n                            <div [ngClass]=\"apiCall.requestMethod\">\n                                {{ apiCall.requestMethod }}\n                            </div>\n                            <div [ngClass]=\"'statusCode-' + apiCall.responseStatus.toString()[0]\">\n                                {{ apiCall.responseStatus }}\n                            </div>\n                        </div>\n                    </mat-panel-title>\n                </mat-expansion-panel-header>\n\n                <div>\n                    <div class=\"table\">\n                        <div class=\"row\">\n                            <div class=\"mainCol heading\">Request</div>\n                            <div class=\"mainCol heading\">Response</div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Date</div>\n                                <div class=\"data\">\n                                    {{ apiCall.requestDate | smartDevToolDatePipe }}\n                                </div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Date</div>\n                                <div class=\"data\">\n                                    {{ apiCall.responseDate | smartDevToolDatePipe }}\n                                </div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Headers</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Headers</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.requestHeader\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.requestHeader)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.requestHeader\" class=\"data\">null</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.responseHeader\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.responseHeader)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.responseHeader\" class=\"data\">null</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\"></div>\n                                <div class=\"data\"></div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Status</div>\n                                <div class=\"data\">\n                                    {{ apiCall.responseStatus }}\n                                </div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\"></div>\n                                <div class=\"data\"></div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Status text</div>\n                                <div class=\"data\">\n                                    {{ apiCall.responseStatusText }}\n                                </div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Body</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Body</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.requestBody\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.requestBody)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.requestBody\" class=\"data\">null</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.responseBody\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.responseBody)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.responseBody\" class=\"data\">null</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Session Storage</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Local Storage</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <div class=\"heading\">Cookies</div>\n                            </div>\n                        </div>\n                        <div class=\"row\">\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.sessionStorage\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.sessionStorage)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.sessionStorage\" class=\"data\">null</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.localStorage\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.localStorage)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.localStorage\" class=\"data\">null</div>\n                            </div>\n                            <div class=\"mainCol\">\n                                <pre\n                                    *ngIf=\"apiCall.cookies\"\n                                    class=\"data\"\n                                    [innerHTML]=\"getBody(apiCall.cookies)\"\n                                ></pre>\n                                <div *ngIf=\"!apiCall.cookies\" class=\"data\">null</div>\n                            </div>\n                        </div>\n                    </div>\n                </div>\n            </mat-expansion-panel>\n        </mat-accordion>\n    </div>\n    <div class=\"buttonsContainer\">\n        <button color=\"primary\" mat-raised-button (click)=\"copy()\">Copy</button>\n        <button color=\"warn\" mat-raised-button (click)=\"clear()\">Clear</button>\n    </div>\n</div>\n", styles: [".smartDevToolDialogContainer{display:flex;flex-direction:column;gap:1rem;width:78vw;height:90vh}.header{display:flex;flex-direction:row;justify-content:space-between}.requestsContainer{display:flex;flex-direction:column;gap:1rem;flex:1;overflow:auto}.requestCard{background-color:var(--primary-lighter-color);padding:.5rem;border-radius:.5rem;display:flex;flex-direction:column}.table{display:flex;flex-direction:column;gap:.25rem}.row{display:flex;flex-direction:row;gap:1rem}.mainCol{flex:1;display:flex;flex-direction:row;gap:.5rem;overflow:auto}.heading{font-weight:700}.data{word-wrap:break-word}.buttonsContainer{display:flex;flex-direction:row;justify-content:space-between}pre{outline:1px solid #000;padding:5px;margin:5px}.string{color:green}.number{color:#ff8c00}.boolean{color:#00f}.null{color:#f0f}.key{color:red}@media only screen and (max-width: 1000px){.row{flex-direction:column;gap:.5rem}.mainCol{flex-direction:column;overflow-x:auto;overflow-y:visible;flex:auto}.requestCard h4{font-size:small;overflow:auto}.smartDevToolDialogContainer{width:calc(80vw - 3rem)}}.hasError{background-color:var(--warn-lighter-color)}.titlePanel{flex:1;display:flex;flex-direction:row;gap:1rem}.urlText{flex:1;text-decoration:underline}.PATCH{color:#d38042}.DELETE{color:#a41e22}.GET{color:#0f6ab4}.POST{color:#10a54a}.PUT{color:#c5862b}.HEAD{color:#ffd20f}.statusCode-2{color:#5fb442}.statusCode-3{color:#5970f6}.statusCode-4{color:#ec6762}.statusCode-5{color:#f2a63b}\n"] }]
+        }], ctorParameters: function () { return [{ type: SmartDevToolDialogService }]; } });
+const copyToClipboard = async ({ target, message, value }) => {
+    try {
+        let copyValue = '';
+        if (!navigator.clipboard) {
+            throw new Error("Browser don't have support for native clipboard.");
+        }
+        if (target) {
+            const node = document.querySelector(target);
+            if (!node || !node.textContent) {
+                throw new Error('Element not found');
+            }
+            value = node.textContent;
+        }
+        if (value) {
+            copyValue = value;
+        }
+        await navigator.clipboard.writeText(copyValue);
+    }
+    catch (error) {
+        console.error(error.toString());
+    }
+};
+
+class SmartDevToolFloatingButtonComponent {
+    constructor(service) {
+        this.service = service;
+        this._destroy$ = new Subject();
+        this.adminKeyName = "useDevTool";
+        this.isShown = false;
+        this.errorsCount = "";
+        this.service.service.newErrorsCountChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this.errorsCount = `${this.service.service.newErrorsCount > 0 ? this.service.service.newErrorsCount : ""}`;
+        });
+        window.addEventListener("storage", (event) => {
+            if (event.storageArea === localStorage) {
+                if (Object.keys(localStorage).includes(this.adminKeyName)) {
+                    this.isShown = localStorage.getItem(this.adminKeyName) === "true";
+                }
+            }
+        });
+        this.isShown = localStorage.getItem(this.adminKeyName) === "true";
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    openDevToolDialog() {
+        this.service.openDialog();
+    }
+}
+SmartDevToolFloatingButtonComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolFloatingButtonComponent, deps: [{ token: SmartDevToolDialogService }], target: i0.ɵɵFactoryTarget.Component });
+SmartDevToolFloatingButtonComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: SmartDevToolFloatingButtonComponent, selector: "smart-session-dev-tool", ngImport: i0, template: "<button\n    *ngIf=\"isShown\"\n    mat-fab\n    [color]=\"errorsCount.length ? 'warn' : 'accent'\"\n    class=\"floatingButton\"\n    extended\n    title=\"devTool\"\n    (click)=\"openDevToolDialog()\"\n>\n    <smart-icon color=\"white\" icon=\"developer_mode\"></smart-icon>\n    {{ errorsCount }}\n</button>\n", styles: [".floatingButton{position:fixed;right:2rem;bottom:2rem}.mat-icon.mat-white{color:#fff}\n"], components: [{ 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: i4$1.SmartIconComponent, selector: "smart-icon", inputs: ["icon", "color"] }], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolFloatingButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "smart-session-dev-tool", template: "<button\n    *ngIf=\"isShown\"\n    mat-fab\n    [color]=\"errorsCount.length ? 'warn' : 'accent'\"\n    class=\"floatingButton\"\n    extended\n    title=\"devTool\"\n    (click)=\"openDevToolDialog()\"\n>\n    <smart-icon color=\"white\" icon=\"developer_mode\"></smart-icon>\n    {{ errorsCount }}\n</button>\n", styles: [".floatingButton{position:fixed;right:2rem;bottom:2rem}.mat-icon.mat-white{color:#fff}\n"] }]
+        }], ctorParameters: function () { return [{ type: SmartDevToolDialogService }]; } });
+
+class SmartDevToolInterceptor {
+    constructor(service) {
+        this.service = service;
+    }
+    intercept(request, next) {
+        if (!this.service.isActive) {
+            return next.handle(request);
+        }
+        let requestDate = new Date();
+        return next.handle(request).pipe(map((event) => {
+            if (event.type === HttpEventType.Response) {
+                let responseDate = new Date();
+                this.service.writeResponse(request, event, requestDate, responseDate);
+            }
+            return event;
+        }));
+    }
+}
+SmartDevToolInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolInterceptor, deps: [{ token: SmartDevToolService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartDevToolInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: SmartDevToolService }]; } });
+class SmartDevToolErrorInterceptor {
+    constructor(service) {
+        this.service = service;
+    }
+    intercept(request, next) {
+        if (!this.service.isActive) {
+            return next.handle(request);
+        }
+        let requestDate = new Date();
+        return next.handle(request).pipe(catchError((error) => {
+            if (error.status !== 200) {
+                let responseDate = new Date();
+                this.service.writeResponse(request, error, requestDate, responseDate);
+            }
+            return throwError(error);
+        }));
+    }
+}
+SmartDevToolErrorInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolErrorInterceptor, deps: [{ token: SmartDevToolService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartDevToolErrorInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolErrorInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartDevToolErrorInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: SmartDevToolService }]; } });
+
+var SessionErrorBehaviour;
+(function (SessionErrorBehaviour) {
+    SessionErrorBehaviour[SessionErrorBehaviour["REFRESH"] = 0] = "REFRESH";
+    SessionErrorBehaviour[SessionErrorBehaviour["RESTART"] = 1] = "RESTART";
+})(SessionErrorBehaviour || (SessionErrorBehaviour = {}));
+
+class SmartSessionTimerService {
+    constructor(session) {
+        this.session = session;
+        this._destroy$ = new Subject();
+        this.totalTimeInMinutes = 30;
+        this.sessionExpiration = "sessionExpiracy";
+        this.timeChanged = new Subject();
+        this.onTimerExpired = new Subject();
+        this.session.sessionExpiracyChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this.restart();
+        });
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    startTimer() {
+        let sessionInfoData = this.session.sessionInfoData;
+        let expiration = new Date(sessionInfoData.expiration);
+        let now = new Date();
+        this.timeLeftInSeconds = Math.floor((expiration.getTime() - now.getTime()) / 1000);
+        this.timer = setInterval(() => {
+            this.timeLeftInSeconds--;
+            if (this.timeLeftInSeconds === 0) {
+                this.timeout();
+            }
+            this.timeChanged.next();
+        }, 1000);
+    }
+    restart() {
+        clearInterval(this.timer);
+        this.startTimer();
+    }
+    timeout() {
+        clearInterval(this.timer);
+        this.onTimerExpired.next();
+    }
+}
+SmartSessionTimerService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerService, deps: [{ token: SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartSessionTimerService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: SmartSessionService }]; } });
+
+class SmartSessionTimerComponent {
+    constructor(service) {
+        this.service = service;
+        this._destroy$ = new Subject();
+    }
+    ngOnInit() {
+        this.service.startTimer();
+        this.timeInSeconds = this.service.timeLeftInSeconds;
+        this.service.timeChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this.timeInSeconds = this.service.timeLeftInSeconds;
+        });
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    formatTime(seconds) {
+        let minutes = Math.floor(seconds / 60);
+        let remainingSeconds = seconds % 60;
+        return `${minutes}:${remainingSeconds < 10 ? "0" : ""}${remainingSeconds}`;
+    }
+}
+SmartSessionTimerComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerComponent, deps: [{ token: SmartSessionTimerService }], target: i0.ɵɵFactoryTarget.Component });
+SmartSessionTimerComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: SmartSessionTimerComponent, selector: "smart-session-timer", providers: [SmartSessionTimerService], ngImport: i0, template: "<div class=\"smart-session-timer-container\">\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\n        {{ formatTime(timeInSeconds!) }}\n    </span>\n</div>\n", styles: [""], directives: [{ type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionTimerComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "smart-session-timer", providers: [SmartSessionTimerService], template: "<div class=\"smart-session-timer-container\">\n    <span class=\"smart-session-timer\" *ngIf=\"timeInSeconds\">\n        {{ formatTime(timeInSeconds!) }}\n    </span>\n</div>\n", styles: [""] }]
+        }], ctorParameters: function () { return [{ type: SmartSessionTimerService }]; } });
+
+/*
+ * Public API Surface of smart-session
+ */
+
+class SmartErrorCatchingInterceptor {
+    constructor(session) {
+        this.session = session;
+        this.sessionErrorCodes = [
+            {
+                code: "session.expired",
+                behaviour: SessionErrorBehaviour.REFRESH,
+            },
+            {
+                code: "session.refreshtoken.invalid",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.badrequest.missingtoken",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.security.nocontext",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.invalidsessionuri",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.notinitialized",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+            {
+                code: "session.viewcontext.missing",
+                behaviour: SessionErrorBehaviour.RESTART,
+            },
+        ];
+    }
+    intercept(request, next) {
+        return next.handle(request).pipe(catchError$1((error) => {
+            if (error.status === 400 && error.error.code) {
+                let sessionError = this.sessionErrorCodes.find((sessionError) => sessionError.code === error.error.code);
+                if (sessionError) {
+                    return this.resolveError(sessionError).pipe(switchMap(() => {
+                        this.session.headerParams.map((headerParam) => {
+                            request = request.clone({
+                                headers: request.headers.set(headerParam.headerName, headerParam.value),
+                            });
+                        });
+                        return next.handle(request);
+                    }));
+                }
+            }
+            return throwError(error);
+        }));
+    }
+    resolveError(sessionError) {
+        if (sessionError.behaviour === SessionErrorBehaviour.RESTART) {
+            return from(this.session.handleSessionError(sessionError));
+        }
+        return from(this.session.refreshSession());
+    }
+}
+SmartErrorCatchingInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartErrorCatchingInterceptor, deps: [{ token: SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartErrorCatchingInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartErrorCatchingInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartErrorCatchingInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: SmartSessionService }]; } });
+
+class SmartHeaderMaintainerInterceptor {
+    constructor(session) {
+        this.session = session;
+    }
+    intercept(request, next) {
+        const hasHeaders = this.session.headerParams && this.session.headerParams.length;
+        let headers = {};
+        if (hasHeaders) {
+            this.session.headerParams.map((headerParam) => {
+                headers[headerParam.headerName] = headerParam.value;
+            });
+        }
+        let url = request.urlWithParams.replace("http://localhost", this.session.getBasePath());
+        // TODO fix me
+        if (request.urlWithParams.includes("/kerb/sso")) {
+            request = request.clone({
+                url: url,
+            });
+            return next.handle(request);
+        }
+        request = request.clone({
+            url: url,
+            setHeaders: headers,
+        });
+        return next.handle(request);
+    }
+}
+SmartHeaderMaintainerInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartHeaderMaintainerInterceptor, deps: [{ token: SmartSessionService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartHeaderMaintainerInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartHeaderMaintainerInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartHeaderMaintainerInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: SmartSessionService }]; } });
+
+class SmartSessionModule {
+}
+SmartSessionModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SmartSessionModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionModule, declarations: [SmartDevToolDialogComponent,
+        SmartDevToolFloatingButtonComponent,
+        SmartDevToolDatePipe,
+        SmartSessionTimerComponent], imports: [BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule], exports: [SmartDevToolFloatingButtonComponent, SmartSessionTimerComponent] });
+SmartSessionModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionModule, providers: [
+        SmartCookieService,
+        SmartSessionService,
+        SmartdialogModule,
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: SmartErrorCatchingInterceptor,
+            multi: true,
+        },
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: SmartHeaderMaintainerInterceptor,
+            multi: true,
+        },
+        { provide: HTTP_INTERCEPTORS, useClass: SmartDevToolInterceptor, multi: true },
+        { provide: HTTP_INTERCEPTORS, useClass: SmartDevToolErrorInterceptor, multi: true },
+    ], imports: [[BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartSessionModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        SmartDevToolDialogComponent,
+                        SmartDevToolFloatingButtonComponent,
+                        SmartDevToolDatePipe,
+                        SmartSessionTimerComponent,
+                    ],
+                    imports: [BrowserModule, MatCommonModule, MatExpansionModule, MatButtonModule, SmartIconModule],
+                    exports: [SmartDevToolFloatingButtonComponent, SmartSessionTimerComponent],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
+                    providers: [
+                        SmartCookieService,
+                        SmartSessionService,
+                        SmartdialogModule,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: SmartErrorCatchingInterceptor,
+                            multi: true,
+                        },
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: SmartHeaderMaintainerInterceptor,
+                            multi: true,
+                        },
+                        { provide: HTTP_INTERCEPTORS, useClass: SmartDevToolInterceptor, multi: true },
+                        { provide: HTTP_INTERCEPTORS, useClass: SmartDevToolErrorInterceptor, multi: true },
+                    ],
+                }]
+        }] });
+
+class SmartViewContextErrorDialogService extends SmartdialogService {
+    constructor(dialog, router, viewContext) {
+        super(dialog, router);
+        this.viewContext = viewContext;
+    }
+    handleAfterClosed(result) { }
+    openDialog() {
+        const dialogData = {
+            content: {
+                title: "",
+            },
+            size: {},
+            customComponent: SmartViewContextErrorDialogComponent,
+        };
+        this.createDialog(dialogData, SmartViewContextErrorDialogComponent);
+    }
+    getSmartViewContextApiError() {
+        if (this.viewApiError?.code) {
+            return this.viewContext.getSmartViewContextApiErrorByCode(this.viewApiError.code);
+        }
+        return {
+            code: this.viewApiError?.code ?? "",
+            message: this.viewApiError?.message ?? "An error has occured",
+            buttonLabel: "Ok",
+            dialogTitle: "Hiba",
+        };
+    }
+}
+SmartViewContextErrorDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogService, deps: [{ token: i1$1.MatDialog }, { token: i2$1.Router }, { token: SmartViewContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartViewContextErrorDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.MatDialog }, { type: i2$1.Router }, { type: SmartViewContextService }]; } });
+
+class SmartViewContextErrorDialogComponent {
+    constructor(service) {
+        this.service = service;
+        this.smartViewContextApiError = this.service.getSmartViewContextApiError();
+    }
+    ngOnInit() { }
+    onActionClick() {
+        if (this.smartViewContextApiError.customAction) {
+            this.smartViewContextApiError.customAction();
+        }
+        this.service.closeDialog();
+    }
+}
+SmartViewContextErrorDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogComponent, deps: [{ token: SmartViewContextErrorDialogService }], target: i0.ɵɵFactoryTarget.Component });
+SmartViewContextErrorDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: SmartViewContextErrorDialogComponent, selector: "lib-smart-view-context-error-dialog", ngImport: i0, template: "<div class=\"container\">\n    <h3 class=\"color-accent-700\">\n        {{ smartViewContextApiError.dialogTitle }}\n    </h3>\n    <div class=\"content\">\n        <p>\n            {{ smartViewContextApiError.message }}\n        </p>\n    </div>\n    <div class=\"buttonContainer\">\n        <button mat-raised-button color=\"primary\" (click)=\"onActionClick()\">\n            {{ smartViewContextApiError.buttonLabel }}\n        </button>\n    </div>\n</div>\n", styles: [".container{display:flex;flex-direction:column;gap:1em;min-width:25rem;max-width:50vw;height:auto;max-height:75vh}.content{flex:1;overflow:auto}.buttonContainer{display:flex;flex-direction:row;justify-content:flex-end}\n"], components: [{ 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"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextErrorDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "lib-smart-view-context-error-dialog", template: "<div class=\"container\">\n    <h3 class=\"color-accent-700\">\n        {{ smartViewContextApiError.dialogTitle }}\n    </h3>\n    <div class=\"content\">\n        <p>\n            {{ smartViewContextApiError.message }}\n        </p>\n    </div>\n    <div class=\"buttonContainer\">\n        <button mat-raised-button color=\"primary\" (click)=\"onActionClick()\">\n            {{ smartViewContextApiError.buttonLabel }}\n        </button>\n    </div>\n</div>\n", styles: [".container{display:flex;flex-direction:column;gap:1em;min-width:25rem;max-width:50vw;height:auto;max-height:75vh}.content{flex:1;overflow:auto}.buttonContainer{display:flex;flex-direction:row;justify-content:flex-end}\n"] }]
+        }], ctorParameters: function () { return [{ type: SmartViewContextErrorDialogService }]; } });
+
+class SmartViewContextInterceptor {
+    constructor(viewContextErrorDialog) {
+        this.viewContextErrorDialog = viewContextErrorDialog;
+    }
+    intercept(request, next) {
+        return next.handle(request).pipe(catchError((error) => {
+            if (error.status === 409 &&
+                (error.error.code || error.error.message)) {
+                this.openErrorDialog(error.error);
+            }
+            return throwError(error);
+        }));
+    }
+    openErrorDialog(viewApiError) {
+        this.viewContextErrorDialog.viewApiError = viewApiError;
+        this.viewContextErrorDialog.openDialog();
+    }
+}
+SmartViewContextInterceptor.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextInterceptor, deps: [{ token: SmartViewContextErrorDialogService }], target: i0.ɵɵFactoryTarget.Injectable });
+SmartViewContextInterceptor.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextInterceptor });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextInterceptor, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: SmartViewContextErrorDialogService }]; } });
+
+class SmartViewRedirect {
+    constructor(service, navigation, route) {
+        this.service = service;
+        this.navigation = navigation;
+        this.route = route;
+        this.navigation.route = this.route;
+        this.navigation.subscribeToUrlChange((url) => {
+            let channel = this.route.snapshot.paramMap.get(SmartLinkChannelVariableInPath);
+            let uuid = this.route.snapshot.paramMap.get(SmartLinkUuidVariableInPath);
+            if (!channel || !uuid) {
+                throw new Error("channel or uuid is not reachable from the url!");
+            }
+            this.service.showPublishedView(channel, uuid);
+        });
+    }
+}
+SmartViewRedirect.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewRedirect, deps: [{ token: SmartViewContextService }, { token: i3$1.SmartNavigationService }, { token: i2$1.ActivatedRoute }], target: i0.ɵɵFactoryTarget.Component });
+SmartViewRedirect.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: SmartViewRedirect, selector: "app-redirect", ngImport: i0, template: "<div>Smart redirect</div>", isInline: true });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewRedirect, decorators: [{
+            type: Component,
+            args: [{
+                    selector: "app-redirect",
+                    template: "<div>Smart redirect</div>",
+                }]
+        }], ctorParameters: function () { return [{ type: SmartViewContextService }, { type: i3$1.SmartNavigationService }, { type: i2$1.ActivatedRoute }]; } });
+const SmartLinkChannelVariableInPath = "channel";
+const SmartLinkUuidVariableInPath = "uuid";
+
+class UiActionDescriptorService {
+    constructor(viewContext) {
+        this.viewContext = viewContext;
+        this._destroy$ = new Subject();
+        this.languageChanged = new Subject();
+        this.keysToTranslate = ["title", "text", "placeholder", "caption", "feedbackText"];
+        this.basicActionDescriptors = new Map([
+            [
+                "UNKOWN",
+                {
+                    title: "",
+                    type: UiActionButtonType.Normal,
+                    color: "accent",
+                    icon: "Question",
+                    iconColor: `text-primary`,
+                    iconPosition: UiActionButtonIconPos.Post,
+                    dialog: {
+                        title: "",
+                        placeholder: "placeholder",
+                        actionButton: {
+                            caption: "",
+                            color: "accent",
+                        },
+                        cancelButton: {
+                            caption: "Mégse",
+                            color: "",
+                        },
+                    },
+                },
+            ],
+        ]);
+        if (this.viewContext.translateService) {
+            this.subscribeToTranslateService();
+        }
+        else {
+            this.viewContext.translateServiceChanged
+                .pipe(takeUntil(this._destroy$))
+                .subscribe(() => {
+                this.subscribeToTranslateService();
+            });
+        }
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+        this._destroy$.complete();
+    }
+    subscribeToTranslateService() {
+        this.viewContext
+            .translateService.onLangChange.pipe(takeUntil(this._destroy$))
+            .subscribe(() => {
+            this.languageChanged.next();
+        });
+    }
+    async getActionDescriptor(uiAction) {
+        let code = uiAction.code;
+        let actionDescriptorFromDescriptors = this.viewContext.getActionDescriptors()?.get(code);
+        let actionDescriptor = JSON.parse(JSON.stringify(actionDescriptorFromDescriptors));
+        if (!actionDescriptor) {
+            actionDescriptor = this.basicActionDescriptors.get("UNKOWN");
+            actionDescriptor.title = code;
+        }
+        if (!actionDescriptor.dialog) {
+            actionDescriptor = this.setUpUnkownDialogDescriptor(code, actionDescriptor, "dialog");
+        }
+        if (!actionDescriptor.feedbackType && uiAction.submit) {
+            actionDescriptor.feedbackType = UiActionFeedbackType.Snackbar;
+        }
+        if (this.viewContext.translateService && actionDescriptor) {
+            actionDescriptor = await this.translateUiActionDescriptor(actionDescriptor);
+        }
+        return actionDescriptor;
+    }
+    async translateUiActionDescriptor(uiActionDescriptor) {
+        uiActionDescriptor = await this.deepTranslate(uiActionDescriptor);
+        return uiActionDescriptor;
+    }
+    async deepTranslate(model) {
+        Object.keys(model).map(async (key) => {
+            if (model[key] !== undefined &&
+                typeof model[key] === "string" &&
+                model[key].length &&
+                this.keysToTranslate.includes(key)) {
+                model[key] = await this.viewContext.translateService.get(model[key]).toPromise();
+            }
+            else if (model[key] !== undefined && typeof model[key] === "object") {
+                model[key] = await this.deepTranslate(model[key]);
+            }
+            return model;
+        });
+        return model;
+    }
+    setUpUnkownDialogDescriptor(code, uiActionDescriptor, dialogType) {
+        let unkownDescriptor = this.basicActionDescriptors.get("UNKOWN");
+        uiActionDescriptor[dialogType] = unkownDescriptor.dialog;
+        uiActionDescriptor[dialogType].title = code;
+        uiActionDescriptor[dialogType].actionButton.caption = code;
+        return uiActionDescriptor;
+    }
+}
+UiActionDescriptorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionDescriptorService, deps: [{ token: SmartViewContextService }], target: i0.ɵɵFactoryTarget.Injectable });
+UiActionDescriptorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionDescriptorService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionDescriptorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: SmartViewContextService }]; } });
+
+class SuccessSnackBarComponent {
+    constructor(data, viewContext, manager) {
+        this.data = data;
+        this.viewContext = viewContext;
+        this.manager = manager;
+        this.manager.getActionDescriptor(data).then((descriptor) => {
+            if (descriptor.feedbackText) {
+                this.text = descriptor.feedbackText;
+            }
+            else {
+                this.text = this.viewContext.commonFeedbackText ?? "A mentés sikeres volt!";
+            }
+        });
+    }
+}
+SuccessSnackBarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SuccessSnackBarComponent, deps: [{ token: MAT_SNACK_BAR_DATA }, { token: SmartViewContextService }, { token: UiActionDescriptorService }], target: i0.ɵɵFactoryTarget.Component });
+SuccessSnackBarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: SuccessSnackBarComponent, selector: "app-success-snack-bar", ngImport: i0, template: "<span class=\"successSnakBarContainer\" matSnackBarLabel> {{ text }} </span>\n", styles: ["::ng-deep .mat-snack-bar-container{text-align:center;border-radius:2rem}.successSnakBarContainer{color:#fff}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SuccessSnackBarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "app-success-snack-bar", template: "<span class=\"successSnakBarContainer\" matSnackBarLabel> {{ text }} </span>\n", styles: ["::ng-deep .mat-snack-bar-container{text-align:center;border-radius:2rem}.successSnakBarContainer{color:#fff}\n"] }]
+        }], ctorParameters: function () { return [{ type: undefined, decorators: [{
+                    type: Inject,
+                    args: [MAT_SNACK_BAR_DATA]
+                }] }, { type: SmartViewContextService }, { type: UiActionDescriptorService }]; } });
+
+class UiActionConfirmDialogComponent {
+    constructor(service, manager) {
+        this.service = service;
+        this.manager = manager;
+        this.code = this.service.action.code;
+        this.setUp();
+    }
+    async setUp() {
+        this.descriptor = await this.manager.getActionDescriptor(this.service.action);
+        this.dialogType = this.descriptor.confirmDialog ? "confirmDialog" : "dialog";
+    }
+    ngOnDestroy() {
+        this.service._destroy$.next();
+        this.cancel();
+    }
+    getTitle() {
+        return this.descriptor[this.dialogType].title;
+    }
+    getText() {
+        return this.descriptor[this.dialogType].text ?? "";
+    }
+    getActionButtonLabel() {
+        return this.descriptor[this.dialogType].actionButton.caption;
+    }
+    getActionButtonColor() {
+        return this.descriptor[this.dialogType].actionButton.color;
+    }
+    getCancelButtonLabel() {
+        return this.descriptor[this.dialogType].cancelButton.caption;
+    }
+    getCancelButtonColor() {
+        return this.descriptor[this.dialogType].cancelButton.color;
+    }
+    doAction() {
+        this.service.doAction();
+    }
+    cancel() {
+        this.service.cancel();
+    }
+}
+UiActionConfirmDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionConfirmDialogComponent, deps: [{ token: UiActionConfirmDialogService }, { token: UiActionDescriptorService }], target: i0.ɵɵFactoryTarget.Component });
+UiActionConfirmDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: UiActionConfirmDialogComponent, selector: "app-ui-action-confirm-dialog", ngImport: i0, template: "<div class=\"folderNameDialogContainer\">\n\t<div class=\"headerContainer\">\n\t\t<h3 class=\"color-accent-700\">\n\t\t\t{{ getTitle() }}\n\t\t</h3>\n\t\t<button mat-icon-button title=\"close\" (click)=\"cancel()\">\n\t\t\t<smart-icon [color]=\"'primary'\" [icon]=\"'X'\"></smart-icon>\n\t\t</button>\n\t</div>\n\t<p>\n\t\t{{ getText() }}\n\t</p>\n\t<div class=\"folderNameDialogButtonsContainer\">\n\t\t<button mat-button color=\"accent\" [color]=\"getCancelButtonColor()\" (click)=\"cancel()\">\n\t\t\t{{ getCancelButtonLabel() }}\n\t\t</button>\n\t\t<button mat-raised-button [color]=\"getActionButtonColor()\" (click)=\"doAction()\">\n\t\t\t{{ getActionButtonLabel() }}\n\t\t</button>\n\t</div>\n</div>\n", styles: [".folderNameDialogContainer{width:25rem;display:flex;flex-direction:column;gap:1rem}.headerContainer{display:flex;flex-direction:row;justify-content:space-between}.headerContainer h3{margin:0}.folderNameDialogButtonsContainer{display:flex;flex-direction:row;justify-content:flex-end;gap:.5rem}\n"], components: [{ 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: i4$1.SmartIconComponent, selector: "smart-icon", inputs: ["icon", "color"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionConfirmDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "app-ui-action-confirm-dialog", template: "<div class=\"folderNameDialogContainer\">\n\t<div class=\"headerContainer\">\n\t\t<h3 class=\"color-accent-700\">\n\t\t\t{{ getTitle() }}\n\t\t</h3>\n\t\t<button mat-icon-button title=\"close\" (click)=\"cancel()\">\n\t\t\t<smart-icon [color]=\"'primary'\" [icon]=\"'X'\"></smart-icon>\n\t\t</button>\n\t</div>\n\t<p>\n\t\t{{ getText() }}\n\t</p>\n\t<div class=\"folderNameDialogButtonsContainer\">\n\t\t<button mat-button color=\"accent\" [color]=\"getCancelButtonColor()\" (click)=\"cancel()\">\n\t\t\t{{ getCancelButtonLabel() }}\n\t\t</button>\n\t\t<button mat-raised-button [color]=\"getActionButtonColor()\" (click)=\"doAction()\">\n\t\t\t{{ getActionButtonLabel() }}\n\t\t</button>\n\t</div>\n</div>\n", styles: [".folderNameDialogContainer{width:25rem;display:flex;flex-direction:column;gap:1rem}.headerContainer{display:flex;flex-direction:row;justify-content:space-between}.headerContainer h3{margin:0}.folderNameDialogButtonsContainer{display:flex;flex-direction:row;justify-content:flex-end;gap:.5rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: UiActionConfirmDialogService }, { type: UiActionDescriptorService }]; } });
+
+class UiActionConfirmDialogService extends SmartdialogService {
+    constructor(dialog, router) {
+        super(dialog, router);
+        this._destroy$ = new Subject();
+        this.onAction = new Subject();
+        this.shouldDoAction = false;
+    }
+    openDialog() {
+        this.shouldDoAction = false;
+        this.onAction = new Subject();
+        const dialogData = {
+            content: {
+                title: "",
+            },
+            size: {},
+            customComponent: UiActionConfirmDialogComponent,
+        };
+        this.createDialog(dialogData, UiActionConfirmDialogComponent);
+    }
+    doAction() {
+        this.shouldDoAction = true;
+        this.onAction.complete();
+        this.closeDialog();
+        this.onAction = new Subject();
+    }
+    cancel() {
+        this.onAction.complete();
+        this.closeDialog();
+        this.onAction = new Subject();
+    }
+}
+UiActionConfirmDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionConfirmDialogService, deps: [{ token: i1$1.MatDialog }, { token: i2$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+UiActionConfirmDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionConfirmDialogService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionConfirmDialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.MatDialog }, { type: i2$1.Router }]; } });
+
+class UiActionInputDialogComponent {
+    constructor(service, manager) {
+        this.service = service;
+        this.manager = manager;
+        this.code = this.service.action.code;
+        this.setUp();
+    }
+    ngOnDestroy() {
+        this.service._destroy$.next();
+        this.cancel();
+    }
+    async setUp() {
+        this.descriptor = await this.manager.getActionDescriptor(this.service.action);
+        if (this.descriptor[this.service.inputTypeName]) {
+            this.dialogType = this.service.inputTypeName;
+        }
+        else {
+            this.dialogType = this.descriptor.inputDialog ? "inputDialog" : "dialog";
+        }
+        this.constructForm();
+    }
+    getTitle() {
+        return this.descriptor[this.dialogType].title;
+    }
+    getActionButtonLabel() {
+        return this.descriptor[this.dialogType].actionButton.caption;
+    }
+    getActionButtonColor() {
+        return this.descriptor[this.dialogType].actionButton.color;
+    }
+    getCancelButtonLabel() {
+        return this.descriptor[this.dialogType].cancelButton.caption;
+    }
+    getCancelButtonColor() {
+        return this.descriptor[this.dialogType].cancelButton.color;
+    }
+    constructForm() {
+        let model = {};
+        let inputName;
+        if (this.service.inputTypeName === "inputDialog") {
+            inputName = "input";
+        }
+        else {
+            inputName = "input2";
+        }
+        if (this.service.nodeName) {
+            model[inputName] = this.service.nodeName;
+        }
+        else {
+            model[inputName] = "";
+        }
+        let type;
+        let inputType = `${inputName}Type`;
+        if (this.service.action[inputType] === UiActionInputType.Textfield) {
+            type = SmartFormWidgetType.TEXT_FIELD;
+        }
+        else {
+            type = SmartFormWidgetType.TEXT_BOX;
+        }
+        this.folderForm = {
+            direction: SmartFormWidgetDirection.COL,
+            model,
+            widgets: [
+                {
+                    key: inputName,
+                    label: "",
+                    type,
+                    value: "",
+                    validators: [
+                        {
+                            validator: Validators.required,
+                            name: SmartValidatorName.required,
+                            errorMessage: "Ez a mező kötelező",
+                        },
+                    ],
+                    placeholder: this.descriptor[this.dialogType].placeholder ?? "",
+                    showLabel: true,
+                },
+            ],
+        };
+    }
+    save() {
+        let form = this.folderFormChild.submitForm();
+        if (form.invalidFields) {
+            throw new Error("The form is invalid!");
+        }
+        this.service.onSave(form.model);
+    }
+    cancel() {
+        this.service.cancel();
+    }
+}
+UiActionInputDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionInputDialogComponent, deps: [{ token: UiActionInputDialogService }, { token: UiActionDescriptorService }], target: i0.ɵɵFactoryTarget.Component });
+UiActionInputDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: UiActionInputDialogComponent, selector: "smart-ui-action-input-dialog", viewQueries: [{ propertyName: "folderFormChild", first: true, predicate: ["form"], descendants: true }], ngImport: i0, template: "<div class=\"folderNameDialogContainer\">\n\t<div class=\"headerContainer\">\n\t\t<h3 class=\"color-accent-700\">\n\t\t\t{{ getTitle() }}\n\t\t</h3>\n\t\t<button mat-icon-button title=\"close\" (click)=\"cancel()\">\n\t\t\t<smart-icon [color]=\"'primary'\" [icon]=\"'X'\"></smart-icon>\n\t\t</button>\n\t</div>\n\t<smartform #form [smartForm]=\"folderForm\"></smartform>\n\t<div class=\"folderNameDialogButtonsContainer\">\n\t\t<button mat-button color=\"accent\" [color]=\"getCancelButtonColor()\" (click)=\"cancel()\">\n\t\t\t{{ getCancelButtonLabel() }}\n\t\t</button>\n\t\t<button mat-raised-button [color]=\"getActionButtonColor()\" (click)=\"save()\">\n\t\t\t{{ getActionButtonLabel() }}\n\t\t</button>\n\t</div>\n</div>\n", styles: [".folderNameDialogContainer{width:25rem;display:flex;flex-direction:column;gap:1rem}.headerContainer{display:flex;flex-direction:row;justify-content:space-between}.headerContainer h3{margin:0}.folderNameDialogButtonsContainer{display:flex;flex-direction:row;justify-content:flex-end;gap:.5rem}\n"], components: [{ 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: i4$1.SmartIconComponent, selector: "smart-icon", inputs: ["icon", "color"] }, { type: i5$1.SmartformComponent, selector: "smartform", inputs: ["smartForm"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionInputDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "smart-ui-action-input-dialog", template: "<div class=\"folderNameDialogContainer\">\n\t<div class=\"headerContainer\">\n\t\t<h3 class=\"color-accent-700\">\n\t\t\t{{ getTitle() }}\n\t\t</h3>\n\t\t<button mat-icon-button title=\"close\" (click)=\"cancel()\">\n\t\t\t<smart-icon [color]=\"'primary'\" [icon]=\"'X'\"></smart-icon>\n\t\t</button>\n\t</div>\n\t<smartform #form [smartForm]=\"folderForm\"></smartform>\n\t<div class=\"folderNameDialogButtonsContainer\">\n\t\t<button mat-button color=\"accent\" [color]=\"getCancelButtonColor()\" (click)=\"cancel()\">\n\t\t\t{{ getCancelButtonLabel() }}\n\t\t</button>\n\t\t<button mat-raised-button [color]=\"getActionButtonColor()\" (click)=\"save()\">\n\t\t\t{{ getActionButtonLabel() }}\n\t\t</button>\n\t</div>\n</div>\n", styles: [".folderNameDialogContainer{width:25rem;display:flex;flex-direction:column;gap:1rem}.headerContainer{display:flex;flex-direction:row;justify-content:space-between}.headerContainer h3{margin:0}.folderNameDialogButtonsContainer{display:flex;flex-direction:row;justify-content:flex-end;gap:.5rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: UiActionInputDialogService }, { type: UiActionDescriptorService }]; }, propDecorators: { folderFormChild: [{
+                type: ViewChild,
+                args: ["form"]
+            }] } });
+
+class UiActionInputDialogService extends SmartdialogService {
+    constructor(dialog, router) {
+        super(dialog, router);
+        this._destroy$ = new Subject();
+        this.onAction = new Subject();
+    }
+    setDataAndOpenDialog(action, nodeName) {
+        this.action = action;
+        this.nodeName = nodeName;
+        this.openDialog();
+    }
+    openDialog() {
+        this.params = undefined;
+        this.onAction = new Subject();
+        const dialogData = {
+            content: {
+                title: "",
+            },
+            size: {},
+            customComponent: UiActionInputDialogComponent,
+        };
+        this.createDialog(dialogData, UiActionInputDialogComponent);
+    }
+    async onSave(params) {
+        this.params = params;
+        this.onAction.complete();
+        this.closeDialog();
+        this.onAction = new Subject();
+    }
+    cancel() {
+        this.onAction.complete();
+        this.closeDialog();
+        this.onAction = new Subject();
+    }
+}
+UiActionInputDialogService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionInputDialogService, deps: [{ token: i1$1.MatDialog }, { token: i2$1.Router }], target: i0.ɵɵFactoryTarget.Injectable });
+UiActionInputDialogService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionInputDialogService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionInputDialogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: i1$1.MatDialog }, { type: i2$1.Router }]; } });
+
+class UiActionService {
+    constructor(confirmDialogService, textFieldDialogService, _snackBar) {
+        this.confirmDialogService = confirmDialogService;
+        this.textFieldDialogService = textFieldDialogService;
+        this._snackBar = _snackBar;
+    }
+    async execute(uiAction) {
+        let uiActionRequest;
+        uiActionRequest = {
+            code: uiAction.code,
+            identifier: uiAction.identifier,
+            params: uiAction.params ?? {},
+        };
+        if (uiAction.submit) {
+            this.uiActionModel.serviceToUse.submit.next();
+            try {
+                await this.uiActionModel.serviceToUse.submit.toPromise();
+                this.uiActionModel.serviceToUse.submit = new Subject();
+                this.uiActionModel.serviceToUse.reSubscribeToChange.next();
+            }
+            catch (error) {
+                console.error(error);
+                this.uiActionModel.serviceToUse.submit = new Subject();
+                this.uiActionModel.serviceToUse.reSubscribeToChange.next();
+                return;
+            }
+        }
+        if (uiAction.confirm) {
+            this.confirmDialogService.action = uiAction;
+            this.confirmDialogService.openDialog();
+            await this.confirmDialogService.onAction.toPromise();
+            if (!this.confirmDialogService.shouldDoAction) {
+                return;
+            }
+        }
+        // InputType
+        if (uiAction.inputType) {
+            uiActionRequest = await this.handleInputType(uiAction.inputType, uiAction, uiActionRequest, "inputDialog");
+            if (!uiActionRequest) {
+                return;
+            }
+            await new Promise((resolve) => setTimeout(resolve, 250));
+        }
+        // Input2Type
+        if (uiAction.input2Type) {
+            uiActionRequest = await this.handleInputType(uiAction.input2Type, uiAction, uiActionRequest, "input2Dialog");
+            if (!uiActionRequest) {
+                return;
+            }
+        }
+        if (this.uiActionModel.exception) {
+            let response = await this.uiActionModel.serviceToUse.handleSpecificDemandsAsynchronously(uiAction, uiActionRequest);
+            if (!response.shouldPerformAction || !response.uiActionRequest) {
+                return;
+            }
+            uiActionRequest = response.uiActionRequest;
+        }
+        this.performAction(uiAction, uiActionRequest);
+    }
+    async handleInputType(inputType, uiAction, uiActionRequest, inputTypeName) {
+        switch (inputType) {
+            case UiActionInputType.None:
+                return uiActionRequest;
+            case UiActionInputType.Textarea:
+            case UiActionInputType.Textfield:
+                return await this.handleInputTypeTextField(inputTypeName, uiAction, uiActionRequest);
+            case UiActionInputType.UserSelect:
+                return await this.handleInputTypeUserSelect(inputTypeName, uiAction, uiActionRequest);
+            default:
+                return uiActionRequest;
+        }
+    }
+    async handleInputTypeTextField(inputTypeName, uiAction, uiActionRequest) {
+        let additionalParams = this.uiActionModel.serviceToUse.getAdditionalParams(uiAction);
+        let inputType = inputTypeName === "inputDialog" ? "inputType" : "input2Type";
+        if (uiAction[inputType] === UiActionInputType.Textfield) {
+            this.textFieldDialogService.nodeName = additionalParams.forTextField;
+        }
+        else if (uiAction[inputType] === UiActionInputType.Textarea) {
+            this.textFieldDialogService.nodeName = additionalParams.forTextArea;
+        }
+        this.textFieldDialogService.inputTypeName = inputTypeName;
+        this.textFieldDialogService.action = uiAction;
+        this.textFieldDialogService.openDialog();
+        await this.textFieldDialogService.onAction.toPromise();
+        let params = this.textFieldDialogService.params;
+        if (!params) {
+            console.error("There was no response from InputDialog");
+            return;
+        }
+        uiActionRequest.params = {
+            ...uiActionRequest.params,
+            ...params,
+        };
+        return uiActionRequest;
+    }
+    async handleInputTypeUserSelect(inputTypeName, uiAction, uiActionRequest) {
+        let response = await this.uiActionModel.serviceToUse.handleSpecificDemandsAsynchronously(uiAction, uiActionRequest);
+        if (!response.shouldPerformAction || !response.uiActionRequest) {
+            return;
+        }
+        uiActionRequest = response.uiActionRequest;
+        return uiActionRequest;
+    }
+    async performAction(uiAction, uiActionRequest) {
+        if (!uiActionRequest.params ||
+            (uiActionRequest.params && !Object.keys(uiActionRequest.params).length)) {
+            uiActionRequest.params = {
+                model: this.uiActionModel.serviceToUse.getModel(),
+            };
+        }
+        else if (uiAction.submit) {
+            uiActionRequest.params["model"] = this.uiActionModel.serviceToUse.getModel();
+        }
+        try {
+            await this.uiActionModel.serviceToUse.performUiActionRequest(uiActionRequest);
+            if (this.uiActionModel.descriptor?.feedbackType === UiActionFeedbackType.Snackbar) {
+                this.showSavedSnackbar(uiAction);
+            }
+        }
+        catch (error) {
+            console.error(error);
+        }
+    }
+    showSavedSnackbar(uiAction) {
+        this._snackBar.openFromComponent(SuccessSnackBarComponent, {
+            duration: 5 * 1000,
+            panelClass: ["backgroundColor-accent"],
+            data: uiAction,
+        });
+    }
+}
+UiActionService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionService, deps: [{ token: UiActionConfirmDialogService }, { token: UiActionInputDialogService }, { token: i3$2.MatSnackBar }], target: i0.ɵɵFactoryTarget.Injectable });
+UiActionService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionService, providedIn: "root" });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: "root",
+                }]
+        }], ctorParameters: function () { return [{ type: UiActionConfirmDialogService }, { type: UiActionInputDialogService }, { type: i3$2.MatSnackBar }]; } });
+
+class UiActionToolbarComponent {
+    constructor(service, manager) {
+        this.service = service;
+        this.manager = manager;
+        this._destroy$ = new Subject();
+        this.manager.languageChanged.pipe(takeUntil(this._destroy$)).subscribe(() => {
+            this.setUp();
+        });
+    }
+    ngOnInit() {
+        this.setUp();
+    }
+    ngOnChanges(changes) {
+        let uiActionModels = changes["uiActionModels"].currentValue;
+        if (uiActionModels) {
+            this.uiActionModels = uiActionModels;
+            this.setUp();
+        }
+    }
+    ngOnDestroy() {
+        this._destroy$.next();
+    }
+    async setUp() {
+        this.uiActionModelsWithDescriptions = await Promise.all(this.uiActionModels.map(async (uiActionModel) => {
+            uiActionModel.descriptor = await this.manager.getActionDescriptor(uiActionModel.uiAction);
+            return uiActionModel;
+        }));
+    }
+    onActionClicked(event, uiActionModel) {
+        event.stopPropagation();
+        this.service.uiActionModel = uiActionModel;
+        this.service.execute(uiActionModel.uiAction);
+    }
+    getType(uiActionModel) {
+        switch (uiActionModel.descriptor?.type) {
+            case UiActionButtonType.Normal:
+                return "mat-button";
+            case UiActionButtonType.Flat:
+                return "mat-flat-button";
+            case UiActionButtonType.Raised:
+                return "mat-raised-button";
+            case UiActionButtonType.Stroked:
+                return "mat-stroked-button";
+            case UiActionButtonType.Icon:
+                return "mat-icon-button";
+            case UiActionButtonType.MiniFab:
+                return "mat-mini-fab";
+            case UiActionButtonType.Fab:
+                return "mat-fab";
+            default:
+                console.log(`Unhandled action button type case: ${uiActionModel.descriptor?.type}`);
+                return `mat-button`;
+        }
+    }
+    iconPosition() {
+        return UiActionButtonIconPos;
+    }
+    isOnlyIcon(uiActionModel) {
+        return (uiActionModel.descriptor?.type === UiActionButtonType.Icon ||
+            uiActionModel.descriptor?.type === UiActionButtonType.MiniFab ||
+            uiActionModel.descriptor?.type === UiActionButtonType.Fab);
+    }
+}
+UiActionToolbarComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionToolbarComponent, deps: [{ token: UiActionService }, { token: UiActionDescriptorService }], target: i0.ɵɵFactoryTarget.Component });
+UiActionToolbarComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.3.12", type: UiActionToolbarComponent, selector: "smart-ui-action-toolbar", inputs: { uiActionModels: "uiActionModels" }, usesOnChanges: true, ngImport: i0, template: "<div class=\"uiActionButtonsContainer\">\n    <button\n        *ngFor=\"let uiActionModel of uiActionModelsWithDescriptions\"\n        mat-button\n        [ngClass]=\"getType(uiActionModel)\"\n        class=\"{{ uiActionModel.cssClass }}\"\n        [color]=\"uiActionModel.descriptor?.color\"\n        (click)=\"onActionClicked($event, uiActionModel)\"\n    >\n        <div *ngIf=\"isOnlyIcon(uiActionModel); then iconOnly; else text\"></div>\n        <ng-template #iconOnly>\n            <smart-icon\n                *ngIf=\"uiActionModel.descriptor?.icon\"\n                [icon]=\"uiActionModel.descriptor!.icon!\"\n                [color]=\"uiActionModel.descriptor?.iconColor ?? uiActionModel.descriptor?.color\"\n            ></smart-icon>\n        </ng-template>\n        <ng-template #text>\n            <smart-icon\n                *ngIf=\"\n                    uiActionModel.descriptor?.icon &&\n                    uiActionModel.descriptor?.iconPosition === iconPosition().Pre\n                \"\n                [icon]=\"uiActionModel.descriptor!.icon!\"\n                [color]=\"uiActionModel.descriptor?.iconColor ?? uiActionModel.descriptor?.color\"\n            ></smart-icon>\n            {{ uiActionModel.descriptor?.title }}\n            <smart-icon\n                *ngIf=\"\n                    uiActionModel.descriptor?.icon &&\n                    uiActionModel.descriptor?.iconPosition === iconPosition().Post\n                \"\n                [icon]=\"uiActionModel.descriptor!.icon!\"\n                [color]=\"uiActionModel.descriptor?.iconColor ?? uiActionModel.descriptor?.color\"\n            ></smart-icon>\n        </ng-template>\n    </button>\n</div>\n", styles: [".uiActionButtonsContainer{display:flex;flex-direction:row;gap:1rem;flex-wrap:wrap;min-height:2.25rem}\n"], components: [{ 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: i4$1.SmartIconComponent, selector: "smart-icon", inputs: ["icon", "color"] }], directives: [{ type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { type: i5.NgClass, selector: "[ngClass]", inputs: ["class", "ngClass"] }, { type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: UiActionToolbarComponent, decorators: [{
+            type: Component,
+            args: [{ selector: "smart-ui-action-toolbar", template: "<div class=\"uiActionButtonsContainer\">\n    <button\n        *ngFor=\"let uiActionModel of uiActionModelsWithDescriptions\"\n        mat-button\n        [ngClass]=\"getType(uiActionModel)\"\n        class=\"{{ uiActionModel.cssClass }}\"\n        [color]=\"uiActionModel.descriptor?.color\"\n        (click)=\"onActionClicked($event, uiActionModel)\"\n    >\n        <div *ngIf=\"isOnlyIcon(uiActionModel); then iconOnly; else text\"></div>\n        <ng-template #iconOnly>\n            <smart-icon\n                *ngIf=\"uiActionModel.descriptor?.icon\"\n                [icon]=\"uiActionModel.descriptor!.icon!\"\n                [color]=\"uiActionModel.descriptor?.iconColor ?? uiActionModel.descriptor?.color\"\n            ></smart-icon>\n        </ng-template>\n        <ng-template #text>\n            <smart-icon\n                *ngIf=\"\n                    uiActionModel.descriptor?.icon &&\n                    uiActionModel.descriptor?.iconPosition === iconPosition().Pre\n                \"\n                [icon]=\"uiActionModel.descriptor!.icon!\"\n                [color]=\"uiActionModel.descriptor?.iconColor ?? uiActionModel.descriptor?.color\"\n            ></smart-icon>\n            {{ uiActionModel.descriptor?.title }}\n            <smart-icon\n                *ngIf=\"\n                    uiActionModel.descriptor?.icon &&\n                    uiActionModel.descriptor?.iconPosition === iconPosition().Post\n                \"\n                [icon]=\"uiActionModel.descriptor!.icon!\"\n                [color]=\"uiActionModel.descriptor?.iconColor ?? uiActionModel.descriptor?.color\"\n            ></smart-icon>\n        </ng-template>\n    </button>\n</div>\n", styles: [".uiActionButtonsContainer{display:flex;flex-direction:row;gap:1rem;flex-wrap:wrap;min-height:2.25rem}\n"] }]
+        }], ctorParameters: function () { return [{ type: UiActionService }, { type: UiActionDescriptorService }]; }, propDecorators: { uiActionModels: [{
+                type: Input
+            }] } });
+
+class SmartViewContextModule {
+}
+SmartViewContextModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SmartViewContextModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextModule, declarations: [MessageDialogComponent,
+        SmartViewContextErrorDialogComponent,
+        SmartViewRedirect,
+        UiActionToolbarComponent,
+        UiActionInputDialogComponent,
+        UiActionConfirmDialogComponent], imports: [CommonModule,
+        HttpClientModule,
+        MatCommonModule,
+        MatButtonModule,
+        MatIconModule,
+        MatSnackBarModule,
+        SmartIconModule,
+        SmartformModule], exports: [UiActionToolbarComponent, UiActionInputDialogComponent] });
+SmartViewContextModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextModule, providers: [
+        SmartViewContextService,
+        {
+            provide: HTTP_INTERCEPTORS,
+            useClass: SmartViewContextInterceptor,
+            multi: true,
+        },
+    ], imports: [[
+            CommonModule,
+            HttpClientModule,
+            MatCommonModule,
+            MatButtonModule,
+            MatIconModule,
+            MatSnackBarModule,
+            SmartIconModule,
+            SmartformModule,
+        ]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartViewContextModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        MessageDialogComponent,
+                        SmartViewContextErrorDialogComponent,
+                        SmartViewRedirect,
+                        UiActionToolbarComponent,
+                        UiActionInputDialogComponent,
+                        UiActionConfirmDialogComponent,
+                    ],
+                    imports: [
+                        CommonModule,
+                        HttpClientModule,
+                        MatCommonModule,
+                        MatButtonModule,
+                        MatIconModule,
+                        MatSnackBarModule,
+                        SmartIconModule,
+                        SmartformModule,
+                    ],
+                    exports: [UiActionToolbarComponent, UiActionInputDialogComponent],
+                    providers: [
+                        SmartViewContextService,
+                        {
+                            provide: HTTP_INTERCEPTORS,
+                            useClass: SmartViewContextInterceptor,
+                            multi: true,
+                        },
+                    ],
+                }]
+        }] });
+
+class SmartNgClientModule {
+}
+SmartNgClientModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+SmartNgClientModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientModule, imports: [SmartSessionModule, SmartViewContextModule], exports: [SmartSessionModule, SmartViewContextModule] });
+SmartNgClientModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientModule, providers: [SmartNgClientService], imports: [[SmartSessionModule, SmartViewContextModule], SmartSessionModule, SmartViewContextModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.3.12", ngImport: i0, type: SmartNgClientModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [],
+                    imports: [SmartSessionModule, SmartViewContextModule],
+                    exports: [SmartSessionModule, SmartViewContextModule],
+                    providers: [SmartNgClientService],
+                }]
+        }] });
+
+var UiActionDialogType;
+(function (UiActionDialogType) {
+    UiActionDialogType["inputDialog"] = "inputDialog";
+    UiActionDialogType["confirmDialog"] = "confirmDialog";
+    UiActionDialogType["dialog"] = "dialog";
+})(UiActionDialogType || (UiActionDialogType = {}));
+
+/*
+ * Public API Surface of smart-view-context
+ */
+
+/*
+ * Public API Surface of smart-ng-client
+ */
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { APIS, BASE_PATH, COLLECTION_FORMATS, CloseResult, Configuration, MessageOptionType, MessageType, SessionAPIS, SessionErrorBehaviour, SessionService, SmartDevToolDatePipe, SmartDevToolFloatingButtonComponent, SmartDevToolService, SmartLinkChannelVariableInPath, SmartLinkUuidVariableInPath, SmartNgClientModule, SmartNgClientService, SmartSessionModule, SmartSessionService, SmartSessionTimerComponent, SmartSessionTimerService, SmartViewContextModule, SmartViewContextService, SmartViewRedirect, UiActionButtonIconPos, UiActionButtonType, UiActionConfirmDialogComponent, UiActionConfirmDialogService, UiActionDescriptorService, UiActionDialogType, UiActionFeedbackType, UiActionInputDialogComponent, UiActionInputDialogService, UiActionInputType, UiActionService, UiActionToolbarComponent, ViewContextApiModule, ViewService, ViewState, ViewType };
+//# sourceMappingURL=smartbit4all-ng-client.mjs.map