@shapediver/viewer.session-engine.session-engine 2.10.1-rc.0 → 2.12.0

package/dist/implementation/SessionEngine.js

@@ -1,3 +1,4 @@
+"use strict";
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -19,21 +20,24 @@ var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
 var _SessionEngine_customizationProcess, _SessionEngine_parameterHistory, _SessionEngine_parameterHistoryCall, _SessionEngine_parameterHistoryForward;
-import { HttpClient, PerformanceEvaluator, UuidGenerator, SystemInfo, Logger, ShapeDiverViewerSessionError, SettingsEngine, EVENTTYPE, EventEngine, StateEngine, ShapeDiverViewerSettingsError } from '@shapediver/viewer.shared.services';
-import { OutputDelayException } from './OutputDelayException';
-import { OutputLoader } from './OutputLoader';
-import { SessionTreeNode } from './SessionTreeNode';
-import { PARAMETER_TYPE } from '../interfaces/ISessionEngine';
-import { SessionData } from './SessionData';
-import { create, ShapeDiverResponseErrorType, ShapeDiverRequestGltfUploadQueryConversion, ShapeDiverResponseExportDefinitionType, ShapeDiverSdkConfigType, ShapeDiverResponseModelComputationStatus, isGBResponseError } from '@shapediver/sdk.geometry-api-sdk-v2';
-import { Tree, TreeNode } from '@shapediver/viewer.shared.node-tree';
-import { TASK_TYPE } from '@shapediver/viewer.shared.types';
-import { FileParameter } from './dto/FileParameter';
-import { Parameter } from './dto/Parameter';
-import { Export } from './dto/Export';
-import { Output } from './dto/Output';
-import { convert, latestVersion, validate } from '@shapediver/viewer.settings';
-export class SessionEngine {
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionEngine = void 0;
+const viewer_settings_1 = require("@shapediver/viewer.settings");
+const sdk_geometry_api_sdk_v2_1 = require("@shapediver/sdk.geometry-api-sdk-v2");
+const viewer_shared_services_1 = require("@shapediver/viewer.shared.services");
+const Export_1 = require("./dto/Export");
+const FileParameter_1 = require("./dto/FileParameter");
+const ISessionEngine_1 = require("../interfaces/ISessionEngine");
+const viewer_shared_types_1 = require("@shapediver/viewer.shared.types");
+const viewer_shared_node_tree_1 = require("@shapediver/viewer.shared.node-tree");
+const Output_1 = require("./dto/Output");
+const OutputDelayException_1 = require("./OutputDelayException");
+const OutputLoader_1 = require("./OutputLoader");
+const Parameter_1 = require("./dto/Parameter");
+const SessionData_1 = require("./SessionData");
+const SessionTreeNode_1 = require("./SessionTreeNode");
+/* eslint-disable @typescript-eslint/no-empty-function */
+class SessionEngine {
     // #endregion Properties (43)
     // #region Constructors (1)
     /**
@@ -42,20 +46,20 @@ export class SessionEngine {
      */
     constructor(properties) {
         // #region Properties (43)
-        this._eventEngine = EventEngine.instance;
+        this._eventEngine = viewer_shared_services_1.EventEngine.instance;
         this._exports = {};
-        this._httpClient = HttpClient.instance;
-        this._logger = Logger.instance;
+        this._httpClient = viewer_shared_services_1.HttpClient.instance;
+        this._logger = viewer_shared_services_1.Logger.instance;
         this._outputs = {};
         this._outputsFreeze = {};
         this._parameterValues = {};
         this._parameters = {};
-        this._performanceEvaluator = PerformanceEvaluator.instance;
-        this._sceneTree = Tree.instance;
-        this._sessionEngineId = (UuidGenerator.instance).create();
-        this._settingsEngine = new SettingsEngine();
-        this._stateEngine = StateEngine.instance;
-        this._uuidGenerator = UuidGenerator.instance;
+        this._performanceEvaluator = viewer_shared_services_1.PerformanceEvaluator.instance;
+        this._sceneTree = viewer_shared_node_tree_1.Tree.instance;
+        this._sessionEngineId = (viewer_shared_services_1.UuidGenerator.instance).create();
+        this._settingsEngine = new viewer_shared_services_1.SettingsEngine();
+        this._stateEngine = viewer_shared_services_1.StateEngine.instance;
+        this._uuidGenerator = viewer_shared_services_1.UuidGenerator.instance;
         _SessionEngine_customizationProcess.set(this, void 0);
         _SessionEngine_parameterHistory.set(this, []);
         _SessionEngine_parameterHistoryCall.set(this, false);
@@ -67,18 +71,18 @@ export class SessionEngine {
         this._dataCache = {};
         this._excludeViewports = [];
         this._headers = {
-            "X-ShapeDiver-Origin": (SystemInfo.instance).origin,
-            "X-ShapeDiver-SessionEngineId": this._sessionEngineId,
-            "X-ShapeDiver-BuildVersion": '',
-            "X-ShapeDiver-BuildDate": ''
+            'X-ShapeDiver-Origin': (viewer_shared_services_1.SystemInfo.instance).origin,
+            'X-ShapeDiver-SessionEngineId': this._sessionEngineId,
+            'X-ShapeDiver-BuildVersion': '',
+            'X-ShapeDiver-BuildDate': ''
         };
         this._initialized = false;
         this._retryCounter = 0;
         this._updateCallback = null;
-        this._viewerSettingsVersion = latestVersion;
-        this._viewerSettingsVersionBackend = latestVersion;
+        this._viewerSettingsVersion = viewer_settings_1.latestVersion;
+        this._viewerSettingsVersionBackend = viewer_settings_1.latestVersion;
         this._id = properties.id;
-        this._node = new TreeNode(properties.id);
+        this._node = new viewer_shared_node_tree_1.TreeNode(properties.id);
         this._guid = properties.guid;
         this._ticket = properties.ticket;
         this._modelViewUrl = properties.modelViewUrl;
@@ -86,17 +90,17 @@ export class SessionEngine {
         this._jwtToken = properties.jwtToken;
         this._headers['X-ShapeDiver-BuildDate'] = properties.buildDate;
         this._headers['X-ShapeDiver-BuildVersion'] = properties.buildVersion;
-        this._outputLoader = new OutputLoader(this);
+        this._outputLoader = new OutputLoader_1.OutputLoader(this);
         try {
-            this._sdk = create(this._modelViewUrl, this._jwtToken);
-            this._sdk.setConfigurationValue(ShapeDiverSdkConfigType.REQUEST_HEADERS, this._headers);
+            this._sdk = (0, sdk_geometry_api_sdk_v2_1.create)(this._modelViewUrl, this._jwtToken);
+            this._sdk.setConfigurationValue(sdk_geometry_api_sdk_v2_1.ShapeDiverSdkConfigType.REQUEST_HEADERS, this._headers);
         }
         catch (e) {
             throw this._httpClient.convertError(e);
         }
     }
     // #endregion Constructors (1)
-    // #region Public Accessors (24)
+    // #region Public Accessors (25)
     get automaticSceneUpdate() {
         return this._automaticSceneUpdate;
     }
@@ -180,8 +184,8 @@ export class SessionEngine {
     get viewerSettings() {
         return this._viewerSettings;
     }
-    // #endregion Public Accessors (24)
-    // #region Public Methods (24)
+    // #endregion Public Accessors (25)
+    // #region Public Methods (27)
     applySettings(response, sections) {
         sections = sections || {};
         if (sections.session === undefined) {
@@ -201,25 +205,25 @@ export class SessionEngine {
             config = response.viewer.config;
         }
         else {
-            throw new ShapeDiverViewerSettingsError('Session.applySettings: No config object available.');
+            throw new viewer_shared_services_1.ShapeDiverViewerSettingsError('Session.applySettings: No config object available.');
         }
         try {
-            validate(config);
+            (0, viewer_settings_1.validate)(config);
         }
         catch (e) {
-            throw new ShapeDiverViewerSettingsError('Session.applySettings: Was not able to validate config object.');
+            throw new viewer_shared_services_1.ShapeDiverViewerSettingsError('Session.applySettings: Was not able to validate config object.');
         }
-        const settings = convert(config, latestVersion);
+        const settings = (0, viewer_settings_1.convert)(config, viewer_settings_1.latestVersion);
         const exportMappingUid = {};
         if (sections.session.export.displayname || sections.session.export.order || sections.session.export.hidden)
             if (response.exports)
-                for (let exportId in response.exports)
+                for (const exportId in response.exports)
                     if (response.exports[exportId].uid !== undefined)
                         exportMappingUid[response.exports[exportId].uid] = exportId;
         const currentSettings = this._settingsEngine.settings;
         // apply parameter settings
         if (sections.session.parameter.displayname || sections.session.parameter.order || sections.session.parameter.hidden || sections.session.parameter.value) {
-            for (let p in this.parameters) {
+            for (const p in this.parameters) {
                 if (settings.session[p]) {
                     if (sections.session.parameter.displayname)
                         this.parameters[p].displayname = settings.session[p].displayname;
@@ -228,7 +232,7 @@ export class SessionEngine {
                     if (sections.session.parameter.hidden)
                         this.parameters[p].hidden = settings.session[p].hidden || false;
                 }
-                if (response.parameters && response.parameters[p]) {
+                if (response.parameters && response.parameters[p] && !((this.parameters[p] instanceof FileParameter_1.FileParameter) || this.parameters[p].type.startsWith('s'))) {
                     if (sections.session.parameter.value)
                         this.parameters[p].value = response.parameters[p].defval !== undefined ? response.parameters[p].defval : this.parameters[p].value;
                 }
@@ -236,7 +240,7 @@ export class SessionEngine {
         }
         // apply export settings
         if (sections.session.export.displayname || sections.session.export.order || sections.session.export.hidden) {
-            for (let p in this.exports) {
+            for (const p in this.exports) {
                 let idForSettings = '';
                 if (settings.session[p]) {
                     idForSettings = p;
@@ -314,6 +318,14 @@ export class SessionEngine {
     canGoForward() {
         return __classPrivateFieldGet(this, _SessionEngine_parameterHistoryForward, "f").length > 0;
     }
+    cancelCustomization() {
+        if (__classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f")) {
+            for (const r in this._stateEngine.renderingEngines)
+                if (this._stateEngine.renderingEngines[r].busy.includes(__classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f")))
+                    this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(__classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f")), 1);
+        }
+        __classPrivateFieldSet(this, _SessionEngine_customizationProcess, undefined, "f");
+    }
     close(retry = false) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkAvailability('close');
@@ -336,7 +348,7 @@ export class SessionEngine {
      * @param parameters the parameter set to update the session
      * @returns promise with a scene graph node
      */
-    customize(force = false) {
+    customize(force = false, waitForViewportUpdate = false) {
         return __awaiter(this, void 0, void 0, function* () {
             const eventId = this._uuidGenerator.create();
             const customizationId = this._uuidGenerator.create();
@@ -350,61 +362,31 @@ export class SessionEngine {
                     if (changes === false)
                         return this.node;
                 }
-                const eventStart = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0, data: { sessionId: this.id }, status: 'Customizing session' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_START, eventStart);
+                const eventStart = { type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0, data: { sessionId: this.id }, status: 'Customizing session' };
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_START, eventStart);
                 const oldNode = this.node.cloneInstance();
                 __classPrivateFieldSet(this, _SessionEngine_customizationProcess, customizationId, "f");
                 this._logger.debugLow(`Session(${this.id}).customize: Customizing session.`);
-                for (let r in this._stateEngine.renderingEngines)
+                for (const r in this._stateEngine.renderingEngines)
                     if (!this.excludeViewports.includes(r))
                         this._stateEngine.renderingEngines[r].busy.push(customizationId);
-                const eventFileUpload = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0.1, data: { sessionId: this.id }, status: 'Uploading file parameters' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventFileUpload);
+                const eventFileUpload = { type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0.1, data: { sessionId: this.id }, status: 'Uploading file parameters' };
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_PROCESS, eventFileUpload);
                 const fileParameterIds = {};
                 // load file parameter first
                 for (const parameterId in this.parameters) {
-                    if (this.parameters[parameterId] instanceof FileParameter) {
+                    if (this.parameters[parameterId] instanceof FileParameter_1.FileParameter) {
                         fileParameterIds[parameterId] = yield this.parameters[parameterId].upload();
                         // OPTION TO SKIP - PART 1a
-                        if (__classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f") !== customizationId) {
-                            for (let r in this._stateEngine.renderingEngines)
-                                if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                                    this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-                            this._logger.debug(`Session(${this.id}).customize: Session customization was exceeded by other customization request.`);
-                            const eventCancel1a = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customization was exceeded by other customization request' };
-                            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1a);
-                            return new SessionTreeNode();
-                        }
-                        else if (this._closed === true) {
-                            for (let r in this._stateEngine.renderingEngines)
-                                if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                                    this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-                            this._logger.debug(`Session(${this.id}).customize: Session was closed during customization request.`);
-                            const eventCancel1a = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session was closed during customization request' };
-                            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1a);
-                            return new SessionTreeNode();
-                        }
+                        const cancelResult = this.cancelProcess(customizationId, eventId, viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+                        if (cancelResult)
+                            return cancelResult;
                     }
                 }
                 // OPTION TO SKIP - PART 1b
-                if (__classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f") !== customizationId) {
-                    for (let r in this._stateEngine.renderingEngines)
-                        if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                            this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-                    const eventCancel1b = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customization was exceeded by other customization request' };
-                    this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1b);
-                    this._logger.debug(`Session(${this.id}).customize: Session customization was exceeded by other customization request.`);
-                    return new SessionTreeNode();
-                }
-                else if (this._closed === true) {
-                    for (let r in this._stateEngine.renderingEngines)
-                        if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                            this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-                    this._logger.debug(`Session(${this.id}).customize: Session was closed during customization request.`);
-                    const eventCancel1b = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session was closed during customization request' };
-                    this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1b);
-                    return new SessionTreeNode();
-                }
+                const cancelResult = this.cancelProcess(customizationId, eventId, viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+                if (cancelResult)
+                    return cancelResult;
                 // assign the uploaded parameters
                 for (const parameterId in fileParameterIds)
                     this.parameters[parameterId].value = fileParameterIds[parameterId];
@@ -420,37 +402,41 @@ export class SessionEngine {
                 for (const parameterId in this.parameters)
                     this.parameterValues[parameterId] = parameterSet[parameterId].valueString;
                 this._logger.info(`Session(${this.id}).customize: Customizing session with parameters ${JSON.stringify(this.parameterValues)}.`);
-                const eventRequest = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0.1, data: { sessionId: this.id }, status: 'Sending customization request' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventRequest);
+                const eventRequest = { type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0.1, data: { sessionId: this.id }, status: 'Sending customization request' };
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_PROCESS, eventRequest);
+                const oldOutputVersions = this._outputLoader.getCurrentOutputVersions();
                 const newNode = yield this.customizeInternal(() => __classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f") !== customizationId, {
                     eventId,
-                    type: TASK_TYPE.SESSION_CUSTOMIZATION,
+                    type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION,
                     progressRange: {
                         min: 0.1,
                         max: 0.9
                     },
                     data: { sessionId: this.id }
                 });
-                const eventSceneUpdate = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0.9, data: { sessionId: this.id }, status: 'Updating scene' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventSceneUpdate);
                 // OPTION TO SKIP - PART 2
-                if (__classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f") !== customizationId) {
-                    for (let r in this._stateEngine.renderingEngines)
-                        if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                            this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-                    const eventCancel2 = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customization was exceeded by other customization request' };
-                    this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel2);
-                    this._logger.debug(`Session(${this.id}).customize: Session customization was exceeded by other customization request.`);
-                    return newNode;
-                }
-                else if (this._closed === true) { // I get a TS warning here that the type of _closed is "false", I think TS doesn't get that there is a promise inbetween
-                    for (let r in this._stateEngine.renderingEngines)
-                        if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                            this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-                    this._logger.debug(`Session(${this.id}).customize: Session was closed during customization request.`);
-                    const eventCancel2 = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session was closed during customization request' };
-                    this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel2);
-                    return new SessionTreeNode();
+                const cancelResult2 = this.cancelProcess(customizationId, eventId, viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+                if (cancelResult2)
+                    return cancelResult2;
+                const newOutputVersions = this._outputLoader.getCurrentOutputVersions();
+                const eventSceneUpdate = { type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0.9, data: { sessionId: this.id }, status: 'Updating scene' };
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_PROCESS, eventSceneUpdate);
+                // call the update callbacks
+                if (waitForViewportUpdate === false) {
+                    for (const outputId in this.outputs) {
+                        if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                            this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.OUTPUT.OUTPUT_UPDATED, {
+                                outputId: outputId,
+                                outputVersion: newOutputVersions[outputId],
+                                newNode: newNode.children.find(c => c.name === outputId),
+                                oldNode: oldNode.children.find(c => c.name === outputId)
+                            });
+                        }
+                    }
+                    yield this.waitForUpdateCallbacks(newOutputVersions, oldOutputVersions, newNode, oldNode);
+                    const cancelResult = this.cancelProcess(customizationId, eventId, viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+                    if (cancelResult)
+                        return cancelResult;
                 }
                 // if this is not a call by the goBack or goForward functions, add the parameter values to the history and delete the forward history
                 if (!__classPrivateFieldGet(this, _SessionEngine_parameterHistoryCall, "f")) {
@@ -474,64 +460,83 @@ export class SessionEngine {
                     this.exports[exportId].updateExport();
                 this._warningCreator();
                 this.node.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
-                for (let r in this._stateEngine.renderingEngines)
+                for (const r in this._stateEngine.renderingEngines)
                     if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
                         this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
                 this._logger.debug(`Session(${this.id}).customize: Session customized.`);
-                this._eventEngine.emitEvent(EVENTTYPE.SESSION.SESSION_CUSTOMIZED, { sessionId: this.id });
-                const eventEnd = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customized' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_END, eventEnd);
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.SESSION.SESSION_CUSTOMIZED, { sessionId: this.id });
+                const eventEnd = { type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customized' };
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_END, eventEnd);
                 // update the viewports
-                for (let r in this._stateEngine.renderingEngines)
-                    if (!this.excludeViewports.includes(this._stateEngine.renderingEngines[r].id))
-                        this._stateEngine.renderingEngines[r].update(`SessionEngine(${this.id}).customize`);
-                // call the update callback function on the session
-                if (this._updateCallback)
-                    this._updateCallback(newNode, oldNode);
-                // call the update callback functions on the outputs
-                for (const outputId in this.outputs)
-                    this.outputs[outputId].triggerUpdateCallback(newNode.children.find(c => c.name === outputId), oldNode.children.find(c => c.name === outputId));
+                if (waitForViewportUpdate) {
+                    for (const r in this._stateEngine.renderingEngines)
+                        if (!this.excludeViewports.includes(this._stateEngine.renderingEngines[r].id))
+                            this._stateEngine.renderingEngines[r].update(`SessionEngine(${this.id}).customize`);
+                    for (const outputId in this.outputs) {
+                        if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                            this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.OUTPUT.OUTPUT_UPDATED, {
+                                outputId: outputId,
+                                outputVersion: newOutputVersions[outputId],
+                                newNode: newNode.children.find(c => c.name === outputId),
+                                oldNode: oldNode.children.find(c => c.name === outputId)
+                            });
+                        }
+                    }
+                    // call the update callbacks
+                    yield this.waitForUpdateCallbacks(newOutputVersions, oldOutputVersions, newNode, oldNode);
+                    const cancelResult = this.cancelProcess(customizationId, eventId, viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, 1, { sessionId: this.id });
+                    if (cancelResult)
+                        return cancelResult;
+                }
+                if (!waitForViewportUpdate) {
+                    setTimeout(() => {
+                        for (const r in this._stateEngine.renderingEngines)
+                            if (!this.excludeViewports.includes(this._stateEngine.renderingEngines[r].id))
+                                this._stateEngine.renderingEngines[r].update(`SessionEngine(${this.id}).customize`);
+                    }, 0);
+                }
                 return this.node;
             }
             catch (e) {
-                const eventCancel = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customization failed' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel);
-                for (let r in this._stateEngine.renderingEngines)
+                const eventCancel = { type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customization failed' };
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_CANCEL, eventCancel);
+                for (const r in this._stateEngine.renderingEngines)
                     if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
                         this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
                 throw this._httpClient.convertError(e);
             }
         });
     }
-    customizeParallel(parameterValues) {
+    customizeParallel(parameterValues, loadOutputs = true) {
         return __awaiter(this, void 0, void 0, function* () {
             const eventId = this._uuidGenerator.create();
-            const eventStart = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0, data: { sessionId: this.id }, status: 'Customizing session' };
-            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_START, eventStart);
+            const eventStart = { type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 0, data: { sessionId: this.id }, status: 'Customizing session' };
+            this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_START, eventStart);
             const parameterSet = {};
             // create a set of the current validated parameter values
             for (const parameterId in this.parameters)
                 parameterSet[parameterId] = parameterValues[parameterId] !== undefined ? (' ' + parameterValues[parameterId]).slice(1) : this.parameters[parameterId].stringify();
-            const newNode = yield this.customizeSession(parameterSet, () => false, {
+            const result = yield this.customizeSession(parameterSet, () => false, {
                 eventId,
-                type: TASK_TYPE.SESSION_CUSTOMIZATION,
+                type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION,
                 progressRange: {
                     min: 0.0,
                     max: 1
                 },
                 data: { sessionId: this.id }
-            }, true);
-            newNode.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
-            const eventEnd = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customized' };
-            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_END, eventEnd);
-            return newNode;
+            }, true, loadOutputs);
+            if (result instanceof SessionTreeNode_1.SessionTreeNode)
+                result.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
+            const eventEnd = { type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session customized' };
+            this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_END, eventEnd);
+            return result;
         });
     }
     goBack() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.canGoBack()) {
                 this._logger.debug(`Session(${this.id}).goBack: Cannot go further back.`);
-                return new TreeNode();
+                return new viewer_shared_node_tree_1.TreeNode();
             }
             // get the current parameter set and store it in the forward history later on
             const currentParameterSet = __classPrivateFieldGet(this, _SessionEngine_parameterHistory, "f").pop();
@@ -552,7 +557,7 @@ export class SessionEngine {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.canGoForward()) {
                 this._logger.debug(`Session(${this.id}).goForward: Cannot go further forward.`);
-                return new TreeNode();
+                return new viewer_shared_node_tree_1.TreeNode();
             }
             // get the last undone parameter set and apply the values to the parameters
             const lastParameterSet = __classPrivateFieldGet(this, _SessionEngine_parameterHistoryForward, "f").pop();
@@ -576,7 +581,7 @@ export class SessionEngine {
         var _a, _b;
         return __awaiter(this, void 0, void 0, function* () {
             if (this._initialized === true)
-                throw new ShapeDiverViewerSessionError('Session.init: Session already initialized.');
+                throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.init: Session already initialized.');
             try {
                 this._performanceEvaluator.startSection('sessionResponse');
                 const parameterSet = {};
@@ -591,11 +596,11 @@ export class SessionEngine {
                 }
                 else {
                     // we should never get here
-                    throw new ShapeDiverViewerSessionError(`Session.init: Initialization of session failed. Neither a ticket nor a guid are available.`);
+                    throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.init: Initialization of session failed. Neither a ticket nor a guid are available.');
                 }
                 this._performanceEvaluator.endSection('sessionResponse');
                 this._viewerSettings = (_a = this._responseDto.viewer) === null || _a === void 0 ? void 0 : _a.config;
-                this._viewerSettingsVersionBackend = this._responseDto.viewerSettingsVersion || latestVersion;
+                this._viewerSettingsVersionBackend = this._responseDto.viewerSettingsVersion || viewer_settings_1.latestVersion;
                 this._sessionId = this._responseDto.sessionId;
                 this._modelId = (_b = this._responseDto.model) === null || _b === void 0 ? void 0 : _b.id;
                 this._httpClient.addDataLoading(this._sessionId, {
@@ -604,9 +609,9 @@ export class SessionEngine {
                 });
                 this._settingsEngine.loadSettings(this._viewerSettings);
                 if (!this._sessionId)
-                    throw new ShapeDiverViewerSessionError(`Session.init: Initialization of session failed. ResponseDto did not have a sessionId.`);
+                    throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.init: Initialization of session failed. ResponseDto did not have a sessionId.');
                 if (!this._modelId)
-                    throw new ShapeDiverViewerSessionError(`Session.init: Initialization of session failed. ResponseDto did not have a model.id.`);
+                    throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.init: Initialization of session failed. ResponseDto did not have a model.id.');
                 this.updateResponseDto(this._responseDto, parameterSet);
                 this._initialized = true;
             }
@@ -616,6 +621,55 @@ export class SessionEngine {
             }
         });
     }
+    loadCachedOutputsParallel(outputMapping, taskEventInfo, retry = false) {
+        var _a;
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkAvailability();
+            // if there is already task event info, use it
+            // this happens after a retry
+            const eventId = taskEventInfo ? taskEventInfo.eventId : this._uuidGenerator.create();
+            const eventType = taskEventInfo ? taskEventInfo.type : viewer_shared_types_1.TASK_TYPE.SESSION_OUTPUTS_LOADING;
+            const eventData = taskEventInfo ? taskEventInfo.data : { sessionId: this.id };
+            taskEventInfo = taskEventInfo ? taskEventInfo : {
+                eventId,
+                type: eventType,
+                progressRange: {
+                    min: 0,
+                    max: 1
+                },
+                data: eventData
+            };
+            try {
+                // send start event if this function was called initially
+                if (!taskEventInfo) {
+                    const eventStart = { type: eventType, id: eventId, progress: 0, data: eventData, status: 'Loading cached outputs' };
+                    this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_START, eventStart);
+                }
+                // get the cached outputs
+                const responseDto = yield this._sdk.output.getCache(this._sessionId, outputMapping);
+                // create atomic output api objects for them
+                const outputs = {};
+                for (const outputId in responseDto.outputs) {
+                    responseDto.outputs[outputId].id = outputId;
+                    outputs[outputId] = new Output_1.Output(responseDto.outputs[outputId], this);
+                }
+                // process the output data
+                const node = yield this._outputLoader.loadOutputs(((_a = this._responseDto.model) === null || _a === void 0 ? void 0 : _a.name) || 'model', outputs, {}, taskEventInfo, false);
+                // send the end event once done
+                const eventEnd = { type: eventType, id: eventId, progress: 1, data: eventData, status: 'Loaded cached outputs' };
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_END, eventEnd);
+                // create a mapping with a dictionary for the id of the outputs
+                const outputNodeMapping = {};
+                for (const outputId in outputMapping)
+                    outputNodeMapping[outputId] = node.children.find(n => n.name === outputId);
+                return outputNodeMapping;
+            }
+            catch (e) {
+                yield this.handleError(e, retry);
+                return yield this.loadCachedOutputsParallel(outputMapping, taskEventInfo, true);
+            }
+        });
+    }
     /**
      * Load the outputs and return the scene graph node of the result.
      * In case the outputs have a delay property, another customization request with the parameter set is sent.
@@ -624,50 +678,47 @@ export class SessionEngine {
      * @param outputs the outputs to load
      * @returns promise with a scene graph node
      */
-    loadOutputsParallel(responseDto, cancelRequest = () => false, taskEventInfo, retry = false) {
+    loadOutputs(cancelRequest = () => false, taskEventInfo, retry = false) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.checkAvailability();
-            let outputs = {};
-            let outputsFreeze = {};
-            for (let outputId in responseDto.outputs) {
-                responseDto.outputs[outputId].id = outputId;
-                if (this.outputsFreeze[outputId] === undefined)
-                    outputsFreeze[outputId] = false;
-                outputs[outputId] = new Output(responseDto.outputs[outputId], this);
-            }
+            const o = Object.assign({}, this._outputs);
+            const of = Object.assign({}, this._outputsFreeze);
             try {
-                const node = yield this._outputLoader.loadOutputs(((_a = this._responseDto.model) === null || _a === void 0 ? void 0 : _a.name) || 'model', outputs, outputsFreeze, taskEventInfo);
-                node.data.push(new SessionData(responseDto));
+                const node = yield this._outputLoader.loadOutputs(((_a = this._responseDto.model) === null || _a === void 0 ? void 0 : _a.name) || 'model', o, of, taskEventInfo);
+                node.data.push(new SessionData_1.SessionData(this._responseDto));
+                if (cancelRequest())
+                    return node;
+                node.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
                 return node;
             }
             catch (e) {
-                if (e instanceof OutputDelayException) {
+                if (e instanceof OutputDelayException_1.OutputDelayException) {
                     yield this.timeout(e.delay);
                 }
                 else {
                     yield this.handleError(e, retry);
                     if (cancelRequest())
-                        return new SessionTreeNode();
-                    return yield this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo, true);
+                        return new SessionTreeNode_1.SessionTreeNode();
+                    return yield this.loadOutputs(cancelRequest, taskEventInfo, true);
                 }
                 if (cancelRequest())
-                    return new SessionTreeNode();
-                let outputMapping = {};
-                for (let output in outputs)
-                    outputMapping[output] = outputs[output].version;
+                    return new SessionTreeNode_1.SessionTreeNode();
+                const outputMapping = {};
+                for (const output in o)
+                    outputMapping[output] = o[output].version;
                 try {
                     const responseDto = yield this._sdk.output.getCache(this._sessionId, outputMapping);
                     if (cancelRequest())
-                        return new SessionTreeNode();
+                        return new SessionTreeNode_1.SessionTreeNode();
                     this.updateResponseDto(responseDto);
-                    return yield this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo);
+                    return yield this.loadOutputs(cancelRequest, taskEventInfo);
                 }
                 catch (e) {
                     yield this.handleError(e, retry);
                     if (cancelRequest())
-                        return new SessionTreeNode();
-                    return yield this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo, true);
+                        return new SessionTreeNode_1.SessionTreeNode();
+                    return yield this.loadOutputs(cancelRequest, taskEventInfo, true);
                 }
             }
         });
