@shapediver/viewer.session 3.0.0

package/src/implementation/ParameterApi.ts

@@ -0,0 +1,176 @@
+import { InputValidator, Logger } from '@shapediver/viewer.shared.services';
+import { IParameter } from '@shapediver/viewer.session-engine.session-engine';
+import { IParameterApi } from '../interfaces/IParameterApi';
+import { PARAMETER_TYPE, PARAMETER_VISUALIZATION } from '@shapediver/viewer.shared.types';
+import { ShapeDiverResponseParameterGroup, ShapeDiverResponseParameterStructure } from '@shapediver/sdk.geometry-api-sdk-v2';
+
+export class ParameterApi<T> implements IParameterApi<T> {
+    // #region Properties (3)
+
+    readonly #inputValidator: InputValidator = InputValidator.instance;
+    readonly #logger: Logger = Logger.instance;
+    readonly #parameter: IParameter<T>;
+
+    // #endregion Properties (3)
+
+    // #region Constructors (1)
+
+    constructor(parameter: IParameter<T>) {
+        this.#parameter = parameter;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (25)
+
+    public get choices(): string[] | undefined {
+        return this.#parameter.choices;
+    }
+
+    public get decimalplaces(): number | undefined {
+        return this.#parameter.decimalplaces;
+    }
+
+    public get defval(): string {
+        return this.#parameter.defval;
+    }
+
+    public get displayname(): string | undefined {
+        return this.#parameter.displayname;
+    }
+
+    public set displayname(value: string | undefined) {
+        const scope = 'displayname';
+        this.#inputValidator.validateAndError(`ParameterApi.${scope}`, value, 'string', false);
+        this.#parameter.displayname = value;
+        this.#logger.debug(`ParameterApi.${scope}: ${scope} was set to ${this.#parameter.displayname}.`);
+    }
+
+    public get expression(): string | undefined {
+        return this.#parameter.expression;
+    }
+
+    public get format(): string[] | undefined {
+        return this.#parameter.format;
+    }
+
+    public get group(): ShapeDiverResponseParameterGroup | undefined {
+        return this.#parameter.group;
+    }
+
+    public get hidden(): boolean {
+        return this.#parameter.hidden;
+    }
+
+    public set hidden(value: boolean) {
+        const scope = 'hidden';
+        this.#inputValidator.validateAndError(`ParameterApi.${scope}`, value, 'boolean');
+        this.#parameter.hidden = value;
+        this.#logger.debug(`ParameterApi.${scope}: ${scope} was set to ${this.#parameter.hidden}.`);
+    }
+
+    public get id(): string {
+        return this.#parameter.id;
+    }
+
+    public get max(): number | undefined {
+        return this.#parameter.max;
+    }
+
+    public get min(): number | undefined {
+        return this.#parameter.min;
+    }
+
+    public get name(): string {
+        return this.#parameter.name;
+    }
+
+    public get order(): number | undefined {
+        return this.#parameter.order;
+    }
+
+    public set order(value: number | undefined) {
+        const scope = 'order';
+        this.#inputValidator.validateAndError(`ParameterApi.${scope}`, value, 'number', false);
+        this.#parameter.order = value;
+        this.#logger.debug(`ParameterApi.${scope}: ${scope} was set to ${this.#parameter.order}.`);
+    }
+
+    public get sessionValue(): T | string {
+        return this.#parameter.sessionValue;
+    }
+
+    public set sessionValue(value: T | string) {
+        const scope = 'sessionValue';
+        this.#parameter.sessionValue = value;
+        this.#logger.debug(`ParameterApi.${scope}: ${scope} was set to ${this.#parameter.value}.`);
+    }
+
+    public get structure(): ShapeDiverResponseParameterStructure | undefined {
+        return this.#parameter.structure;
+    }
+
+    public get tooltip(): string | undefined {
+        return this.#parameter.tooltip;
+    }
+
+    public set tooltip(value: string | undefined) {
+        const scope = 'tooltip';
+        this.#inputValidator.validateAndError(`ParameterApi.${scope}`, value, 'string', false);
+        this.#parameter.tooltip = value;
+        this.#logger.debug(`ParameterApi.${scope}: ${scope} was set to ${this.#parameter.tooltip}.`);
+    }
+
+    public get type(): PARAMETER_TYPE {
+        return <PARAMETER_TYPE>this.#parameter.type;
+    }
+
+    public get value(): T | string {
+        return this.#parameter.value;
+    }
+
+    public set value(value: T | string) {
+        const scope = 'value';
+        this.isValid(value, true);
+        this.#parameter.value = value;
+        this.#logger.debug(`ParameterApi.${scope}: ${scope} was set to ${this.#parameter.value}.`);
+    }
+
+    public get visualization(): PARAMETER_VISUALIZATION | undefined {
+        return <PARAMETER_VISUALIZATION>this.#parameter.visualization;
+    }
+
+    // #endregion Public Getters And Setters (25)
+
+    // #region Public Methods (4)
+
+    public isValid(value: unknown, throwError?: boolean): boolean {
+        const scope = 'isValid';
+        this.#inputValidator.validateAndError(`ParameterApi.${scope}`, throwError, 'boolean', false);
+
+        if (throwError === false) {
+            try {
+                this.#parameter.isValid(value);
+            } catch (e) {
+                return false;
+            }
+            return true;
+        } else {
+            return this.#parameter.isValid(value);
+        }
+    }
+
+    public resetToDefaultValue(): void {
+        return this.#parameter.resetToDefaultValue();
+    }
+
+    public resetToSessionValue(): void {
+        return this.#parameter.resetToSessionValue();
+    }
+
+    public stringify(): string {
+        return this.#parameter.stringify();
+    }
+
+    // #endregion Public Methods (4)
+}

package/src/implementation/SessionApi.ts

@@ -0,0 +1,408 @@
+import { CreationControlCenterSession, ICreationControlCenterSession } from '@shapediver/viewer.creation-control-center.session';
+import { ExportApi } from './ExportApi';
+import { FileParameter, SessionEngine } from '@shapediver/viewer.session-engine.session-engine';
+import { FileParameterApi } from './FileParameterApi';
+import { GLTFConverter } from '@shapediver/viewer.data-engine.gltf-converter';
+import { IExportApi } from '../interfaces/IExportApi';
+import {
+    InputValidator,
+    Logger,
+    ShapeDiverViewerSessionError,
+    StateEngine
+} from '@shapediver/viewer.shared.services';
+import { IOutputApi } from '../interfaces/IOutputApi';
+import { IParameterApi } from '../interfaces//IParameterApi';
+import { ISessionApi } from '../interfaces/ISessionApi';
+import { ISettingsSections } from '@shapediver/viewer.shared.types';
+import { ITreeNode } from '@shapediver/viewer.shared.node-tree';
+import { OutputApi } from './OutputApi';
+import { ParameterApi } from './ParameterApi';
+import { SessionApiData } from './data/SessionApiData';
+import { ShapeDiverRequestExport, ShapeDiverResponseDto } from '@shapediver/sdk.geometry-api-sdk-v2';
+
+export class SessionApi implements ISessionApi {
+    // #region Properties (9)
+
+    readonly #creationControlCenterSession: ICreationControlCenterSession = CreationControlCenterSession.instance;
+    readonly #exports: { [key: string]: IExportApi; } = {};
+    readonly #gltfConverter: GLTFConverter = GLTFConverter.instance;
+    readonly #inputValidator: InputValidator = InputValidator.instance;
+    readonly #logger: Logger = Logger.instance;
+    readonly #outputs: { [key: string]: IOutputApi; } = {};
+    readonly #parameters: { [key: string]: IParameterApi<unknown>; } = {};
+    readonly #sessionEngine: SessionEngine;
+    readonly #stateEngine: StateEngine = StateEngine.instance;
+
+    // #endregion Properties (9)
+
+    // #region Constructors (1)
+
+    constructor(sessionEngine: SessionEngine) {
+        this.#sessionEngine = sessionEngine;
+        if (!this.#sessionEngine.initialized)
+            throw new ShapeDiverViewerSessionError('Session could not be initialized.');
+
+        this.#sessionEngine.updateCallback = (newNode?: ITreeNode) => {
+            if (!newNode) return;
+
+            if (newNode.data.findIndex(d => d instanceof SessionApiData) === -1)
+                newNode.addData(new SessionApiData(this));
+        };
+        this.#sessionEngine.updateCallback(this.node, this.node);
+
+        for (const o in this.#sessionEngine.outputs)
+            this.#outputs[o] = new OutputApi(this.#sessionEngine.outputs[o]);
+
+        for (const e in this.#sessionEngine.exports)
+            this.#exports[e] = new ExportApi(this.#sessionEngine.exports[e]);
+
+        for (const p in this.#sessionEngine.parameters) {
+            if (this.#sessionEngine.parameters[p] instanceof FileParameter) {
+                this.#parameters[p] = new FileParameterApi(<FileParameter>this.#sessionEngine.parameters[p]);
+            } else {
+                this.#parameters[p] = new ParameterApi(this.#sessionEngine.parameters[p]);
+            }
+        }
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (28)
+
+    public get automaticSceneUpdate(): boolean {
+        return this.#sessionEngine.automaticSceneUpdate;
+    }
+
+    public set automaticSceneUpdate(value: boolean) {
+        const scope = 'automaticSceneUpdate';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, value, 'boolean');
+        this.#sessionEngine.automaticSceneUpdate = value;
+        this.#logger.debug(`SessionApi.${scope}: ${scope} was set to ${value}`);
+    }
+
+    public get commitParameters(): boolean {
+        return this.#sessionEngine.settingsEngine.general.commitParameters;
+    }
+
+    public set commitParameters(value: boolean) {
+        const scope = 'commitParameters';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, value, 'boolean');
+        this.#sessionEngine.settingsEngine.general.commitParameters = value;
+        this.#logger.debug(`SessionApi.${scope}: ${scope} was set to ${value}`);
+    }
+
+    public get commitSettings(): boolean {
+        return this.#sessionEngine.settingsEngine.general.commitSettings;
+    }
+
+    public set commitSettings(value: boolean) {
+        const scope = 'commitSettings';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, value, 'boolean');
+        this.#sessionEngine.settingsEngine.general.commitSettings = value;
+        this.#logger.debug(`SessionApi.${scope}: ${scope} was set to ${value}`);
+    }
+
+    public get customizeOnParameterChange(): boolean {
+        return this.#sessionEngine.customizeOnParameterChange;
+    }
+
+    public set customizeOnParameterChange(value: boolean) {
+        const scope = 'customizeOnParameterChange';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, value, 'boolean');
+        this.#sessionEngine.customizeOnParameterChange = value;
+        this.#logger.debug(`SessionApi.${scope}: ${scope} was set to ${value}`);
+    }
+
+    public get excludeViewports(): string[] {
+        return this.#sessionEngine.excludeViewports;
+    }
+
+    public set excludeViewports(value: string[]) {
+        const scope = 'excludeViewports';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, value, 'stringArray');
+        this.#sessionEngine.excludeViewports = value;
+        this.#logger.debug(`SessionApi.${scope}: ${scope} was set to ${value}`);
+    }
+
+    public get exports(): { [key: string]: IExportApi; } {
+        return this.#exports;
+    }
+
+    public get guid(): string | undefined {
+        return this.#sessionEngine.guid;
+    }
+
+    public get id(): string {
+        return this.#sessionEngine.id;
+    }
+
+    public get initialized(): boolean {
+        return this.#sessionEngine.initialized;
+    }
+
+    public get jwtToken(): string | undefined {
+        return this.#sessionEngine.jwtToken;
+    }
+
+    public get loadSdtf(): boolean {
+        return this.#sessionEngine.loadSdtf;
+    }
+
+    public set loadSdtf(value: boolean) {
+        const scope = 'loadSdtf';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, value, 'boolean');
+        this.#sessionEngine.loadSdtf = value;
+        this.#logger.debug(`SessionApi.${scope}: ${scope} was set to ${value}`);
+    }
+
+    public get modelViewUrl(): string {
+        return this.#sessionEngine.modelViewUrl;
+    }
+
+    public get node(): ITreeNode {
+        return this.#sessionEngine.node;
+    }
+
+    public get outputs(): { [key: string]: IOutputApi; } {
+        return this.#outputs;
+    }
+
+    public get parameterDefaultValues(): { [key: string]: unknown; } {
+        const parameterDefaultValues: { [key: string]: unknown; } = {};
+        for (const key in this.parameters)
+            parameterDefaultValues[key] = this.parameters[key].defval;
+        return parameterDefaultValues;
+    }
+
+    public get parameterSessionValues(): { [key: string]: unknown; } {
+        const parameterSessionValues: { [key: string]: unknown; } = {};
+        for (const key in this.parameters)
+            parameterSessionValues[key] = this.parameters[key].sessionValue;
+        return parameterSessionValues;
+    }
+
+    public get parameterValues(): { [key: string]: unknown; } {
+        const parameterValues: { [key: string]: unknown; } = {};
+        for (const key in this.parameters)
+            parameterValues[key] = this.parameters[key].value;
+        return parameterValues;
+    }
+
+    public get parameters(): { [key: string]: IParameterApi<unknown>; } {
+        return this.#parameters;
+    }
+
+    public get refreshJwtToken(): (() => Promise<string>) | undefined {
+        return this.#sessionEngine.refreshJwtToken;
+    }
+
+    public set refreshJwtToken(value: (() => Promise<string>) | undefined) {
+        const scope = 'refreshJwtToken';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, value, 'function', false);
+        this.#sessionEngine.refreshJwtToken = value;
+        this.#logger.debug(`SessionApi.${scope}: ${scope} was set to ${value}`);
+    }
+
+    public get ticket(): string | undefined {
+        return this.#sessionEngine.ticket;
+    }
+
+    public get updateCallback(): ((newNode: ITreeNode, oldNode: ITreeNode) => void | Promise<void>) | null {
+        return this.#sessionEngine.updateCallback;
+    }
+
+    public set updateCallback(value: ((newNode: ITreeNode, oldNode: ITreeNode) => void | Promise<void>) | null) {
+        const scope = 'updateCallback';
+        if (value) this.#inputValidator.validateAndError(`SessionApi.${scope}`, value, 'function', false);
+        this.#sessionEngine.updateCallback = async (newNode: ITreeNode, oldNode: ITreeNode) => {
+            if (newNode.data.findIndex(d => d instanceof SessionApiData) === -1)
+                newNode.addData(new SessionApiData(this));
+            if (value) await Promise.resolve(value(newNode, oldNode));
+        };
+        this.#logger.debug(`SessionApi.${scope}: ${scope} was updated to ${value}.`);
+    }
+
+    // #endregion Public Getters And Setters (28)
+
+    // #region Public Methods (31)
+
+    public applySettings(response: ShapeDiverResponseDto, sections?: ISettingsSections): Promise<void> {
+        const scope = 'applySettings';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, response, 'object');
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, sections, 'object', false);
+        return this.#creationControlCenterSession.applySettings(this.id, response, sections);
+    }
+
+    public canGoBack(): boolean {
+        return this.#sessionEngine.canGoBack();
+    }
+
+    public canGoForward(): boolean {
+        return this.#sessionEngine.canGoForward();
+    }
+
+    public cancelCustomization(): void {
+        this.#sessionEngine.cancelCustomization();
+    }
+
+    public async close(): Promise<void> {
+        return await this.#creationControlCenterSession.closeSessionEngine(this.id);
+    }
+
+    public async convertToGlTF(): Promise<Blob> {
+        for (const r in this.#stateEngine.viewportEngines)
+            this.#stateEngine.viewportEngines[r].update('SessionApi.convertToGlTF');
+
+        const result = await this.#gltfConverter.convert(this.node, false);
+        return new Blob([result], { type: 'application/octet-stream' });
+    }
+
+    public customize(parameterValues?: { [key: string]: unknown; }, force: boolean = false, waitForViewportUpdate: boolean = false): Promise<ITreeNode> {
+        const scope = 'customize';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, parameterValues, 'object', false);
+
+        // if there are parameter values specified, we set them directly
+        // the validation happens in the setter of the ParameterApi
+        if (parameterValues)
+            for (const p in parameterValues)
+                this.parameters[p].value = parameterValues[p];
+
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, force, 'boolean', false);
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, waitForViewportUpdate, 'boolean', false);
+        return this.#sessionEngine.customize(force, waitForViewportUpdate);
+    }
+
+    public customizeParallel(parameterValues: { [key: string]: unknown; }): Promise<ITreeNode> {
+        const scope = 'customizeParallel';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, parameterValues, 'object');
+        return this.#sessionEngine.customizeParallel(parameterValues) as Promise<ITreeNode>;
+    }
+
+    public customizeResult(parameterValues: { [key: string]: unknown; }): Promise<ShapeDiverResponseDto> {
+        const scope = 'customizeResult';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, parameterValues, 'object');
+        return this.#sessionEngine.customizeParallel(parameterValues, false) as Promise<ShapeDiverResponseDto>;
+    }
+
+    public getExportById(id: string): IExportApi | null {
+        const scope = 'getExportById';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, id, 'string');
+        return this.#exports[id];
+    }
+
+    public getExportByName(name: string): IExportApi[] {
+        const scope = 'getExportByName';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, name, 'string');
+        return Object.values(this.#exports).filter(e => e.name === name);
+    }
+
+    public getExportByType(type: string): IExportApi[] {
+        const scope = 'getExportByType';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, type, 'string');
+        return Object.values(this.#exports).filter(e => e.type === type);
+    }
+
+    public getOutputByFormat(format: string): IOutputApi[] {
+        const scope = 'getOutputByFormat';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, format, 'string');
+        return Object.values(this.#outputs).filter(o => o.format.includes(format));
+    }
+
+    public getOutputById(id: string): IOutputApi | null {
+        const scope = 'getOutputById';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, id, 'string');
+        return this.#outputs[id];
+    }
+
+    public getOutputByName(name: string): IOutputApi[] {
+        const scope = 'getOutputByName';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, name, 'string');
+        return Object.values(this.#outputs).filter(o => o.name === name);
+    }
+
+    public getParameterById(id: string): IParameterApi<unknown> | null {
+        const scope = 'getParameterById';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, id, 'string');
+        return this.#parameters[id];
+    }
+
+    public getParameterByName(name: string): IParameterApi<unknown>[] {
+        const scope = 'getParameterByName';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, name, 'string');
+        return Object.values(this.#parameters).filter(p => p.name === name);
+    }
+
+    public getParameterByType(type: string): IParameterApi<unknown>[] {
+        const scope = 'getParameterByType';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, type, 'string');
+        return Object.values(this.#parameters).filter(p => p.type === type);
+    }
+
+    public goBack(): Promise<ITreeNode> {
+        return this.#sessionEngine.goBack();
+    }
+
+    public goForward(): Promise<ITreeNode> {
+        return this.#sessionEngine.goForward();
+    }
+
+    public async loadCachedOutputs(outputs: { [key: string]: string; }): Promise<{ [key: string]: ITreeNode | undefined }> {
+        return await this.#sessionEngine.loadCachedOutputsParallel(outputs);
+    }
+
+    public async requestExports(body: ShapeDiverRequestExport, loadOutputs?: boolean, maxWaitMsec?: number): Promise<ShapeDiverResponseDto> {
+        const scope = 'requestExports';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, body, 'object');
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, loadOutputs, 'boolean', false);
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, maxWaitMsec, 'number', false);
+        return this.#sessionEngine.requestExports(body, loadOutputs, maxWaitMsec);
+    }
+
+    public resetParameterValues(force: boolean = false, waitForViewportUpdate: boolean = false): Promise<ITreeNode> {
+        const scope = 'resetParameterValues';
+        for (const p in this.parameters)
+            this.parameters[p].value = this.parameters[p].defval;
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, force, 'boolean', false);
+        return this.#sessionEngine.customize(force, waitForViewportUpdate);
+    }
+
+    public resetSettings(sections?: ISettingsSections): Promise<void> {
+        const scope = 'applySettings';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, sections, 'object', false);
+        return this.#creationControlCenterSession.resetSettings(this.id, sections);
+    }
+
+    public saveDefaultParameterValues(): Promise<boolean> {
+        return this.#sessionEngine.saveDefaultParameterValues();
+    }
+
+    public saveSettings(viewportId?: string): Promise<boolean> {
+        const scope = 'saveDefaultParameterValues';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, viewportId, 'string', false);
+        return this.#creationControlCenterSession.saveSettings(this.id, viewportId);
+    }
+
+    public saveUiProperties(): Promise<boolean> {
+        return this.#sessionEngine.saveUiProperties();
+    }
+
+    public async setJwtToken(value: string): Promise<void> {
+        const scope = 'setJwtToken';
+        this.#inputValidator.validateAndError(`SessionApi.${scope}`, value, 'string', false);
+        await this.#sessionEngine.setJwtToken(value);
+        this.#logger.debug(`SessionApi.${scope}: ${scope} was set to ${value}`);
+        return;
+    }
+
+    public updateOutputs(waitForViewportUpdate: boolean = false): Promise<ITreeNode> {
+        return this.#sessionEngine.updateOutputs(undefined, waitForViewportUpdate);
+    }
+
+    public async uploadFileParameters(values: { [key: string]: string | File | Blob }): Promise<{ [key: string]: string }> {
+        const fileParameters: { [key: string]: string | File | Blob } = values || {};
+        const fileParameterIds = await this.#sessionEngine.uploadFileParameters(fileParameters);
+        return fileParameterIds; 
+    }
+
+    // #endregion Public Methods (31)
+}

