@kritzel/editor 0.4.31

package/dist/collection/components/kritzel-editor/kritzel-editor.js

@@ -0,0 +1,4678 @@
+import { Host, h } from "@stencil/core";
+import { KritzelIconRegistry } from "@kritzel/engine";
+import { ShapeType } from "@kritzel/engine";
+import { KritzelAlignment } from "@kritzel/engine";
+import { KritzelSelectionTool } from "@kritzel/engine";
+import { KritzelEraserTool } from "@kritzel/engine";
+import { KritzelImageTool } from "@kritzel/engine";
+import { KritzelBrushTool } from "@kritzel/engine";
+import { KritzelLineTool } from "@kritzel/engine";
+import { KritzelTextTool } from "@kritzel/engine";
+import { KritzelShapeTool } from "@kritzel/engine";
+import { DEFAULT_BRUSH_CONFIG } from "@kritzel/engine";
+import { DEFAULT_LINE_TOOL_CONFIG } from "@kritzel/engine";
+import { DEFAULT_TEXT_CONFIG } from "@kritzel/engine";
+import { DEFAULT_SHAPE_CONFIG } from "@kritzel/engine";
+import { ABSOLUTE_SCALE_MAX, ABSOLUTE_SCALE_MIN } from "@kritzel/engine";
+import { KritzelKeyboardHelper } from "@kritzel/engine";
+import { KritzelDevicesHelper } from "@kritzel/engine";
+import { hasRemoteSyncProvider } from "@kritzel/engine";
+import { DEFAULT_ASSET_STORAGE_CONFIG } from "@kritzel/engine";
+import { DEFAULT_SYNC_CONFIG } from "@kritzel/engine";
+import { ThemeHelper } from "@kritzel/engine";
+import { lightTheme } from "@kritzel/engine";
+import { darkTheme } from "@kritzel/engine";
+import { KritzelSelectionGroup } from "@kritzel/engine";
+import { KritzelSelectionBox } from "@kritzel/engine";
+import { ObjectHelper } from "@kritzel/engine";
+import { KritzelFontRegistry } from "@kritzel/engine";
+import { resolveTextToolAvailableFonts } from "@kritzel/engine";
+export class KritzelEditor {
+    host;
+    scaleMax = ABSOLUTE_SCALE_MAX;
+    scaleMin = ABSOLUTE_SCALE_MIN;
+    lockDrawingScale = true;
+    viewportBoundaryLeft = -Infinity;
+    viewportBoundaryRight = Infinity;
+    viewportBoundaryTop = -Infinity;
+    viewportBoundaryBottom = Infinity;
+    debugInfo = {
+        showViewportInfo: false,
+        showObjectInfo: false,
+        showSyncProviderInfo: true,
+        showMigrationInfo: true,
+        showAssetResolverInfo: false,
+    };
+    user;
+    activeUsers;
+    toolbarItems = [
+        {
+            name: 'selection',
+            type: 'tool',
+            isDefault: true,
+            tool: KritzelSelectionTool,
+            icon: 'cursor',
+        },
+        {
+            name: 'brush',
+            type: 'tool',
+            tool: KritzelBrushTool,
+            icon: 'pen',
+            config: DEFAULT_BRUSH_CONFIG,
+        },
+        {
+            name: 'eraser',
+            type: 'tool',
+            tool: KritzelEraserTool,
+            icon: 'eraser',
+        },
+        {
+            name: 'line',
+            type: 'tool',
+            tool: KritzelLineTool,
+            icon: 'arrow',
+            config: DEFAULT_LINE_TOOL_CONFIG,
+        },
+        {
+            name: 'shape',
+            type: 'tool',
+            tool: KritzelShapeTool,
+            icon: 'shape-rectangle',
+            config: DEFAULT_SHAPE_CONFIG,
+            subOptions: [
+                { id: 'rectangle', icon: 'shape-rectangle', label: 'Rectangle', value: ShapeType.Rectangle, toolProperty: 'shapeType' },
+                { id: 'ellipse', icon: 'shape-ellipse', label: 'Ellipse', value: ShapeType.Ellipse, toolProperty: 'shapeType' },
+                { id: 'triangle', icon: 'shape-triangle', label: 'Triangle', value: ShapeType.Triangle, toolProperty: 'shapeType' },
+            ],
+        },
+        {
+            name: 'text',
+            type: 'tool',
+            tool: KritzelTextTool,
+            icon: 'type',
+            config: DEFAULT_TEXT_CONFIG,
+        },
+        {
+            name: 'image',
+            type: 'tool',
+            tool: KritzelImageTool,
+            icon: 'image',
+        },
+        {
+            name: 'config',
+            type: 'config',
+        },
+    ];
+    globalContextMenuItems = [
+        {
+            label: 'menu.paste',
+            icon: 'paste',
+            action: menu => this.engineRef.paste(menu.x, menu.y),
+        },
+        {
+            label: 'menu.selectAll',
+            icon: 'select-all',
+            action: () => this.selectAllObjectsInViewport(),
+        },
+    ];
+    objectContextMenuItems = [
+        { label: 'menu.copy', icon: 'copy', group: 'clipboard', action: () => this.engineRef.copy() },
+        { label: 'menu.cut', icon: 'cut', group: 'clipboard', action: () => this.engineRef.cut() },
+        {
+            label: 'menu.paste',
+            icon: 'paste',
+            group: 'clipboard',
+            action: (menu, _) => this.engineRef.paste(menu.x, menu.y),
+        },
+        {
+            label: 'menu.export',
+            icon: 'upload',
+            group: 'clipboard',
+            isVisible: (_, objects) => this.canExportObjects(objects),
+            action: (_, objects) => {
+                const format = this.getPreferredExportFormat(objects);
+                if (!format) {
+                    return;
+                }
+                void this.engineRef.exportSelectedObject(format);
+            },
+        },
+        {
+            label: 'menu.order',
+            icon: 'ordering',
+            group: 'other',
+            children: [
+                { label: 'menu.bringToFront', icon: 'bring-to-front', action: () => this.engineRef.bringToFront() },
+                { label: 'menu.sendToBack', icon: 'send-to-back', action: () => this.engineRef.sendToBack() },
+                { label: 'menu.moveUp', icon: 'arrow-up-from-dot', action: () => this.engineRef.bringForward() },
+                { label: 'menu.moveDown', icon: 'arrow-down-from-dot', action: () => this.engineRef.sendBackward() },
+            ],
+        },
+        {
+            label: 'menu.align',
+            icon: 'align',
+            group: 'other',
+            children: [
+                { label: 'menu.alignLeft', icon: 'align-start-vertical', action: () => this.engineRef.alignObjects(KritzelAlignment.StartHorizontal) },
+                { label: 'menu.alignCenterHorizontal', icon: 'align-center-horizontal', action: () => this.engineRef.alignObjects(KritzelAlignment.CenterHorizontal) },
+                { label: 'menu.alignRight', icon: 'align-end-vertical', action: () => this.engineRef.alignObjects(KritzelAlignment.EndHorizontal) },
+                { label: 'menu.alignTop', icon: 'align-start-horizontal', action: () => this.engineRef.alignObjects(KritzelAlignment.StartVertical) },
+                { label: 'menu.alignCenterVertical', icon: 'align-center-vertical', action: () => this.engineRef.alignObjects(KritzelAlignment.CenterVertical) },
+                { label: 'menu.alignBottom', icon: 'align-end-horizontal', action: () => this.engineRef.alignObjects(KritzelAlignment.EndVertical) },
+            ],
+        },
+        {
+            label: 'menu.group',
+            icon: 'group',
+            group: 'other',
+            children: [
+                {
+                    label: 'menu.group',
+                    icon: 'group',
+                    action: () => this.engineRef.group(),
+                },
+                {
+                    label: 'menu.ungroup',
+                    icon: 'ungroup',
+                    action: () => this.engineRef.ungroup(),
+                },
+            ],
+        },
+        { label: 'menu.delete', icon: 'delete', group: 'edit', action: () => this.engineRef.delete() },
+    ];
+    moreMenuItems = [
+        {
+            id: 'share',
+            label: 'menu.share',
+            icon: 'share',
+            isVisible: async () => hasRemoteSyncProvider(this.syncConfig),
+            action: () => {
+                if (!this.isLoggedIn && this.loginConfig) {
+                    this.openLoginDialog();
+                    return;
+                }
+                this.shareDialogRef.open();
+            },
+        },
+        {
+            id: 'export',
+            label: 'menu.export',
+            icon: 'upload',
+            action: async () => {
+                const preview = await this.engineRef.getScreenshot('png');
+                this.exportRef.open(preview ?? undefined);
+            },
+        },
+        {
+            id: 'import',
+            label: 'menu.import',
+            icon: 'download',
+            action: () => this.engineRef.importFromFile(),
+        },
+        {
+            id: 'settings',
+            label: 'menu.settings',
+            icon: 'settings',
+            action: () => this.settingsRef.open(),
+        },
+    ];
+    themes;
+    theme = 'light';
+    /** License key that, when valid, removes the "Powered by Kritzel" watermark. */
+    licenseKey;
+    /** The current locale (language) code applied to the editor, e.g. 'en', 'de', 'fr'. */
+    locale = 'en';
+    /** An array of available locale definitions (with optional partial term overrides). */
+    locales;
+    /** The locale used to resolve terms missing from the active locale. */
+    fallbackLocale = 'en';
+    customSvgIcons = {};
+    /**
+     * Registers fonts for runtime usage (for example custom object rendering).
+    * Text-tool config tooltip options are controlled via toolbarItems[].config.availableFonts.
+     */
+    customFonts = {};
+    isPanningEnabled = true;
+    isZoomingEnabled = true;
+    isToolbarVisible = true;
+    isUtilityPanelVisible = true;
+    isWorkspaceManagerVisible = true;
+    isMoreMenuVisible = true;
+    isZoomPanelVisible = true;
+    syncConfig = DEFAULT_SYNC_CONFIG;
+    assetStorageConfig = DEFAULT_ASSET_STORAGE_CONFIG;
+    /** The element to use as the target for the cursor. Defaults to the editor container if not set. */
+    cursorTarget;
+    /** Optional login configuration. When provided, a "Sign in" button is shown that opens a login dialog with the configured providers. */
+    loginConfig;
+    /** Optional unique identifier for namespacing storage keys across multiple editor instances. */
+    editorId;
+    /** Optional workspace ID to set as active. If provided, the editor will automatically activate the workspace with this ID. */
+    activeWorkspaceId;
+    /** Authoritative workspace catalog for this editor instance. When provided, provider-only workspaces are hidden but not deleted. */
+    workspaces;
+    isReady;
+    activeWorkspaceChange;
+    objectsChange;
+    objectsAdded;
+    objectsRemoved;
+    objectsUpdated;
+    objectsSelectionChange;
+    undoStateChange;
+    themeChange;
+    localeChange;
+    viewportChange;
+    logout;
+    login;
+    isPublicChange;
+    awarenessChange;
+    isEngineReady = false;
+    isToolbarReady = false;
+    isWorkspaceManagerReady = false;
+    availableWorkspaces = [];
+    activeWorkspace;
+    isVirtualKeyboardOpen = false;
+    undoState = null;
+    isBackToContentButtonVisible = false;
+    /** Localized strings for editor-owned UI (e.g. the more menu), resolved from the active locale. */
+    resolvedTerms = {};
+    /** Available locales as `{ code, label }` options for the settings language selector. */
+    availableLocaleOptions = [];
+    currentZoomPercent = 100;
+    shortcuts = [];
+    currentIsPublic = false;
+    isEditorVisible = false;
+    activeNotification;
+    isNotificationDismissing = false;
+    contextMenuState;
+    resolvedMoreMenuItems = [];
+    isLoadingOverlayVisible = false;
+    loadingOverlayShowTimeout;
+    loadingOverlayHideTimeout;
+    loadingOverlayShownTimestamp;
+    loadingOverlayDelayMs = 300;
+    loadingOverlayMinDisplayDurationMs = 400;
+    notificationDismissTimeout;
+    notificationDismissAnimationTimeout;
+    notificationDisplayDurationMs = 5000;
+    notificationDismissAnimationDurationMs = 180;
+    isNotificationHovered = false;
+    customFontsLoadVersion = 0;
+    customFontsReady = Promise.resolve();
+    onIsEngineReady(newValue) {
+        if (newValue && this.isToolbarReady) {
+            this.checkIsReady();
+        }
+    }
+    onIsToolbarReady(newValue) {
+        if (newValue && this.isEngineReady) {
+            this.checkIsReady();
+        }
+    }
+    onAvailableWorkspacesChange(newWorkspaces) {
+        const activeWorkspace = this.activeWorkspace;
+        if (activeWorkspace) {
+            const updatedActiveWorkspace = newWorkspaces.find(ws => ws.id === activeWorkspace.id);
+            if (updatedActiveWorkspace && updatedActiveWorkspace !== activeWorkspace) {
+                this.activeWorkspace = updatedActiveWorkspace;
+            }
+        }
+        // If activeWorkspaceId is set, try to keep it in sync with the updated workspaces list
+        if (this.activeWorkspaceId) {
+            const workspaceWithId = newWorkspaces.find(ws => ws.id === this.activeWorkspaceId);
+            if (workspaceWithId && workspaceWithId !== this.activeWorkspace) {
+                this.activeWorkspace = workspaceWithId;
+            }
+        }
+    }
+    onActiveWorkspaceChange() {
+        this.updateCurrentIsPublic();
+    }
+    onCustomFontsChange(newValue) {
+        void this.registerCustomFonts(newValue);
+    }
+    onMoreMenuItemsChange() {
+        this.recomputeMoreMenuItems();
+    }
+    onSyncConfigChange() {
+        this.recomputeMoreMenuItems();
+    }
+    onLoginConfigChange() {
+        this.recomputeMoreMenuItems();
+    }
+    onUserChange() {
+        this.recomputeMoreMenuItems();
+    }
+    onActiveWorkspaceIdChange(newId) {
+        // If no ID is provided, do nothing (allows other logic to control activeWorkspace)
+        if (!newId) {
+            return;
+        }
+        // If workspaces are not loaded yet, the watch will fire again once they are
+        if (this.availableWorkspaces.length === 0) {
+            return;
+        }
+        // Find the workspace with the matching ID
+        const workspace = this.availableWorkspaces.find(ws => ws.id === newId);
+        if (workspace) {
+            // Only update if it's different from the current activeWorkspace
+            if (workspace !== this.activeWorkspace) {
+                this.activeWorkspace = workspace;
+            }
+        }
+        else {
+            console.warn(`[KritzelEditor] No workspace found with ID: ${newId}`);
+        }
+    }
+    onCurrentThemeChange() {
+        this.applyTheme();
+        setTimeout(() => this.setOsSpecificCssVariables(), 0);
+        if (this.engineRef) {
+            this.engineRef.saveSettings(this.currentSettingsConfig);
+        }
+    }
+    onThemesChange() {
+        this.applyTheme();
+    }
+    onLocaleChange(newValue) {
+        if (this.engineRef) {
+            this.engineRef.setLocale(newValue);
+            this.engineRef.saveSettings(this.currentSettingsConfig);
+            void this.refreshLocalizedTerms();
+        }
+    }
+    onLocalesChange(newValue) {
+        if (this.engineRef) {
+            void this.engineRef.configureLocales(newValue).then(() => this.refreshLocalizedTerms());
+        }
+    }
+    /**
+     * Refreshes the editor-owned localized strings (e.g. the more menu and the
+     * strings forwarded to child UI components) from the engine's localization
+     * manager for the active locale.
+     */
+    async refreshLocalizedTerms() {
+        if (!this.engineRef) {
+            return;
+        }
+        const resolvedLocale = await this.engineRef.getLocale();
+        if (resolvedLocale !== this.locale) {
+            // Auto-selected because the previous locale isn't in the (possibly replaced) available set.
+            this.locale = resolvedLocale;
+            this.localeChange.emit(resolvedLocale);
+        }
+        this.resolvedTerms = await this.engineRef.getResolvedTerms();
+        this.availableLocaleOptions = await this.engineRef.getAvailableLocaleOptions();
+        this.recomputeMoreMenuItems();
+    }
+    onTouchStart(event) {
+        if (event.cancelable) {
+            event.preventDefault();
+        }
+    }
+    async getObjectById(id) {
+        return this.engineRef.getObjectById(id);
+    }
+    async addObject(object) {
+        return this.engineRef.addObject(object);
+    }
+    async addObjects(objects) {
+        return this.engineRef.addObjects(objects);
+    }
+    async updateObject(object, updatedProperties) {
+        return this.engineRef.updateObject(object, updatedProperties);
+    }
+    async removeObject(object) {
+        return this.engineRef.removeObject(object);
+    }
+    async removeObjects(objects) {
+        return this.engineRef.removeObjects(objects);
+    }
+    async getSelectedObjects() {
+        return this.engineRef.getSelectedObjects();
+    }
+    async selectObjects(objects) {
+        return this.engineRef.selectObjects(objects);
+    }
+    async selectAllObjectsInViewport() {
+        return this.engineRef.selectAllObjectsInViewport();
+    }
+    async clearSelection() {
+        this.engineRef.clearSelection();
+    }
+    async centerObjectInViewport(object) {
+        return this.engineRef.centerObjectInViewport(object);
+    }
+    async panToObject(object) {
+        return this.engineRef.panToObject(object);
+    }
+    async backToContent() {
+        return this.engineRef.backToContent();
+    }
+    async centerAllObjects(animate = true) {
+        return this.engineRef.centerAllObjects(animate);
+    }
+    async centerObjects(objects, animate = true) {
+        return this.engineRef.centerObjects(objects, animate);
+    }
+    async setViewport(x, y, scale) {
+        return this.engineRef.setViewport(x, y, scale);
+    }
+    async panTo(x, y) {
+        return this.engineRef.panTo(x, y);
+    }
+    async zoomTo(scale, worldX, worldY) {
+        return this.engineRef.zoomTo(scale, worldX, worldY);
+    }
+    async zoomIn(factor = 1.6, duration = 200) {
+        return this.engineRef.zoomIn(factor, duration);
+    }
+    async zoomOut(factor = 1.6, duration = 200) {
+        return this.engineRef.zoomOut(factor, duration);
+    }
+    async getViewport() {
+        return this.engineRef.getViewport();
+    }
+    async screenToWorld(x, y) {
+        return this.engineRef.screenToWorld(x, y);
+    }
+    async worldToScreen(x, y) {
+        return this.engineRef.worldToScreen(x, y);
+    }
+    async setActiveWorkspace(id) {
+        return this.engineRef.setActiveWorkspace(id);
+    }
+    async createWorkspace(workspace) {
+        return this.engineRef.createWorkspace(workspace);
+    }
+    async updateWorkspace(workspace) {
+        return this.engineRef.updateWorkspace(workspace);
+    }
+    async deleteWorkspace(workspace) {
+        return this.engineRef.deleteWorkspace(workspace);
+    }
+    async getWorkspaces() {
+        return this.engineRef.getWorkspaces();
+    }
+    async getActiveWorkspace() {
+        return this.engineRef.getActiveWorkspace();
+    }
+    async loadSharedWorkspace(token) {
+        return this.engineRef.loadSharedWorkspace(token);
+    }
+    async reinitSync() {
+        return this.engineRef.reinitSync();
+    }
+    // ── Tool management ─────────────────────────────────────────────────
+    async registerTool(toolName, toolClass, toolConfig) {
+        return this.engineRef.registerTool(toolName, toolClass, toolConfig);
+    }
+    async changeActiveTool(toolName) {
+        return this.engineRef.changeActiveTool(toolName);
+    }
+    async disable() {
+        return this.engineRef.disable();
+    }
+    async enable() {
+        return this.engineRef.enable();
+    }
+    async copy() {
+        return this.engineRef.copy();
+    }
+    async cut() {
+        return this.engineRef.cut();
+    }
+    async paste(x, y) {
+        return this.engineRef.paste(x, y);
+    }
+    async delete() {
+        return this.engineRef.delete();
+    }
+    async bringForward(object) {
+        return this.engineRef.bringForward(object);
+    }
+    async sendBackward(object) {
+        return this.engineRef.sendBackward(object);
+    }
+    async bringToFront(object) {
+        return this.engineRef.bringToFront(object);
+    }
+    async sendToBack(object) {
+        return this.engineRef.sendToBack(object);
+    }
+    async alignObjects(alignment) {
+        return this.engineRef.alignObjects(alignment);
+    }
+    async group() {
+        return this.engineRef.group();
+    }
+    async ungroup() {
+        return this.engineRef.ungroup();
+    }
+    async undo() {
+        return this.engineRef.undo();
+    }
+    async redo() {
+        return this.engineRef.redo();
+    }
+    async getScreenshot(format = 'png') {
+        return this.engineRef.getScreenshot(format);
+    }
+    async exportViewportAsPng() {
+        return this.engineRef.exportViewportAsPng();
+    }
+    async exportViewportAsSvg() {
+        return this.engineRef.exportViewportAsSvg();
+    }
+    async getSelectedObjectSupportedExportFormats() {
+        return this.engineRef.getSelectedObjectSupportedExportFormats();
+    }
+    async canExportSelectedObjectAs(format) {
+        return this.engineRef.canExportSelectedObjectAs(format);
+    }
+    async exportSelectedObject(format) {
+        return this.engineRef.exportSelectedObject(format);
+    }
+    async exportAsJson() {
+        return this.engineRef.exportAsJson();
+    }
+    async importFromJson(json) {
+        return this.engineRef.importFromJson(json);
+    }
+    async downloadAsJson(filename) {
+        return this.engineRef.downloadAsJson(filename);
+    }
+    async importFromFile() {
+        return this.engineRef.importFromFile();
+    }
+    async loadObjectsFromJson(json) {
+        return this.engineRef.loadObjectsFromJson(json);
+    }
+    async getObjectsTotalCount() {
+        return this.engineRef.getObjectsTotalCount();
+    }
+    async getAllObjects() {
+        return this.engineRef.getAllObjects();
+    }
+    async findObjects(predicate) {
+        return this.engineRef.findObjects(predicate);
+    }
+    async getObjectsInViewport() {
+        return this.engineRef.getObjectsInViewport();
+    }
+    async hideContextMenu() {
+        return this.engineRef.hideContextMenu();
+    }
+    async openContextMenu(options) {
+        return this.engineRef.openContextMenu(options);
+    }
+    async openWorkspaceManagerMenu() {
+        if (!this.isWorkspaceManagerVisible) {
+            return;
+        }
+        await this.workspaceManagerRef?.open();
+    }
+    async closeWorkspaceManagerMenu() {
+        await this.workspaceManagerRef?.close();
+    }
+    async openMoreMenu() {
+        if (!this.isMoreMenuVisible) {
+            return;
+        }
+        await this.moreMenuRef?.open();
+    }
+    async closeMoreMenu() {
+        await this.moreMenuRef?.close();
+    }
+    async openUserDialog() {
+        await this.currentUserDialogRef?.open();
+    }
+    async closeUserDialog() {
+        await this.currentUserDialogRef?.close();
+    }
+    async openExportDialog() {
+        const preview = await this.engineRef.getScreenshot('png');
+        await this.exportRef?.open(preview ?? undefined);
+    }
+    async closeExportDialog() {
+        await this.exportRef?.close();
+    }
+    async openImportDialog() {
+        await this.engineRef.importFromFile();
+    }
+    async closeImportDialog() {
+        await this.engineRef.cancelImportFromFile();
+    }
+    async openSettingsDialog() {
+        await this.settingsRef?.open();
+    }
+    async closeSettingsDialog() {
+        await this.settingsRef?.close();
+    }
+    async openShareDialog() {
+        await this.shareDialogRef?.open();
+    }
+    async closeShareDialog() {
+        await this.shareDialogRef?.close();
+    }
+    async triggerSelectionChange() {
+        return this.engineRef.triggerSelectionChange();
+    }
+    async beginSceneBootstrap() {
+        return this.engineRef.beginSceneBootstrap();
+    }
+    async endSceneBootstrap() {
+        return this.engineRef.endSceneBootstrap();
+    }
+    async getDisplayableShortcuts() {
+        return this.engineRef.getDisplayableShortcuts();
+    }
+    async openLoginDialog() {
+        this.loginDialogRef?.open();
+    }
+    async closeLoginDialog() {
+        this.loginDialogRef?.close();
+    }
+    async setLoginLoading(provider) {
+        this.loginDialogRef?.setLoading(provider);
+    }
+    /**
+     * Sets the active locale (language) and re-renders the UI.
+     * @param code - The locale code to activate, e.g. 'de'.
+     */
+    async setLocale(code) {
+        this.locale = code;
+        await this.engineRef?.setLocale(code);
+    }
+    /**
+     * Gets the currently active locale code.
+     */
+    async getLocale() {
+        return this.engineRef ? this.engineRef.getLocale() : this.locale;
+    }
+    /**
+     * Gets the list of available locale codes (built-in and registered).
+     */
+    async getAvailableLocales() {
+        return this.engineRef ? this.engineRef.getAvailableLocales() : [];
+    }
+    /**
+     * Registers additional locale definitions (with optional partial term overrides).
+     * @param locales - The locale definitions to register.
+     */
+    async registerLocales(locales) {
+        await this.engineRef?.registerLocales(locales);
+    }
+    /**
+     * Registers custom fonts for the editor runtime.
+     * @param fonts - Mapping from font keys to family names or font definitions.
+     * @remarks This no longer controls the text-tool config tooltip font options.
+    * Configure tooltip fonts via toolbarItems[].config.availableFonts.
+     */
+    async registerFonts(fonts) {
+        await this.registerCustomFonts(fonts);
+    }
+    /**
+     * Resolves a term key to its translated string for the active locale.
+     * @param key - The term key to resolve.
+     * @param vars - Optional values for `{placeholder}` interpolation.
+     */
+    async t(key, vars) {
+        return this.engineRef ? this.engineRef.t(key, vars) : key;
+    }
+    /**
+     * Triggers a UI notification programmatically.
+     * @param notification - Notification payload. `id` and `timestamp` are optional.
+     */
+    async triggerNotification(notification) {
+        const normalizedNotification = {
+            ...notification,
+            id: notification.id ?? ObjectHelper.generateUUID(),
+            timestamp: notification.timestamp ?? new Date(),
+        };
+        this.clearNotificationDismissAnimationTimer();
+        this.isNotificationDismissing = false;
+        this.isNotificationHovered = false;
+        this.activeNotification = normalizedNotification;
+        this.scheduleNotificationDismiss();
+    }
+    engineRef;
+    toolbarRef;
+    settingsRef;
+    exportRef;
+    splitButtonRef;
+    workspaceManagerRef;
+    moreMenuRef;
+    shareDialogRef;
+    loginDialogRef;
+    currentUserDialogRef;
+    componentWillLoad() {
+        this.recomputeMoreMenuItems();
+        this.loadSettingsFromStorage();
+        this.applyTheme();
+    }
+    isTextToolConfig(config) {
+        return !!config && 'fontFamily' in config && 'size' in config && 'color' in config;
+    }
+    lastToolbarItemsRef = null;
+    lastNormalizedToolbarItems = [];
+    getNormalizedToolbarItems() {
+        if (this.toolbarItems !== this.lastToolbarItemsRef) {
+            this.lastToolbarItemsRef = this.toolbarItems;
+            this.lastNormalizedToolbarItems = this.normalizeToolbar(this.toolbarItems);
+        }
+        return this.lastNormalizedToolbarItems;
+    }
+    normalizeToolbar(toolbarItems) {
+        return toolbarItems.map(control => {
+            if (!this.isTextToolConfig(control.config)) {
+                return control;
+            }
+            return {
+                ...control,
+                config: {
+                    ...control.config,
+                    availableFonts: resolveTextToolAvailableFonts(control.config.availableFonts),
+                },
+            };
+        });
+    }
+    recomputeMoreMenuItems() {
+        if (this.moreMenuItems) {
+            this.resolvedMoreMenuItems = this.moreMenuItems;
+            return;
+        }
+    }
+    applyTheme() {
+        const themeObj = this.resolveThemeObject();
+        ThemeHelper.applyThemeToElement(this.host, themeObj);
+    }
+    resolveThemeObject() {
+        return this.themes?.find(t => t.name === this.theme) ?? (this.theme === 'dark' ? darkTheme : lightTheme);
+    }
+    componentDidLoad() {
+        this.registerCustomSvgIcons();
+        this.registerCustomFonts();
+        this.listenForMobileKeyboard();
+        this.setOsSpecificCssVariables();
+    }
+    disconnectedCallback() {
+        this.clearLoadingOverlayShowTimer();
+        this.clearLoadingOverlayHideTimer();
+        this.clearNotificationDismissTimer();
+        this.clearNotificationDismissAnimationTimer();
+    }
+    async checkIsReady() {
+        await customElements.whenDefined('kritzel-editor');
+        await customElements.whenDefined('kritzel-workspace-manager');
+        await customElements.whenDefined('kritzel-toolbar');
+        await customElements.whenDefined('kritzel-engine');
+        await this.waitForCustomFontsReady();
+        if (!this.isEngineReady || !this.isToolbarReady || !this.isWorkspaceManagerReady || !this.activeWorkspace) {
+            return;
+        }
+        this.isEditorVisible = true;
+        const { id, name, isPublic, createdAt, updatedAt } = this.activeWorkspace;
+        this.isReady.emit({
+            host: this.host,
+            activeWorkspace: {
+                id,
+                name,
+                isPublic,
+                createdAt,
+                updatedAt,
+            },
+            syncConfig: this.syncConfig,
+            assetStorageConfig: this.assetStorageConfig,
+            loginConfig: this.loginConfig,
+            theme: this.theme,
+        });
+    }
+    async onEngineReady(event) {
+        this.isEngineReady = true;
+        if (!event.detail.activeWorkspace) {
+            return;
+        }
+        this.activeWorkspace = event.detail.activeWorkspace;
+        this.availableWorkspaces = event.detail.workspaces;
+        this.currentIsPublic = await this.engineRef.getIsPublic();
+        await this.refreshLocalizedTerms();
+        const viewport = await this.engineRef.getViewport();
+        this.currentZoomPercent = this.getZoomPercentFromScale(viewport.scale);
+        this.loadShortcuts();
+    }
+    handleWorkspacesChange(event) {
+        event.stopPropagation();
+        this.availableWorkspaces = event.detail;
+    }
+    async handleWorkspaceManagerChange(event) {
+        event.stopPropagation();
+        const workspace = event.detail;
+        this.activeWorkspace = workspace ?? undefined;
+        if (!workspace) {
+            return;
+        }
+        await this.engineRef.setActiveWorkspace(workspace.id);
+    }
+    handleActiveWorkspaceChange(event) {
+        event.stopPropagation();
+        this.activeWorkspace = event.detail;
+        if (!this.isEngineReady) {
+            return;
+        }
+        const { id, name, isPublic, createdAt, updatedAt } = this.activeWorkspace;
+        this.activeWorkspaceChange.emit({
+            id,
+            name,
+            isPublic,
+            createdAt,
+            updatedAt,
+        });
+    }
+    handleObjectsChange(event) {
+        event.stopPropagation();
+        this.objectsChange.emit(event.detail);
+    }
+    handleObjectsAdded(event) {
+        event.stopPropagation();
+        this.objectsAdded.emit(event.detail);
+    }
+    handleObjectsRemoved(event) {
+        event.stopPropagation();
+        this.objectsRemoved.emit(event.detail);
+    }
+    handleObjectsUpdated(event) {
+        event.stopPropagation();
+        this.objectsUpdated.emit(event.detail);
+    }
+    handleObjectsSelectionChange(event) {
+        console.log(event.detail);
+        event.stopPropagation();
+        this.objectsSelectionChange.emit(event.detail);
+    }
+    handleUndoStateChange(event) {
+        event.stopPropagation();
+        this.undoStateChange.emit(event.detail);
+        this.undoState = event.detail;
+    }
+    async handleObjectsInViewportChange(event) {
+        event.stopPropagation();
+        const hasVisibleObjects = this.getContentObjects(event.detail).length > 0;
+        const hasAnyObjectsAtAll = this.getContentObjects(await this.engineRef.getAllObjects()).length > 0;
+        this.isBackToContentButtonVisible = !hasVisibleObjects && hasAnyObjectsAtAll;
+    }
+    handleViewportChange(event) {
+        event.stopPropagation();
+        this.currentZoomPercent = this.getZoomPercentFromScale(event.detail.scale);
+        this.viewportChange.emit(event.detail);
+    }
+    getZoomPercentFromScale(scale) {
+        if (!Number.isFinite(scale) || scale <= 0) {
+            return 100;
+        }
+        return Math.round(scale * 100);
+    }
+    handleAwarenessChange(event) {
+        event.stopPropagation();
+        this.awarenessChange.emit(event.detail);
+    }
+    handleNotificationsChange(event) {
+        event.stopPropagation();
+        this.clearNotificationDismissAnimationTimer();
+        this.isNotificationDismissing = false;
+        this.isNotificationHovered = false;
+        this.activeNotification = event.detail;
+        this.scheduleNotificationDismiss();
+    }
+    handleContextMenuStateChange(event) {
+        event.stopPropagation();
+        this.contextMenuState = event.detail.isVisible ? event.detail : undefined;
+    }
+    handleIsLoadingChange(event) {
+        console.log('isLoadingChange event:', event.detail);
+        event.stopPropagation();
+        this.clearLoadingOverlayShowTimer();
+        this.clearLoadingOverlayHideTimer();
+        if (event.detail) {
+            this.loadingOverlayShowTimeout = setTimeout(() => {
+                this.isLoadingOverlayVisible = true;
+                this.loadingOverlayShownTimestamp = Date.now();
+                this.loadingOverlayShowTimeout = undefined;
+            }, this.loadingOverlayDelayMs);
+            return;
+        }
+        if (this.isLoadingOverlayVisible && this.loadingOverlayShownTimestamp !== undefined) {
+            const elapsed = Date.now() - this.loadingOverlayShownTimestamp;
+            const remaining = this.loadingOverlayMinDisplayDurationMs - elapsed;
+            if (remaining > 0) {
+                this.loadingOverlayHideTimeout = setTimeout(() => {
+                    this.isLoadingOverlayVisible = false;
+                    this.loadingOverlayShownTimestamp = undefined;
+                    this.loadingOverlayHideTimeout = undefined;
+                }, remaining);
+                return;
+            }
+        }
+        this.isLoadingOverlayVisible = false;
+        this.loadingOverlayShownTimestamp = undefined;
+    }
+    clearLoadingOverlayShowTimer() {
+        if (this.loadingOverlayShowTimeout) {
+            clearTimeout(this.loadingOverlayShowTimeout);
+            this.loadingOverlayShowTimeout = undefined;
+        }
+    }
+    clearLoadingOverlayHideTimer() {
+        if (this.loadingOverlayHideTimeout) {
+            clearTimeout(this.loadingOverlayHideTimeout);
+            this.loadingOverlayHideTimeout = undefined;
+        }
+    }
+    handleContextMenuActionSelected(event) {
+        const contextMenuState = this.contextMenuState;
+        if (!contextMenuState || !event.detail.action) {
+            void this.hideContextMenu();
+            return;
+        }
+        event.detail.action({
+            x: contextMenuState.worldPosition.x,
+            y: contextMenuState.worldPosition.y,
+        }, contextMenuState.objects);
+        void this.hideContextMenu();
+    }
+    handleNotificationHoverChange(event) {
+        event.stopPropagation();
+        this.isNotificationHovered = event.detail;
+        if (this.isNotificationHovered) {
+            this.clearNotificationDismissTimer();
+            return;
+        }
+        if (this.activeNotification && !this.isNotificationDismissing) {
+            this.scheduleNotificationDismiss();
+        }
+    }
+    scheduleNotificationDismiss() {
+        this.clearNotificationDismissTimer();
+        this.notificationDismissTimeout = setTimeout(() => {
+            this.dismissNotification();
+        }, this.notificationDisplayDurationMs);
+    }
+    clearNotificationDismissTimer() {
+        if (this.notificationDismissTimeout) {
+            clearTimeout(this.notificationDismissTimeout);
+            this.notificationDismissTimeout = undefined;
+        }
+    }
+    clearNotificationDismissAnimationTimer() {
+        if (this.notificationDismissAnimationTimeout) {
+            clearTimeout(this.notificationDismissAnimationTimeout);
+            this.notificationDismissAnimationTimeout = undefined;
+        }
+    }
+    dismissNotification = () => {
+        this.clearNotificationDismissTimer();
+        this.isNotificationHovered = false;
+        if (!this.activeNotification || this.isNotificationDismissing) {
+            return;
+        }
+        this.isNotificationDismissing = true;
+        this.clearNotificationDismissAnimationTimer();
+        this.notificationDismissAnimationTimeout = setTimeout(() => {
+            this.activeNotification = undefined;
+            this.isNotificationDismissing = false;
+            this.notificationDismissAnimationTimeout = undefined;
+        }, this.notificationDismissAnimationDurationMs);
+    };
+    handleSettingsChange(event) {
+        this.scaleMin = event.detail.scaleMin;
+        this.scaleMax = event.detail.scaleMax;
+        this.lockDrawingScale = event.detail.lockDrawingScale;
+        this.theme = event.detail.theme;
+        if (typeof event.detail.locale === 'string' && event.detail.locale !== this.locale) {
+            this.locale = event.detail.locale;
+            this.localeChange.emit(event.detail.locale);
+        }
+        this.viewportBoundaryLeft = event.detail.viewportBoundaryLeft ?? -Infinity;
+        this.viewportBoundaryRight = event.detail.viewportBoundaryRight ?? Infinity;
+        this.viewportBoundaryTop = event.detail.viewportBoundaryTop ?? -Infinity;
+        this.viewportBoundaryBottom = event.detail.viewportBoundaryBottom ?? Infinity;
+        this.debugInfo = event.detail.debugInfo;
+        if (this.engineRef) {
+            this.engineRef.saveSettings(event.detail);
+        }
+        this.themeChange.emit(event.detail.theme);
+    }
+    handleToggleIsPublic = async (event) => {
+        const isPublic = event.detail;
+        const activeWorkspace = await this.engineRef.getActiveWorkspace();
+        activeWorkspace.isPublic = isPublic;
+        await this.engineRef.updateWorkspace(activeWorkspace);
+        this.activeWorkspace = activeWorkspace.clone();
+        this.isPublicChange.emit({ isPublic, workspaceId: activeWorkspace.id });
+    };
+    /**
+     * Updates the currentIsPublic state from the active workspace and emits the isPublicChange event.
+     */
+    updateCurrentIsPublic() {
+        const isPublic = this.activeWorkspace?.isPublic ?? false;
+        const workspaceId = this.activeWorkspace?.id;
+        this.currentIsPublic = isPublic;
+        if (!workspaceId) {
+            return;
+        }
+        this.isPublicChange.emit({ isPublic, workspaceId });
+    }
+    handleProviderLogin = (event) => {
+        this.login.emit(event.detail);
+    };
+    handleCurrentUserLogout = () => {
+        this.logout.emit();
+    };
+    get isLoggedIn() {
+        return !!this.user && !this.user.isGuest;
+    }
+    canExportObjectsAs(objects, format) {
+        if (!objects || objects.length !== 1) {
+            return false;
+        }
+        const [selected] = objects;
+        if (!ObjectHelper.isKritzelExportable(selected)) {
+            return false;
+        }
+        return selected.getSupportedExportFormats().includes(format);
+    }
+    canExportObjects(objects) {
+        return this.canExportObjectsAs(objects, 'png') || this.canExportObjectsAs(objects, 'svg');
+    }
+    getPreferredExportFormat(objects) {
+        if (this.canExportObjectsAs(objects, 'png')) {
+            return 'png';
+        }
+        if (this.canExportObjectsAs(objects, 'svg')) {
+            return 'svg';
+        }
+        return null;
+    }
+    getSettingsStorageKey() {
+        return this.editorId ? `kritzel-settings-${this.editorId}` : 'kritzel-settings';
+    }
+    loadSettingsFromStorage() {
+        const stored = localStorage.getItem(this.getSettingsStorageKey());
+        if (stored) {
+            try {
+                const parsed = JSON.parse(stored);
+                if (typeof parsed.scaleMin === 'number') {
+                    this.scaleMin = parsed.scaleMin;
+                }
+                if (typeof parsed.scaleMax === 'number') {
+                    this.scaleMax = parsed.scaleMax;
+                }
+                if (typeof parsed.lockDrawingScale === 'boolean') {
+                    this.lockDrawingScale = parsed.lockDrawingScale;
+                }
+                if (typeof parsed.theme === 'string') {
+                    this.theme = parsed.theme;
+                }
+                if (typeof parsed.locale === 'string') {
+                    this.locale = parsed.locale;
+                }
+                if (typeof parsed.viewportBoundaryLeft === 'number') {
+                    this.viewportBoundaryLeft = parsed.viewportBoundaryLeft;
+                }
+                if (typeof parsed.viewportBoundaryRight === 'number') {
+                    this.viewportBoundaryRight = parsed.viewportBoundaryRight;
+                }
+                if (typeof parsed.viewportBoundaryTop === 'number') {
+                    this.viewportBoundaryTop = parsed.viewportBoundaryTop;
+                }
+                if (typeof parsed.viewportBoundaryBottom === 'number') {
+                    this.viewportBoundaryBottom = parsed.viewportBoundaryBottom;
+                }
+                if (parsed.debugInfo) {
+                    this.debugInfo = { ...this.debugInfo, ...parsed.debugInfo };
+                }
+            }
+            catch {
+                // Invalid JSON, use prop defaults
+            }
+        }
+    }
+    async loadShortcuts() {
+        this.shortcuts = await this.engineRef.getDisplayableShortcuts();
+    }
+    get currentSettingsConfig() {
+        return {
+            scaleMin: this.scaleMin,
+            scaleMax: this.scaleMax,
+            lockDrawingScale: this.lockDrawingScale,
+            theme: this.theme,
+            locale: this.locale,
+            viewportBoundaryLeft: this.viewportBoundaryLeft,
+            viewportBoundaryRight: this.viewportBoundaryRight,
+            viewportBoundaryTop: this.viewportBoundaryTop,
+            viewportBoundaryBottom: this.viewportBoundaryBottom,
+            debugInfo: this.debugInfo,
+        };
+    }
+    getContentObjects(objects) {
+        return objects.filter(obj => !(obj instanceof KritzelSelectionGroup) && !(obj instanceof KritzelSelectionBox));
+    }
+    registerCustomSvgIcons() {
+        for (const [name, svg] of Object.entries(this.customSvgIcons)) {
+            KritzelIconRegistry.register(name, svg);
+        }
+    }
+    async registerCustomFonts(fonts = this.customFonts) {
+        KritzelFontRegistry.registerFonts(fonts);
+        const currentVersion = ++this.customFontsLoadVersion;
+        const loadPromise = KritzelFontRegistry.waitForFonts(fonts);
+        this.customFontsReady = loadPromise;
+        await loadPromise;
+        if (currentVersion !== this.customFontsLoadVersion) {
+            await this.waitForCustomFontsReady();
+        }
+    }
+    async waitForCustomFontsReady() {
+        while (true) {
+            const version = this.customFontsLoadVersion;
+            await this.customFontsReady;
+            if (version === this.customFontsLoadVersion) {
+                return;
+            }
+        }
+    }
+    listenForMobileKeyboard() {
+        KritzelKeyboardHelper.onKeyboardVisibleChanged(isOpen => {
+            this.isVirtualKeyboardOpen = isOpen;
+        });
+    }
+    setOsSpecificCssVariables() {
+        const os = KritzelDevicesHelper.detectOS();
+        switch (os) {
+            case 'iOS':
+                // iOS specific adjustments
+                this.host.style.setProperty('--kritzel-editor-top-left-buttons-top', '14px');
+                this.host.style.setProperty('--kritzel-editor-top-left-buttons-left', '14px');
+                this.host.style.setProperty('--kritzel-editor-toolbar-bottom', '14px');
+                this.host.style.setProperty('--kritzel-editor-toolbar-transition', 'cubic-bezier(0.25, 0.1, 0.25, 1.0)');
+                this.host.style.setProperty('--kritzel-editor-toolbar-transform', 'translateY(200%)');
+                this.host.style.setProperty('--kritzel-editor-toolbar-transition-duration', '0.25s');
+                break;
+            case 'Android':
+                // Android specific adjustments
+                this.host.style.setProperty('--kritzel-editor-top-left-buttons-top', '14px');
+                this.host.style.setProperty('--kritzel-editor-top-left-buttons-left', '14px');
+                this.host.style.setProperty('--kritzel-editor-toolbar-bottom', '24px');
+                this.host.style.setProperty('--kritzel-editor-toolbar-transition', 'cubic-bezier(0.25, 0.1, 0.25, 1.0)');
+                this.host.style.setProperty('--kritzel-editor-toolbar-transform', 'translateY(200%)');
+                this.host.style.setProperty('--kritzel-editor-toolbar-transition-duration', '0.25s');
+                break;
+            default:
+                // Default for Windows/Linux
+                this.host.style.setProperty('--kritzel-editor-top-left-buttons-top', '14px');
+                this.host.style.setProperty('--kritzel-editor-top-left-buttons-left', '14px');
+                this.host.style.setProperty('--kritzel-editor-toolbar-bottom', '14px');
+                break;
+        }
+    }
+    render() {
+        const isLoggedIn = this.isLoggedIn;
+        const shouldShowCurrentUser = isLoggedIn;
+        const shouldShowLoginButton = this.isReady && !!this.loginConfig && !isLoggedIn;
+        const normalizedToolbarItems = this.getNormalizedToolbarItems();
+        return (h(Host, { key: '34f8001fb3d6ac1f52a51aa57eef893a41fb1c8c' }, h("div", { key: '61ae20a731ee495361bdd9cb0ed334cde2b3af42', class: "editor-content", style: {
+                opacity: this.isEditorVisible ? '1' : '0',
+                visibility: this.isEditorVisible ? 'visible' : 'hidden',
+                transition: 'opacity 0.2s ease-in-out, visibility 0.2s ease-in-out',
+            } }, h("div", { key: '760c5f02ae80fba30fff328f307fa78e45531f13', class: "top-left-buttons" }, h("kritzel-workspace-manager", { key: '4daf1b5fbc6523c46ce3c0b4bec206f1905cf1b7', ref: el => {
+                if (el) {
+                    this.workspaceManagerRef = el;
+                }
+            }, visible: this.isWorkspaceManagerVisible, workspaces: this.availableWorkspaces, activeWorkspace: this.activeWorkspace, terms: this.resolvedTerms, onWorkspaceChange: event => this.handleWorkspaceManagerChange(event), onIsWorkspaceManagerReady: () => (this.isWorkspaceManagerReady = true) }), h("kritzel-back-to-content", { key: '72e7649d13e3f03bcb7cd7c0507d1bd15e2f4cb3', visible: this.isBackToContentButtonVisible, text: this.resolvedTerms['backToContent.label'] ?? 'Back to content', onBackToContent: () => this.backToContent() })), this.activeNotification && (h("div", { key: '0651bba45fabb7342ea28e120bc930be5ee45de6', class: "top-center-notification-layer", role: "presentation" }, h("div", { key: 'b4b0bf29824b7cb025ef168a7c7be31d5054c0ff', class: { 'top-center-notification-container': true, 'is-dismissing': this.isNotificationDismissing }, role: "presentation" }, h("kritzel-notification-card", { key: '93c6f6b313a082f155eca9c60e623bcfbdd4119f', notification: this.activeNotification, locale: this.locale, onDismiss: this.dismissNotification, onHoverChange: event => this.handleNotificationHoverChange(event) })))), this.contextMenuState && this.contextMenuState.items.length > 0 && (h("kritzel-context-menu", { key: '0ad85b0ee5e85fffa081f88cdc991b3233ddd5ad', class: "context-menu", items: this.contextMenuState.items, objects: this.contextMenuState.objects, style: {
+                position: 'absolute',
+                left: `${this.contextMenuState.position.x}px`,
+                top: `${this.contextMenuState.position.y}px`,
+                zIndex: '10002',
+            }, onActionSelected: event => this.handleContextMenuActionSelected(event), onClose: () => this.hideContextMenu() })), h("kritzel-loading-overlay", { key: 'bf4a9e25c3f78633831bcfdaf580a45171b67fff', visible: this.isLoadingOverlayVisible, text: this.resolvedTerms['editor.loading'] ?? 'Loading...' }), h("kritzel-engine", { key: '46bdfb77cddd106b7c6e8f7767520a331608592f', ref: el => {
+                if (el) {
+                    this.engineRef = el;
+                }
+            }, workspaces: this.workspaces, activeWorkspaceId: this.activeWorkspaceId, editorId: this.editorId, syncConfig: this.syncConfig, assetStorageConfig: this.assetStorageConfig, user: this.user, scaleMax: this.scaleMax, lockDrawingScale: this.lockDrawingScale, scaleMin: this.scaleMin, cursorTarget: this.cursorTarget, viewportBoundaryLeft: this.viewportBoundaryLeft, viewportBoundaryRight: this.viewportBoundaryRight, viewportBoundaryTop: this.viewportBoundaryTop, viewportBoundaryBottom: this.viewportBoundaryBottom, isPanningEnabled: this.isPanningEnabled, isZoomingEnabled: this.isZoomingEnabled, theme: this.theme, themes: this.themes, licenseKey: this.licenseKey, locale: this.locale, locales: this.locales, fallbackLocale: this.fallbackLocale, debugInfo: this.debugInfo, globalContextMenuItems: this.globalContextMenuItems, objectContextMenuItems: this.objectContextMenuItems, onIsEngineReady: event => this.onEngineReady(event), onWorkspacesChange: event => this.handleWorkspacesChange(event), onActiveWorkspaceChange: event => this.handleActiveWorkspaceChange(event), onObjectsChange: event => this.handleObjectsChange(event), onObjectsAdded: event => this.handleObjectsAdded(event), onObjectsRemoved: event => this.handleObjectsRemoved(event), onObjectsUpdated: event => this.handleObjectsUpdated(event), onObjectsSelectionChange: event => this.handleObjectsSelectionChange(event), onUndoStateChange: event => this.handleUndoStateChange(event), onObjectsInViewportChange: event => this.handleObjectsInViewportChange(event), onViewportChange: event => this.handleViewportChange(event), onAwarenessChange: event => this.handleAwarenessChange(event), onNotificationsChange: event => this.handleNotificationsChange(event), onContextMenuStateChange: event => this.handleContextMenuStateChange(event), onIsLoadingChange: event => this.handleIsLoadingChange(event) }), h("kritzel-toolbar", { key: 'f19449a3b6aa08c51eb58ba53a37e133a6d1d1d5', visible: this.isToolbarVisible, class: { 'keyboard-open': this.isVirtualKeyboardOpen }, ref: el => {
+                if (el) {
+                    this.toolbarRef = el;
+                }
+            }, toolbarItems: normalizedToolbarItems, isUtilityPanelVisible: this.isUtilityPanelVisible, undoState: this.undoState ?? undefined, theme: this.theme, terms: this.resolvedTerms, onIsToolbarReady: () => (this.isToolbarReady = true) }), h("div", { key: '3d7b417b286f9e003137d02a7520ef1d9b5563f2', class: "bottom-left-buttons" }, h("kritzel-zoom-panel", { key: '1d366c23cb68e5e345a8cb8833cdc61c9a0c607b', visible: this.isZoomPanelVisible, zoomPercent: this.currentZoomPercent, terms: this.resolvedTerms, onZoomIn: () => this.zoomIn(), onZoomOut: () => this.zoomOut() })), h("div", { key: '1c27cd556dea88b7dcf1fb6960157cff37210260', class: "top-right-buttons" }, h("kritzel-settings", { key: '61be74fbd336e64236a618bc40c5a68c9e4ba2a9', ref: el => {
+                if (el) {
+                    this.settingsRef = el;
+                }
+            }, shortcuts: this.shortcuts, availableThemes: this.themes && this.themes.length > 0 ? this.themes.map(t => t.name) : ['light', 'dark'], availableLocales: this.availableLocaleOptions, settings: this.currentSettingsConfig, terms: this.resolvedTerms, onSettingsChange: event => this.handleSettingsChange(event) }), h("kritzel-export", { key: '4e84be18db6d1c1982bd6420d034f80876b22651', ref: el => {
+                if (el) {
+                    this.exportRef = el;
+                }
+            }, workspaceName: this.activeWorkspace?.name || 'workspace', terms: this.resolvedTerms, onExportPng: () => this.engineRef.exportViewportAsPng(), onExportSvg: () => this.engineRef.exportViewportAsSvg(), onExportJson: event => this.engineRef.downloadAsJson(event.detail) }), h("kritzel-active-users", { key: 'a5c1b3de7e67ecddbac0a581a00585f796cd3dc3', users: this.activeUsers }), shouldShowCurrentUser && h("kritzel-current-user", { key: 'ff5f5668cb662f7275f714b3bad7ae7baff89eb4', user: this.user, terms: this.resolvedTerms, onClick: () => this.currentUserDialogRef?.open() }), shouldShowCurrentUser && (h("kritzel-current-user-dialog", { key: '18139a2382c60adec64fcb093e05904d3f37a639', ref: el => {
+                if (el) {
+                    this.currentUserDialogRef = el;
+                }
+            }, user: this.user, terms: this.resolvedTerms, onLogoutRequest: this.handleCurrentUserLogout })), shouldShowLoginButton && h("kritzel-button", { key: 'c1d72827c6416efda9ba1f5576390135c8161665', onButtonClick: () => this.loginDialogRef?.open() }, this.resolvedTerms['login.dialogTitle'] ?? 'Sign in'), h("kritzel-more-menu", { key: '6cf3f77fd2a1c5f9e04e3cf415e775dd60e94927', ref: el => {
+                if (el) {
+                    this.moreMenuRef = el;
+                }
+            }, items: this.resolvedMoreMenuItems, visible: this.isMoreMenuVisible, terms: this.resolvedTerms }), h("kritzel-share-dialog", { key: '60de09f78488162b0739f0494cc52706ba0df58d', ref: el => {
+                if (el) {
+                    this.shareDialogRef = el;
+                }
+            }, isPublic: this.currentIsPublic, workspaceId: this.activeWorkspace?.id, terms: this.resolvedTerms, onToggleIsPublic: this.handleToggleIsPublic }), this.loginConfig && (h("kritzel-login-dialog", { key: 'ab05733b8c6985f3b3a3d327c4effd58e57b0a8f', ref: el => {
+                if (el) {
+                    this.loginDialogRef = el;
+                }
+            }, providers: this.loginConfig.providers, dialogTitle: this.loginConfig.title ?? this.resolvedTerms['login.dialogTitle'] ?? 'Sign in', subtitle: this.loginConfig.subtitle, onProviderLogin: this.handleProviderLogin }))))));
+    }
+    static get is() { return "kritzel-editor"; }
+    static get originalStyleUrls() {
+        return {
+            "$": ["kritzel-editor.css"]
+        };
+    }
+    static get styleUrls() {
+        return {
+            "$": ["kritzel-editor.css"]
+        };
+    }
+    static get properties() {
+        return {
+            "scaleMax": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "scale-max",
+                "defaultValue": "1000"
+            },
+            "scaleMin": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "scale-min",
+                "defaultValue": "0.0001"
+            },
+            "lockDrawingScale": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "lock-drawing-scale",
+                "defaultValue": "true"
+            },
+            "viewportBoundaryLeft": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "viewport-boundary-left",
+                "defaultValue": "-Infinity"
+            },
+            "viewportBoundaryRight": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "viewport-boundary-right",
+                "defaultValue": "Infinity"
+            },
+            "viewportBoundaryTop": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "viewport-boundary-top",
+                "defaultValue": "-Infinity"
+            },
+            "viewportBoundaryBottom": {
+                "type": "number",
+                "mutable": true,
+                "complexType": {
+                    "original": "number",
+                    "resolved": "number",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "viewport-boundary-bottom",
+                "defaultValue": "Infinity"
+            },
+            "debugInfo": {
+                "type": "unknown",
+                "mutable": true,
+                "complexType": {
+                    "original": "KritzelDebugInfo",
+                    "resolved": "KritzelDebugInfo",
+                    "references": {
+                        "KritzelDebugInfo": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelDebugInfo",
+                            "referenceLocation": "KritzelDebugInfo"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "{\r\n    showViewportInfo: false,\r\n    showObjectInfo: false,\r\n    showSyncProviderInfo: true,\r\n    showMigrationInfo: true,\r\n    showAssetResolverInfo: false,\r\n  }"
+            },
+            "user": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "IKritzelUser",
+                    "resolved": "IKritzelUser",
+                    "references": {
+                        "IKritzelUser": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::IKritzelUser",
+                            "referenceLocation": "IKritzelUser"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false
+            },
+            "activeUsers": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "IKritzelUser[]",
+                    "resolved": "IKritzelUser[]",
+                    "references": {
+                        "IKritzelUser": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::IKritzelUser",
+                            "referenceLocation": "IKritzelUser"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false
+            },
+            "toolbarItems": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "KritzelToolbarItem[]",
+                    "resolved": "KritzelToolbarItem[]",
+                    "references": {
+                        "KritzelToolbarItem": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelToolbarItem",
+                            "referenceLocation": "KritzelToolbarItem"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[\r\n    {\r\n      name: 'selection',\r\n      type: 'tool',\r\n      isDefault: true,\r\n      tool: KritzelSelectionTool,\r\n      icon: 'cursor',\r\n    },\r\n    {\r\n      name: 'brush',\r\n      type: 'tool',\r\n      tool: KritzelBrushTool,\r\n      icon: 'pen',\r\n      config: DEFAULT_BRUSH_CONFIG,\r\n    },\r\n    {\r\n      name: 'eraser',\r\n      type: 'tool',\r\n      tool: KritzelEraserTool,\r\n      icon: 'eraser',\r\n    },\r\n    {\r\n      name: 'line',\r\n      type: 'tool',\r\n      tool: KritzelLineTool,\r\n      icon: 'arrow',\r\n      config: DEFAULT_LINE_TOOL_CONFIG,\r\n    },\r\n    {\r\n      name: 'shape',\r\n      type: 'tool',\r\n      tool: KritzelShapeTool,\r\n      icon: 'shape-rectangle',\r\n      config: DEFAULT_SHAPE_CONFIG,\r\n      subOptions: [\r\n        { id: 'rectangle', icon: 'shape-rectangle', label: 'Rectangle', value: ShapeType.Rectangle, toolProperty: 'shapeType' },\r\n        { id: 'ellipse', icon: 'shape-ellipse', label: 'Ellipse', value: ShapeType.Ellipse, toolProperty: 'shapeType' },\r\n        { id: 'triangle', icon: 'shape-triangle', label: 'Triangle', value: ShapeType.Triangle, toolProperty: 'shapeType' },\r\n      ],\r\n    },\r\n    {\r\n      name: 'text',\r\n      type: 'tool',\r\n      tool: KritzelTextTool,\r\n      icon: 'type',\r\n      config: DEFAULT_TEXT_CONFIG,\r\n    },\r\n    {\r\n      name: 'image',\r\n      type: 'tool',\r\n      tool: KritzelImageTool,\r\n      icon: 'image',\r\n    },\r\n    {\r\n      name: 'config',\r\n      type: 'config',\r\n    },\r\n  ]"
+            },
+            "globalContextMenuItems": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ContextMenuItem[]",
+                    "resolved": "ContextMenuItem[]",
+                    "references": {
+                        "ContextMenuItem": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::ContextMenuItem",
+                            "referenceLocation": "ContextMenuItem"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[\r\n    {\r\n      label: 'menu.paste',\r\n      icon: 'paste',\r\n      action: menu => this.engineRef.paste(menu.x, menu.y),\r\n    },\r\n    {\r\n      label: 'menu.selectAll',\r\n      icon: 'select-all',\r\n      action: () => this.selectAllObjectsInViewport(),\r\n    },\r\n  ]"
+            },
+            "objectContextMenuItems": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "ContextMenuItem[]",
+                    "resolved": "ContextMenuItem[]",
+                    "references": {
+                        "ContextMenuItem": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::ContextMenuItem",
+                            "referenceLocation": "ContextMenuItem"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[\r\n    { label: 'menu.copy', icon: 'copy', group: 'clipboard', action: () => this.engineRef.copy() },\r\n    { label: 'menu.cut', icon: 'cut', group: 'clipboard', action: () => this.engineRef.cut() },\r\n    {\r\n      label: 'menu.paste',\r\n      icon: 'paste',\r\n      group: 'clipboard',\r\n      action: (menu, _) => this.engineRef.paste(menu.x, menu.y),\r\n    },\r\n    {\r\n      label: 'menu.export',\r\n      icon: 'upload',\r\n      group: 'clipboard',\r\n      isVisible: (_, objects) => this.canExportObjects(objects),\r\n      action: (_, objects) => {\r\n        const format = this.getPreferredExportFormat(objects);\r\n        if (!format) {\r\n          return;\r\n        }\r\n\r\n        void this.engineRef.exportSelectedObject(format);\r\n      },\r\n    },\r\n    {\r\n      label: 'menu.order',\r\n      icon: 'ordering',\r\n      group: 'other',\r\n      children: [\r\n        { label: 'menu.bringToFront', icon: 'bring-to-front', action: () => this.engineRef.bringToFront() },\r\n        { label: 'menu.sendToBack', icon: 'send-to-back', action: () => this.engineRef.sendToBack() },\r\n        { label: 'menu.moveUp', icon: 'arrow-up-from-dot', action: () => this.engineRef.bringForward() },\r\n        { label: 'menu.moveDown', icon: 'arrow-down-from-dot', action: () => this.engineRef.sendBackward() },\r\n      ],\r\n    },\r\n    {\r\n      label: 'menu.align',\r\n      icon: 'align',\r\n      group: 'other',\r\n      children: [\r\n        { label: 'menu.alignLeft', icon: 'align-start-vertical', action: () => this.engineRef.alignObjects(KritzelAlignment.StartHorizontal) },\r\n        { label: 'menu.alignCenterHorizontal', icon: 'align-center-horizontal', action: () => this.engineRef.alignObjects(KritzelAlignment.CenterHorizontal) },\r\n        { label: 'menu.alignRight', icon: 'align-end-vertical', action: () => this.engineRef.alignObjects(KritzelAlignment.EndHorizontal) },\r\n        { label: 'menu.alignTop', icon: 'align-start-horizontal', action: () => this.engineRef.alignObjects(KritzelAlignment.StartVertical) },\r\n        { label: 'menu.alignCenterVertical', icon: 'align-center-vertical', action: () => this.engineRef.alignObjects(KritzelAlignment.CenterVertical) },\r\n        { label: 'menu.alignBottom', icon: 'align-end-horizontal', action: () => this.engineRef.alignObjects(KritzelAlignment.EndVertical) },\r\n      ],\r\n    },\r\n    {\r\n      label: 'menu.group',\r\n      icon: 'group',\r\n      group: 'other',\r\n      children: [\r\n        {\r\n          label: 'menu.group',\r\n          icon: 'group',\r\n          action: () => this.engineRef.group(),\r\n        },\r\n        {\r\n          label: 'menu.ungroup',\r\n          icon: 'ungroup',\r\n          action: () => this.engineRef.ungroup(),\r\n        },\r\n      ],\r\n    },\r\n    { label: 'menu.delete', icon: 'delete', group: 'edit', action: () => this.engineRef.delete() },\r\n  ]"
+            },
+            "moreMenuItems": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "IKritzelMenuItem[]",
+                    "resolved": "IKritzelMenuItem<any>[]",
+                    "references": {
+                        "IKritzelMenuItem": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::IKritzelMenuItem",
+                            "referenceLocation": "IKritzelMenuItem"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "[\r\n    {\r\n      id: 'share',\r\n      label: 'menu.share',\r\n      icon: 'share',\r\n      isVisible: async () => hasRemoteSyncProvider(this.syncConfig),\r\n      action: () => {\r\n        if (!this.isLoggedIn && this.loginConfig) {\r\n          this.openLoginDialog();\r\n          return;\r\n        }\r\n        this.shareDialogRef.open();\r\n      },\r\n    },\r\n    {\r\n      id: 'export',\r\n      label: 'menu.export',\r\n      icon: 'upload',\r\n      action: async () => {\r\n        const preview = await this.engineRef.getScreenshot('png');\r\n        this.exportRef.open(preview ?? undefined);\r\n      },\r\n    },\r\n    {\r\n      id: 'import',\r\n      label: 'menu.import',\r\n      icon: 'download',\r\n      action: () => this.engineRef.importFromFile(),\r\n    },\r\n    {\r\n      id: 'settings',\r\n      label: 'menu.settings',\r\n      icon: 'settings',\r\n      action: () => this.settingsRef.open(),\r\n    },\r\n  ]"
+            },
+            "themes": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "KritzelTheme[]",
+                    "resolved": "KritzelTheme[]",
+                    "references": {
+                        "KritzelTheme": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelTheme",
+                            "referenceLocation": "KritzelTheme"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false
+            },
+            "theme": {
+                "type": "string",
+                "mutable": true,
+                "complexType": {
+                    "original": "ThemeName",
+                    "resolved": "\"dark\" | \"light\" | string & {}",
+                    "references": {
+                        "ThemeName": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::ThemeName",
+                            "referenceLocation": "ThemeName"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "theme",
+                "defaultValue": "'light'"
+            },
+            "licenseKey": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "License key that, when valid, removes the \"Powered by Kritzel\" watermark."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "license-key"
+            },
+            "locale": {
+                "type": "string",
+                "mutable": true,
+                "complexType": {
+                    "original": "LocaleCode",
+                    "resolved": "\"de\" | \"en\" | \"fr\" | string & {}",
+                    "references": {
+                        "LocaleCode": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::LocaleCode",
+                            "referenceLocation": "LocaleCode"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The current locale (language) code applied to the editor, e.g. 'en', 'de', 'fr'."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "locale",
+                "defaultValue": "'en'"
+            },
+            "locales": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "KritzelLocale[]",
+                    "resolved": "KritzelLocale[]",
+                    "references": {
+                        "KritzelLocale": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelLocale",
+                            "referenceLocation": "KritzelLocale"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "An array of available locale definitions (with optional partial term overrides)."
+                },
+                "getter": false,
+                "setter": false
+            },
+            "fallbackLocale": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "LocaleCode",
+                    "resolved": "\"de\" | \"en\" | \"fr\" | string & {}",
+                    "references": {
+                        "LocaleCode": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::LocaleCode",
+                            "referenceLocation": "LocaleCode"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "The locale used to resolve terms missing from the active locale."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "fallback-locale",
+                "defaultValue": "'en'"
+            },
+            "customSvgIcons": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "Record<string, string>",
+                    "resolved": "string",
+                    "references": {
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "{}"
+            },
+            "customFonts": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "KritzelFontMap",
+                    "resolved": "{ [x: string]: KritzelFontRegistration; }",
+                    "references": {
+                        "KritzelFontMap": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelFontMap",
+                            "referenceLocation": "KritzelFontMap"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": "Registers fonts for runtime usage (for example custom object rendering).\r\nText-tool config tooltip options are controlled via toolbarItems[].config.availableFonts."
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "{}"
+            },
+            "isPanningEnabled": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "is-panning-enabled",
+                "defaultValue": "true"
+            },
+            "isZoomingEnabled": {
+                "type": "boolean",
+                "mutable": true,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "is-zooming-enabled",
+                "defaultValue": "true"
+            },
+            "isToolbarVisible": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "is-toolbar-visible",
+                "defaultValue": "true"
+            },
+            "isUtilityPanelVisible": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "is-utility-panel-visible",
+                "defaultValue": "true"
+            },
+            "isWorkspaceManagerVisible": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "is-workspace-manager-visible",
+                "defaultValue": "true"
+            },
+            "isMoreMenuVisible": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "is-more-menu-visible",
+                "defaultValue": "true"
+            },
+            "isZoomPanelVisible": {
+                "type": "boolean",
+                "mutable": false,
+                "complexType": {
+                    "original": "boolean",
+                    "resolved": "boolean",
+                    "references": {}
+                },
+                "required": false,
+                "optional": false,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "is-zoom-panel-visible",
+                "defaultValue": "true"
+            },
+            "syncConfig": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "KritzelSyncConfig",
+                    "resolved": "KritzelSyncConfig",
+                    "references": {
+                        "KritzelSyncConfig": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelSyncConfig",
+                            "referenceLocation": "KritzelSyncConfig"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "DEFAULT_SYNC_CONFIG"
+            },
+            "assetStorageConfig": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "KritzelAssetStorageConfig",
+                    "resolved": "KritzelAssetStorageConfig",
+                    "references": {
+                        "KritzelAssetStorageConfig": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelAssetStorageConfig",
+                            "referenceLocation": "KritzelAssetStorageConfig"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "getter": false,
+                "setter": false,
+                "defaultValue": "DEFAULT_ASSET_STORAGE_CONFIG"
+            },
+            "cursorTarget": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "HTMLElement",
+                    "resolved": "HTMLElement",
+                    "references": {
+                        "HTMLElement": {
+                            "location": "global",
+                            "id": "global::HTMLElement"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "The element to use as the target for the cursor. Defaults to the editor container if not set."
+                },
+                "getter": false,
+                "setter": false
+            },
+            "loginConfig": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "KritzelLoginConfig",
+                    "resolved": "KritzelLoginConfig",
+                    "references": {
+                        "KritzelLoginConfig": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelLoginConfig",
+                            "referenceLocation": "KritzelLoginConfig"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Optional login configuration. When provided, a \"Sign in\" button is shown that opens a login dialog with the configured providers."
+                },
+                "getter": false,
+                "setter": false
+            },
+            "editorId": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Optional unique identifier for namespacing storage keys across multiple editor instances."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "editor-id"
+            },
+            "activeWorkspaceId": {
+                "type": "string",
+                "mutable": false,
+                "complexType": {
+                    "original": "string",
+                    "resolved": "string",
+                    "references": {}
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Optional workspace ID to set as active. If provided, the editor will automatically activate the workspace with this ID."
+                },
+                "getter": false,
+                "setter": false,
+                "reflect": false,
+                "attribute": "active-workspace-id"
+            },
+            "workspaces": {
+                "type": "unknown",
+                "mutable": false,
+                "complexType": {
+                    "original": "KritzelWorkspace[]",
+                    "resolved": "KritzelWorkspace[]",
+                    "references": {
+                        "KritzelWorkspace": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/core/workspace.class.d.ts::KritzelWorkspace",
+                            "referenceLocation": "KritzelWorkspace"
+                        }
+                    }
+                },
+                "required": false,
+                "optional": true,
+                "docs": {
+                    "tags": [],
+                    "text": "Authoritative workspace catalog for this editor instance. When provided, provider-only workspaces are hidden but not deleted."
+                },
+                "getter": false,
+                "setter": false
+            }
+        };
+    }
+    static get states() {
+        return {
+            "isEngineReady": {},
+            "isToolbarReady": {},
+            "isWorkspaceManagerReady": {},
+            "availableWorkspaces": {},
+            "activeWorkspace": {},
+            "isVirtualKeyboardOpen": {},
+            "undoState": {},
+            "isBackToContentButtonVisible": {},
+            "resolvedTerms": {},
+            "availableLocaleOptions": {},
+            "currentZoomPercent": {},
+            "shortcuts": {},
+            "currentIsPublic": {},
+            "isEditorVisible": {},
+            "activeNotification": {},
+            "isNotificationDismissing": {},
+            "contextMenuState": {},
+            "resolvedMoreMenuItems": {},
+            "isLoadingOverlayVisible": {}
+        };
+    }
+    static get events() {
+        return [{
+                "method": "isReady",
+                "name": "isReady",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "EditorIsReadyEvent",
+                    "resolved": "EditorIsReadyEvent",
+                    "references": {
+                        "EditorIsReadyEvent": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::EditorIsReadyEvent",
+                            "referenceLocation": "EditorIsReadyEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "activeWorkspaceChange",
+                "name": "activeWorkspaceChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "ActiveWorkspaceChangeEvent",
+                    "resolved": "ActiveWorkspaceChangeEvent",
+                    "references": {
+                        "ActiveWorkspaceChangeEvent": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::ActiveWorkspaceChangeEvent",
+                            "referenceLocation": "ActiveWorkspaceChangeEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "objectsChange",
+                "name": "objectsChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "KritzelBaseObject[]",
+                    "resolved": "KritzelBaseObject<HTMLElement | SVGElement>[]",
+                    "references": {
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    }
+                }
+            }, {
+                "method": "objectsAdded",
+                "name": "objectsAdded",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "ObjectsAddedEvent",
+                    "resolved": "ObjectsAddedEvent",
+                    "references": {
+                        "ObjectsAddedEvent": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::ObjectsAddedEvent",
+                            "referenceLocation": "ObjectsAddedEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "objectsRemoved",
+                "name": "objectsRemoved",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "ObjectsRemovedEvent",
+                    "resolved": "ObjectsRemovedEvent",
+                    "references": {
+                        "ObjectsRemovedEvent": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::ObjectsRemovedEvent",
+                            "referenceLocation": "ObjectsRemovedEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "objectsUpdated",
+                "name": "objectsUpdated",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "ObjectsUpdatedEvent",
+                    "resolved": "ObjectsUpdatedEvent",
+                    "references": {
+                        "ObjectsUpdatedEvent": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::ObjectsUpdatedEvent",
+                            "referenceLocation": "ObjectsUpdatedEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "objectsSelectionChange",
+                "name": "objectsSelectionChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "KritzelBaseObject[]",
+                    "resolved": "KritzelBaseObject<HTMLElement | SVGElement>[]",
+                    "references": {
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    }
+                }
+            }, {
+                "method": "undoStateChange",
+                "name": "undoStateChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "KritzelUndoState",
+                    "resolved": "KritzelUndoState",
+                    "references": {
+                        "KritzelUndoState": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelUndoState",
+                            "referenceLocation": "KritzelUndoState"
+                        }
+                    }
+                }
+            }, {
+                "method": "themeChange",
+                "name": "themeChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "ThemeName",
+                    "resolved": "\"dark\" | \"light\" | string & {}",
+                    "references": {
+                        "ThemeName": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::ThemeName",
+                            "referenceLocation": "ThemeName"
+                        }
+                    }
+                }
+            }, {
+                "method": "localeChange",
+                "name": "localeChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "LocaleCode",
+                    "resolved": "\"de\" | \"en\" | \"fr\" | string & {}",
+                    "references": {
+                        "LocaleCode": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::LocaleCode",
+                            "referenceLocation": "LocaleCode"
+                        }
+                    }
+                }
+            }, {
+                "method": "viewportChange",
+                "name": "viewportChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "KritzelViewportState",
+                    "resolved": "KritzelViewportState",
+                    "references": {
+                        "KritzelViewportState": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelViewportState",
+                            "referenceLocation": "KritzelViewportState"
+                        }
+                    }
+                }
+            }, {
+                "method": "logout",
+                "name": "logout",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "void",
+                    "resolved": "void",
+                    "references": {}
+                }
+            }, {
+                "method": "login",
+                "name": "login",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "LoginEvent",
+                    "resolved": "LoginEvent",
+                    "references": {
+                        "LoginEvent": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::LoginEvent",
+                            "referenceLocation": "LoginEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "isPublicChange",
+                "name": "isPublicChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "IKritzelIsPublicChangeEvent",
+                    "resolved": "IKritzelIsPublicChangeEvent",
+                    "references": {
+                        "IKritzelIsPublicChangeEvent": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::IKritzelIsPublicChangeEvent",
+                            "referenceLocation": "IKritzelIsPublicChangeEvent"
+                        }
+                    }
+                }
+            }, {
+                "method": "awarenessChange",
+                "name": "awarenessChange",
+                "bubbles": true,
+                "cancelable": true,
+                "composed": true,
+                "docs": {
+                    "tags": [],
+                    "text": ""
+                },
+                "complexType": {
+                    "original": "Map<number, Record<string, any>>",
+                    "resolved": "Map<number, Record<string, any>>",
+                    "references": {
+                        "Map": {
+                            "location": "global",
+                            "id": "global::Map"
+                        },
+                        "Record": {
+                            "location": "global",
+                            "id": "global::Record"
+                        }
+                    }
+                }
+            }];
+    }
+    static get methods() {
+        return {
+            "getObjectById": {
+                "complexType": {
+                    "signature": "<T extends KritzelBaseObject>(id: string) => Promise<T | null>",
+                    "parameters": [{
+                            "name": "id",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "T": {
+                            "location": "global",
+                            "id": "global::T"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<T>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "addObject": {
+                "complexType": {
+                    "signature": "<T extends KritzelBaseObject>(object: T) => Promise<T | null>",
+                    "parameters": [{
+                            "name": "object",
+                            "type": "T",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "T": {
+                            "location": "global",
+                            "id": "global::T"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<T>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "addObjects": {
+                "complexType": {
+                    "signature": "<T extends KritzelBaseObject>(objects: T[]) => Promise<T[]>",
+                    "parameters": [{
+                            "name": "objects",
+                            "type": "T[]",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "T": {
+                            "location": "global",
+                            "id": "global::T"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<T[]>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "updateObject": {
+                "complexType": {
+                    "signature": "<T extends KritzelBaseObject>(object: T, updatedProperties: Partial<T>) => Promise<T | null>",
+                    "parameters": [{
+                            "name": "object",
+                            "type": "T",
+                            "docs": ""
+                        }, {
+                            "name": "updatedProperties",
+                            "type": "{ [P in keyof T]?: T[P]; }",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "T": {
+                            "location": "global",
+                            "id": "global::T"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        },
+                        "Partial": {
+                            "location": "global",
+                            "id": "global::Partial"
+                        }
+                    },
+                    "return": "Promise<T>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "removeObject": {
+                "complexType": {
+                    "signature": "<T extends KritzelBaseObject>(object: T) => Promise<T | null>",
+                    "parameters": [{
+                            "name": "object",
+                            "type": "T",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "T": {
+                            "location": "global",
+                            "id": "global::T"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<T>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "removeObjects": {
+                "complexType": {
+                    "signature": "<T extends KritzelBaseObject>(objects: T[]) => Promise<T[]>",
+                    "parameters": [{
+                            "name": "objects",
+                            "type": "T[]",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "T": {
+                            "location": "global",
+                            "id": "global::T"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<T[]>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getSelectedObjects": {
+                "complexType": {
+                    "signature": "() => Promise<KritzelBaseObject[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        },
+                        "HTMLElement": {
+                            "location": "global",
+                            "id": "global::HTMLElement"
+                        },
+                        "SVGElement": {
+                            "location": "global",
+                            "id": "global::SVGElement"
+                        }
+                    },
+                    "return": "Promise<KritzelBaseObject<HTMLElement | SVGElement>[]>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "selectObjects": {
+                "complexType": {
+                    "signature": "(objects: KritzelBaseObject[]) => Promise<void>",
+                    "parameters": [{
+                            "name": "objects",
+                            "type": "KritzelBaseObject<HTMLElement | SVGElement>[]",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "selectAllObjectsInViewport": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "clearSelection": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "centerObjectInViewport": {
+                "complexType": {
+                    "signature": "(object: KritzelBaseObject) => Promise<KritzelBaseObject<HTMLElement | SVGElement>>",
+                    "parameters": [{
+                            "name": "object",
+                            "type": "KritzelBaseObject<HTMLElement | SVGElement>",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        },
+                        "HTMLElement": {
+                            "location": "global",
+                            "id": "global::HTMLElement"
+                        },
+                        "SVGElement": {
+                            "location": "global",
+                            "id": "global::SVGElement"
+                        }
+                    },
+                    "return": "Promise<KritzelBaseObject<HTMLElement | SVGElement>>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "panToObject": {
+                "complexType": {
+                    "signature": "(object: KritzelBaseObject) => Promise<void>",
+                    "parameters": [{
+                            "name": "object",
+                            "type": "KritzelBaseObject<HTMLElement | SVGElement>",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "backToContent": {
+                "complexType": {
+                    "signature": "() => Promise<boolean>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "centerAllObjects": {
+                "complexType": {
+                    "signature": "(animate?: boolean) => Promise<boolean>",
+                    "parameters": [{
+                            "name": "animate",
+                            "type": "boolean",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "centerObjects": {
+                "complexType": {
+                    "signature": "(objects: KritzelBaseObject[], animate?: boolean) => Promise<boolean>",
+                    "parameters": [{
+                            "name": "objects",
+                            "type": "KritzelBaseObject<HTMLElement | SVGElement>[]",
+                            "docs": ""
+                        }, {
+                            "name": "animate",
+                            "type": "boolean",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "setViewport": {
+                "complexType": {
+                    "signature": "(x: number, y: number, scale: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "x",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "y",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "scale",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "panTo": {
+                "complexType": {
+                    "signature": "(x: number, y: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "x",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "y",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "zoomTo": {
+                "complexType": {
+                    "signature": "(scale: number, worldX?: number, worldY?: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "scale",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "worldX",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "worldY",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "zoomIn": {
+                "complexType": {
+                    "signature": "(factor?: number, duration?: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "factor",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "duration",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "zoomOut": {
+                "complexType": {
+                    "signature": "(factor?: number, duration?: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "factor",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "duration",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getViewport": {
+                "complexType": {
+                    "signature": "() => Promise<KritzelViewportState>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelViewportState": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelViewportState",
+                            "referenceLocation": "KritzelViewportState"
+                        }
+                    },
+                    "return": "Promise<KritzelViewportState>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "screenToWorld": {
+                "complexType": {
+                    "signature": "(x: number, y: number) => Promise<{ x: number; y: number; }>",
+                    "parameters": [{
+                            "name": "x",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "y",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<{ x: number; y: number; }>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "worldToScreen": {
+                "complexType": {
+                    "signature": "(x: number, y: number) => Promise<{ x: number; y: number; }>",
+                    "parameters": [{
+                            "name": "x",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "y",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<{ x: number; y: number; }>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "setActiveWorkspace": {
+                "complexType": {
+                    "signature": "(id: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "id",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "createWorkspace": {
+                "complexType": {
+                    "signature": "(workspace: KritzelWorkspace) => Promise<KritzelWorkspace | null>",
+                    "parameters": [{
+                            "name": "workspace",
+                            "type": "KritzelWorkspace",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelWorkspace": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/core/workspace.class.d.ts::KritzelWorkspace",
+                            "referenceLocation": "KritzelWorkspace"
+                        }
+                    },
+                    "return": "Promise<KritzelWorkspace>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "updateWorkspace": {
+                "complexType": {
+                    "signature": "(workspace: KritzelWorkspace) => Promise<void>",
+                    "parameters": [{
+                            "name": "workspace",
+                            "type": "KritzelWorkspace",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelWorkspace": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/core/workspace.class.d.ts::KritzelWorkspace",
+                            "referenceLocation": "KritzelWorkspace"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "deleteWorkspace": {
+                "complexType": {
+                    "signature": "(workspace: KritzelWorkspace) => Promise<void>",
+                    "parameters": [{
+                            "name": "workspace",
+                            "type": "KritzelWorkspace",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelWorkspace": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/core/workspace.class.d.ts::KritzelWorkspace",
+                            "referenceLocation": "KritzelWorkspace"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getWorkspaces": {
+                "complexType": {
+                    "signature": "() => Promise<KritzelWorkspace[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelWorkspace": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/core/workspace.class.d.ts::KritzelWorkspace",
+                            "referenceLocation": "KritzelWorkspace"
+                        }
+                    },
+                    "return": "Promise<KritzelWorkspace[]>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getActiveWorkspace": {
+                "complexType": {
+                    "signature": "() => Promise<KritzelWorkspace>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelWorkspace": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/core/workspace.class.d.ts::KritzelWorkspace",
+                            "referenceLocation": "KritzelWorkspace"
+                        }
+                    },
+                    "return": "Promise<KritzelWorkspace>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "loadSharedWorkspace": {
+                "complexType": {
+                    "signature": "(token: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "token",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "reinitSync": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "registerTool": {
+                "complexType": {
+                    "signature": "(toolName: string, toolClass: any, toolConfig?: KritzelTextToolConfig | KritzelBrushToolConfig | KritzelLineToolConfig | KritzelShapeToolConfig) => Promise<KritzelBaseTool | null>",
+                    "parameters": [{
+                            "name": "toolName",
+                            "type": "string",
+                            "docs": ""
+                        }, {
+                            "name": "toolClass",
+                            "type": "any",
+                            "docs": ""
+                        }, {
+                            "name": "toolConfig",
+                            "type": "KritzelTextToolConfig | KritzelBrushToolConfig | KritzelLineToolConfig | KritzelShapeToolConfig",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseTool": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/tools/base-tool.class.d.ts::KritzelBaseTool",
+                            "referenceLocation": "KritzelBaseTool"
+                        },
+                        "KritzelTextToolConfig": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelTextToolConfig",
+                            "referenceLocation": "KritzelTextToolConfig"
+                        },
+                        "KritzelBrushToolConfig": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelBrushToolConfig",
+                            "referenceLocation": "KritzelBrushToolConfig"
+                        },
+                        "KritzelLineToolConfig": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelLineToolConfig",
+                            "referenceLocation": "KritzelLineToolConfig"
+                        },
+                        "KritzelShapeToolConfig": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelShapeToolConfig",
+                            "referenceLocation": "KritzelShapeToolConfig"
+                        }
+                    },
+                    "return": "Promise<KritzelBaseTool>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "changeActiveTool": {
+                "complexType": {
+                    "signature": "(toolName: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "toolName",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "disable": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "enable": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "copy": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "cut": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "paste": {
+                "complexType": {
+                    "signature": "(x: number, y: number) => Promise<void>",
+                    "parameters": [{
+                            "name": "x",
+                            "type": "number",
+                            "docs": ""
+                        }, {
+                            "name": "y",
+                            "type": "number",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "delete": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "bringForward": {
+                "complexType": {
+                    "signature": "(object?: KritzelBaseObject<any>) => Promise<void>",
+                    "parameters": [{
+                            "name": "object",
+                            "type": "KritzelBaseObject<any>",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "sendBackward": {
+                "complexType": {
+                    "signature": "(object?: KritzelBaseObject<any>) => Promise<void>",
+                    "parameters": [{
+                            "name": "object",
+                            "type": "KritzelBaseObject<any>",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "bringToFront": {
+                "complexType": {
+                    "signature": "(object?: KritzelBaseObject<any>) => Promise<void>",
+                    "parameters": [{
+                            "name": "object",
+                            "type": "KritzelBaseObject<any>",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "sendToBack": {
+                "complexType": {
+                    "signature": "(object?: KritzelBaseObject<any>) => Promise<void>",
+                    "parameters": [{
+                            "name": "object",
+                            "type": "KritzelBaseObject<any>",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "alignObjects": {
+                "complexType": {
+                    "signature": "(alignment: KritzelAlignment) => Promise<void>",
+                    "parameters": [{
+                            "name": "alignment",
+                            "type": "KritzelAlignment",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelAlignment": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/enums/alignment.enum.d.ts::KritzelAlignment",
+                            "referenceLocation": "KritzelAlignment"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "group": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "ungroup": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "undo": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "redo": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getScreenshot": {
+                "complexType": {
+                    "signature": "(format?: \"png\" | \"svg\") => Promise<string | null>",
+                    "parameters": [{
+                            "name": "format",
+                            "type": "\"svg\" | \"png\"",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<string>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "exportViewportAsPng": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "exportViewportAsSvg": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getSelectedObjectSupportedExportFormats": {
+                "complexType": {
+                    "signature": "() => Promise<KritzelObjectExportFormat[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelObjectExportFormat": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelObjectExportFormat",
+                            "referenceLocation": "KritzelObjectExportFormat"
+                        }
+                    },
+                    "return": "Promise<KritzelObjectExportFormat[]>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "canExportSelectedObjectAs": {
+                "complexType": {
+                    "signature": "(format: KritzelObjectExportFormat) => Promise<boolean>",
+                    "parameters": [{
+                            "name": "format",
+                            "type": "\"svg\" | \"png\"",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelObjectExportFormat": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelObjectExportFormat",
+                            "referenceLocation": "KritzelObjectExportFormat"
+                        }
+                    },
+                    "return": "Promise<boolean>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "exportSelectedObject": {
+                "complexType": {
+                    "signature": "(format: KritzelObjectExportFormat) => Promise<void>",
+                    "parameters": [{
+                            "name": "format",
+                            "type": "\"svg\" | \"png\"",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelObjectExportFormat": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelObjectExportFormat",
+                            "referenceLocation": "KritzelObjectExportFormat"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "exportAsJson": {
+                "complexType": {
+                    "signature": "() => Promise<string>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<string>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "importFromJson": {
+                "complexType": {
+                    "signature": "(json: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "json",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "downloadAsJson": {
+                "complexType": {
+                    "signature": "(filename?: string) => Promise<void>",
+                    "parameters": [{
+                            "name": "filename",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "importFromFile": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "loadObjectsFromJson": {
+                "complexType": {
+                    "signature": "(json: string) => Promise<number>",
+                    "parameters": [{
+                            "name": "json",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<number>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getObjectsTotalCount": {
+                "complexType": {
+                    "signature": "() => Promise<number>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<number>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getAllObjects": {
+                "complexType": {
+                    "signature": "<T extends KritzelBaseObject>() => Promise<T[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "T": {
+                            "location": "global",
+                            "id": "global::T"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        }
+                    },
+                    "return": "Promise<T[]>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "findObjects": {
+                "complexType": {
+                    "signature": "<T extends KritzelBaseObject>(predicate: (obj: KritzelBaseObject<Element>) => boolean) => Promise<T[]>",
+                    "parameters": [{
+                            "name": "predicate",
+                            "type": "(obj: KritzelBaseObject<Element>) => boolean",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "T": {
+                            "location": "global",
+                            "id": "global::T"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        },
+                        "Element": {
+                            "location": "import",
+                            "path": "@stencil/core",
+                            "id": "../../../node_modules/@stencil/core/internal/stencil-core/index.d.ts::Element",
+                            "referenceLocation": "Element"
+                        }
+                    },
+                    "return": "Promise<T[]>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getObjectsInViewport": {
+                "complexType": {
+                    "signature": "() => Promise<KritzelBaseObject[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelBaseObject": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/classes/objects/base-object.class.d.ts::KritzelBaseObject",
+                            "referenceLocation": "KritzelBaseObject"
+                        },
+                        "HTMLElement": {
+                            "location": "global",
+                            "id": "global::HTMLElement"
+                        },
+                        "SVGElement": {
+                            "location": "global",
+                            "id": "global::SVGElement"
+                        }
+                    },
+                    "return": "Promise<KritzelBaseObject<HTMLElement | SVGElement>[]>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "hideContextMenu": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "openContextMenu": {
+                "complexType": {
+                    "signature": "(options: { x: number; y: number; objectId?: string; }) => Promise<void>",
+                    "parameters": [{
+                            "name": "options",
+                            "type": "{ x: number; y: number; objectId?: string; }",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "openWorkspaceManagerMenu": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "closeWorkspaceManagerMenu": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "openMoreMenu": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "closeMoreMenu": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "openUserDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "closeUserDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "openExportDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "closeExportDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "openImportDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "closeImportDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "openSettingsDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "closeSettingsDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "openShareDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "closeShareDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "triggerSelectionChange": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "beginSceneBootstrap": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "endSceneBootstrap": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "getDisplayableShortcuts": {
+                "complexType": {
+                    "signature": "() => Promise<Omit<KritzelShortcut, \"action\" | \"condition\">[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "Omit": {
+                            "location": "global",
+                            "id": "global::Omit"
+                        },
+                        "KritzelShortcut": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelShortcut",
+                            "referenceLocation": "KritzelShortcut"
+                        }
+                    },
+                    "return": "Promise<Omit<KritzelShortcut, \"action\" | \"condition\">[]>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "openLoginDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "closeLoginDialog": {
+                "complexType": {
+                    "signature": "() => Promise<void>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "setLoginLoading": {
+                "complexType": {
+                    "signature": "(provider: string | null) => Promise<void>",
+                    "parameters": [{
+                            "name": "provider",
+                            "type": "string",
+                            "docs": ""
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "",
+                    "tags": []
+                }
+            },
+            "setLocale": {
+                "complexType": {
+                    "signature": "(code: LocaleCode) => Promise<void>",
+                    "parameters": [{
+                            "name": "code",
+                            "type": "(string & {}) | \"en\" | \"de\" | \"fr\"",
+                            "docs": "- The locale code to activate, e.g. 'de'."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "LocaleCode": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::LocaleCode",
+                            "referenceLocation": "LocaleCode"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Sets the active locale (language) and re-renders the UI.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "code - The locale code to activate, e.g. 'de'."
+                        }]
+                }
+            },
+            "getLocale": {
+                "complexType": {
+                    "signature": "() => Promise<LocaleCode>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "LocaleCode": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::LocaleCode",
+                            "referenceLocation": "LocaleCode"
+                        }
+                    },
+                    "return": "Promise<LocaleCode>"
+                },
+                "docs": {
+                    "text": "Gets the currently active locale code.",
+                    "tags": []
+                }
+            },
+            "getAvailableLocales": {
+                "complexType": {
+                    "signature": "() => Promise<LocaleCode[]>",
+                    "parameters": [],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "LocaleCode": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::LocaleCode",
+                            "referenceLocation": "LocaleCode"
+                        }
+                    },
+                    "return": "Promise<LocaleCode[]>"
+                },
+                "docs": {
+                    "text": "Gets the list of available locale codes (built-in and registered).",
+                    "tags": []
+                }
+            },
+            "registerLocales": {
+                "complexType": {
+                    "signature": "(locales: KritzelLocale[]) => Promise<void>",
+                    "parameters": [{
+                            "name": "locales",
+                            "type": "KritzelLocale[]",
+                            "docs": "- The locale definitions to register."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelLocale": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelLocale",
+                            "referenceLocation": "KritzelLocale"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Registers additional locale definitions (with optional partial term overrides).",
+                    "tags": [{
+                            "name": "param",
+                            "text": "locales - The locale definitions to register."
+                        }]
+                }
+            },
+            "registerFonts": {
+                "complexType": {
+                    "signature": "(fonts: KritzelFontMap) => Promise<void>",
+                    "parameters": [{
+                            "name": "fonts",
+                            "type": "{ [x: string]: KritzelFontRegistration; }",
+                            "docs": "- Mapping from font keys to family names or font definitions."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelFontMap": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelFontMap",
+                            "referenceLocation": "KritzelFontMap"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Registers custom fonts for the editor runtime.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "fonts - Mapping from font keys to family names or font definitions."
+                        }, {
+                            "name": "remarks",
+                            "text": "This no longer controls the text-tool config tooltip font options.\r\nConfigure tooltip fonts via toolbarItems[].config.availableFonts."
+                        }]
+                }
+            },
+            "t": {
+                "complexType": {
+                    "signature": "(key: KritzelTermKey, vars?: KritzelTermVars) => Promise<string>",
+                    "parameters": [{
+                            "name": "key",
+                            "type": "keyof KritzelTerms",
+                            "docs": "- The term key to resolve."
+                        }, {
+                            "name": "vars",
+                            "type": "{ [x: string]: string | number; }",
+                            "docs": "- Optional values for `{placeholder}` interpolation."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "KritzelTermKey": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelTermKey",
+                            "referenceLocation": "KritzelTermKey"
+                        },
+                        "KritzelTermVars": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelTermVars",
+                            "referenceLocation": "KritzelTermVars"
+                        }
+                    },
+                    "return": "Promise<string>"
+                },
+                "docs": {
+                    "text": "Resolves a term key to its translated string for the active locale.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "key - The term key to resolve."
+                        }, {
+                            "name": "param",
+                            "text": "vars - Optional values for `{placeholder}` interpolation."
+                        }]
+                }
+            },
+            "triggerNotification": {
+                "complexType": {
+                    "signature": "(notification: Omit<KritzelNotification, \"id\"> & Partial<Pick<KritzelNotification, \"id\" | \"timestamp\">>) => Promise<void>",
+                    "parameters": [{
+                            "name": "notification",
+                            "type": "Omit<KritzelNotification, \"id\"> & Partial<Pick<KritzelNotification, \"id\" | \"timestamp\">>",
+                            "docs": "- Notification payload. `id` and `timestamp` are optional."
+                        }],
+                    "references": {
+                        "Promise": {
+                            "location": "global",
+                            "id": "global::Promise"
+                        },
+                        "Omit": {
+                            "location": "global",
+                            "id": "global::Omit"
+                        },
+                        "KritzelNotification": {
+                            "location": "import",
+                            "path": "@kritzel/engine",
+                            "id": "../../engine/core/dist/types/index.d.ts::KritzelNotification",
+                            "referenceLocation": "KritzelNotification"
+                        },
+                        "Partial": {
+                            "location": "global",
+                            "id": "global::Partial"
+                        },
+                        "Pick": {
+                            "location": "global",
+                            "id": "global::Pick"
+                        }
+                    },
+                    "return": "Promise<void>"
+                },
+                "docs": {
+                    "text": "Triggers a UI notification programmatically.",
+                    "tags": [{
+                            "name": "param",
+                            "text": "notification - Notification payload. `id` and `timestamp` are optional."
+                        }]
+                }
+            }
+        };
+    }
+    static get elementRef() { return "host"; }
+    static get watchers() {
+        return [{
+                "propName": "isEngineReady",
+                "methodName": "onIsEngineReady"
+            }, {
+                "propName": "isToolbarReady",
+                "methodName": "onIsToolbarReady"
+            }, {
+                "propName": "availableWorkspaces",
+                "methodName": "onAvailableWorkspacesChange"
+            }, {
+                "propName": "activeWorkspace",
+                "methodName": "onActiveWorkspaceChange"
+            }, {
+                "propName": "customFonts",
+                "methodName": "onCustomFontsChange"
+            }, {
+                "propName": "moreMenuItems",
+                "methodName": "onMoreMenuItemsChange"
+            }, {
+                "propName": "syncConfig",
+                "methodName": "onSyncConfigChange"
+            }, {
+                "propName": "loginConfig",
+                "methodName": "onLoginConfigChange"
+            }, {
+                "propName": "user",
+                "methodName": "onUserChange"
+            }, {
+                "propName": "activeWorkspaceId",
+                "methodName": "onActiveWorkspaceIdChange"
+            }, {
+                "propName": "theme",
+                "methodName": "onCurrentThemeChange"
+            }, {
+                "propName": "themes",
+                "methodName": "onThemesChange"
+            }, {
+                "propName": "locale",
+                "methodName": "onLocaleChange"
+            }, {
+                "propName": "locales",
+                "methodName": "onLocalesChange"
+            }];
+    }
+    static get listeners() {
+        return [{
+                "name": "dblclick",
+                "method": "onTouchStart",
+                "target": undefined,
+                "capture": false,
+                "passive": false
+            }];
+    }
+}