@@ -680,52 +731,50 @@ export class SessionEngine {
      * @param outputs the outputs to load
      * @returns promise with a scene graph node
      */
-    loadOutputs(cancelRequest = () => false, taskEventInfo, retry = false) {
+    loadOutputsParallel(responseDto, cancelRequest = () => false, taskEventInfo, retry = false) {
         var _a;
         return __awaiter(this, void 0, void 0, function* () {
             this.checkAvailability();
-            const o = Object.assign({}, this._outputs);
-            const of = Object.assign({}, this._outputsFreeze);
+            const outputs = {};
+            const outputsFreeze = {};
+            for (const outputId in responseDto.outputs) {
+                responseDto.outputs[outputId].id = outputId;
+                if (this.outputsFreeze[outputId] === undefined)
+                    outputsFreeze[outputId] = false;
+                outputs[outputId] = new Output_1.Output(responseDto.outputs[outputId], this);
+            }
             try {
-                const node = yield this._outputLoader.loadOutputs(((_a = this._responseDto.model) === null || _a === void 0 ? void 0 : _a.name) || 'model', o, of, taskEventInfo);
-                node.data.push(new SessionData(this._responseDto));
-                if (cancelRequest())
-                    return node;
-                if (this._automaticSceneUpdate)
-                    this.removeFromSceneTree(this._node);
-                this._node = node;
-                if (this._automaticSceneUpdate && this._closed === false)
-                    this.addToSceneTree(this._node);
-                this.node.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
+                const node = yield this._outputLoader.loadOutputs(((_a = this._responseDto.model) === null || _a === void 0 ? void 0 : _a.name) || 'model', outputs, outputsFreeze, taskEventInfo);
+                node.data.push(new SessionData_1.SessionData(responseDto));
                 return node;
             }
             catch (e) {
-                if (e instanceof OutputDelayException) {
+                if (e instanceof OutputDelayException_1.OutputDelayException) {
                     yield this.timeout(e.delay);
                 }
                 else {
                     yield this.handleError(e, retry);
                     if (cancelRequest())
-                        return new SessionTreeNode();
-                    return yield this.loadOutputs(cancelRequest, taskEventInfo, true);
+                        return new SessionTreeNode_1.SessionTreeNode();
+                    return yield this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo, true);
                 }
                 if (cancelRequest())
-                    return new SessionTreeNode();
-                let outputMapping = {};
-                for (let output in o)
-                    outputMapping[output] = o[output].version;
+                    return new SessionTreeNode_1.SessionTreeNode();
+                const outputMapping = {};
+                for (const output in outputs)
+                    outputMapping[output] = outputs[output].version;
                 try {
                     const responseDto = yield this._sdk.output.getCache(this._sessionId, outputMapping);
                     if (cancelRequest())
-                        return new SessionTreeNode();
+                        return new SessionTreeNode_1.SessionTreeNode();
                     this.updateResponseDto(responseDto);
-                    return yield this.loadOutputs(cancelRequest, taskEventInfo);
+                    return yield this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo);
                 }
                 catch (e) {
                     yield this.handleError(e, retry);
                     if (cancelRequest())
-                        return new SessionTreeNode();
-                    return yield this.loadOutputs(cancelRequest, taskEventInfo, true);
+                        return new SessionTreeNode_1.SessionTreeNode();
+                    return yield this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo, true);
                 }
             }
         });
@@ -734,27 +783,7 @@ export class SessionEngine {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkAvailability('export');
             try {
-                const requestParameterSet = {};
-                // first step, we convert all our names and displaynames to ids
-                for (const parameterIdOrName in parameters) {
-                    // we prioritize id, then name and then displayname
-                    // if there are two parameters with the same name or displayname, we take the one that is found first (no way for us to evaluate which one the user meant)
-                    const parameterObject = Object.values(this._parameters).find(p => p.id === parameterIdOrName || p.name === parameterIdOrName || p.displayname === parameterIdOrName);
-                    // in case the key of the key value pair was neither the id, name or displayname, skip
-                    if (!parameterObject)
-                        continue;
-                    // deep copy into new dictionary
-                    requestParameterSet[parameterObject.id] = (' ' + parameters[parameterIdOrName]).slice(1);
-                }
-                // seconds step, fill all other parameter values that are currently not set
-                const currentParameters = this.parameterValues;
-                for (const parameterId in currentParameters) {
-                    // if already set by input values, skip
-                    if (requestParameterSet[parameterId] !== undefined)
-                        continue;
-                    // deep copy into new dictionary
-                    requestParameterSet[parameterId] = (' ' + currentParameters[parameterId]).slice(1);
-                }
+                const requestParameterSet = this.cleanExportParameters(parameters);
                 const responseDto = yield this._sdk.utils.submitAndWaitForExport(this._sdk, this._sessionId, { exports: { id: exportId }, parameters: requestParameterSet }, maxWaitTime);
                 this.updateResponseDto(responseDto);
                 return this.exports[exportId];
@@ -765,9 +794,24 @@ export class SessionEngine {
             }
         });
     }