package/src/implementation/data/OutputApiData.ts

@@ -0,0 +1,53 @@
+import { AbstractTreeNodeData } from '@shapediver/viewer.shared.node-tree';
+import { IOutputApi } from '../../interfaces/IOutputApi';
+import { IOutputApiData } from '../../interfaces/data/IOutputApiData';
+
+export class OutputApiData extends AbstractTreeNodeData implements IOutputApiData {
+    // #region Properties (1)
+
+    #api: IOutputApi;
+
+    // #endregion Properties (1)
+
+    // #region Constructors (1)
+
+    /**
+     * Creates a OutputApi data node.
+     * 
+     * @param _data the data as key- value pairs 
+     * @param id the id
+     */
+    constructor(
+        api: IOutputApi,
+        id?: string,
+        version?: string
+    ) {
+        super(id, version);
+        this.#api = api;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (2)
+
+    public get api(): IOutputApi {
+        return this.#api;
+    }
+
+    public set api(value: IOutputApi) {
+        this.#api = value;
+    }
+
+    // #endregion Public Getters And Setters (2)
+
+    // #region Public Methods (1)
+
+    /**
+     * Clones the scene graph data.
+     */
+    public clone(): IOutputApiData {
+        return new OutputApiData(this.api, this.id, this.version);
+    }
+
+    // #endregion Public Methods (1)
+}

package/src/implementation/data/SessionApiData.ts

@@ -0,0 +1,53 @@
+import { AbstractTreeNodeData } from '@shapediver/viewer.shared.node-tree';
+import { ISessionApi } from '../../interfaces/ISessionApi';
+import { ISessionApiData } from '../../interfaces/data/ISessionApiData';
+
+export class SessionApiData extends AbstractTreeNodeData implements ISessionApiData {
+    // #region Properties (1)
+
+    #api: ISessionApi;
+
+    // #endregion Properties (1)
+
+    // #region Constructors (1)
+
+    /**
+     * Creates a SessionApi data node.
+     * 
+     * @param _data the data as key- value pairs 
+     * @param id the id
+     */
+    constructor(
+        api: ISessionApi,
+        id?: string,
+        version?: string
+    ) {
+        super(id, version);
+        this.#api = api;
+    }
+
+    // #endregion Constructors (1)
+
+    // #region Public Getters And Setters (2)
+
+    public get api(): ISessionApi {
+        return this.#api;
+    }
+
+    public set api(value: ISessionApi) {
+        this.#api = value;
+    }
+
+    // #endregion Public Getters And Setters (2)
+
+    // #region Public Methods (1)
+
+    /**
+     * Clones the scene graph data.
+     */
+    public clone(): ISessionApiData {
+        return new SessionApiData(this.api, this.id, this.version);
+    }
+
+    // #endregion Public Methods (1)
+}