+    requestExports(body, maxWaitMsec, retry = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.checkAvailability('export');
+            try {
+                const requestParameterSet = this.cleanExportParameters(body.parameters);
+                const responseDto = yield this._sdk.utils.submitAndWaitForExport(this._sdk, this._sessionId, { exports: body.exports, parameters: requestParameterSet, outputs: body.outputs, max_wait_time: body.max_wait_time }, maxWaitMsec);
+                this.updateResponseDto(responseDto);
+                return responseDto;
+            }
+            catch (e) {
+                yield this.handleError(e, retry);
+                return yield this.requestExports(body, maxWaitMsec, true);
+            }
+        });
+    }
     resetSettings(sections) {
         if (!this._responseDto)
-            throw new ShapeDiverViewerSessionError(`Session.resetSettings: responseDto not available.`);
+            throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.resetSettings: responseDto not available.');
         sections = sections || {};
         if (sections.session === undefined) {
             sections.session = {
@@ -791,7 +835,7 @@ export class SessionEngine {
                 this._logger.debug(`Session(${this.id}).saveDefaultParameters: Saved default parameters.`);
             }
             else {
-                throw new ShapeDiverViewerSessionError(`Session(${this.id}).saveDefaultParameters: Could not save default parameters.`);
+                throw new viewer_shared_services_1.ShapeDiverViewerSessionError(`Session(${this.id}).saveDefaultParameters: Could not save default parameters.`);
             }
             return response;
         });
@@ -870,14 +914,14 @@ export class SessionEngine {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkAvailability('configure', true);
             try {
-                validate(json, this._viewerSettingsVersion);
+                (0, viewer_settings_1.validate)(json, this._viewerSettingsVersion);
                 // if viewer settings version is higher than backend settings version
                 // convert to backend settings version
                 if (+this._viewerSettingsVersion > +this._viewerSettingsVersionBackend)
-                    json = convert(json, this._viewerSettingsVersionBackend);
+                    json = (0, viewer_settings_1.convert)(json, this._viewerSettingsVersionBackend);
             }
             catch (e) {
-                throw new ShapeDiverViewerSettingsError('Session.saveSettings: Settings could not be validated. ' + e.message, e);
+                throw new viewer_shared_services_1.ShapeDiverViewerSettingsError('Session.saveSettings: Settings could not be validated. ' + e.message, e);
             }
             try {
                 yield this._sdk.model.updateConfig(this._modelId, json);
@@ -895,7 +939,7 @@ export class SessionEngine {
             // settings saving 
             this._saveSessionSettings();
             let properties = {};
-            for (let p in this.parameters) {
+            for (const p in this.parameters) {
                 properties[p] = {
                     displayname: this.parameters[p].displayname !== undefined ? this.parameters[p].displayname : '',
                     hidden: this.parameters[p].hidden !== undefined ? this.parameters[p].hidden : false,
@@ -905,7 +949,7 @@ export class SessionEngine {
             }
             const responseP = Object.values(properties).length !== 0 ? yield this.saveParameterProperties(properties) : true;
             properties = {};
-            for (let e in this.exports) {
+            for (const e in this.exports) {
                 properties[e] = {
                     displayname: this.exports[e].displayname !== undefined ? this.exports[e].displayname : '',
                     hidden: this.exports[e].hidden !== undefined ? this.exports[e].hidden : false,
@@ -915,7 +959,7 @@ export class SessionEngine {
             }
             const responseE = Object.values(properties).length !== 0 ? yield this.saveExportProperties(properties) : true;
             properties = {};
-            for (let o in this.outputs) {
+            for (const o in this.outputs) {
                 properties[o] = {
                     displayname: this.outputs[o].displayname !== undefined ? this.outputs[o].displayname : '',
                     hidden: this.outputs[o].hidden !== undefined ? this.outputs[o].hidden : false,
@@ -940,7 +984,7 @@ export class SessionEngine {
             this.checkAvailability();
             this._jwtToken = value;
             try {
-                this._sdk.setConfigurationValue(ShapeDiverSdkConfigType.JWT_TOKEN, value);
+                this._sdk.setConfigurationValue(sdk_geometry_api_sdk_v2_1.ShapeDiverSdkConfigType.JWT_TOKEN, value);
                 const responseDto = yield this._sdk.session.default(this._sessionId);
                 if (this._responseDto)
                     this._responseDto.actions = responseDto.actions;
@@ -950,24 +994,25 @@ export class SessionEngine {
             }
         });
     }
-    updateOutputs(taskEventInfo) {
+    updateOutputs(taskEventInfo, waitForViewportUpdate = false) {
         return __awaiter(this, void 0, void 0, function* () {
             const eventId = taskEventInfo ? taskEventInfo.eventId : this._uuidGenerator.create();
-            const eventType = taskEventInfo ? taskEventInfo.type : TASK_TYPE.SESSION_OUTPUTS_UPDATE;
+            const eventType = taskEventInfo ? taskEventInfo.type : viewer_shared_types_1.TASK_TYPE.SESSION_OUTPUTS_UPDATE;
             const eventData = taskEventInfo ? taskEventInfo.data : { sessionId: this.id };
             if (!taskEventInfo) {
                 const eventStart = { type: eventType, id: eventId, progress: 0, data: eventData, status: 'Updating outputs' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_START, eventStart);
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_START, eventStart);
             }
             const customizationId = this._uuidGenerator.create();
             const oldNode = this.node.cloneInstance();
             __classPrivateFieldSet(this, _SessionEngine_customizationProcess, customizationId, "f");
             this._logger.debugLow(`Session(${this.id}).updateOutputs: Updating Outputs.`);
-            for (let r in this._stateEngine.renderingEngines)
+            for (const r in this._stateEngine.renderingEngines)
                 if (!this.excludeViewports.includes(r))
                     this._stateEngine.renderingEngines[r].busy.push(customizationId);
             const eventRequest = { type: eventType, id: eventId, progress: taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 0.1 + taskEventInfo.progressRange.min : 0.1, data: eventData, status: 'Loading outputs' };
-            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventRequest);
+            this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_PROCESS, eventRequest);
+            const oldOutputVersions = this._outputLoader.getCurrentOutputVersions();
             const newNode = yield this.loadOutputs(() => __classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f") !== customizationId, {
                 eventId,
                 type: eventType,
@@ -977,26 +1022,30 @@ export class SessionEngine {
                 },
                 data: eventData
             });
+            const newOutputVersions = this._outputLoader.getCurrentOutputVersions();
             const eventSceneUpdate = { type: eventType, id: eventId, progress: taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 0.9 + taskEventInfo.progressRange.min : 0.9, data: eventData, status: 'Updating scene' };
-            this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_PROCESS, eventSceneUpdate);
+            this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_PROCESS, eventSceneUpdate);
             // OPTION TO SKIP - PART 1
-            if (__classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f") !== customizationId) {
-                for (let r in this._stateEngine.renderingEngines)
-                    if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                        this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-                const eventCancel1 = { type: eventType, id: eventId, progress: taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 1 + taskEventInfo.progressRange.min : 1, data: eventData, status: 'Output updating was exceeded by other customization request' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1);
-                this._logger.debug(`Session(${this.id}).updateOutputs: Output updating was exceeded by other request.`);
-                return newNode;
-            }
-            else if (this._closed === true) {
-                for (let r in this._stateEngine.renderingEngines)
-                    if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
-                        this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
-                this._logger.debug(`Session(${this.id}).customize: Session was closed during customization request.`);
-                const eventCancel1a = { type: TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'Session was closed during customization request' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_CANCEL, eventCancel1a);
-                return new SessionTreeNode();
+            const cancelResult = this.cancelProcess(customizationId, eventId, eventType, taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 1 + taskEventInfo.progressRange.min : 1, eventData, newNode);
+            if (cancelResult)
+                return cancelResult;
+            // call the update callbacks
+            if (waitForViewportUpdate === false) {
+                for (const outputId in this.outputs) {
+                    if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                        this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.OUTPUT.OUTPUT_UPDATED, {
+                            outputId: outputId,
+                            outputVersion: newOutputVersions[outputId],
+                            newNode: newNode.children.find(c => c.name === outputId),
+                            oldNode: oldNode.children.find(c => c.name === outputId)
+                        });
+                    }
+                }
+                yield this.waitForUpdateCallbacks(newOutputVersions, oldOutputVersions, newNode, oldNode);
+                // OPTION TO SKIP - PART 2
+                const cancelResult = this.cancelProcess(customizationId, eventId, eventType, taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 1 + taskEventInfo.progressRange.min : 1, eventData, newNode);
+                if (cancelResult)
+                    return cancelResult;
             }
             if (this.automaticSceneUpdate)
                 this.removeFromSceneTree(this.node);
@@ -1013,24 +1062,35 @@ export class SessionEngine {
                 this.exports[exportId].updateExport();
             this._warningCreator();
             this.node.excludeViewports = JSON.parse(JSON.stringify(this._excludeViewports));
-            for (let r in this._stateEngine.renderingEngines)
+            for (const r in this._stateEngine.renderingEngines)
                 if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
                     this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
             this._logger.debug(`Session(${this.id}).updateOutputs: Updated outputs.`);
             if (!taskEventInfo) {
                 const eventEnd = { type: eventType, id: eventId, progress: 1, data: eventData, status: 'Outputs updated' };
-                this._eventEngine.emitEvent(EVENTTYPE.TASK.TASK_END, eventEnd);
+                this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_END, eventEnd);
             }
             // update the viewports
-            for (let r in this._stateEngine.renderingEngines)
-                if (!this.excludeViewports.includes(this._stateEngine.renderingEngines[r].id))
-                    this._stateEngine.renderingEngines[r].update(`SessionEngine(${this.id}).customize`);
-            // call the update callback function on the session
-            if (this._updateCallback)
-                this._updateCallback(newNode, oldNode);
-            // call the update callback functions on the outputs
-            for (const outputId in this.outputs)
-                this.outputs[outputId].triggerUpdateCallback(newNode.children.find(c => c.name === outputId), oldNode.children.find(c => c.name === outputId));
+            if (waitForViewportUpdate) {
+                for (const r in this._stateEngine.renderingEngines)
+                    if (!this.excludeViewports.includes(this._stateEngine.renderingEngines[r].id))
+                        this._stateEngine.renderingEngines[r].update(`SessionEngine(${this.id}).updateOutputs`);
+                for (const outputId in this.outputs) {
+                    if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                        this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.OUTPUT.OUTPUT_UPDATED, {
+                            outputId: outputId,
+                            outputVersion: newOutputVersions[outputId],
+                            newNode: newNode.children.find(c => c.name === outputId),
+                            oldNode: oldNode.children.find(c => c.name === outputId)
+                        });
+                    }
+                }
+                yield this.waitForUpdateCallbacks(newOutputVersions, oldOutputVersions, newNode, oldNode);
+                // OPTION TO SKIP - PART 3
+                const cancelResult = this.cancelProcess(customizationId, eventId, eventType, taskEventInfo ? (taskEventInfo.progressRange.max - taskEventInfo.progressRange.min) * 1 + taskEventInfo.progressRange.min : 1, eventData, newNode);
+                if (cancelResult)
+                    return cancelResult;
+            }
             return this.node;
         });
     }
@@ -1047,7 +1107,7 @@ export class SessionEngine {
                     return fileAsset.id;
                 }
                 else {
-                    throw new ShapeDiverViewerSessionError(`Session.uploadFile: Upload reply has not the required format.`);
+                    throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.uploadFile: Upload reply has not the required format.');
                 }
             }
             catch (e) {
@@ -1056,13 +1116,13 @@ export class SessionEngine {
             }
         });
     }
-    uploadGLTF(blob, conversion = ShapeDiverRequestGltfUploadQueryConversion.NONE, retry = false) {
+    uploadGLTF(blob, conversion = sdk_geometry_api_sdk_v2_1.ShapeDiverRequestGltfUploadQueryConversion.NONE, retry = false) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkAvailability('gltf-upload');
             try {
                 const responseDto = yield this._sdk.gltf.upload(this._sessionId, yield blob.arrayBuffer(), 'model/gltf-binary', conversion);
                 if (!responseDto || !responseDto.gltf || !responseDto.gltf.href)
-                    throw new ShapeDiverViewerSessionError(`Session.uploadGLTF: Upload reply has not the required format.`);
+                    throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.uploadGLTF: Upload reply has not the required format.');
                 return responseDto;
             }
             catch (e) {
@@ -1071,20 +1131,20 @@ export class SessionEngine {
             }
         });
     }
-    // #endregion Public Methods (24)
-    // #region Private Methods (10)
+    // #endregion Public Methods (27)
+    // #region Private Methods (13)
     _saveSessionSettings() {
         const parameters = this.parameters;
         const exports = this.exports;
         const sessionProperties = {};
-        for (let p in parameters) {
+        for (const p in parameters) {
             sessionProperties[p] = {
                 order: parameters[p].order || 0,
                 displayname: parameters[p].displayname || '',
                 hidden: parameters[p].hidden
             };
         }
-        for (let e in exports) {
+        for (const e in exports) {
             sessionProperties[e] = {
                 order: exports[e].order || 0,
                 displayname: exports[e].displayname || '',
@@ -1093,10 +1153,10 @@ export class SessionEngine {
         }
         this._settingsEngine.session = sessionProperties;
         let orderedOutputs = [];
-        for (let o in this.outputs)
+        for (const o in this.outputs)
             orderedOutputs.push(this.outputs[o]);
         orderedOutputs.sort((a, b) => ((a.order || Infinity) - (b.order || Infinity)));
-        let zerosOutputs = orderedOutputs.filter(x => x.order === 0);
+        const zerosOutputs = orderedOutputs.filter(x => x.order === 0);
         orderedOutputs = orderedOutputs.filter((el) => { return !zerosOutputs.includes(el); });
         orderedOutputs = zerosOutputs.concat(orderedOutputs);
         const controlOrderOutputs = orderedOutputs.map((value) => { return value.id; });
@@ -1112,9 +1172,9 @@ export class SessionEngine {
             let warning = '';
             if (this.outputs[outputId].msg)
                 warning += `\n\t- ${this.outputs[outputId].msg}`;
-            if (this.outputs[outputId].status_collect && this.outputs[outputId].status_collect !== ShapeDiverResponseModelComputationStatus.SUCCESS)
+            if (this.outputs[outputId].status_collect && this.outputs[outputId].status_collect !== sdk_geometry_api_sdk_v2_1.ShapeDiverResponseModelComputationStatus.SUCCESS)
                 warning += `\n\t- status_collect is ${this.outputs[outputId].status_collect}`;
-            if (this.outputs[outputId].status_computation && this.outputs[outputId].status_computation !== ShapeDiverResponseModelComputationStatus.SUCCESS)
+            if (this.outputs[outputId].status_computation && this.outputs[outputId].status_computation !== sdk_geometry_api_sdk_v2_1.ShapeDiverResponseModelComputationStatus.SUCCESS)
                 warning += `\n\t- status_computation is ${this.outputs[outputId].status_computation}`;
             if (warning)
                 this._logger.warn(`\nOutput(${outputId}):${warning}`);
@@ -1124,9 +1184,9 @@ export class SessionEngine {
             let warning = '';
             if (this.exports[exportId].msg)
                 warning += `\n\t- ${this.exports[exportId].msg}`;
-            if (this.exports[exportId].status_collect && this.exports[exportId].status_collect !== ShapeDiverResponseModelComputationStatus.SUCCESS)
+            if (this.exports[exportId].status_collect && this.exports[exportId].status_collect !== sdk_geometry_api_sdk_v2_1.ShapeDiverResponseModelComputationStatus.SUCCESS)
                 warning += `\n\t- status_collect is ${this.exports[exportId].status_collect}`;
-            if (this.exports[exportId].status_computation && this.exports[exportId].status_computation !== ShapeDiverResponseModelComputationStatus.SUCCESS)
+            if (this.exports[exportId].status_computation && this.exports[exportId].status_computation !== sdk_geometry_api_sdk_v2_1.ShapeDiverResponseModelComputationStatus.SUCCESS)
                 warning += `\n\t- status_computation is ${this.exports[exportId].status_computation}`;
             if (warning)
                 this._logger.warn(`\nExport(${exportId}):${warning}`);
@@ -1136,53 +1196,115 @@ export class SessionEngine {
         this._sceneTree.addNode(node);
         this._sceneTree.root.updateVersion();
     }
+    cancelProcess(customizationId, eventId, eventType, eventProgress, eventData, newNode = new SessionTreeNode_1.SessionTreeNode()) {
+        if (__classPrivateFieldGet(this, _SessionEngine_customizationProcess, "f") !== customizationId) {
+            for (const r in this._stateEngine.renderingEngines)
+                if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
+                    this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
+            const eventCancel = {
+                type: eventType,
+                id: eventId,
+                progress: eventProgress,
+                data: eventData,
+                status: 'The request was exceeded by another customization request'
+            };
+            this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_CANCEL, eventCancel);
+            this._logger.debug(`Session(${this.id}).cancelProcess: The request was was exceeded by another request.`);
+            return newNode;
+        }
+        else if (this._closed === true) {
+            for (const r in this._stateEngine.renderingEngines)
+                if (this._stateEngine.renderingEngines[r].busy.includes(customizationId))
+                    this._stateEngine.renderingEngines[r].busy.splice(this._stateEngine.renderingEngines[r].busy.indexOf(customizationId), 1);
+            this._logger.debug(`Session(${this.id}).cancelProcess: The session was closed during the request.`);
+            const eventCancel = { type: viewer_shared_types_1.TASK_TYPE.SESSION_CUSTOMIZATION, id: eventId, progress: 1, data: { sessionId: this.id }, status: 'The session was closed during the request.' };
+            this._eventEngine.emitEvent(viewer_shared_services_1.EVENTTYPE.TASK.TASK_CANCEL, eventCancel);
+            return new SessionTreeNode_1.SessionTreeNode();
+        }
+    }
     checkAvailability(action, checkForModelId = false) {
         var _a;
         if (!this._responseDto)
-            throw new ShapeDiverViewerSessionError(`Session.checkAvailability: responseDto not available.`);
+            throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.checkAvailability: responseDto not available.');
         if (!this._sessionId)
-            throw new ShapeDiverViewerSessionError(`Session.checkAvailability: sessionId not available.`);
+            throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.checkAvailability: sessionId not available.');
         if (checkForModelId && !this._modelId)
-            throw new ShapeDiverViewerSessionError(`Session.checkAvailability: modelId not available.`);
+            throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.checkAvailability: modelId not available.');
         if (action && !this._responseDto.actions)
-            throw new ShapeDiverViewerSessionError(`Session.checkAvailability: actions not available.`);
+            throw new viewer_shared_services_1.ShapeDiverViewerSessionError('Session.checkAvailability: actions not available.');
         const responseDtoAction = (_a = this._responseDto.actions) === null || _a === void 0 ? void 0 : _a.find(a => a.name === action);
         if (action && !responseDtoAction)
-            throw new ShapeDiverViewerSessionError(`Session.checkAvailability: action ${action} not available.`);
+            throw new viewer_shared_services_1.ShapeDiverViewerSessionError(`Session.checkAvailability: action ${action} not available.`);
+    }
+    cleanExportParameters(parameters) {
+        const requestParameterSet = {};
+        // first step, we convert all our names and displaynames to ids
+        for (const parameterIdOrName in parameters) {
+            // we prioritize id, then name and then displayname
+            // if there are two parameters with the same name or displayname, we take the one that is found first (no way for us to evaluate which one the user meant)
+            const parameterObject = Object.values(this._parameters).find(p => p.id === parameterIdOrName || p.name === parameterIdOrName || p.displayname === parameterIdOrName);
+            // in case the key of the key value pair was neither the id, name or displayname, skip
+            if (!parameterObject)
+                continue;
+            // copy into new dictionary
+            requestParameterSet[parameterObject.id] = parameters[parameterIdOrName];
+        }
+        // seconds step, fill all other parameter values that are currently not set
+        const currentParameters = this.parameterValues;
+        for (const parameterId in currentParameters) {
+            // if already set by input values, skip
+            if (requestParameterSet[parameterId] !== undefined)
+                continue;
+            // deep copy into new dictionary
+            requestParameterSet[parameterId] = (' ' + currentParameters[parameterId]).slice(1);
+        }
+        return requestParameterSet;
     }
     customizeInternal(cancelRequest, taskEventInfo) {
         return __awaiter(this, void 0, void 0, function* () {
             return this.customizeSession(this._parameterValues, cancelRequest, taskEventInfo);
         });
     }
-    customizeSession(parameters, cancelRequest, taskEventInfo, parallel = false, retry = false) {
+    customizeSession(parameters, cancelRequest, taskEventInfo, parallel = false, loadOutputs = true, retry = false) {
         return __awaiter(this, void 0, void 0, function* () {
             this.checkAvailability('customize');
             try {
                 this._performanceEvaluator.startSection('sessionResponse');
                 const responseDto = yield this._sdk.utils.submitAndWaitForCustomization(this._sdk, this._sessionId, parameters);
                 this._performanceEvaluator.endSection('sessionResponse');
-                if (cancelRequest())
-                    return new SessionTreeNode();
-                if (parallel === false)
-                    this.updateResponseDto(responseDto);
-                return parallel === false ? this.loadOutputs(cancelRequest, taskEventInfo) : this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo);
+                if (loadOutputs === true) {
+                    if (cancelRequest())
+                        return new SessionTreeNode_1.SessionTreeNode();
+                    if (parallel === true) {
+                        // special case, we load the outputs put don't add them to the scene
+                        return this.loadOutputsParallel(responseDto, cancelRequest, taskEventInfo);
+                    }
+                    else {
+                        // default case, we load the outputs and return the nodes
+                        this.updateResponseDto(responseDto);
+                        return this.loadOutputs(cancelRequest, taskEventInfo);
+                    }
+                }
+                else {
+                    // special case, we don't load the outputs and only return the responseDto
+                    return responseDto;
+                }
             }
             catch (e) {
                 yield this.handleError(e, retry);
                 if (cancelRequest())
-                    return new SessionTreeNode();
-                return yield this.customizeSession(parameters, cancelRequest, taskEventInfo, parallel, true);
+                    return new SessionTreeNode_1.SessionTreeNode();
+                return yield this.customizeSession(parameters, cancelRequest, taskEventInfo, parallel, loadOutputs, true);
             }
         });
     }
     handleError(e, retry = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (isGBResponseError(e)) {
-                if (e.error === ShapeDiverResponseErrorType.SESSION_GONE_ERROR) {
+            if ((0, sdk_geometry_api_sdk_v2_1.isGBResponseError)(e)) {
+                if (e.error === sdk_geometry_api_sdk_v2_1.ShapeDiverResponseErrorType.SESSION_GONE_ERROR) {
                     // case 1: the session is no longer available
                     // we try to re-initialize the session 3 times, if that does not work, we close it
-                    this._logger.warn(`The session has been closed, trying to re-initialize.`);
+                    this._logger.warn('The session has been closed, trying to re-initialize.');
                     if (this._sessionId)
                         this._httpClient.removeDataLoading(this._sessionId);
                     if (this._retryCounter < 3) {
@@ -1194,6 +1316,7 @@ export class SessionEngine {
                     else {
                         // the retries were exceeded, we close the session
                         this._logger.warn('Tried to retry the connect multiple times, bearer token still not valid. Closing Session.');
+                        // eslint-disable-next-line no-empty
                         try {
                             yield this._closeOnFailure();
                         }
@@ -1201,7 +1324,7 @@ export class SessionEngine {
                         throw this._httpClient.convertError(e);
                     }
                 }
-                else if (e.error === ShapeDiverResponseErrorType.JWT_VALIDATION_ERROR) {
+                else if (e.error === sdk_geometry_api_sdk_v2_1.ShapeDiverResponseErrorType.JWT_VALIDATION_ERROR) {
                     // if any of the above errors occur, we try to get a new bearer token
                     // if we get a new one, we retry 3 times (by requiring new bearer tokens every time)
                     if (this._retryCounter < 3) {
@@ -1213,6 +1336,7 @@ export class SessionEngine {
                         else {
                             // no bearer tokens are supplied, we close the session
                             this._logger.warn('No retry possible, no new bearer token was supplied. Closing Session.');
+                            // eslint-disable-next-line no-empty
                             try {
                                 yield this._closeOnFailure();
                             }
@@ -1223,6 +1347,7 @@ export class SessionEngine {
                     else {
                         // the retries were exceeded, we close the session
                         this._logger.warn('Tried to retry the connect multiple times, bearer token still not valid. Closing Session.');
+                        // eslint-disable-next-line no-empty
                         try {
                             yield this._closeOnFailure();
                         }
@@ -1261,14 +1386,14 @@ export class SessionEngine {
         }
         // convert parameters
         if (responseDto.parameters) {
-            for (let parameterId in responseDto.parameters) {
+            for (const parameterId in responseDto.parameters) {
                 this._responseDto.parameters = this._responseDto.parameters || {};
                 this._responseDto.parameters[parameterId] = this._responseDto.parameters[parameterId] || responseDto.parameters[parameterId];
             }
         }
         // convert outputs
         if (responseDto.outputs) {
-            for (let outputId in responseDto.outputs) {
+            for (const outputId in responseDto.outputs) {
                 this._responseDto.outputs = this._responseDto.outputs || {};
                 if ('version' in responseDto.outputs[outputId] || !(this._responseDto.outputs[outputId] && 'version' in this._responseDto.outputs[outputId]))
                     this._responseDto.outputs[outputId] = responseDto.outputs[outputId];
@@ -1276,32 +1401,32 @@ export class SessionEngine {
         }
         // convert exports
         if (responseDto.exports) {
-            for (let exportId in responseDto.exports) {
+            for (const exportId in responseDto.exports) {
                 this._responseDto.exports = this._responseDto.exports || {};
                 if ('version' in responseDto.exports[exportId] || !(this._responseDto.exports[exportId] && 'version' in this._responseDto.exports[exportId]))
                     this._responseDto.exports[exportId] = responseDto.exports[exportId];
             }
         }
         const parameterSet = {};
-        for (let parameterId in this._responseDto.parameters) {
+        for (const parameterId in this._responseDto.parameters) {
             if (this.parameters[parameterId])
                 continue;
             this._responseDto.parameters[parameterId].id = parameterId;
             switch (true) {
-                case this._responseDto.parameters[parameterId].type === PARAMETER_TYPE.BOOL:
-                    this.parameters[parameterId] = new Parameter(this._responseDto.parameters[parameterId], this);
+                case this._responseDto.parameters[parameterId].type === ISessionEngine_1.PARAMETER_TYPE.BOOL:
+                    this.parameters[parameterId] = new Parameter_1.Parameter(this._responseDto.parameters[parameterId], this);
                     break;
-                case this._responseDto.parameters[parameterId].type === PARAMETER_TYPE.COLOR:
-                    this.parameters[parameterId] = new Parameter(this._responseDto.parameters[parameterId], this);
+                case this._responseDto.parameters[parameterId].type === ISessionEngine_1.PARAMETER_TYPE.COLOR:
+                    this.parameters[parameterId] = new Parameter_1.Parameter(this._responseDto.parameters[parameterId], this);
                     break;
-                case this._responseDto.parameters[parameterId].type === PARAMETER_TYPE.FILE:
-                    this.parameters[parameterId] = new FileParameter(this._responseDto.parameters[parameterId], this);
+                case this._responseDto.parameters[parameterId].type === ISessionEngine_1.PARAMETER_TYPE.FILE:
+                    this.parameters[parameterId] = new FileParameter_1.FileParameter(this._responseDto.parameters[parameterId], this);
                     break;
-                case this._responseDto.parameters[parameterId].type === PARAMETER_TYPE.EVEN || this._responseDto.parameters[parameterId].type === PARAMETER_TYPE.FLOAT || this._responseDto.parameters[parameterId].type === PARAMETER_TYPE.INT || this._responseDto.parameters[parameterId].type === PARAMETER_TYPE.ODD:
-                    this.parameters[parameterId] = new Parameter(this._responseDto.parameters[parameterId], this);
+                case this._responseDto.parameters[parameterId].type === ISessionEngine_1.PARAMETER_TYPE.EVEN || this._responseDto.parameters[parameterId].type === ISessionEngine_1.PARAMETER_TYPE.FLOAT || this._responseDto.parameters[parameterId].type === ISessionEngine_1.PARAMETER_TYPE.INT || this._responseDto.parameters[parameterId].type === ISessionEngine_1.PARAMETER_TYPE.ODD:
+                    this.parameters[parameterId] = new Parameter_1.Parameter(this._responseDto.parameters[parameterId], this);
                     break;
                 default:
-                    this.parameters[parameterId] = new Parameter(this._responseDto.parameters[parameterId], this);
+                    this.parameters[parameterId] = new Parameter_1.Parameter(this._responseDto.parameters[parameterId], this);
                     break;
             }
             // we don't have to do larger restrictions for this as the backend would have already thrown an error if the values were not correct
@@ -1330,29 +1455,45 @@ export class SessionEngine {
         // store the initialization as the first parameter set in the history
         if (!this.initialized)
             __classPrivateFieldGet(this, _SessionEngine_parameterHistory, "f").push(parameterSet);
-        for (let exportId in this._responseDto.exports) {
-            if (this._responseDto.exports[exportId].type === ShapeDiverResponseExportDefinitionType.EMAIL || this._responseDto.exports[exportId].type === ShapeDiverResponseExportDefinitionType.DOWNLOAD) {
+        for (const exportId in this._responseDto.exports) {
+            if (this._responseDto.exports[exportId].type === sdk_geometry_api_sdk_v2_1.ShapeDiverResponseExportDefinitionType.EMAIL || this._responseDto.exports[exportId].type === sdk_geometry_api_sdk_v2_1.ShapeDiverResponseExportDefinitionType.DOWNLOAD) {
                 if (!this.exports[exportId]) {
                     this._responseDto.exports[exportId].id = exportId;
-                    this.exports[exportId] = new Export(this._responseDto.exports[exportId], this);
+                    this.exports[exportId] = new Export_1.Export(this._responseDto.exports[exportId], this);
                 }
                 else {
                     this.exports[exportId].updateExportDefinition(this._responseDto.exports[exportId]);
                 }
             }
         }
-        for (let outputId in this._responseDto.outputs) {
+        for (const outputId in this._responseDto.outputs) {
             if (!this.outputs[outputId]) {
                 this._responseDto.outputs[outputId].id = outputId;
                 if (this.outputsFreeze[outputId] === undefined)
                     this.outputsFreeze[outputId] = false;
-                this.outputs[outputId] = new Output(this._responseDto.outputs[outputId], this);
+                this.outputs[outputId] = new Output_1.Output(this._responseDto.outputs[outputId], this);
             }
             else {
                 this.outputs[outputId].updateOutputDefinition(this._responseDto.outputs[outputId]);
             }
         }
     }
+    waitForUpdateCallbacks(newOutputVersions, oldOutputVersions, newNode, oldNode) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // call the update callback function on the session
+            if (this._updateCallback)
+                yield Promise.resolve(this._updateCallback(newNode, oldNode));
+            const promises = [];
+            // call the update callback functions on the outputs
+            for (const outputId in this.outputs) {
+                if (oldOutputVersions[outputId] !== newOutputVersions[outputId]) {
+                    promises.push(this.outputs[outputId].triggerUpdateCallback(newNode.children.find(c => c.name === outputId), oldNode.children.find(c => c.name === outputId)));
+                }
+            }
+            yield Promise.all(promises);
+        });
+    }
 }
+exports.SessionEngine = SessionEngine;
 _SessionEngine_customizationProcess = new WeakMap(), _SessionEngine_parameterHistory = new WeakMap(), _SessionEngine_parameterHistoryCall = new WeakMap(), _SessionEngine_parameterHistoryForward = new WeakMap();
 //# sourceMappingURL=SessionEngine.js.map