@plurid/plurid-data 0.0.0-20 → 0.0.0-21

package/distribution/index.d.ts

@@ -1,3 +1,2678 @@
-export * from './constants';
-export * from './enumerations';
-export * from './interfaces';
+import { ThemeName, Theme } from '@plurid/plurid-themes';
+
+declare enum SHORTCUTS {
+    TOGGLE_FIRST_PERSON = "TOGGLE_FIRST_PERSON",
+    MOVE_FORWARD = "MOVE_FORWARD",
+    MOVE_BACKWARD = "MOVE_BACKWARD",
+    MOVE_LEFT = "MOVE_LEFT",
+    MOVE_RIGHT = "MOVE_RIGHT",
+    MOVE_UP = "MOVE_UP",
+    MOVE_DOWN = "MOVE_DOWN",
+    TURN_LEFT = "TURN_LEFT",
+    TURN_RIGHT = "TURN_RIGHT",
+    TURN_UP = "TURN_UP",
+    TURN_DOWN = "TURN_DOWN",
+    ROTATE_UP = "ROTATE_UP",
+    ROTATE_DOWN = "ROTATE_DOWN",
+    ROTATE_LEFT = "ROTATE_LEFT",
+    ROTATE_RIGHT = "ROTATE_RIGHT",
+    TOGGLE_ROTATE = "TOGGLE_ROTATE",
+    TRANSLATE_UP = "TRANSLATE_UP",
+    TRANSLATE_DOWN = "TRANSLATE_DOWN",
+    TRANSLATE_LEFT = "TRANSLATE_LEFT",
+    TRANSLATE_RIGHT = "TRANSLATE_RIGHT",
+    TRANSLATE_IN = "TRANSLATE_IN",
+    TRANSLATE_OUT = "TRANSLATE_OUT",
+    TOGGLE_TRANSLATE = "TOGGLE_TRANSLATE",
+    SCALE_UP = "SCALE_UP",
+    SCALE_DOWN = "SCALE_DOWN",
+    TOGGLE_SCALE = "TOGGLE_SCALE",
+    FOCUS_PLANE = "FOCUS_PLANE",
+    FOCUS_PARENT = "FOCUS_PARENT",
+    REFRESH_PLANE = "REFRESH_PLANE",
+    ISOLATE_PLANE = "ISOLATE_PLANE",
+    OPEN_CLOSED_PLANE = "OPEN_CLOSED_PLANE",
+    CLOSE_PLANE = "CLOSE_PLANE",
+    PREVIOUS_ROOT = "PREVIOUS_ROOT",
+    NEXT_ROOT = "NEXT_ROOT",
+    FOCUS_ROOT = "FOCUS_ROOT"
+}
+declare enum KEY_MODIFIERS {
+    SHIFT = "SHIFT",
+    ALT = "ALT",
+    CTRL = "CTRL",
+    META = "META",
+    METACTRL = "METACTRL"
+}
+declare enum LAYOUT_TYPES {
+    COLUMNS = "COLUMNS",
+    ROWS = "ROWS",
+    FACE_TO_FACE = "FACE_TO_FACE",
+    ZIG_ZAG = "ZIG_ZAG",
+    SHEAVES = "SHEAVES",
+    META = "META"
+}
+declare enum SIZES {
+    SMALL = "SMALL",
+    NORMAL = "NORMAL",
+    LARGE = "LARGE"
+}
+declare enum TRANSFORM_MODES {
+    ROTATION = "ROTATION",
+    SCALE = "SCALE",
+    TRANSLATION = "TRANSLATION",
+    ALL = "ALL"
+}
+declare enum TRANSFORM_TOUCHES {
+    SWIPE = "SWIPE",
+    PAN = "PAN"
+}
+declare enum TOOLBAR_DRAWERS {
+    ALL = "ALL",
+    GLOBAL = "GLOBAL",
+    TRANSFORM = "TRANSFORM",
+    SPACE = "SPACE",
+    TOOLBAR = "TOOLBAR",
+    VIEWCUBE = "VIEWCUBE",
+    MINIMAP = "MINIMAP",
+    TECHNICAL = "TECHNICAL",
+    SHORTCUTS = "SHORTCUTS"
+}
+
+interface Indexed<T> {
+    [key: string]: T;
+}
+interface WithID {
+    id: string;
+}
+type Identified<T> = T & WithID;
+type RecursivePartial<T> = {
+    [P in keyof T]?: RecursivePartial<T[P]>;
+};
+
+interface Layout {
+    type: keyof typeof LAYOUT_TYPES;
+}
+interface LayoutMeta extends Layout {
+    type: LAYOUT_TYPES.META;
+    layouts: LayoutMetaLayout[];
+}
+interface LayoutMetaLayout {
+    size?: number;
+    pages?: string[];
+    layout: LayoutColumns | LayoutRows | LayoutFaceToFace | LayoutZigZag | LayoutSheaves;
+}
+interface LayoutColumns extends Layout {
+    /**
+     * Layout Top View
+     *
+     * ‾1‾ ‾4‾
+     * ‾2‾ ‾5‾
+     * ‾3‾
+     *
+     */
+    type: LAYOUT_TYPES.COLUMNS;
+    /**
+     * Integer value indicating the number of columns.
+     *
+     * If the number of pages is greater than the number of columns,
+     * the pages will overflow onto the next row.
+     */
+    columns?: number;
+    /**
+     * Number of planes per column.
+     */
+    columnLength?: number;
+    /**
+     * Distance between columns.
+     *
+     * Value between `0.00` and `x.00` (floating numbers) indicating percent of view width
+     * or between `0` and `x0...0` (integers) indicating pixel values.
+     *
+     * For example:
+     * `0.5` is 50% of view width,
+     * `5` is five pixels,
+     * `1.00` is 100% of view width,
+     * `1` is one pixels,
+     * `1.35` is 135% of view width,
+     * `135` is 135 pixels.
+     */
+    gap?: number;
+}
+interface LayoutRows extends Layout {
+    /**
+     * Layout Top View
+     *
+     * ‾1‾ ‾2‾
+     * ‾3‾ ‾4‾
+     * ‾5‾
+     *
+     */
+    type: LAYOUT_TYPES.ROWS;
+    /**
+     * Integer value indicating the number of rows.
+     *
+     * If the number of pages is greater than the number of rows,
+     * the pages will overflow onto the next column.
+     */
+    rows?: number;
+    /**
+     * Number of planes per row.
+     */
+    rowLength?: number;
+    /**
+     * Distance between rows.
+     *
+     * Value between `0.00` and `x.00` (floating numbers) indicating percent of view width
+     * or between `0` and `x0...0` (integers) indicating pixel values.
+     *
+     * For example:
+     * `0.5` is 50% of view width,
+     * `5` is five pixels,
+     * `1.00` is 100% of view width,
+     * `1` is one pixels,
+     * `1.35` is 135% of view width,
+     * `135` is 135 pixels.
+     */
+    gap?: number;
+}
+interface LayoutFaceToFace extends Layout {
+    /**
+     * Layout Top View
+     *
+     * ╱ ‾‾ ╲
+     *
+     * ╱    first plane
+     *
+     * —    (optional) middle plane(s)
+     *
+     * ╲    last plane
+     */
+    type: LAYOUT_TYPES.FACE_TO_FACE;
+    /**
+     * Angle between the first plane and the last plane of a row.
+     *
+     * Value between `0.00` and `360.00`. Recommended between `0` and `180`.
+     *
+     * Default is `90`.
+     */
+    angle?: number;
+    /**
+     * Distance between columns.
+     *
+     * Value between `0.00` and `x.00` (floating numbers) indicating percent of view width
+     * or between `0` and `x0...0` (integers) indicating pixel values.
+     *
+     * For example:
+     * `0.5` is 50% of view width,
+     * `5` is five pixels,
+     * `1.00` is 100% of view width,
+     * `1` is one pixels,
+     * `1.35` is 135% of view width,
+     * `135` is 135 pixels.
+     */
+    gap?: number;
+    /**
+     * Integer value indicating the number of planes (columns) to be inserted in the middle.
+     *
+     * Default is `0`.
+     */
+    middle?: number;
+}
+interface LayoutZigZag extends Layout {
+    type: LAYOUT_TYPES.ZIG_ZAG;
+    /**
+     * Value between `0.00` and `360.00` and can be negative.
+     */
+    angle?: number;
+}
+interface LayoutSheaves extends Layout {
+    type: LAYOUT_TYPES.SHEAVES;
+    /**
+     * Value between `0.00` and `x.00` (floating numbers) or between `0` and `x00` (integers).
+     *
+     * The value is based on the current width of the screen and can be negative.
+     */
+    depth?: number;
+    /**
+     * Value between `0.00` and `x.00` (floating numbers) or between `0` and `x00` (integers).
+     *
+     * The value is based on the current width of the screen and can be negative.
+     */
+    offsetX?: number;
+    /**
+     * Value between `0.00` and `x.00` (floating numbers) or between `0` and `x00` (integers).
+     *
+     * The value is based on the current height of the screen and can be negative.
+     */
+    offsetY?: number;
+}
+type PluridLayout = LayoutColumns | LayoutRows | LayoutZigZag | LayoutFaceToFace | LayoutSheaves | LayoutMeta;
+
+declare const internationalizationFields: {
+    readonly viewcubeFront: "viewcubeFront";
+    readonly viewcubeBack: "viewcubeBack";
+    readonly viewcubeLeft: "viewcubeLeft";
+    readonly viewcubeRight: "viewcubeRight";
+    readonly viewcubeTop: "viewcubeTop";
+    readonly viewcubeBase: "viewcubeBase";
+    readonly toolbarTransformRotate: "toolbarTransformRotate";
+    readonly toolbarTransformScale: "toolbarTransformScale";
+    readonly toolbarTransformTranslate: "toolbarTransformTranslate";
+    readonly toolbarDrawerGlobalTitle: "toolbarDrawerGlobalTitle";
+    readonly toolbarDrawerGlobalGeneralTheme: "toolbarDrawerGlobalGeneralTheme";
+    readonly toolbarDrawerGlobalInteractionTheme: "toolbarDrawerGlobalInteractionTheme";
+    readonly toolbarDrawerGlobalLanguage: "toolbarDrawerGlobalLanguage";
+    readonly toolbarDrawerTransformTitle: "toolbarDrawerTransformTitle";
+    readonly toolbarDrawerTransformMultiModeTransform: "toolbarDrawerTransformMultiModeTransform";
+    readonly toolbarDrawerTransformAllowRotationX: "toolbarDrawerTransformAllowRotationX";
+    readonly toolbarDrawerTransformAllowRotationY: "toolbarDrawerTransformAllowRotationY";
+    readonly toolbarDrawerTransformAllowTranslationX: "toolbarDrawerTransformAllowTranslationX";
+    readonly toolbarDrawerTransformAllowTranslationY: "toolbarDrawerTransformAllowTranslationY";
+    readonly toolbarDrawerTransformAllowTranslationZ: "toolbarDrawerTransformAllowTranslationZ";
+    readonly toolbarDrawerTransformAllowScale: "toolbarDrawerTransformAllowScale";
+    readonly toolbarDrawerTransformTouchTransform: "toolbarDrawerTransformTouchTransform";
+    readonly toolbarDrawerSpaceTitle: "toolbarDrawerSpaceTitle";
+    readonly toolbarDrawerSpaceTransparentUserInterface: "toolbarDrawerSpaceTransparentUserInterface";
+    readonly toolbarDrawerSpaceShowTransformOrigin: "toolbarDrawerSpaceShowTransformOrigin";
+    readonly toolbarDrawerSpaceTransformOriginSize: "toolbarDrawerSpaceTransformOriginSize";
+    readonly toolbarDrawerSpacePlaneOpacity: "toolbarDrawerSpacePlaneOpacity";
+    readonly toolbarDrawerSpaceLayoutType: "toolbarDrawerSpaceLayoutType";
+    readonly toolbarDrawerToolbarTitle: "toolbarDrawerToolbarTitle";
+    readonly toolbarDrawerToolbarAlwaysOpaque: "toolbarDrawerToolbarAlwaysOpaque";
+    readonly toolbarDrawerToolbarShowTransformIcons: "toolbarDrawerToolbarShowTransformIcons";
+    readonly toolbarDrawerToolbarShowTransformArrows: "toolbarDrawerToolbarShowTransformArrows";
+    readonly toolbarDrawerToolbarConcealToolbar: "toolbarDrawerToolbarConcealToolbar";
+    readonly toolbarDrawerViewcubeTitle: "toolbarDrawerViewcubeTitle";
+    readonly toolbarDrawerViewcubeShowViewcube: "toolbarDrawerViewcubeShowViewcube";
+    readonly toolbarDrawerViewcubeShowTransformButtons: "toolbarDrawerViewcubeShowTransformButtons";
+    readonly toolbarDrawerViewcubeAlwaysOpaque: "toolbarDrawerViewcubeAlwaysOpaque";
+    readonly toolbarDrawerViewcubeConcealViewcube: "toolbarDrawerViewcubeConcealViewcube";
+    readonly toolbarDrawerMinimapTitle: "toolbarDrawerMinimapTitle";
+    readonly toolbarDrawerMinimapShowMinimap: "toolbarDrawerMinimapShowMinimap";
+    readonly toolbarDrawerMinimapTransparent: "toolbarDrawerMinimapTransparent";
+    readonly toolbarDrawerTechnicalTitle: "toolbarDrawerTechnicalTitle";
+    readonly toolbarDrawerTechnicalCullingDistance: "toolbarDrawerTechnicalCullingDistance";
+    readonly toolbarDrawerShortcutsTitle: "toolbarDrawerShortcutsTitle";
+    readonly toolbarDrawerShortcutsToggleFirstPerson: "toolbarDrawerShortcutsToggleFirstPerson";
+    readonly toolbarDrawerShortcutsMoveForward: "toolbarDrawerShortcutsMoveForward";
+    readonly toolbarDrawerShortcutsMoveBackward: "toolbarDrawerShortcutsMoveBackward";
+    readonly toolbarDrawerShortcutsMoveLeft: "toolbarDrawerShortcutsMoveLeft";
+    readonly toolbarDrawerShortcutsMoveRight: "toolbarDrawerShortcutsMoveRight";
+    readonly toolbarDrawerShortcutsMoveUp: "toolbarDrawerShortcutsMoveUp";
+    readonly toolbarDrawerShortcutsMoveDown: "toolbarDrawerShortcutsMoveDown";
+    readonly toolbarDrawerShortcutsTurnLeft: "toolbarDrawerShortcutsTurnLeft";
+    readonly toolbarDrawerShortcutsTurnRight: "toolbarDrawerShortcutsTurnRight";
+    readonly toolbarDrawerShortcutsTurnUp: "toolbarDrawerShortcutsTurnUp";
+    readonly toolbarDrawerShortcutsTurnDown: "toolbarDrawerShortcutsTurnDown";
+    readonly toolbarDrawerShortcutsRotateUp: "toolbarDrawerShortcutsRotateUp";
+    readonly toolbarDrawerShortcutsRotateDown: "toolbarDrawerShortcutsRotateDown";
+    readonly toolbarDrawerShortcutsRotateLeft: "toolbarDrawerShortcutsRotateLeft";
+    readonly toolbarDrawerShortcutsRotateRight: "toolbarDrawerShortcutsRotateRight";
+    readonly toolbarDrawerShortcutsToggleRotate: "toolbarDrawerShortcutsToggleRotate";
+    readonly toolbarDrawerShortcutsTranslateUp: "toolbarDrawerShortcutsTranslateUp";
+    readonly toolbarDrawerShortcutsTranslateDown: "toolbarDrawerShortcutsTranslateDown";
+    readonly toolbarDrawerShortcutsTranslateLeft: "toolbarDrawerShortcutsTranslateLeft";
+    readonly toolbarDrawerShortcutsTranslateRight: "toolbarDrawerShortcutsTranslateRight";
+    readonly toolbarDrawerShortcutsTranslateIn: "toolbarDrawerShortcutsTranslateIn";
+    readonly toolbarDrawerShortcutsTranslateOut: "toolbarDrawerShortcutsTranslateOut";
+    readonly toolbarDrawerShortcutsToggleTranslate: "toolbarDrawerShortcutsToggleTranslate";
+    readonly toolbarDrawerShortcutsScaleUp: "toolbarDrawerShortcutsScaleUp";
+    readonly toolbarDrawerShortcutsScaleDown: "toolbarDrawerShortcutsScaleDown";
+    readonly toolbarDrawerShortcutsToggleScale: "toolbarDrawerShortcutsToggleScale";
+    readonly toolbarDrawerShortcutsFocusPlane: "toolbarDrawerShortcutsFocusPlane";
+    readonly toolbarDrawerShortcutsFocusParent: "toolbarDrawerShortcutsFocusParent";
+    readonly toolbarDrawerShortcutsRefreshPlane: "toolbarDrawerShortcutsRefreshPlane";
+    readonly toolbarDrawerShortcutsIsolatePlane: "toolbarDrawerShortcutsIsolatePlane";
+    readonly toolbarDrawerShortcutsOpenClosedPlane: "toolbarDrawerShortcutsOpenClosedPlane";
+    readonly toolbarDrawerShortcutsClosePlane: "toolbarDrawerShortcutsClosePlane";
+    readonly toolbarDrawerShortcutsPreviousRoot: "toolbarDrawerShortcutsPreviousRoot";
+    readonly toolbarDrawerShortcutsNextRoot: "toolbarDrawerShortcutsNextRoot";
+    readonly toolbarDrawerShortcutsFocusRoot: "toolbarDrawerShortcutsFocusRoot";
+    readonly toolbarDrawerShortcutsArrowOrScrollUp: "toolbarDrawerShortcutsArrowOrScrollUp";
+    readonly toolbarDrawerShortcutsArrowOrScrollDown: "toolbarDrawerShortcutsArrowOrScrollDown";
+    readonly toolbarDrawerShortcutsArrowOrScrollLeft: "toolbarDrawerShortcutsArrowOrScrollLeft";
+    readonly toolbarDrawerShortcutsArrowOrScrollRight: "toolbarDrawerShortcutsArrowOrScrollRight";
+};
+
+type InternationalizationChinese = 'chinese';
+type InternationalizationEnglish = 'english';
+type InternationalizationFrench = 'french';
+type InternationalizationGerman = 'german';
+type InternationalizationHindi = 'hindi';
+type InternationalizationItalian = 'italian';
+type InternationalizationJapanese = 'japanese';
+type InternationalizationRomanian = 'romanian';
+type InternationalizationRussian = 'russian';
+type InternationalizationSpanish = 'spanish';
+type InternationalizationLanguageType = InternationalizationChinese | InternationalizationEnglish | InternationalizationFrench | InternationalizationGerman | InternationalizationHindi | InternationalizationItalian | InternationalizationJapanese | InternationalizationRomanian | InternationalizationRussian | InternationalizationSpanish;
+type InternationalizationFields = typeof internationalizationFields;
+type InternationalizationFieldType = keyof InternationalizationFields;
+type Internationalization = Record<InternationalizationFieldType, string>;
+
+type PluridPartialConfiguration = RecursivePartial<PluridConfiguration>;
+/**
+ * A FLAT shorthand for the most common `PluridConfiguration` options, so consumers don't have to
+ * author the full 5-level nested object for everyday setup. Expanded + merged over the defaults by
+ * the engine's `definePluridConfiguration`. Everything is optional; anything not covered here can
+ * be supplied as a normal nested partial via `extend` (merged last, so it wins).
+ */
+interface FlatPluridConfiguration {
+    /** `global.theme` — a plurid theme name, or `{ general, interaction }`. */
+    theme?: ThemeName | PluridConfigurationTheme;
+    /** `global.micro` — render the space with NO engine elements (toolbar/viewcube/controls). */
+    micro?: boolean;
+    /** `global.transparentUI` — render the engine elements transparent. */
+    transparentUI?: boolean;
+    /** `global.language` — UI language. */
+    language?: InternationalizationLanguageType;
+    /** `space.layout` — the plane layout (e.g. `{ type: SPACE_LAYOUT.COLUMNS, columns: 3 }`). */
+    layout?: PluridLayout;
+    /** `space.perspective` — CSS perspective; recommended 1300–2000. */
+    perspective?: number;
+    /** `space.center` — center the camera on the first root. */
+    center?: boolean;
+    /** `space.firstPerson` — first-person ("fly") navigation. */
+    firstPerson?: boolean;
+    /** `space.collaboration` — opt in to the collaboration seam (publish/apply arrangement snapshots). */
+    collaboration?: boolean;
+    /** `space.undo` — record spatial undo/redo history. ON by default; set false to drop the middleware. */
+    undo?: boolean;
+    /** `space.viewpointURLWrite` — reflect the camera into the URL query param. */
+    viewpointURLWrite?: boolean;
+    /** `space.viewpointURLRestore` — restore the camera from the URL query param on load. */
+    viewpointURLRestore?: boolean;
+    /** `space.viewpointURLParam` — the viewpoint query-param name (default `v`). */
+    viewpointURLParam?: string;
+    /** `space.viewpointURLDebounce` — ms to coalesce URL writes during an orbit. */
+    viewpointURLDebounce?: number;
+    /** `space.timings` — tunable debounce windows (persist, viewpoint-change). */
+    timings?: PluridConfigurationSpaceTimings;
+    /** `space.gestures` — pointer-navigation sensitivities, drag threshold, momentum. */
+    gestures?: PluridConfigurationSpaceGestures;
+    /** `space.shortcuts` — disable / remap / extend the engine keyboard shortcuts. */
+    shortcuts?: PluridConfigurationSpaceShortcuts;
+    /** `space.bridge.length` — parent→child gap + rendered bridge length. */
+    bridgeLength?: number;
+    /** `space.bridge.planeAngle` — spawned child plane angle. */
+    bridgePlaneAngle?: number;
+    /** `space.transformLocks` — lock a subset of the transform axes. */
+    transformLocks?: RecursivePartial<PluridConfigurationSpaceTransformLocks>;
+    /** `space.opaque` — opaque space background. Default `true`. */
+    opaque?: boolean;
+    /** `space.camera` — ID of the root to point the camera at. */
+    camera?: string;
+    /** `space.transformOrigin` — show / size the transform-origin indicator. */
+    transformOrigin?: RecursivePartial<PluridConfigurationSpaceTransformOrigin>;
+    /** `space.transformMode` — restrict to one transform type, or all. */
+    transformMode?: keyof typeof TRANSFORM_MODES;
+    /** `space.transformMultimode` — allow multiple simultaneous transforms. */
+    transformMultimode?: boolean;
+    /** `space.transformTouch` — touch-gesture → transform mapping. */
+    transformTouch?: keyof typeof TRANSFORM_TOUCHES;
+    /** `space.cullingDistance` — distance beyond which planes are culled. */
+    cullingDistance?: number;
+    /** `space.fadeInTime` — plane fade-in duration (ms). */
+    fadeInTime?: number;
+    /** `elements.plane.width` — fraction of the viewport (≤1) or absolute px (>1). */
+    planeWidth?: number;
+    /** `elements.plane.opacity`. */
+    planeOpacity?: number;
+    /** `elements.plane.controls.show` — per-plane control buttons. */
+    planeControls?: boolean;
+    /** `elements.toolbar.show`. */
+    toolbar?: boolean;
+    /** `elements.viewcube.show`. */
+    viewcube?: boolean;
+    /** `elements.minimap.show` — the 2D top-down overview of the space. */
+    minimap?: boolean;
+    /** Escape hatch: a normal nested partial config, merged LAST (overrides the flat fields above). */
+    extend?: PluridPartialConfiguration;
+}
+interface PluridConfiguration {
+    global: PluridConfigurationGlobal;
+    elements: PluridConfigurationElements;
+    space: PluridConfigurationSpace;
+    network: PluridConfigurationNetwork;
+    development: PluridConfigurationDevelopment;
+}
+interface PluridConfigurationGlobal {
+    /**
+     * Renders the application without any elements
+     * (toolbar, viewcube, plane controls, switch, etc.).
+     */
+    micro: boolean;
+    /**
+     * A theme name based on plurid themes, https://meta.plurid.com/themes,
+     * or specific theme names/objects for `general` and for the `interaction` elements.
+     */
+    theme: ThemeName | PluridConfigurationTheme;
+    /**
+     * Supported languages:
+     *
+     * + `chinese`
+     * + `english`
+     * + `french`
+     * + `german`
+     * + `hindi`
+     * + `italian`
+     * + `japanese`
+     * + `romanian`
+     * + `russian`
+     * + `spanish`
+     *
+     */
+    language: InternationalizationLanguageType;
+    /**
+     * Render the elements transparent.
+     *
+     * Default: `false`.
+     */
+    transparentUI: boolean;
+    /**
+     * Render the view as a `plurid` space, or as a `legacy` web page.
+     *
+     * When setting to `legacy`, the `switch` configuration element (`elements.switch.show`)
+     * should also be set to `true`, allowing the user to switch from rendering types
+     * through the interface.
+     *
+     * Default: `plurid`.
+     */
+    render: 'plurid' | 'legacy';
+}
+interface PluridConfigurationTheme {
+    general: ThemeName | Theme;
+    interaction: ThemeName | Theme;
+}
+interface PluridConfigurationSpace {
+    layout: PluridLayout;
+    /**
+     * Perspective value. Recommended between 1300 and 2000.
+     *
+     * Default `2000`.
+     */
+    perspective: number;
+    /**
+     * Make the background of the `Plurid Space` opaque.
+     *
+     * Default `true`.
+     */
+    opaque: boolean;
+    /**
+     * ID of the `Plurid Root` on which to point the camera at.
+     */
+    camera?: string;
+    /**
+     * Centers the camera on the first `Plurid Root Page`,
+     * or, if camera is set, on the Root indicated by the camera.
+     */
+    center: boolean;
+    transformOrigin: PluridConfigurationSpaceTransformOrigin;
+    transformLocks: PluridConfigurationSpaceTransformLocks;
+    /**
+     * Allow only one type of transformation, or all of them.
+     */
+    transformMode: keyof typeof TRANSFORM_MODES;
+    /**
+     * Allow multiple types of transformations.
+     */
+    transformMultimode: boolean;
+    transformTouch: keyof typeof TRANSFORM_TOUCHES;
+    firstPerson: boolean;
+    /**
+     * Opt in to the collaboration seam: the engine publishes `space.collaborationMutation`
+     * snapshots when the shared arrangement changes and applies `space.applyRemoteMutation` from
+     * peers. Off by default — a single-user app shouldn't broadcast mutations. The host wires the
+     * transport + presence.
+     *
+     * Default `false`.
+     */
+    collaboration?: boolean;
+    /**
+     * Record spatial undo/redo history (the arrangement-signature middleware). ON by default. Set
+     * `false` to drop the history middleware entirely — a host that owns its own undo, or one that
+     * never mutates the arrangement, pays neither the per-action signature cost nor the snapshot
+     * memory. When off, `space.undo` / `space.redo` (pubsub + shortcuts) are no-ops. Default `true`.
+     */
+    undo?: boolean;
+    /**
+     * Reflect the camera viewpoint into the URL query string on every change (so a view is
+     * shareable / bookmarkable). OFF by default — the engine does NOT touch the URL unless asked.
+     * Independent of `viewpointURLRestore`. Default `false`.
+     */
+    viewpointURLWrite?: boolean;
+    /**
+     * Restore the camera viewpoint FROM the URL query string on load (a deep-link wins over the
+     * last-saved camera). OFF by default. Independent of `viewpointURLWrite`. Default `false`.
+     */
+    viewpointURLRestore?: boolean;
+    /**
+     * The query-param name the viewpoint rides on, e.g. `?v=…`. Default `'v'`.
+     */
+    viewpointURLParam?: string;
+    /**
+     * Debounce (ms) before a changed viewpoint is written to the URL — the camera changes per frame
+     * during an orbit, so this coalesces the writes. Default `400`.
+     */
+    viewpointURLDebounce?: number;
+    /**
+     * Tunable debounce windows (persist, viewpoint-change). Each field defaults independently; see
+     * {@link PluridConfigurationSpaceTimings}.
+     */
+    timings?: PluridConfigurationSpaceTimings;
+    /**
+     * Tune pointer-navigation feel — sensitivities, drag threshold, momentum; see
+     * {@link PluridConfigurationSpaceGestures}. Read live by the gesture layer.
+     */
+    gestures?: PluridConfigurationSpaceGestures;
+    /**
+     * Disable / remap / extend the engine's keyboard shortcuts; see
+     * {@link PluridConfigurationSpaceShortcuts}.
+     */
+    shortcuts?: PluridConfigurationSpaceShortcuts;
+    cullingDistance: number;
+    /**
+     * Geometry of the bridge that joins a plurid-link-spawned child plane to its parent.
+     * `length` — the bridge depth (default 100); `planeAngle` — the child plane's angle
+     * off the parent in degrees (default 90).
+     */
+    bridge?: {
+        length?: number;
+        planeAngle?: number;
+    };
+    /**
+     * Time for the planes to fade in, in milliseconds.
+     *
+     * Default 1500
+     */
+    fadeInTime: number;
+}
+interface PluridConfigurationSpaceTransformOrigin {
+    show: boolean;
+    size: keyof typeof SIZES;
+}
+interface PluridConfigurationSpaceTransformLocks {
+    rotationX: boolean;
+    rotationY: boolean;
+    translationY: boolean;
+    translationX: boolean;
+    translationZ: boolean;
+    scale: boolean;
+}
+/**
+ * Stable IDs for the engine's keyboard shortcuts — the keys of `shortcuts.disabled` / `shortcuts.keymap`.
+ * `transformNudge` is the whole arrow-key transform group (rotate/translate/scale by step).
+ */
+type PluridShortcutID = 'undo' | 'clearSelection' | 'fitToView' | 'toggleFirstPerson' | 'modeRotation' | 'modeTranslation' | 'modeScale' | 'transformNudge' | 'focusPlane' | 'focusParent' | 'refreshPlane' | 'isolatePlane' | 'openClosedPlane' | 'closePlane' | 'focusPreviousRoot' | 'focusNextRoot' | 'cycleRoot' | 'focusRootIndex';
+/**
+ * Take control of the keyboard. `disabled` drops engine shortcuts (`true` = all, or specific IDs) so
+ * a host can claim those keys; `keymap` remaps a shortcut's primary `event.code` (single-key
+ * shortcuts only — not the `transformNudge` arrows); `onUnhandledKey` receives every keydown the
+ * engine did NOT consume, so a host extends with its own bindings without fighting the engine.
+ */
+interface PluridConfigurationSpaceShortcuts {
+    disabled?: boolean | PluridShortcutID[];
+    keymap?: Partial<Record<PluridShortcutID, string>>;
+    onUnhandledKey?: (event: KeyboardEvent) => void;
+}
+/**
+ * Tunable debounce windows (ms). The defaults coalesce per-frame churn during an orbit/zoom into a
+ * single trailing write/callback; raise them to persist/notify less often, lower them for snappier
+ * round-trips. Each field falls back to its default when omitted.
+ */
+interface PluridConfigurationSpaceTimings {
+    /** Debounce before the space snapshot is persisted after the state settles. Default `300`. */
+    persistDebounce?: number;
+    /** Debounce before `onViewpointChange` fires after the camera settles. Default `250`. */
+    viewpointChangeDebounce?: number;
+}
+/**
+ * Tune the feel of pointer navigation — sensitivities, the click-vs-orbit threshold, and the
+ * post-orbit momentum fling. Each field defaults independently (read live, so a host can retune
+ * mid-session); omit the object entirely to keep every default.
+ */
+interface PluridConfigurationSpaceGestures {
+    /** Orbit rotation sensitivity, degrees per pixel of drag. Default `0.22`. */
+    rotateSensitivity?: number;
+    /** Pan translation sensitivity, pixels per pixel of drag. Default `1`. */
+    translateSensitivity?: number;
+    /** Drag-to-scale sensitivity. Default `0.004`. */
+    scaleSensitivity?: number;
+    /** Two-pointer pinch-zoom sensitivity. Default `0.01`. */
+    pinchSensitivity?: number;
+    /**
+     * Fly-mode look sensitivity, degrees per pixel. Governs both drag-to-look (default `0.18`) and
+     * pointer-locked mouse-look (default `0.12`); set it to unify both.
+     */
+    flyLookSensitivity?: number;
+    /** Fly-mode planar move speed, pixels per frame (WASD). Default `9`. */
+    flySpeed?: number;
+    /** Pixels a press must travel before it becomes an orbit (below it stays a click). Default `4`. */
+    dragThreshold?: number;
+    /** Per-frame momentum velocity decay, 0–1 (lower = stops sooner). Default `0.92`. */
+    momentumDecay?: number;
+    /** Momentum halts once |velocity| drops below this. Default `0.05`. */
+    momentumMin?: number;
+    /** Disable the post-orbit momentum fling entirely (release stops dead). Default `false`. */
+    disableMomentum?: boolean;
+    /**
+     * Remap what each pointer input does in the default (ALL) transform mode — so a host can make
+     * left-drag orbit directly (no grab mode), claim left-drag for itself (`disabled`), or stop the
+     * wheel from zooming. Only consulted when set; omit to keep the CAD defaults (left orbits only in
+     * grab mode, middle / shift-drag pans, wheel zooms in grab / scale / ⌘). Does not affect the
+     * explicit rotate/translate/scale modes, selection-drag, or fly mode.
+     */
+    buttonMap?: PluridConfigurationSpaceGesturesButtonMap;
+}
+interface PluridConfigurationSpaceGesturesButtonMap {
+    /** Left-button drag. Default: orbit, but only while grab mode is on. */
+    left?: 'orbit' | 'pan' | 'zoom' | 'disabled';
+    /** Middle-button drag. Default: pan. */
+    middle?: 'orbit' | 'pan' | 'zoom' | 'disabled';
+    /** Wheel / trackpad. Default: zoom (in grab / scale / ⌘). `disabled` leaves scrolling to the page. */
+    wheel?: 'zoom' | 'disabled';
+}
+interface PluridConfigurationElements {
+    toolbar: PluridConfigurationElementsToolbar;
+    viewcube: PluridConfigurationElementsViewcube;
+    /** Optional opt-in: a 2D top-down overview/minimap of the space. */
+    minimap?: PluridConfigurationElementsMinimap;
+    plane: PluridConfigurationElementsPlane;
+    link: PluridConfigurationElementsLink;
+    switch: PluridConfigurationElementsSwitch;
+    /** The 3D beams drawn between plane↔plane links. Shown by default; `{ show: false }` hides them. */
+    planeLinks?: PluridConfigurationElementsToggle;
+    /** The live alignment guides drawn while dragging a selection. Shown by default. */
+    alignmentGuides?: PluridConfigurationElementsToggle;
+}
+/** A minimal `{ show }` toggle for elements whose only configuration is visibility. */
+interface PluridConfigurationElementsToggle {
+    show?: boolean;
+}
+interface PluridConfigurationElementsToolbar {
+    show: boolean;
+    opaque: boolean;
+    conceal: boolean;
+    transformIcons: boolean;
+    transformButtons: boolean;
+    drawers: (keyof typeof TOOLBAR_DRAWERS)[];
+    toggledDrawers: (keyof typeof TOOLBAR_DRAWERS)[];
+}
+interface PluridConfigurationElementsViewcube {
+    show: boolean;
+    opaque: boolean;
+    conceal: boolean;
+    /**
+     * Show the rotation arrow buttons, and the other buttons for translation, scale, and fit view.
+     */
+    buttons: boolean;
+}
+interface PluridConfigurationElementsMinimap {
+    show: boolean;
+    /** Transparent (see-through) by default, solid only on hover. */
+    transparent: boolean;
+}
+interface PluridConfigurationElementsPlane {
+    /**
+     * Value between `0.00` and `x.00` (floating numbers) or between `0` and `x00` (integers).
+     *
+     * The value is based on the current width of the screen and cannot be negative.
+     *
+     * `1` and `1.00` are based on screen width.
+     */
+    width: number;
+    /**
+     * Value between `0.00` and `1.00` (floating numbers).
+     *
+     * Default `1.00`.
+     */
+    opacity: number;
+    controls: PluridConfigurationElementsPlaneControls;
+}
+interface PluridConfigurationElementsPlaneControls {
+    show: boolean;
+    /**
+     * Show plane title.
+     */
+    title: boolean;
+    pathbar: PluridConfigurationElementsPlaneControlsPathbar;
+}
+interface PluridConfigurationElementsPlaneControlsPathbar {
+    /**
+     * If true, renders the page path in the controls as a domain URL.
+     */
+    domainURL: boolean;
+    /**
+     * Executed when the pathbar from the controls has an `change` event.
+     */
+    onChange?: (event: any, pageID: string) => void;
+    /**
+     * Executed when the pathbar from the controls has an `keyDown` event.
+     */
+    onKeyDown?: (event: any, pageID: string) => void;
+}
+interface PluridConfigurationElementsLink {
+    suffix: string;
+    preview: {
+        show: boolean;
+        fadeIn: number;
+        fadeOut: number;
+        offsetX: number;
+        offsetY: number;
+    };
+}
+interface PluridConfigurationElementsSwitch {
+    /**
+     * Default: `false`.
+     */
+    show: boolean;
+}
+interface PluridConfigurationNetwork {
+    /**
+     * Default `'https'`.
+     */
+    protocol: 'http' | 'https';
+    /**
+     * Defaults to the host serving the application (`window.location.host`)
+     * for the browser environment, and to `'originhost'` for server environments.
+     */
+    host: string;
+}
+interface PluridConfigurationDevelopment {
+    /**
+     * Show debugging information for each plane.
+     */
+    planeDebugger: boolean;
+    /**
+     * Show debugging information for the space.
+     */
+    spaceDebugger: boolean;
+}
+
+type CompareTypeEqual = '==';
+type CompareTypeEqualLessThan = '<=';
+type CompareTypeLessThan = '<';
+type CompareTypeEqualGreaterThan = '>=';
+type CompareTypeGreaterThan = '>';
+type CompareType = CompareTypeEqual | CompareTypeEqualLessThan | CompareTypeLessThan | CompareTypeEqualGreaterThan | CompareTypeGreaterThan;
+interface CompareTypes {
+    equal: CompareTypeEqual;
+    equalLessThan: CompareTypeEqualLessThan;
+    lessThan: CompareTypeLessThan;
+    equalGreaterThan: CompareTypeEqualGreaterThan;
+    greaterThan: CompareTypeGreaterThan;
+}
+
+type PluridRouteMultispaceAlignment = 'x' | 'y';
+type PluridRouteMultispaceSnapType = 'none' | 'mandatory' | 'proximity';
+interface PluridRouteMultispace<C> {
+    /**
+     * Default: `y`.
+     */
+    alignment?: PluridRouteMultispaceAlignment;
+    /**
+     * Default: `mandatory`.
+     */
+    snapType?: PluridRouteMultispaceSnapType;
+    header?: C;
+    footer?: C;
+}
+
+type PluridRouteResolver<C> = Omit<PluridRoute<C>, 'value' | 'resolver'>;
+/**
+ * A route can be `plurid space` or `exterior`-based.
+ */
+interface PluridRoute<C, G = any> {
+    /**
+     * The route `value` can:
+     * + be a simple string, e.g. `'/route/to/page'`;
+     * + be a parametric location, e.g. `'/route/to/:page'`, where `:page` is the parameter name;
+     * + receive query `key=value` pairs,
+     * e.g. `'/route/to/page?id=1&show=true'`, where `id=1` and `show=true` are `key=value` pairs;
+     */
+    value: string;
+    parameters?: Record<string, PluridRouteParameter>;
+    /**
+     * Accepts a component which will be rendered outside of the `spaces`.
+     */
+    exterior?: C;
+    /**
+     * A route can have planes and/or spaces.
+     */
+    planes?: PluridRoutePlane<C>[];
+    view?: string[];
+    /**
+     * A route can have planes and/or spaces.
+     */
+    spaces?: PluridRouteSpace<C>[];
+    /**
+     * Pass the rendered `spaces[]` components as a property to the `exterior` component
+     * to be rendered in particular slots.
+     */
+    slotted?: boolean;
+    multispace?: PluridRouteMultispace<C>;
+    defaultConfiguration?: PluridPartialConfiguration;
+    /**
+     * Resolve the route at request time.
+     *
+     * Receives the `globals` from the preserve, if any.
+     */
+    resolver?: (globals: G | undefined) => PluridRouteResolver<C> | Promise<PluridRouteResolver<C>>;
+}
+interface PluridRouteParameter {
+    /**
+     * Constrain the route parameter to be of a certain length.
+     */
+    length?: number;
+    /**
+     * Ensure that the `length` of the route parameter is of a certain type:
+     *
+     * * `'=='`     - equal,
+     * * `'<='`     - equal or less than,
+     * * `'<'`      - less than,
+     * * `'>='`     - equal or greater than,
+     * * `'>'`      - greater than.
+     *
+     * Default `'<='`, if a `length` is provided.
+     */
+    lengthType?: CompareType;
+    startsWith?: string;
+    endsWith?: string;
+    includes?: string[];
+}
+interface PluridRouteSpace<C> {
+    value: string;
+    /**
+     * Accepts a component which will be rendered outside of the `space`.
+     */
+    exterior?: C;
+    /**
+     * A space can have planes and/or universes.
+     */
+    planes?: PluridRoutePlane<C>[];
+    view?: string[];
+    /**
+     * A space can have planes and/or universes.
+     */
+    universes?: PluridRouteUniverse<C>[];
+    configuration?: PluridPartialConfiguration;
+}
+interface PluridRouteUniverse<C> {
+    value: string;
+    planes?: PluridRoutePlane<C>[];
+    view?: string[];
+    /**
+     * By default, the order the documents are shown in is based on their index in the `documents[]`.
+     * The ordinal can be used to overrule the default order.
+     * If not unique, the documents with equal `ordinal` will be ordered by index.
+     *
+     * 0-based.
+     */
+    ordinal?: number;
+    /**
+     * Set the document as active. By default the first document is active.
+     *
+     * Only one document can be active at a time.
+     */
+    active?: boolean;
+}
+interface PluridRoutePlaneOptions {
+    /**
+     * Map a direct link for a specific plane.
+     *
+     * e.g. `/plane-one` will route in browser the path `protocol://host/plane-one`
+     *
+     * Default composed from route and plane value, `/<route.value/<plane.value>`
+     */
+    link?: string;
+    /**
+     * On direct link access (from the browser), show the plane in a `plurid` space,
+     * or as the legacy view of an web page.
+     *
+     * Default `'plurid'`
+     */
+    linkView?: 'legacy' | 'plurid';
+    /**
+     * Injectable into other `plurid` spaces.
+     *
+     * Default `true`
+     */
+    injectable?: boolean;
+    /**
+     * Direct access to the plane from the browser.
+     *
+     * Default plane link composed from route and plane value, `/<route.value/<plane.value>`;
+     * changeable through the `link` property.
+     *
+     * Default `true`
+     */
+    urlable?: boolean;
+    /**
+     * Access to the plane through the `gateway` path.
+     *
+     * Default `true`
+     */
+    gateable?: boolean;
+    /**
+     * Render route exterior when directly accessed.
+     *
+     * Default `true`
+     */
+    directExterior?: boolean;
+    /**
+     * Render route exterior when injected into other `plurid` space.
+     *
+     * Default `false`
+     */
+    injectExterior?: boolean;
+    /**
+     * Constraints for the parameters.
+     */
+    parameters?: Record<string, PluridRouteParameter>;
+}
+interface PluridRoutePlaneObject<C> extends PluridRoutePlaneOptions {
+    value: string;
+    component: C;
+}
+type PluridRoutePlaneTuple<C> = [
+    /**
+     * See `PluridRoutePlaneObject<C>.value`.
+     */
+    value: string,
+    /**
+     * See `PluridRoutePlaneObject<C>.component`.
+     */
+    component: C,
+    options?: PluridRoutePlaneOptions
+];
+type PluridRoutePlane<C> = PluridRoutePlaneObject<C> | PluridRoutePlaneTuple<C>;
+
+interface PluridRouteFragments {
+    texts: PluridRouteFragmentText[];
+    elements: PluridRouteFragmentElement[];
+}
+interface PluridRouteFragment {
+    type: string;
+}
+interface PluridRouteFragmentText extends PluridRouteFragment {
+    type: 'text';
+    start: string;
+    end: string;
+    occurence: number;
+}
+interface PluridRouteFragmentElement extends PluridRouteFragment {
+    type: 'element';
+    id: string;
+    occurence: number;
+}
+
+interface PluridPreserve<M = any, RQ = any, RS = any> {
+    /**
+     * Served path value.
+     */
+    serve: string;
+    /**
+     * The function will be executed and awaited before rendering the application on the server.
+     *
+     * The function can return one or more providers which will be passed to their appropriate consumers,
+     * can redirect to a different path, or can handle any cross-cutting concerns, such as eventing or logging.
+     */
+    onServe: PluridPreserveOnServe<M, RQ, RS>;
+    /**
+     * Function called after route is served successfully.
+     */
+    afterServe?: PluridPreserveAfterServe<M, RQ, RS>;
+    /**
+     * Function called if `onServe` throws an error.
+     */
+    onError?: PluridPreserveOnError<M, RQ, RS>;
+}
+type PluridPreserveOnServe<M, RQ, RS> = (transmission: PluridPreserveTransmission<M, RQ, RS>) => Promise<PluridPreserveResponse | undefined>;
+type PluridPreserveAfterServe<M, RQ, RS> = (transmission: PluridPreserveTransmission<M, RQ, RS>) => Promise<undefined>;
+type PluridPreserveOnError<M, RQ, RS> = (error: any, transmission: PluridPreserveTransmission<M, RQ, RS>) => Promise<PluridPreserveResponse | undefined>;
+interface PluridPreserveTransmission<M, RQ, RS> {
+    context: PluridPreserveTransmissionContext<M>;
+    request: RQ;
+    response: RS;
+}
+interface PluridPreserveTransmissionContext<M = undefined> {
+    match: M;
+    route: string;
+}
+interface PluridPreserveResponse {
+    providers?: PluridPreserveResponseProviders;
+    /**
+     * Redirect to another route.
+     */
+    redirect?: string;
+    /**
+     * If `response` is handled within the preserve `action`, set the `responded` value to `true`,
+     * to prevent the server from sending a double response.
+     */
+    responded?: boolean;
+    /**
+     * Handle the server response without taking into account the preserve.
+     * Considers only the first match.
+     */
+    depreserve?: boolean;
+    /**
+     * Ignore the preserve computation, but continue to try to find a match in the preserves array.
+     * To be used with the catch-all matcher `'*'` or with complex routing with overlapping parameters.
+     */
+    pass?: boolean;
+    /**
+     * Key-value pairs which will be inserted as globals on the window as in
+     * `window.${key} = ${value}`.
+     */
+    globals?: Record<string, string>;
+    template?: PluridPreserveResponseTemplate;
+}
+type PluridPreserveResponseProviders = Record<string, any>;
+interface PluridPreserveResponseTemplate {
+    htmlLanguage?: string;
+    htmlAttributes?: Record<string, string>;
+    bodyAttributes?: Record<string, string>;
+    headScripts?: string[];
+    bodyScripts?: string[];
+    styles?: string[];
+}
+
+interface PluridRouterProperties<C> {
+    routes: PluridRoute<C>[];
+    /**
+     * Plurid planes not specific to any route.
+     */
+    planes?: PluridRoutePlane<C>[];
+    /**
+     * Component to be rendered outside of the current `path` component and of the `shell`.
+     */
+    exterior?: C;
+    /**
+     * Component to wrap around the current path component.
+     */
+    shell?: C;
+    /**
+     * Path to navigate to when using clean navigation.
+     */
+    view?: string;
+    /**
+     * Navigate without changing the browser URL.
+     */
+    cleanNavigation?: boolean;
+    /**
+     * Development default: 'http'.
+     * Production default: 'https'.
+     */
+    protocol?: string;
+    /**
+     * Default: `'origin'` | `window.location.host`.
+     */
+    hostname?: string;
+    /**
+     * The `gatewayPath` is used to receive external routing requests.
+     *
+     * e.g.
+     *
+     * `https://example.com/gateway?plurid=https://subdomain.example.com://path/to/123://s://u://c://a-plane`
+     *
+     * will route to that specific
+     *
+     * `host://path://space://universe://cluster://plane`
+     */
+    gatewayPath?: string;
+    /**
+     * Component to be rendered on the gateway path, external to the plurid view.
+     */
+    gatewayExterior?: C;
+    /**
+     * Redirect not found paths to this path.
+     * Default: `/not-found`.
+     */
+    notFoundPath?: string;
+    /**
+     * API endpoint to request the elements for the paths not found in the initial routing.
+     */
+    api?: string;
+    static?: PluridRouterStatic;
+    /**
+     * Replace the internal plurid plane with a custom implementation.
+     */
+    customPlane?: C;
+    /**
+     * After router navigation scroll to the top.
+     *
+     * Default: `smooth`.
+     */
+    scrollToTop?: boolean | 'instant' | 'smooth';
+    /**
+     * Fade in from black, in milliseconds.
+     *
+     * Default: `10`
+     */
+    fadeIn?: number;
+}
+interface PluridRouterStatic {
+    path: string;
+    directPlane?: string;
+}
+
+interface TreePlane {
+    /**
+     * The application defined plane ID that is the source
+     */
+    sourceID: string;
+    planeID: string;
+    parentPlaneID?: string;
+    /**
+     * The full route string, adequately formatted
+     * <protocol>://<host>://<path>://<space>://universe://cluster://<plane>
+     */
+    route: string;
+    routeDivisions: RouteDivisions;
+    linkCoordinates?: LinkCoordinates;
+    height: number;
+    width: number;
+    location: TreePlaneLocation;
+    show: boolean;
+    children?: TreePlane[];
+    bridgeLength?: number;
+    planeAngle?: number;
+    /**
+     * Set when the user has dragged this plane to a manual position. The auto-layout then leaves it
+     * pinned (its `location` is carried across relayouts, like measured `width`/`height`) and arranges
+     * only the un-pinned planes around it. Persisted with the tree, so manual arrangement survives reload.
+     */
+    manuallyPositioned?: boolean;
+}
+/**
+ * An arbitrary directed relationship between two planes, independent of the parent→child tree.
+ * Links cross the tree (any plane may relate to any other), so they live in a SEPARATE adjacency
+ * list on space state — not on `TreePlane`. The engine treats `kind` opaquely (a product label).
+ */
+interface PlaneLink {
+    id: string;
+    sourcePlaneID: string;
+    targetPlaneID: string;
+    /** Opaque, product-defined relationship label (e.g. 'reference', 'mention'). */
+    kind?: string;
+    /** Where on each plane the edge attaches; defaults to the plane centre. */
+    sourceAnchor?: PlaneLinkAnchor;
+    targetAnchor?: PlaneLinkAnchor;
+}
+type PlaneLinkAnchor = 'center' | 'top' | 'bottom' | 'left' | 'right';
+interface RouteDivisions {
+    protocol: RouteHostProtocol;
+    host: RouteHostDivision;
+    path: RoutePathDivision;
+    space: RouteSpaceDivision;
+    universe: RouteUniverseDivision;
+    cluster: RouteClusterDivision;
+    plane: RoutePlaneDivision;
+    valid: boolean;
+}
+interface RouteDivision {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+}
+interface RouteHostProtocol {
+    value: string;
+    secure: boolean;
+}
+interface RouteHostDivision {
+    value: string;
+    controlled: boolean;
+}
+interface RoutePathDivision {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+}
+interface RouteSpaceDivision {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+}
+interface RouteUniverseDivision {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+}
+interface RouteClusterDivision {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+}
+interface RoutePlaneDivision {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+    fragments: PluridRouteFragments;
+}
+interface PathParameters {
+    [key: string]: string;
+}
+interface PathQuery {
+    [key: string]: string;
+}
+interface TreePlaneLocation {
+    translateX: number;
+    translateY: number;
+    translateZ: number;
+    rotateX: number;
+    rotateY: number;
+}
+interface SpaceLocation {
+    translationX: number;
+    translationY: number;
+    translationZ: number;
+    rotationX: number;
+    rotationY: number;
+    scale: number;
+}
+interface LocationCoordinates {
+    x: number;
+    y: number;
+    z: number;
+}
+interface LinkCoordinates {
+    x: number;
+    y: number;
+}
+interface TopPlanePoint {
+    x: number;
+    z: number;
+}
+
+interface Coordinates {
+    x: number;
+    y: number;
+    z: number;
+}
+interface ViewSize {
+    width: number;
+    height: number;
+}
+interface SpaceSize {
+    width: number;
+    height: number;
+    depth: number;
+    topCorner: {
+        x: number;
+        y: number;
+        z: number;
+    };
+}
+
+interface PluridState {
+    configuration: PluridConfiguration;
+    shortcuts: PluridStateShortcuts;
+    space: PluridStateSpace;
+    themes: PluridStateThemes;
+    ui: PluridStateUI;
+}
+interface PluridStateShortcuts {
+    global: boolean;
+}
+interface PluridStateSpace {
+    loading: boolean;
+    resolvedLayout: boolean;
+    animatedTransform: boolean;
+    transformTime: number;
+    scale: number;
+    rotationX: number;
+    rotationY: number;
+    translationX: number;
+    translationY: number;
+    translationZ: number;
+    transform: string;
+    tree: TreePlane[];
+    /** Arbitrary plane↔plane relationships, independent of the parent→child `tree`. */
+    links: PlaneLink[];
+    activeUniverseID: string;
+    camera: Coordinates;
+    viewSize: ViewSize;
+    spaceSize: SpaceSize;
+    view: PluridApplicationView;
+    culledView: PluridApplicationView;
+    activePlaneID: string;
+    isolatePlane: string;
+    lastClosedPlane: string;
+    /** Multi-selection working set — the planes the user has selected to act on as a group. */
+    selectedPlaneIDs: string[];
+    /** True while the selection is being drag-moved — drives the live alignment-guide overlay. */
+    draggingSelection: boolean;
+}
+interface PluridStateThemes {
+    general: Theme;
+    interaction: Theme;
+}
+interface PluridStateUI {
+    toolbarScrollPosition: number;
+}
+
+interface PluridPlaneOptions {
+    /**
+     * Constraints for the parameters.
+     */
+    parameters?: Record<string, PluridRouteParameter>;
+}
+interface PluridPlaneObject<C> extends PluridPlaneOptions {
+    /**
+     * Route to the plane, e.g. `/plane-1`. By convention, it starts with an '/'.
+     *
+     * The `route` can be
+     * + unassigned,
+     * + assigned,
+     * + absolute.
+     *
+     * The unassigned route respects the format
+     * `/plane` and will be automatically assigned
+     * to the `default` space, `default` universe, `default` cluster.
+     *
+     * The assigned path respects the format
+     * `/path://space://universe://cluster://plane`
+     * and it presupposes the given `protocol` and `host`.
+     *
+     * The absolute path respects the format
+     * `protocol://host://path://space://universe://cluster://plane`
+     * and is useful for cross-origins requests.
+     *
+     * The route can have parameters, e.g. `/plane/:id`.
+     *
+     * The parameter, in the example `id`,
+     * will be passed in the property `plurid.parameters` to the component,
+     * e.g. `componentProperties.plurid.route.plane.parameters.id`.
+     *
+     */
+    route: string;
+    /**
+     * Component to be rendered in the PluridPlane.
+     */
+    component: C;
+}
+type PluridPlaneTuple<C> = [
+    /**
+     * See `PluridPlaneObject<C>.route`.
+     */
+    route: string,
+    /**
+     * See `PluridPlaneObject<C>.component`.
+     */
+    component: C,
+    /**
+     * See `PluridPlaneOptions`.
+     */
+    options?: PluridPlaneOptions
+];
+type PluridPlane<C> = PluridPlaneObject<C> | PluridPlaneTuple<C>;
+type PluridPlaneContext<T> = any;
+interface RouteSegment {
+    [key: string]: any;
+}
+interface RegisteredPluridPlane<C> {
+    route: {
+        absolute: string;
+        fragments: PluridRouteFragments;
+        parameters: Record<string, string>;
+        query: Record<string, string>;
+    };
+    component: C;
+}
+
+interface PluridUniverse<C> {
+    value: string;
+    planes?: PluridPlane<C>[];
+    view?: string[];
+    /**
+     * By default, the order the documents are shown in is based on their index in the `documents[]`.
+     * The ordinal can be used to overrule the default order.
+     * If not unique, the documents with equal `ordinal` will be ordered by index.
+     *
+     * 0-based.
+     */
+    ordinal?: number;
+    /**
+     * Set the document as active. By default the first document is active.
+     *
+     * Only one document can be active at a time.
+     */
+    active?: boolean;
+}
+
+interface PluridView {
+    /**
+     * Route to a `PluridPlane`.
+     *
+     * The route can be URL-like, e.g. `'/plane/one?query=true'`,
+     * for a plane in the same space, or fully defined,
+     * e.g. `'protocol://host://path://space://universe://cluster://plane`.
+     */
+    plane: string;
+    /**
+     * By default, the order the planes are shown in is based on their index in the `view[]`.
+     * The ordinal can be used to overrule the default order.
+     * If not unique, the planes with equal `ordinal` will be ordered by index.
+     *
+     * 0-based.
+     */
+    ordinal?: number;
+}
+
+declare const PLURID_PUBSUB_TOPIC: {
+    readonly CONFIGURATION: "configuration";
+    readonly SPACE_ANIMATED_TRANSFORM: "space.animatedTransform";
+    readonly SPACE_ROTATE_UP: "space.rotateUp";
+    readonly SPACE_ROTATE_DOWN: "space.rotateDown";
+    readonly SPACE_ROTATE_LEFT: "space.rotateLeft";
+    readonly SPACE_ROTATE_RIGHT: "space.rotateRight";
+    readonly SPACE_ROTATE_X_WITH: "space.rotateXWith";
+    readonly SPACE_ROTATE_Y_WITH: "space.rotateYWith";
+    readonly SPACE_ROTATE_X_TO: "space.rotateXTo";
+    readonly SPACE_ROTATE_Y_TO: "space.rotateYTo";
+    readonly SPACE_TRANSLATE_UP: "space.translateUp";
+    readonly SPACE_TRANSLATE_DOWN: "space.translateDown";
+    readonly SPACE_TRANSLATE_LEFT: "space.translateLeft";
+    readonly SPACE_TRANSLATE_RIGHT: "space.translateRight";
+    readonly SPACE_TRANSLATE_X_WITH: "space.translateXWith";
+    readonly SPACE_TRANSLATE_Y_WITH: "space.translateYWith";
+    readonly SPACE_TRANSLATE_Z_WITH: "space.translateZWith";
+    readonly SPACE_TRANSLATE_X_TO: "space.translateXTo";
+    readonly SPACE_TRANSLATE_Y_TO: "space.translateYTo";
+    readonly SPACE_TRANSLATE_Z_TO: "space.translateZTo";
+    readonly SPACE_SCALE_UP: "space.scaleUp";
+    readonly SPACE_SCALE_DOWN: "space.scaleDown";
+    readonly SPACE_SCALE_WITH: "space.scaleWith";
+    readonly SPACE_TRANSFORM: "space.transform";
+    readonly VIEW_ADD_PLANE: "view.addPlane";
+    readonly VIEW_SET_PLANES: "view.setPlanes";
+    readonly VIEW_REMOVE_PLANE: "view.removePlane";
+    readonly NAVIGATE_TO_PLANE: "space.navigateToPlane";
+    readonly REFRESH_PLANE: "space.refreshPlane";
+    readonly ISOLATE_PLANE: "space.isolatePlane";
+    readonly OPEN_CLOSED_PLANE: "space.openClosedPlane";
+    readonly CLOSE_PLANE: "space.closePlane";
+    readonly PREVIOUS_ROOT: "space.previousRoot";
+    readonly NEXT_ROOT: "space.nextRoot";
+    readonly NAVIGATE_TO_ROOT: "space.navigateToRoot";
+    readonly ADD_PLANE_LINK: "space.addPlaneLink";
+    readonly REMOVE_PLANE_LINK: "space.removePlaneLink";
+    readonly SET_PLANE_LINKS: "space.setPlaneLinks";
+    readonly SET_SELECTION: "space.setSelection";
+    readonly TOGGLE_SELECTION: "space.toggleSelection";
+    readonly CLEAR_SELECTION: "space.clearSelection";
+    readonly COLLABORATION_MUTATION: "space.collaborationMutation";
+    readonly APPLY_REMOTE_MUTATION: "space.applyRemoteMutation";
+    /** Programmatic camera control: a host publishes an encoded viewpoint to move/jump the camera. */
+    readonly SET_VIEWPOINT: "space.setViewpoint";
+    readonly FIT_TO_VIEW: "space.fitToView";
+    readonly RESET_TRANSFORM: "space.resetTransform";
+    readonly UNDO: "space.undo";
+    readonly REDO: "space.redo";
+    readonly SET_TREE: "space.setTree";
+    /**
+     * The single engine→host OBSERVE channel: published as `{ kind, value }` whenever a watched slice
+     * changes (`selection`/`tree`/`links`/`activePlane`/`isolate`/`layoutResolved`/`loading`). One
+     * subscription covers all of them — finer than diffing snapshots, lighter than N topics.
+     */
+    readonly CHANGED: "space.changed";
+    readonly SET_PLANE_PATH: "plane.setPath";
+};
+type PluridPubSubTopic = typeof PLURID_PUBSUB_TOPIC;
+type PluridPubSubTopicKeys = keyof typeof PLURID_PUBSUB_TOPIC;
+type PluridPubSubTopicKeysType = typeof PLURID_PUBSUB_TOPIC[PluridPubSubTopicKeys];
+
+type PluridPubSubCallback<D = any> = (data: D) => void;
+interface PluridPubSubDataValueNumber {
+    value: number;
+}
+interface PluridPubSubDataValueString {
+    value: string;
+}
+interface PluridPubSubPublishMessageConfiguration {
+    topic: typeof PLURID_PUBSUB_TOPIC.CONFIGURATION;
+    data: PluridPartialConfiguration;
+}
+interface PluridPubSubSubscribeMessageConfiguration {
+    topic: typeof PLURID_PUBSUB_TOPIC.CONFIGURATION;
+    callback: PluridPubSubCallback<PluridPartialConfiguration>;
+}
+interface PluridPubSubPublishMessageSpaceAnimatedTransform {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ANIMATED_TRANSFORM;
+    data?: any;
+}
+interface PluridPubSubSubscribeMessageSpaceAnimatedTransform {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ANIMATED_TRANSFORM;
+    callback: PluridPubSubCallback<any>;
+}
+interface PluridPubSubPublishMessageSpaceRotateUp {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_UP;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceRotateDown {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_DOWN;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceRotateLeft {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_LEFT;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceRotateRight {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_RIGHT;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubSubscribeMessageSpaceRotateUp {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_UP;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceRotateDown {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_DOWN;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceRotateLeft {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_LEFT;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceRotateRight {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_RIGHT;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubPublishMessageSpaceRotateXWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_X_WITH;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceRotateYWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_Y_WITH;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubSubscribeMessageSpaceRotateXWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_X_WITH;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceRotateYWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_Y_WITH;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubPublishMessageSpaceRotateXTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_X_TO;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceRotateYTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_Y_TO;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubSubscribeMessageSpaceRotateXTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_X_TO;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceRotateYTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_ROTATE_Y_TO;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubPublishMessageSpaceTranslateUp {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_UP;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceTranslateDown {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_DOWN;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceTranslateLeft {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_LEFT;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceTranslateRight {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_RIGHT;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateUp {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_UP;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateDown {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_DOWN;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateLeft {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_LEFT;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateRight {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_RIGHT;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubPublishMessageSpaceTranslateXWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_X_WITH;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceTranslateYWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_Y_WITH;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceTranslateZWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_Z_WITH;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateXWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_X_WITH;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateYWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_Y_WITH;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateZWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_Z_WITH;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubPublishMessageSpaceTranslateXTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_X_TO;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceTranslateYTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_Y_TO;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceTranslateZTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_Z_TO;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateXTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_X_TO;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateYTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_Y_TO;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceTranslateZTo {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSLATE_Z_TO;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubPublishMessageSpaceScaleUp {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_SCALE_UP;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceScaleDown {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_SCALE_DOWN;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubPublishMessageSpaceScaleWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_SCALE_WITH;
+    data: PluridPubSubDataValueNumber;
+}
+interface PluridPubSubSubscribeMessageSpaceScaleUp {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_SCALE_UP;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceScaleDown {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_SCALE_DOWN;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface PluridPubSubSubscribeMessageSpaceScaleWith {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_SCALE_WITH;
+    callback: PluridPubSubCallback<PluridPubSubDataValueNumber>;
+}
+interface SpaceTransform {
+    rotationX: number;
+    rotationY: number;
+    translationX: number;
+    translationY: number;
+    translationZ: number;
+    scale: number;
+}
+interface PluridPubSubMessageSpaceTransformData {
+    value: Partial<SpaceTransform>;
+    internal?: boolean;
+}
+interface PluridPubSubPublishMessageSpaceTransform {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSFORM;
+    data?: PluridPubSubMessageSpaceTransformData;
+}
+interface PluridPubSubSubscribeMessageSpaceTransform {
+    topic: typeof PLURID_PUBSUB_TOPIC.SPACE_TRANSFORM;
+    callback: PluridPubSubCallback<PluridPubSubMessageSpaceTransformData>;
+}
+interface PluridPubSubMessageViewAddPlaneData {
+    plane: string;
+}
+interface PluridPubSubPublishMessageViewAddPlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.VIEW_ADD_PLANE;
+    data: PluridPubSubMessageViewAddPlaneData;
+}
+interface PluridPubSubSubscribeMessageViewAddPlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.VIEW_ADD_PLANE;
+    callback: PluridPubSubCallback<PluridPubSubMessageViewAddPlaneData>;
+}
+interface PluridPubSubMessageViewSetPlanesData {
+    view: string[];
+}
+interface PluridPubSubPublishMessageViewSetPlanes {
+    topic: typeof PLURID_PUBSUB_TOPIC.VIEW_SET_PLANES;
+    data?: PluridPubSubMessageViewSetPlanesData;
+}
+interface PluridPubSubSubscribeMessageViewSetPlanes {
+    topic: typeof PLURID_PUBSUB_TOPIC.VIEW_SET_PLANES;
+    callback: PluridPubSubCallback<PluridPubSubMessageViewSetPlanesData>;
+}
+interface PluridPubSubMessageViewRemovePlaneData {
+    plane: string;
+}
+interface PluridPubSubPublishMessageViewRemovePlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.VIEW_REMOVE_PLANE;
+    data: PluridPubSubMessageViewRemovePlaneData;
+}
+interface PluridPubSubSubscribeMessageViewRemovePlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.VIEW_REMOVE_PLANE;
+    callback: PluridPubSubCallback<PluridPubSubMessageViewRemovePlaneData>;
+}
+interface PluridPubSubMessageNavigateToPlane {
+    id: string;
+}
+interface PluridPubSubPublishMessageNavigateToPlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.NAVIGATE_TO_PLANE;
+    data: PluridPubSubMessageNavigateToPlane;
+}
+interface PluridPubSubSubscribeMessageNavigateToPlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.NAVIGATE_TO_PLANE;
+    callback: PluridPubSubCallback<PluridPubSubMessageNavigateToPlane>;
+}
+interface PluridPubSubMessageRefreshPlane {
+    id: string;
+}
+interface PluridPubSubPublishMessageRefreshPlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.REFRESH_PLANE;
+    data: PluridPubSubMessageRefreshPlane;
+}
+interface PluridPubSubSubscribeMessageRefreshPlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.REFRESH_PLANE;
+    callback: PluridPubSubCallback<PluridPubSubMessageRefreshPlane>;
+}
+interface PluridPubSubMessageIsolatePlane {
+    id: string;
+}
+interface PluridPubSubPublishMessageIsolatePlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.ISOLATE_PLANE;
+    data: PluridPubSubMessageIsolatePlane;
+}
+interface PluridPubSubSubscribeMessageIsolatePlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.ISOLATE_PLANE;
+    callback: PluridPubSubCallback<PluridPubSubMessageIsolatePlane>;
+}
+interface PluridPubSubPublishMessageOpenClosedPlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.OPEN_CLOSED_PLANE;
+    data?: any;
+}
+interface PluridPubSubSubscribeMessageOpenClosedPlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.OPEN_CLOSED_PLANE;
+    callback: PluridPubSubCallback<any>;
+}
+interface PluridPubSubMessageClosePlane {
+    id: string;
+}
+interface PluridPubSubPublishMessageClosePlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.CLOSE_PLANE;
+    data: PluridPubSubMessageClosePlane;
+}
+interface PluridPubSubSubscribeMessageClosePlane {
+    topic: typeof PLURID_PUBSUB_TOPIC.CLOSE_PLANE;
+    callback: PluridPubSubCallback<PluridPubSubMessageClosePlane>;
+}
+interface PluridPubSubPublishMessagePreviousRoot {
+    topic: typeof PLURID_PUBSUB_TOPIC.PREVIOUS_ROOT;
+    data?: any;
+}
+interface PluridPubSubSubscribeMessagePreviousRoot {
+    topic: typeof PLURID_PUBSUB_TOPIC.PREVIOUS_ROOT;
+    callback: PluridPubSubCallback<any>;
+}
+interface PluridPubSubPublishMessageNextRoot {
+    topic: typeof PLURID_PUBSUB_TOPIC.NEXT_ROOT;
+    data?: any;
+}
+interface PluridPubSubSubscribeMessageNextRoot {
+    topic: typeof PLURID_PUBSUB_TOPIC.NEXT_ROOT;
+    callback: PluridPubSubCallback<any>;
+}
+type PluridPubSubMessageNavigateToRoot = {
+    index: number;
+} | {
+    id: string;
+};
+interface PluridPubSubPublishMessageNavigateToRoot {
+    topic: typeof PLURID_PUBSUB_TOPIC.NAVIGATE_TO_ROOT;
+    data: PluridPubSubMessageNavigateToRoot;
+}
+interface PluridPubSubSubscribeMessageNavigateToRoot {
+    topic: typeof PLURID_PUBSUB_TOPIC.NAVIGATE_TO_ROOT;
+    callback: PluridPubSubCallback<PluridPubSubMessageNavigateToRoot>;
+}
+type PluridPubSubMessageSetPlanePath = {
+    id: string;
+    value: string;
+};
+interface PluridPubSubPublishMessageSetPlanePath {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_PLANE_PATH;
+    data: PluridPubSubMessageSetPlanePath;
+}
+interface PluridPubSubSubscribeMessageSetPlanePath {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_PLANE_PATH;
+    callback: PluridPubSubCallback<PluridPubSubMessageSetPlanePath>;
+}
+interface PluridPubSubPublishMessageAddPlaneLink {
+    topic: typeof PLURID_PUBSUB_TOPIC.ADD_PLANE_LINK;
+    data: PlaneLink;
+}
+interface PluridPubSubSubscribeMessageAddPlaneLink {
+    topic: typeof PLURID_PUBSUB_TOPIC.ADD_PLANE_LINK;
+    callback: PluridPubSubCallback<PlaneLink>;
+}
+interface PluridPubSubMessageRemovePlaneLink {
+    id: string;
+}
+interface PluridPubSubPublishMessageRemovePlaneLink {
+    topic: typeof PLURID_PUBSUB_TOPIC.REMOVE_PLANE_LINK;
+    data: PluridPubSubMessageRemovePlaneLink;
+}
+interface PluridPubSubSubscribeMessageRemovePlaneLink {
+    topic: typeof PLURID_PUBSUB_TOPIC.REMOVE_PLANE_LINK;
+    callback: PluridPubSubCallback<PluridPubSubMessageRemovePlaneLink>;
+}
+interface PluridPubSubMessageSetPlaneLinks {
+    links: PlaneLink[];
+}
+interface PluridPubSubPublishMessageSetPlaneLinks {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_PLANE_LINKS;
+    data: PluridPubSubMessageSetPlaneLinks;
+}
+interface PluridPubSubSubscribeMessageSetPlaneLinks {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_PLANE_LINKS;
+    callback: PluridPubSubCallback<PluridPubSubMessageSetPlaneLinks>;
+}
+interface PluridPubSubMessageSetSelection {
+    ids: string[];
+}
+interface PluridPubSubPublishMessageSetSelection {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_SELECTION;
+    data: PluridPubSubMessageSetSelection;
+}
+interface PluridPubSubSubscribeMessageSetSelection {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_SELECTION;
+    callback: PluridPubSubCallback<PluridPubSubMessageSetSelection>;
+}
+interface PluridPubSubMessageToggleSelection {
+    id: string;
+}
+interface PluridPubSubPublishMessageToggleSelection {
+    topic: typeof PLURID_PUBSUB_TOPIC.TOGGLE_SELECTION;
+    data: PluridPubSubMessageToggleSelection;
+}
+interface PluridPubSubSubscribeMessageToggleSelection {
+    topic: typeof PLURID_PUBSUB_TOPIC.TOGGLE_SELECTION;
+    callback: PluridPubSubCallback<PluridPubSubMessageToggleSelection>;
+}
+interface PluridPubSubPublishMessageClearSelection {
+    topic: typeof PLURID_PUBSUB_TOPIC.CLEAR_SELECTION;
+    data?: any;
+}
+interface PluridPubSubSubscribeMessageClearSelection {
+    topic: typeof PLURID_PUBSUB_TOPIC.CLEAR_SELECTION;
+    callback: PluridPubSubCallback<any>;
+}
+/**
+ * A state-based snapshot of the SHARED arrangement (structure + manual positions via `tree`, and the
+ * link graph). The engine emits it on collaborative change; a peer applies it. (Op-based per-action
+ * mutations are a future enhancement on top of this seam.)
+ */
+interface PluridCollaborationSnapshot {
+    tree?: TreePlane[];
+    links?: PlaneLink[];
+}
+interface PluridPubSubPublishMessageCollaborationMutation {
+    topic: typeof PLURID_PUBSUB_TOPIC.COLLABORATION_MUTATION;
+    data: PluridCollaborationSnapshot;
+}
+interface PluridPubSubSubscribeMessageCollaborationMutation {
+    topic: typeof PLURID_PUBSUB_TOPIC.COLLABORATION_MUTATION;
+    callback: PluridPubSubCallback<PluridCollaborationSnapshot>;
+}
+interface PluridPubSubPublishMessageApplyRemoteMutation {
+    topic: typeof PLURID_PUBSUB_TOPIC.APPLY_REMOTE_MUTATION;
+    data: PluridCollaborationSnapshot;
+}
+interface PluridPubSubSubscribeMessageApplyRemoteMutation {
+    topic: typeof PLURID_PUBSUB_TOPIC.APPLY_REMOTE_MUTATION;
+    callback: PluridPubSubCallback<PluridCollaborationSnapshot>;
+}
+interface PluridPubSubMessageSetViewpoint {
+    /** An encoded viewpoint, e.g. the `v` value `rotationX,rotationY,tX,tY,tZ,scale`. */
+    viewpoint: string;
+    /** Smoothly animate the camera to it (vs jump instantly). Default `false`. */
+    animated?: boolean;
+}
+interface PluridPubSubPublishMessageSetViewpoint {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_VIEWPOINT;
+    data: PluridPubSubMessageSetViewpoint;
+}
+interface PluridPubSubSubscribeMessageSetViewpoint {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_VIEWPOINT;
+    callback: PluridPubSubCallback<PluridPubSubMessageSetViewpoint>;
+}
+interface PluridPubSubPublishMessageFitToView {
+    topic: typeof PLURID_PUBSUB_TOPIC.FIT_TO_VIEW;
+    data?: any;
+}
+interface PluridPubSubSubscribeMessageFitToView {
+    topic: typeof PLURID_PUBSUB_TOPIC.FIT_TO_VIEW;
+    callback: PluridPubSubCallback<any>;
+}
+interface PluridPubSubPublishMessageResetTransform {
+    topic: typeof PLURID_PUBSUB_TOPIC.RESET_TRANSFORM;
+    data?: any;
+}
+interface PluridPubSubSubscribeMessageResetTransform {
+    topic: typeof PLURID_PUBSUB_TOPIC.RESET_TRANSFORM;
+    callback: PluridPubSubCallback<any>;
+}
+interface PluridPubSubPublishMessageUndo {
+    topic: typeof PLURID_PUBSUB_TOPIC.UNDO;
+    data?: any;
+}
+interface PluridPubSubSubscribeMessageUndo {
+    topic: typeof PLURID_PUBSUB_TOPIC.UNDO;
+    callback: PluridPubSubCallback<any>;
+}
+interface PluridPubSubPublishMessageRedo {
+    topic: typeof PLURID_PUBSUB_TOPIC.REDO;
+    data?: any;
+}
+interface PluridPubSubSubscribeMessageRedo {
+    topic: typeof PLURID_PUBSUB_TOPIC.REDO;
+    callback: PluridPubSubCallback<any>;
+}
+interface PluridPubSubMessageSetTree {
+    tree: TreePlane[];
+}
+interface PluridPubSubPublishMessageSetTree {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_TREE;
+    data: PluridPubSubMessageSetTree;
+}
+interface PluridPubSubSubscribeMessageSetTree {
+    topic: typeof PLURID_PUBSUB_TOPIC.SET_TREE;
+    callback: PluridPubSubCallback<PluridPubSubMessageSetTree>;
+}
+type PluridChangeKind = 'selection' | 'tree' | 'links' | 'activePlane' | 'isolate' | 'layoutResolved' | 'loading';
+interface PluridPubSubMessageChanged {
+    kind: PluridChangeKind;
+    value: any;
+}
+interface PluridPubSubPublishMessageChanged {
+    topic: typeof PLURID_PUBSUB_TOPIC.CHANGED;
+    data: PluridPubSubMessageChanged;
+}
+interface PluridPubSubSubscribeMessageChanged {
+    topic: typeof PLURID_PUBSUB_TOPIC.CHANGED;
+    callback: PluridPubSubCallback<PluridPubSubMessageChanged>;
+}
+type PluridPubSubPublishMessage = PluridPubSubPublishMessageConfiguration | PluridPubSubPublishMessageSpaceAnimatedTransform | PluridPubSubPublishMessageSpaceRotateUp | PluridPubSubPublishMessageSpaceRotateDown | PluridPubSubPublishMessageSpaceRotateLeft | PluridPubSubPublishMessageSpaceRotateRight | PluridPubSubPublishMessageSpaceRotateXWith | PluridPubSubPublishMessageSpaceRotateYWith | PluridPubSubPublishMessageSpaceRotateXTo | PluridPubSubPublishMessageSpaceRotateYTo | PluridPubSubPublishMessageSpaceTranslateUp | PluridPubSubPublishMessageSpaceTranslateDown | PluridPubSubPublishMessageSpaceTranslateLeft | PluridPubSubPublishMessageSpaceTranslateRight | PluridPubSubPublishMessageSpaceTranslateXWith | PluridPubSubPublishMessageSpaceTranslateYWith | PluridPubSubPublishMessageSpaceTranslateZWith | PluridPubSubPublishMessageSpaceTranslateXTo | PluridPubSubPublishMessageSpaceTranslateYTo | PluridPubSubPublishMessageSpaceTranslateZTo | PluridPubSubPublishMessageSpaceScaleUp | PluridPubSubPublishMessageSpaceScaleDown | PluridPubSubPublishMessageSpaceScaleWith | PluridPubSubPublishMessageSpaceTransform | PluridPubSubPublishMessageViewAddPlane | PluridPubSubPublishMessageViewSetPlanes | PluridPubSubPublishMessageViewRemovePlane | PluridPubSubPublishMessageNavigateToPlane | PluridPubSubPublishMessageRefreshPlane | PluridPubSubPublishMessageIsolatePlane | PluridPubSubPublishMessageOpenClosedPlane | PluridPubSubPublishMessageClosePlane | PluridPubSubPublishMessagePreviousRoot | PluridPubSubPublishMessageNextRoot | PluridPubSubPublishMessageNavigateToRoot | PluridPubSubPublishMessageSetPlanePath | PluridPubSubPublishMessageAddPlaneLink | PluridPubSubPublishMessageRemovePlaneLink | PluridPubSubPublishMessageSetPlaneLinks | PluridPubSubPublishMessageSetSelection | PluridPubSubPublishMessageToggleSelection | PluridPubSubPublishMessageClearSelection | PluridPubSubPublishMessageCollaborationMutation | PluridPubSubPublishMessageApplyRemoteMutation | PluridPubSubPublishMessageSetViewpoint | PluridPubSubPublishMessageFitToView | PluridPubSubPublishMessageResetTransform | PluridPubSubPublishMessageUndo | PluridPubSubPublishMessageRedo | PluridPubSubPublishMessageSetTree | PluridPubSubPublishMessageChanged;
+type PluridPubSubSubscribeMessage = PluridPubSubSubscribeMessageConfiguration | PluridPubSubSubscribeMessageSpaceAnimatedTransform | PluridPubSubSubscribeMessageSpaceRotateUp | PluridPubSubSubscribeMessageSpaceRotateDown | PluridPubSubSubscribeMessageSpaceRotateLeft | PluridPubSubSubscribeMessageSpaceRotateRight | PluridPubSubSubscribeMessageSpaceRotateXWith | PluridPubSubSubscribeMessageSpaceRotateYWith | PluridPubSubSubscribeMessageSpaceRotateXTo | PluridPubSubSubscribeMessageSpaceRotateYTo | PluridPubSubSubscribeMessageSpaceTranslateUp | PluridPubSubSubscribeMessageSpaceTranslateDown | PluridPubSubSubscribeMessageSpaceTranslateLeft | PluridPubSubSubscribeMessageSpaceTranslateRight | PluridPubSubSubscribeMessageSpaceTranslateXWith | PluridPubSubSubscribeMessageSpaceTranslateYWith | PluridPubSubSubscribeMessageSpaceTranslateZWith | PluridPubSubSubscribeMessageSpaceTranslateXTo | PluridPubSubSubscribeMessageSpaceTranslateYTo | PluridPubSubSubscribeMessageSpaceTranslateZTo | PluridPubSubSubscribeMessageSpaceScaleUp | PluridPubSubSubscribeMessageSpaceScaleDown | PluridPubSubSubscribeMessageSpaceScaleWith | PluridPubSubSubscribeMessageSpaceTransform | PluridPubSubSubscribeMessageViewAddPlane | PluridPubSubSubscribeMessageViewSetPlanes | PluridPubSubSubscribeMessageViewRemovePlane | PluridPubSubSubscribeMessageNavigateToPlane | PluridPubSubSubscribeMessageRefreshPlane | PluridPubSubSubscribeMessageIsolatePlane | PluridPubSubSubscribeMessageOpenClosedPlane | PluridPubSubSubscribeMessageClosePlane | PluridPubSubSubscribeMessagePreviousRoot | PluridPubSubSubscribeMessageNextRoot | PluridPubSubSubscribeMessageNavigateToRoot | PluridPubSubSubscribeMessageSetPlanePath | PluridPubSubSubscribeMessageAddPlaneLink | PluridPubSubSubscribeMessageRemovePlaneLink | PluridPubSubSubscribeMessageSetPlaneLinks | PluridPubSubSubscribeMessageSetSelection | PluridPubSubSubscribeMessageToggleSelection | PluridPubSubSubscribeMessageClearSelection | PluridPubSubSubscribeMessageCollaborationMutation | PluridPubSubSubscribeMessageApplyRemoteMutation | PluridPubSubSubscribeMessageSetViewpoint | PluridPubSubSubscribeMessageFitToView | PluridPubSubSubscribeMessageResetTransform | PluridPubSubSubscribeMessageUndo | PluridPubSubSubscribeMessageRedo | PluridPubSubSubscribeMessageSetTree | PluridPubSubSubscribeMessageChanged;
+
+interface PluridPubSubOptions {
+    debug?: boolean;
+}
+interface PluridPubSub {
+    publish(message: PluridPubSubPublishMessage): void;
+    subscribe(message: PluridPubSubSubscribeMessage): string;
+    unsubscribe(selector: string): boolean;
+}
+
+interface PluridPlanesRegistrar<C> {
+    register(planes: PluridPlane<C>[]): void;
+    identify(): string[];
+    get(route: string): RegisteredPluridPlane<C> | undefined;
+    getAll(): Map<string, RegisteredPluridPlane<C>>;
+}
+
+interface IsoMatcherData<C> {
+    routes?: PluridRoute<C>[];
+    routePlanes?: PluridRoutePlane<C>[];
+    planes?: PluridPlane<C>[];
+}
+type IsoMatcherContext = 'route' | 'plane';
+interface IsoMatcherResultBase {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+}
+interface IsoMatcherRouteResultBase {
+    match: IsoMatcherResultBase;
+}
+interface IsoMatcherRouteResultRoute<C> extends IsoMatcherRouteResultBase {
+    kind: 'Route';
+    data: PluridRoute<C>;
+}
+interface IsoMatcherRouteResultRoutePlane<C> extends IsoMatcherRouteResultBase {
+    kind: 'RoutePlane';
+    data: PluridRoutePlaneObject<C>;
+}
+type IsoMatcherRouteResult<C> = IsoMatcherRouteResultRoute<C> | IsoMatcherRouteResultRoutePlane<C>;
+interface IsoMatcherIndexedRoute<C> {
+    data: PluridRoute<C>;
+}
+type IsoMatcherPlaneType = 'Plane' | 'RoutePlane';
+interface IsoMatcherPlaneResultMatch extends IsoMatcherResultBase {
+    fragments: PluridRouteFragments;
+}
+interface IsoMatcherPlaneResultBase<C> {
+    parent?: string;
+    match: IsoMatcherPlaneResultMatch;
+}
+interface IsoMatcherPlaneResultPlane<C> extends IsoMatcherPlaneResultBase<C> {
+    kind: 'Plane';
+    data: PluridPlaneObject<C>;
+}
+interface IsoMatcherPlaneResultRoutePlane<C> extends IsoMatcherPlaneResultBase<C> {
+    kind: 'RoutePlane';
+    data: PluridRoutePlaneObject<C>;
+}
+type IsoMatcherPlaneResult<C> = IsoMatcherPlaneResultPlane<C> | IsoMatcherPlaneResultRoutePlane<C>;
+type IsoMatcherResult<C> = IsoMatcherRouteResult<C> | IsoMatcherPlaneResult<C>;
+interface IsoMatcherIndexedPlaneBase<C> {
+    parent?: string;
+}
+interface IsoMatcherIndexedPlanePlane<C> extends IsoMatcherIndexedPlaneBase<C> {
+    kind: 'Plane';
+    data: PluridPlaneObject<C>;
+}
+interface IsoMatcherIndexedPlaneRoutePlane<C> extends IsoMatcherIndexedPlaneBase<C> {
+    kind: 'RoutePlane';
+    data: PluridRoutePlaneObject<C>;
+}
+type IsoMatcherIndexedPlane<C> = IsoMatcherIndexedPlanePlane<C> | IsoMatcherIndexedPlaneRoutePlane<C>;
+
+/**
+ * A pluggable key→string storage backend (Web Storage-shaped). Pass one as the `storageAdapter` prop
+ * to redirect ALL of plurid's persistence — the versioned space snapshot AND the opaque
+ * product-content blob — to sessionStorage, an in-memory map, a namespaced / encrypted wrapper, or a
+ * memory-mirrored IndexedDB, instead of the default `localStorage`. The engine keeps owning the
+ * serialization + versioning; the adapter only owns where the bytes land.
+ *
+ * `getItem` is read SYNCHRONOUSLY when the space snapshot seeds the first render, so a purely-async
+ * backend (raw IndexedDB) can't hydrate camera/tree on first paint — mirror it to memory, or restore
+ * asynchronously via the `onReady` store escape hatch. `setItem`/`removeItem` may return a promise:
+ * writes are fire-and-forget, plurid never awaits them.
+ */
+interface PluridStorageAdapter {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void | Promise<void>;
+    removeItem(key: string): void | Promise<void>;
+}
+/** Minimal Redux-store shape exposed on `PluridApi` — no `@reduxjs/toolkit` coupling in the data layer. */
+interface PluridStore {
+    getState(): PluridState;
+    dispatch(action: any): any;
+    subscribe(listener: () => void): () => void;
+}
+/**
+ * The imperative handle handed to `onReady` — the master escape hatch. With this a host can do
+ * ANYTHING the engine can: read any state, invoke any action, observe every change. Prefer the stable
+ * pubsub topics + the getters; reach for `store` only when you need something the seams don't expose.
+ */
+interface PluridApi {
+    /**
+     * The raw Redux store — read (`getState`), invoke (`dispatch` any action; the action creators are
+     * exported as `pluridStateModules`), and observe (`subscribe`). The internal action/state SHAPES are
+     * not a stable API — this is the deliberate power-user escape hatch.
+     */
+    store: PluridStore;
+    /** The instance pubsub bus — publish control topics, subscribe to the `space.*Changed` emit topics. */
+    pubsub: PluridPubSub;
+    /** Read the full current engine state synchronously. */
+    getSnapshot(): PluridState;
+    /** Read the current camera viewpoint as the encoded string (the same `v` value the URL/seam use). */
+    getViewpoint(): string;
+}
+interface PluridApplication<C> {
+    id?: string;
+    planesProperties?: Map<string, any>;
+    /**
+     * The planes which will be rendered by the `PluridApplication`.
+     */
+    planes?: PluridPlane<C>[];
+    /**
+     * Optional context for the plane to have access to.
+     */
+    planeContext?: PluridPlaneContext<any>;
+    /**
+     * Optional context initial value.
+     */
+    planeContextValue?: Record<string, any>;
+    /**
+     * Routes of the planes in view on the initial rendering.
+     */
+    view: PluridApplicationView;
+    /**
+     * Center the view on a plane from `view`.
+     */
+    centerView?: string;
+    /**
+     * The hostname of the server exposed to the internet, e.g. `example.com`,
+     * to be used in plurid plane links.
+     */
+    hostname?: string;
+    /**
+     * A `PluridApplication` must be either planes or universes based.
+     *
+     * A `PluridUniverse` is a collection of `PluridPlane`s.
+     */
+    universes?: PluridUniverse<C>[];
+    /**
+     * Show or not the default Plane Not Found component, or pass a custom component.
+     *
+     * Default `true`.
+     */
+    planeNotFound?: boolean | C;
+    /**
+     * Use or not Plurid Plane Error Boundary and show the default Plurid Plane Render Error component,
+     * or pass a custom component.
+     *
+     * Default `true`.
+     */
+    planeRenderError?: boolean | C;
+    /**
+     * Application-wide partial configuration.
+     */
+    configuration?: PluridPartialConfiguration;
+    /**
+     * Publish/Subscribe bus based on `@plurid/plurid-pubsub`.
+     */
+    pubsub?: PluridPubSub;
+    /**
+     * Render the application statically.
+     */
+    static?: boolean;
+    precomputedState?: Partial<PluridState>;
+    planesRegistrar?: PluridPlanesRegistrar<C>;
+    /**
+     * Save plurid application state to local storage,
+     * and load from local storage at startup.
+     *
+     * If multiple plurid applications run on the same origin,
+     * use the `id` property to differentiate between states.
+     *
+     * `LocalStorageUsage` differentiates between multiple local storages:
+     * for view, for user interface configuration.
+     */
+    useLocalStorage?: boolean;
+    /**
+     * Opt-in CONTENT seam (requires `useLocalStorage`). The engine persists the spatial state
+     * (camera + tree) itself; your *content* (e.g. note bodies) is yours — these callbacks let it
+     * ride the same debounced + `pagehide`-flushed localStorage, keyed by `id`, so you don't
+     * reinvent that machinery.
+     *
+     * `onPersistContent` is invoked on each persist tick; its return value is stored opaquely (the
+     * engine never inspects it — keep it JSON-serializable). `onRestoreContent` is invoked once,
+     * after mount, with the previously-stored value (omitted entirely if there is none). Version
+     * your own content shape inside the blob — the engine does not version it for you.
+     */
+    onPersistContent?: () => unknown;
+    onRestoreContent?: (content: unknown) => void;
+    /**
+     * Redirect ALL of plurid's persistence (the space snapshot + the `onPersistContent` blob) to a
+     * custom key→string backend instead of `localStorage` — sessionStorage, an in-memory map, a
+     * namespaced/encrypted wrapper, a memory-mirrored IndexedDB. Orthogonal to `useLocalStorage`,
+     * which still gates WHETHER persistence runs; this only changes WHERE. Default: `localStorage`.
+     */
+    storageAdapter?: PluridStorageAdapter;
+    /**
+     * Programmatic GET of the camera viewpoint: invoked (debounced) whenever the camera settles,
+     * with the ENCODED viewpoint string (the same `v` value the URL uses). Independent of the URL
+     * config — a host can wire its own share links / storage / sync with this + `space.setViewpoint`
+     * (to set) without the engine ever touching the URL.
+     */
+    onViewpointChange?: (viewpoint: string) => void;
+    /**
+     * The master escape hatch: invoked once after mount with a `PluridApi` ({ store, pubsub,
+     * getSnapshot, getViewpoint }). Lets a host that cares enough read any state, invoke any action,
+     * and observe every change — Plurid stays transparent, the dev stays in full control.
+     */
+    onReady?: (api: PluridApi) => void;
+    /**
+     * Replace the internal plurid plane with a custom implementation.
+     */
+    customPlane?: C;
+    /**
+     * Render-slots: return your own element to REPLACE an engine overlay (rendered at the same spot
+     * inside the view), or omit to keep the default. Orthogonal to the `elements.*.show` flags and
+     * `global.micro` (which HIDE the defaults) — these SUBSTITUTE. The slot is invoked on each render.
+     */
+    renderToolbar?: PluridRenderSlot;
+    renderViewcube?: PluridRenderSlot;
+    renderMinimap?: PluridRenderSlot;
+    renderShortcuts?: PluridRenderSlot;
+    matchedRoute?: IsoMatcherRouteResult<C>;
+    /**
+     * Used to identify the space if using `multispace`.
+     */
+    space?: string;
+}
+type PluridApplicationView = (string | PluridView)[];
+/**
+ * A render-slot — returns the element to render in place of an engine UI overlay. Typed loosely
+ * (`unknown`) to keep the data layer framework-agnostic; in React it is a `() => ReactNode`.
+ */
+type PluridRenderSlot = () => unknown;
+interface LocalStorageUsage {
+    view: boolean;
+    ui: boolean;
+}
+
+type ComponentWithPlurid<T, W> = T & WithPluridComponentProperty<W>;
+interface WithPluridComponentProperty<W> {
+    plurid: W;
+}
+type PlaneComponentWithPluridProperty<T> = ComponentWithPlurid<T, PluridPlaneComponentProperty>;
+type RouteComponentWithPluridProperty<T> = ComponentWithPlurid<T, PluridRouteComponentProperty>;
+interface PluridPlaneComponentProperty {
+    route: PluridRouteComponentProperty;
+    plane: PluridPlaneComponentPropertyPlane;
+    pubSub: PluridPubSub;
+}
+interface PluridPlaneComponentPropertyPlane {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+    fragments: PluridRouteFragments;
+    planeID: string;
+    parentPlaneID?: string;
+}
+interface PluridRouteComponentProperty {
+    value: string;
+    parameters: Record<string, string>;
+    query: Record<string, string>;
+}
+
+type KeyModifiers = 'SHIFT' | 'ALT' | 'CTRL' | 'META' | 'CTRLMETA';
+
+interface PluridLink<C, S, M> {
+    /**
+     * The route of the plane.
+     *
+     * If IDs are provided to the planes, the id of the plane.
+     *
+     * The route path can:
+     *
+     * * be a simple string,
+     * e.g. `'/route/to/plane'` or `'/d71b21673037485a'`,
+     * where `d71b21673037485a` is a generated plane ID;
+     *
+     * * be a parametric route,
+     * e.g. `'/route/to/:plane'`, where `:plane` is the parameter value
+     * for the parameter defined in the `PluridPage[]`;
+     *
+     * * receive query `key=value` pairs,
+     * e.g. `'/route/to/plane?id=1&show=true'`, where `id=1` and `show=true` are `key=value` pairs
+     *
+     * * specify a text fragment,
+     * e.g. `'/route/to/plane#:~:text=A%20door,is%20opened.,[0]'`,
+     * where the fragment `#:~:text=A%20door,is%20opened.,[0]`
+     * is loosely based on the https://github.com/WICG/ScrollToTextFragment specification,
+     * and indicates the link to bring into view the first occurence `[0]`, if any,
+     * of the text fragment starting with `A door` and ending with `is opened.`.
+     *
+     * * specify a page element,
+     * e.g. `'/route/to/plane#:~:element=123,[1]'`,
+     * where the fragment `#:~:element=123,[1]`
+     * indicates the link to bring into view the second occurence `[1]`, if any,
+     * of the element with the attribute `data-plurid-element=123`.
+     *
+     *
+     * ### Larger Syntax Structure
+     *
+     * The syntax `/plane` is used to reference only the plurid planes within the same plurid space.
+     *
+     * In order to reference
+     *
+     * + planes within other clusters,
+     * + planes within other universes,
+     * + planes within other spaces of the same route,
+     * + planes within other spaces of a different route,
+     * + planes within other spaces of a different, controlled origin,
+     * + planes within other spaces of a different, foreign origins,
+     *
+     * the syntax `://` has to be used.
+     *
+     *
+     * A plurid link in the same space, same universe, same cluster.
+     *
+     * `://plane`
+     *
+     * example: `://dashboard`
+     *
+     *
+     * A plurid link to another cluster in the same universe, in the same space.
+     *
+     * `://cluster://plane`
+     *
+     * example: `://two://dashboard`
+     *
+     *
+     * A plurid link to another universe in the same space.
+     *
+     * `://universe://cluster://page`
+     *
+     * example: `://one://two://dashboard`
+     *
+     *
+     * A plurid link to a different space within the same route
+     *
+     * `://space://universe://cluster://plane`
+     *
+     * example: `://user123://dashboard`
+     *
+     *
+     * A plurid link to a different space within an another route.
+     *
+     * `://route://space://universe://cluster://plane`
+     *
+     * example: `://payment://user123://dashboard`
+     *
+     *
+     * A plurid link to a different space within a controlled origin.
+     *
+     * `https://controlled-origin://route://space://universe://cluster://plane`
+     *
+     * example: `https://example-c.com://payment://user123://dashboard`
+     *
+     *
+     * A plurid link to a different space within a foreign origin.
+     *
+     * `https://foreign-origin://route://space://universe://cluster://plane`
+     *
+     * example: `https://example-f.com://payment://user123://dashboard`
+     *
+     *
+     * To handle clusters of clusters use the `|>` syntax, which shows a nesting of clusters,
+     * e.g. `://clusterC|>clusterB|>clusterA`,
+     * denotes that Cluster C includes Cluster B which includes Cluster A.
+     *
+     */
+    route: string;
+    /**
+     * Format the link as a simple anchor element. Default `false`.
+     */
+    devisible?: boolean;
+    /**
+     * String character to be added inline after the PluridLink content. The default is `'`.
+     *
+     * If `devisible` the suffix is disabled.
+     */
+    suffix?: string;
+    /**
+     * Execute function at click (onClick Event).
+     */
+    atClick?: (event?: MouseEvent | M) => void;
+    /**
+     * Show or not the default Not Found component, or pass a custom component
+     */
+    notFound?: boolean | C;
+    preview?: boolean;
+    previewFadeIn?: number;
+    previewFadeOut?: number;
+    previewOffsetX?: number;
+    previewOffsetY?: number;
+    previewComponent?: C;
+    style?: S;
+    className?: string;
+}
+
+type PluridMetastateState = Pick<PluridState, 'configuration' | 'space' | 'ui'>;
+interface PluridMetastate {
+    states: Record<string, PluridMetastateState>;
+}
+
+type PluridalWindow<C> = typeof window & {
+    __pluridPlanesRegistrar__: PluridPlanesRegistrar<C>;
+};
+
+interface PluridContext<C> {
+    planesRegistrar?: PluridPlanesRegistrar<C>;
+    planeContext?: PluridPlaneContext<any>;
+    planeContextValue?: any;
+    customPlane?: C;
+    planeNotFound?: boolean | C;
+    planeRenderError?: boolean | C;
+    matchedRoute?: IsoMatcherRouteResult<C> | undefined;
+    hostname?: string;
+    defaultPubSub: PluridPubSub;
+    registerPubSub: (pubsub: PluridPubSub) => void;
+}
+
+interface ShortcutName {
+    name: InternationalizationFieldType;
+    internationalizedKey?: boolean;
+    key: string;
+    modifier?: string | string[];
+}
+type ShortcutNamesTypes = keyof typeof SHORTCUTS;
+type ShortcutNames = Record<ShortcutNamesTypes, ShortcutName>;
+
+interface WheelDeltas {
+    deltaX: number;
+    deltaY: number;
+}
+interface TransformModes {
+    rotation: boolean;
+    translation: boolean;
+    scale: boolean;
+}
+
+declare const compareTypes: CompareTypes;
+
+declare const defaultConfigurationGlobal: PluridConfigurationGlobal;
+declare const defaultConfigurationElements: PluridConfigurationElements;
+declare const defaultConfigurationSpace: PluridConfigurationSpace;
+declare const defaultConfigurationNetwork: PluridConfigurationNetwork;
+declare const defaultConfigurationDevelopment: PluridConfigurationDevelopment;
+declare const defaultConfiguration: PluridConfiguration;
+declare const layoutNames: {
+    COLUMNS: string;
+    ROWS: string;
+    FACE_TO_FACE: string;
+    ZIG_ZAG: string;
+    SHEAVES: string;
+    META: string;
+};
+
+declare const PLURID_DEFAULT_CONFIGURATION_SPACE_CULLING_DISTANCE = 1500;
+declare const PLURID_DEFAULT_CONFIGURATION_LINK_SUFFIX = "'";
+declare const PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_SHOW = true;
+declare const PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_FADE_IN = 800;
+declare const PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_FADE_OUT = 400;
+declare const PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_OFFSET_X = 5;
+declare const PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_OFFSET_Y = 0;
+declare const PLURID_ROUTE_SEPARATOR = "://";
+declare const PLURID_ROUTE_DEFAULT = "default";
+declare const PLURID_ROUTE_DEFAULT_PATH_VALUE = "/";
+declare const PLURID_ROUTE_DEFAULT_PATH = "p";
+declare const PLURID_ROUTE_DEFAULT_SPACE_VALUE = "default";
+declare const PLURID_ROUTE_DEFAULT_SPACE = "s";
+declare const PLURID_ROUTE_DEFAULT_UNIVERSE_VALUE = "default";
+declare const PLURID_ROUTE_DEFAULT_UNIVERSE = "u";
+declare const PLURID_ROUTE_DEFAULT_CLUSTER_VALUE = "default";
+declare const PLURID_ROUTE_DEFAULT_CLUSTER = "c";
+declare const PLURID_DEFAULT_CONFIGURATION_NETWORK_HOST = "originhost";
+declare const PLURID_ROUTER_STORAGE = "__PLURID_ROUTER__";
+declare const PLURID_DEFAULT_RESIZE_DEBOUNCE_TIME = 50;
+declare const PLURID_DEFAULT_PREVENT_OVERSCROLL_TIMEOUT = 250;
+declare const PLURID_DEFAULT_ANIMATED_TRANSFORM_TIMEOUT = 500;
+
+declare const PLURID_ENTITY_VIEW = "PluridView";
+declare const PLURID_ENTITY_APPLICATION_CONFIGURATOR = "PluridApplicationConfigurator";
+declare const PLURID_ENTITY_TRANSFORM_ORIGIN = "PluridTransformOrigin";
+declare const PLURID_ENTITY_PLANE = "PluridPlane";
+declare const PLURID_ENTITY_PLANE_BRIDGE = "PluridPlaneBridge";
+declare const PLURID_ENTITY_PLANE_CONTROLS = "PluridPlaneControls";
+declare const PLURID_ENTITY_PLANE_CONTENT = "PluridPlaneContent";
+declare const PLURID_ENTITY_PLANE_CONFIGURATOR = "PluridPlaneConfigurator";
+declare const PLURID_ENTITY_PLANE_DEBUGGER = "PluridPlaneDebugger";
+declare const PLURID_ENTITY_LINK = "PluridLink";
+declare const PLURID_ENTITY_ROOT = "PluridRoot";
+declare const PLURID_ENTITY_ROOTS = "PluridRoots";
+declare const PLURID_ENTITY_PLANE_LINKS = "PluridPlaneLinks";
+declare const PLURID_ENTITY_ALIGNMENT_GUIDES = "PluridAlignmentGuides";
+declare const PLURID_ENTITY_SPACE = "PluridSpace";
+declare const PLURID_ENTITY_SPACE_DEBUGGER = "PluridSpaceDebugger";
+declare const PLURID_ENTITY_MULTISPACE = "PluridMultispace";
+declare const PLURID_ENTITY_TOOLBAR = "PluridToolbar";
+declare const PLURID_ENTITY_VIEWCUBE = "PluridViewcube";
+declare const PLURID_ENTITY_UNIVERSE_EXPLORER = "PluridUniverseExplorer";
+
+declare const PLURID_ROUTER_LOCATION_CHANGED = "pluridrouterlocationchanged";
+declare const PLURID_ROUTER_LOCATION_STORED = "pluridrouterlocationstored";
+
+declare const directions: {
+    left: string;
+    right: string;
+    up: string;
+    down: string;
+};
+
+declare const internationalization: {
+    chinese: Internationalization;
+    english: Internationalization;
+    french: Internationalization;
+    german: Internationalization;
+    hindi: Internationalization;
+    italian: Internationalization;
+    japanese: Internationalization;
+    romanian: Internationalization;
+    russian: Internationalization;
+    spanish: Internationalization;
+    fields: {
+        readonly viewcubeFront: "viewcubeFront";
+        readonly viewcubeBack: "viewcubeBack";
+        readonly viewcubeLeft: "viewcubeLeft";
+        readonly viewcubeRight: "viewcubeRight";
+        readonly viewcubeTop: "viewcubeTop";
+        readonly viewcubeBase: "viewcubeBase";
+        readonly toolbarTransformRotate: "toolbarTransformRotate";
+        readonly toolbarTransformScale: "toolbarTransformScale";
+        readonly toolbarTransformTranslate: "toolbarTransformTranslate";
+        readonly toolbarDrawerGlobalTitle: "toolbarDrawerGlobalTitle";
+        readonly toolbarDrawerGlobalGeneralTheme: "toolbarDrawerGlobalGeneralTheme";
+        readonly toolbarDrawerGlobalInteractionTheme: "toolbarDrawerGlobalInteractionTheme";
+        readonly toolbarDrawerGlobalLanguage: "toolbarDrawerGlobalLanguage";
+        readonly toolbarDrawerTransformTitle: "toolbarDrawerTransformTitle";
+        readonly toolbarDrawerTransformMultiModeTransform: "toolbarDrawerTransformMultiModeTransform";
+        readonly toolbarDrawerTransformAllowRotationX: "toolbarDrawerTransformAllowRotationX";
+        readonly toolbarDrawerTransformAllowRotationY: "toolbarDrawerTransformAllowRotationY";
+        readonly toolbarDrawerTransformAllowTranslationX: "toolbarDrawerTransformAllowTranslationX";
+        readonly toolbarDrawerTransformAllowTranslationY: "toolbarDrawerTransformAllowTranslationY";
+        readonly toolbarDrawerTransformAllowTranslationZ: "toolbarDrawerTransformAllowTranslationZ";
+        readonly toolbarDrawerTransformAllowScale: "toolbarDrawerTransformAllowScale";
+        readonly toolbarDrawerTransformTouchTransform: "toolbarDrawerTransformTouchTransform";
+        readonly toolbarDrawerSpaceTitle: "toolbarDrawerSpaceTitle";
+        readonly toolbarDrawerSpaceTransparentUserInterface: "toolbarDrawerSpaceTransparentUserInterface";
+        readonly toolbarDrawerSpaceShowTransformOrigin: "toolbarDrawerSpaceShowTransformOrigin";
+        readonly toolbarDrawerSpaceTransformOriginSize: "toolbarDrawerSpaceTransformOriginSize";
+        readonly toolbarDrawerSpacePlaneOpacity: "toolbarDrawerSpacePlaneOpacity";
+        readonly toolbarDrawerSpaceLayoutType: "toolbarDrawerSpaceLayoutType";
+        readonly toolbarDrawerToolbarTitle: "toolbarDrawerToolbarTitle";
+        readonly toolbarDrawerToolbarAlwaysOpaque: "toolbarDrawerToolbarAlwaysOpaque";
+        readonly toolbarDrawerToolbarShowTransformIcons: "toolbarDrawerToolbarShowTransformIcons";
+        readonly toolbarDrawerToolbarShowTransformArrows: "toolbarDrawerToolbarShowTransformArrows";
+        readonly toolbarDrawerToolbarConcealToolbar: "toolbarDrawerToolbarConcealToolbar";
+        readonly toolbarDrawerViewcubeTitle: "toolbarDrawerViewcubeTitle";
+        readonly toolbarDrawerViewcubeShowViewcube: "toolbarDrawerViewcubeShowViewcube";
+        readonly toolbarDrawerViewcubeShowTransformButtons: "toolbarDrawerViewcubeShowTransformButtons";
+        readonly toolbarDrawerViewcubeAlwaysOpaque: "toolbarDrawerViewcubeAlwaysOpaque";
+        readonly toolbarDrawerViewcubeConcealViewcube: "toolbarDrawerViewcubeConcealViewcube";
+        readonly toolbarDrawerMinimapTitle: "toolbarDrawerMinimapTitle";
+        readonly toolbarDrawerMinimapShowMinimap: "toolbarDrawerMinimapShowMinimap";
+        readonly toolbarDrawerMinimapTransparent: "toolbarDrawerMinimapTransparent";
+        readonly toolbarDrawerTechnicalTitle: "toolbarDrawerTechnicalTitle";
+        readonly toolbarDrawerTechnicalCullingDistance: "toolbarDrawerTechnicalCullingDistance";
+        readonly toolbarDrawerShortcutsTitle: "toolbarDrawerShortcutsTitle";
+        readonly toolbarDrawerShortcutsToggleFirstPerson: "toolbarDrawerShortcutsToggleFirstPerson";
+        readonly toolbarDrawerShortcutsMoveForward: "toolbarDrawerShortcutsMoveForward";
+        readonly toolbarDrawerShortcutsMoveBackward: "toolbarDrawerShortcutsMoveBackward";
+        readonly toolbarDrawerShortcutsMoveLeft: "toolbarDrawerShortcutsMoveLeft";
+        readonly toolbarDrawerShortcutsMoveRight: "toolbarDrawerShortcutsMoveRight";
+        readonly toolbarDrawerShortcutsMoveUp: "toolbarDrawerShortcutsMoveUp";
+        readonly toolbarDrawerShortcutsMoveDown: "toolbarDrawerShortcutsMoveDown";
+        readonly toolbarDrawerShortcutsTurnLeft: "toolbarDrawerShortcutsTurnLeft";
+        readonly toolbarDrawerShortcutsTurnRight: "toolbarDrawerShortcutsTurnRight";
+        readonly toolbarDrawerShortcutsTurnUp: "toolbarDrawerShortcutsTurnUp";
+        readonly toolbarDrawerShortcutsTurnDown: "toolbarDrawerShortcutsTurnDown";
+        readonly toolbarDrawerShortcutsRotateUp: "toolbarDrawerShortcutsRotateUp";
+        readonly toolbarDrawerShortcutsRotateDown: "toolbarDrawerShortcutsRotateDown";
+        readonly toolbarDrawerShortcutsRotateLeft: "toolbarDrawerShortcutsRotateLeft";
+        readonly toolbarDrawerShortcutsRotateRight: "toolbarDrawerShortcutsRotateRight";
+        readonly toolbarDrawerShortcutsToggleRotate: "toolbarDrawerShortcutsToggleRotate";
+        readonly toolbarDrawerShortcutsTranslateUp: "toolbarDrawerShortcutsTranslateUp";
+        readonly toolbarDrawerShortcutsTranslateDown: "toolbarDrawerShortcutsTranslateDown";
+        readonly toolbarDrawerShortcutsTranslateLeft: "toolbarDrawerShortcutsTranslateLeft";
+        readonly toolbarDrawerShortcutsTranslateRight: "toolbarDrawerShortcutsTranslateRight";
+        readonly toolbarDrawerShortcutsTranslateIn: "toolbarDrawerShortcutsTranslateIn";
+        readonly toolbarDrawerShortcutsTranslateOut: "toolbarDrawerShortcutsTranslateOut";
+        readonly toolbarDrawerShortcutsToggleTranslate: "toolbarDrawerShortcutsToggleTranslate";
+        readonly toolbarDrawerShortcutsScaleUp: "toolbarDrawerShortcutsScaleUp";
+        readonly toolbarDrawerShortcutsScaleDown: "toolbarDrawerShortcutsScaleDown";
+        readonly toolbarDrawerShortcutsToggleScale: "toolbarDrawerShortcutsToggleScale";
+        readonly toolbarDrawerShortcutsFocusPlane: "toolbarDrawerShortcutsFocusPlane";
+        readonly toolbarDrawerShortcutsFocusParent: "toolbarDrawerShortcutsFocusParent";
+        readonly toolbarDrawerShortcutsRefreshPlane: "toolbarDrawerShortcutsRefreshPlane";
+        readonly toolbarDrawerShortcutsIsolatePlane: "toolbarDrawerShortcutsIsolatePlane";
+        readonly toolbarDrawerShortcutsOpenClosedPlane: "toolbarDrawerShortcutsOpenClosedPlane";
+        readonly toolbarDrawerShortcutsClosePlane: "toolbarDrawerShortcutsClosePlane";
+        readonly toolbarDrawerShortcutsPreviousRoot: "toolbarDrawerShortcutsPreviousRoot";
+        readonly toolbarDrawerShortcutsNextRoot: "toolbarDrawerShortcutsNextRoot";
+        readonly toolbarDrawerShortcutsFocusRoot: "toolbarDrawerShortcutsFocusRoot";
+        readonly toolbarDrawerShortcutsArrowOrScrollUp: "toolbarDrawerShortcutsArrowOrScrollUp";
+        readonly toolbarDrawerShortcutsArrowOrScrollDown: "toolbarDrawerShortcutsArrowOrScrollDown";
+        readonly toolbarDrawerShortcutsArrowOrScrollLeft: "toolbarDrawerShortcutsArrowOrScrollLeft";
+        readonly toolbarDrawerShortcutsArrowOrScrollRight: "toolbarDrawerShortcutsArrowOrScrollRight";
+    };
+    languages: InternationalizationLanguageType[];
+};
+
+declare const keyModifiers: Record<KeyModifiers, string>;
+
+declare const PROTOCOL_SEPARATOR = "://";
+declare const HTTP_PROTOCOL = "http";
+declare const HTTPS_PROTOCOL = "https";
+declare const PLURID_PROTOCOL = "plurid";
+declare const protocols: {
+    http: string;
+    https: string;
+    plurid: string;
+};
+
+declare const shortcutsNames: ShortcutNames;
+declare const defaultShortcuts: ({
+    type: SHORTCUTS;
+    key: string;
+    modifier?: undefined;
+} | {
+    type: SHORTCUTS;
+    key: string;
+    modifier: KEY_MODIFIERS;
+} | {
+    type: SHORTCUTS;
+    key: string;
+    modifier: KEY_MODIFIERS[];
+})[];
+
+declare const ROTATION_STEP = 3.01;
+declare const TRANSLATION_STEP = 25;
+declare const SCALE_STEP = 0.05;
+declare const SCALE_LOWER_LIMIT = 0.1;
+declare const SCALE_UPPER_LIMIT = 4;
+declare const ROOTS_GAP = 50;
+declare const PLANE_DEFAULT_ANGLE = 90.1;
+declare const FOCUS_ANCHOR_SUFFIX = "-focus";
+
+declare const defaultTreePlane: TreePlane;
+
+export { type CompareType, type CompareTypeEqual, type CompareTypeEqualGreaterThan, type CompareTypeEqualLessThan, type CompareTypeGreaterThan, type CompareTypeLessThan, type CompareTypes, type ComponentWithPlurid, type Coordinates, FOCUS_ANCHOR_SUFFIX, type FlatPluridConfiguration, HTTPS_PROTOCOL, HTTP_PROTOCOL, type Identified, type Indexed, type Internationalization, type InternationalizationChinese, type InternationalizationEnglish, type InternationalizationFieldType, type InternationalizationFields, type InternationalizationFrench, type InternationalizationGerman, type InternationalizationHindi, type InternationalizationItalian, type InternationalizationJapanese, type InternationalizationLanguageType, type InternationalizationRomanian, type InternationalizationRussian, type InternationalizationSpanish, type IsoMatcherContext, type IsoMatcherData, type IsoMatcherIndexedPlane, type IsoMatcherIndexedPlaneBase, type IsoMatcherIndexedPlanePlane, type IsoMatcherIndexedPlaneRoutePlane, type IsoMatcherIndexedRoute, type IsoMatcherPlaneResult, type IsoMatcherPlaneResultBase, type IsoMatcherPlaneResultMatch, type IsoMatcherPlaneResultPlane, type IsoMatcherPlaneResultRoutePlane, type IsoMatcherPlaneType, type IsoMatcherResult, type IsoMatcherResultBase, type IsoMatcherRouteResult, type IsoMatcherRouteResultBase, type IsoMatcherRouteResultRoute, type IsoMatcherRouteResultRoutePlane, KEY_MODIFIERS, type KeyModifiers, LAYOUT_TYPES, type Layout, type LayoutColumns, type LayoutFaceToFace, type LayoutMeta, type LayoutMetaLayout, type LayoutRows, type LayoutSheaves, type LayoutZigZag, type LinkCoordinates, type LocalStorageUsage, type LocationCoordinates, PLANE_DEFAULT_ANGLE, PLURID_DEFAULT_ANIMATED_TRANSFORM_TIMEOUT, PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_FADE_IN, PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_FADE_OUT, PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_OFFSET_X, PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_OFFSET_Y, PLURID_DEFAULT_CONFIGURATION_LINK_PREVIEW_SHOW, PLURID_DEFAULT_CONFIGURATION_LINK_SUFFIX, PLURID_DEFAULT_CONFIGURATION_NETWORK_HOST, PLURID_DEFAULT_CONFIGURATION_SPACE_CULLING_DISTANCE, PLURID_DEFAULT_PREVENT_OVERSCROLL_TIMEOUT, PLURID_DEFAULT_RESIZE_DEBOUNCE_TIME, PLURID_ENTITY_ALIGNMENT_GUIDES, PLURID_ENTITY_APPLICATION_CONFIGURATOR, PLURID_ENTITY_LINK, PLURID_ENTITY_MULTISPACE, PLURID_ENTITY_PLANE, PLURID_ENTITY_PLANE_BRIDGE, PLURID_ENTITY_PLANE_CONFIGURATOR, PLURID_ENTITY_PLANE_CONTENT, PLURID_ENTITY_PLANE_CONTROLS, PLURID_ENTITY_PLANE_DEBUGGER, PLURID_ENTITY_PLANE_LINKS, PLURID_ENTITY_ROOT, PLURID_ENTITY_ROOTS, PLURID_ENTITY_SPACE, PLURID_ENTITY_SPACE_DEBUGGER, PLURID_ENTITY_TOOLBAR, PLURID_ENTITY_TRANSFORM_ORIGIN, PLURID_ENTITY_UNIVERSE_EXPLORER, PLURID_ENTITY_VIEW, PLURID_ENTITY_VIEWCUBE, PLURID_PROTOCOL, PLURID_PUBSUB_TOPIC, PLURID_ROUTER_LOCATION_CHANGED, PLURID_ROUTER_LOCATION_STORED, PLURID_ROUTER_STORAGE, PLURID_ROUTE_DEFAULT, PLURID_ROUTE_DEFAULT_CLUSTER, PLURID_ROUTE_DEFAULT_CLUSTER_VALUE, PLURID_ROUTE_DEFAULT_PATH, PLURID_ROUTE_DEFAULT_PATH_VALUE, PLURID_ROUTE_DEFAULT_SPACE, PLURID_ROUTE_DEFAULT_SPACE_VALUE, PLURID_ROUTE_DEFAULT_UNIVERSE, PLURID_ROUTE_DEFAULT_UNIVERSE_VALUE, PLURID_ROUTE_SEPARATOR, PROTOCOL_SEPARATOR, type PathParameters, type PathQuery, type PlaneComponentWithPluridProperty, type PlaneLink, type PlaneLinkAnchor, type PluridApi, type PluridApplication, type PluridApplicationView, type PluridChangeKind, type PluridCollaborationSnapshot, type PluridConfiguration, type PluridConfigurationDevelopment, type PluridConfigurationElements, type PluridConfigurationElementsLink, type PluridConfigurationElementsMinimap, type PluridConfigurationElementsPlane, type PluridConfigurationElementsPlaneControls, type PluridConfigurationElementsPlaneControlsPathbar, type PluridConfigurationElementsSwitch, type PluridConfigurationElementsToggle, type PluridConfigurationElementsToolbar, type PluridConfigurationElementsViewcube, type PluridConfigurationGlobal, type PluridConfigurationNetwork, type PluridConfigurationSpace, type PluridConfigurationSpaceGestures, type PluridConfigurationSpaceGesturesButtonMap, type PluridConfigurationSpaceShortcuts, type PluridConfigurationSpaceTimings, type PluridConfigurationSpaceTransformLocks, type PluridConfigurationSpaceTransformOrigin, type PluridConfigurationTheme, type PluridContext, type PluridLayout, type PluridLink, type PluridMetastate, type PluridMetastateState, type PluridPartialConfiguration, type PluridPlane, type PluridPlaneComponentProperty, type PluridPlaneComponentPropertyPlane, type PluridPlaneContext, type PluridPlaneObject, type PluridPlaneOptions, type PluridPlaneTuple, type PluridPlanesRegistrar, type PluridPreserve, type PluridPreserveAfterServe, type PluridPreserveOnError, type PluridPreserveOnServe, type PluridPreserveResponse, type PluridPreserveResponseProviders, type PluridPreserveResponseTemplate, type PluridPreserveTransmission, type PluridPreserveTransmissionContext, type PluridPubSub, type PluridPubSubCallback, type PluridPubSubDataValueNumber, type PluridPubSubDataValueString, type PluridPubSubMessageChanged, type PluridPubSubMessageClosePlane, type PluridPubSubMessageIsolatePlane, type PluridPubSubMessageNavigateToPlane, type PluridPubSubMessageNavigateToRoot, type PluridPubSubMessageRefreshPlane, type PluridPubSubMessageRemovePlaneLink, type PluridPubSubMessageSetPlaneLinks, type PluridPubSubMessageSetPlanePath, type PluridPubSubMessageSetSelection, type PluridPubSubMessageSetTree, type PluridPubSubMessageSetViewpoint, type PluridPubSubMessageSpaceTransformData, type PluridPubSubMessageToggleSelection, type PluridPubSubMessageViewAddPlaneData, type PluridPubSubMessageViewRemovePlaneData, type PluridPubSubMessageViewSetPlanesData, type PluridPubSubOptions, type PluridPubSubPublishMessage, type PluridPubSubPublishMessageAddPlaneLink, type PluridPubSubPublishMessageApplyRemoteMutation, type PluridPubSubPublishMessageChanged, type PluridPubSubPublishMessageClearSelection, type PluridPubSubPublishMessageClosePlane, type PluridPubSubPublishMessageCollaborationMutation, type PluridPubSubPublishMessageConfiguration, type PluridPubSubPublishMessageFitToView, type PluridPubSubPublishMessageIsolatePlane, type PluridPubSubPublishMessageNavigateToPlane, type PluridPubSubPublishMessageNavigateToRoot, type PluridPubSubPublishMessageNextRoot, type PluridPubSubPublishMessageOpenClosedPlane, type PluridPubSubPublishMessagePreviousRoot, type PluridPubSubPublishMessageRedo, type PluridPubSubPublishMessageRefreshPlane, type PluridPubSubPublishMessageRemovePlaneLink, type PluridPubSubPublishMessageResetTransform, type PluridPubSubPublishMessageSetPlaneLinks, type PluridPubSubPublishMessageSetPlanePath, type PluridPubSubPublishMessageSetSelection, type PluridPubSubPublishMessageSetTree, type PluridPubSubPublishMessageSetViewpoint, type PluridPubSubPublishMessageSpaceAnimatedTransform, type PluridPubSubPublishMessageSpaceRotateDown, type PluridPubSubPublishMessageSpaceRotateLeft, type PluridPubSubPublishMessageSpaceRotateRight, type PluridPubSubPublishMessageSpaceRotateUp, type PluridPubSubPublishMessageSpaceRotateXTo, type PluridPubSubPublishMessageSpaceRotateXWith, type PluridPubSubPublishMessageSpaceRotateYTo, type PluridPubSubPublishMessageSpaceRotateYWith, type PluridPubSubPublishMessageSpaceScaleDown, type PluridPubSubPublishMessageSpaceScaleUp, type PluridPubSubPublishMessageSpaceScaleWith, type PluridPubSubPublishMessageSpaceTransform, type PluridPubSubPublishMessageSpaceTranslateDown, type PluridPubSubPublishMessageSpaceTranslateLeft, type PluridPubSubPublishMessageSpaceTranslateRight, type PluridPubSubPublishMessageSpaceTranslateUp, type PluridPubSubPublishMessageSpaceTranslateXTo, type PluridPubSubPublishMessageSpaceTranslateXWith, type PluridPubSubPublishMessageSpaceTranslateYTo, type PluridPubSubPublishMessageSpaceTranslateYWith, type PluridPubSubPublishMessageSpaceTranslateZTo, type PluridPubSubPublishMessageSpaceTranslateZWith, type PluridPubSubPublishMessageToggleSelection, type PluridPubSubPublishMessageUndo, type PluridPubSubPublishMessageViewAddPlane, type PluridPubSubPublishMessageViewRemovePlane, type PluridPubSubPublishMessageViewSetPlanes, type PluridPubSubSubscribeMessage, type PluridPubSubSubscribeMessageAddPlaneLink, type PluridPubSubSubscribeMessageApplyRemoteMutation, type PluridPubSubSubscribeMessageChanged, type PluridPubSubSubscribeMessageClearSelection, type PluridPubSubSubscribeMessageClosePlane, type PluridPubSubSubscribeMessageCollaborationMutation, type PluridPubSubSubscribeMessageConfiguration, type PluridPubSubSubscribeMessageFitToView, type PluridPubSubSubscribeMessageIsolatePlane, type PluridPubSubSubscribeMessageNavigateToPlane, type PluridPubSubSubscribeMessageNavigateToRoot, type PluridPubSubSubscribeMessageNextRoot, type PluridPubSubSubscribeMessageOpenClosedPlane, type PluridPubSubSubscribeMessagePreviousRoot, type PluridPubSubSubscribeMessageRedo, type PluridPubSubSubscribeMessageRefreshPlane, type PluridPubSubSubscribeMessageRemovePlaneLink, type PluridPubSubSubscribeMessageResetTransform, type PluridPubSubSubscribeMessageSetPlaneLinks, type PluridPubSubSubscribeMessageSetPlanePath, type PluridPubSubSubscribeMessageSetSelection, type PluridPubSubSubscribeMessageSetTree, type PluridPubSubSubscribeMessageSetViewpoint, type PluridPubSubSubscribeMessageSpaceAnimatedTransform, type PluridPubSubSubscribeMessageSpaceRotateDown, type PluridPubSubSubscribeMessageSpaceRotateLeft, type PluridPubSubSubscribeMessageSpaceRotateRight, type PluridPubSubSubscribeMessageSpaceRotateUp, type PluridPubSubSubscribeMessageSpaceRotateXTo, type PluridPubSubSubscribeMessageSpaceRotateXWith, type PluridPubSubSubscribeMessageSpaceRotateYTo, type PluridPubSubSubscribeMessageSpaceRotateYWith, type PluridPubSubSubscribeMessageSpaceScaleDown, type PluridPubSubSubscribeMessageSpaceScaleUp, type PluridPubSubSubscribeMessageSpaceScaleWith, type PluridPubSubSubscribeMessageSpaceTransform, type PluridPubSubSubscribeMessageSpaceTranslateDown, type PluridPubSubSubscribeMessageSpaceTranslateLeft, type PluridPubSubSubscribeMessageSpaceTranslateRight, type PluridPubSubSubscribeMessageSpaceTranslateUp, type PluridPubSubSubscribeMessageSpaceTranslateXTo, type PluridPubSubSubscribeMessageSpaceTranslateXWith, type PluridPubSubSubscribeMessageSpaceTranslateYTo, type PluridPubSubSubscribeMessageSpaceTranslateYWith, type PluridPubSubSubscribeMessageSpaceTranslateZTo, type PluridPubSubSubscribeMessageSpaceTranslateZWith, type PluridPubSubSubscribeMessageToggleSelection, type PluridPubSubSubscribeMessageUndo, type PluridPubSubSubscribeMessageViewAddPlane, type PluridPubSubSubscribeMessageViewRemovePlane, type PluridPubSubSubscribeMessageViewSetPlanes, type PluridPubSubTopic, type PluridPubSubTopicKeys, type PluridPubSubTopicKeysType, type PluridRenderSlot, type PluridRoute, type PluridRouteComponentProperty, type PluridRouteFragment, type PluridRouteFragmentElement, type PluridRouteFragmentText, type PluridRouteFragments, type PluridRouteMultispace, type PluridRouteMultispaceAlignment, type PluridRouteMultispaceSnapType, type PluridRouteParameter, type PluridRoutePlane, type PluridRoutePlaneObject, type PluridRoutePlaneOptions, type PluridRoutePlaneTuple, type PluridRouteResolver, type PluridRouteSpace, type PluridRouteUniverse, type PluridRouterProperties, type PluridRouterStatic, type PluridShortcutID, type PluridState, type PluridStateShortcuts, type PluridStateSpace, type PluridStateThemes, type PluridStateUI, type PluridStorageAdapter, type PluridStore, type PluridUniverse, type PluridView, type PluridalWindow, ROOTS_GAP, ROTATION_STEP, type RecursivePartial, type RegisteredPluridPlane, type RouteClusterDivision, type RouteComponentWithPluridProperty, type RouteDivision, type RouteDivisions, type RouteHostDivision, type RouteHostProtocol, type RoutePathDivision, type RoutePlaneDivision, type RouteSegment, type RouteSpaceDivision, type RouteUniverseDivision, SCALE_LOWER_LIMIT, SCALE_STEP, SCALE_UPPER_LIMIT, SHORTCUTS, SIZES, type ShortcutName, type ShortcutNames, type ShortcutNamesTypes, type SpaceLocation, type SpaceSize, type SpaceTransform, TOOLBAR_DRAWERS, TRANSFORM_MODES, TRANSFORM_TOUCHES, TRANSLATION_STEP, type TopPlanePoint, type TransformModes, type TreePlane, type TreePlaneLocation, type ViewSize, type WheelDeltas, type WithID, type WithPluridComponentProperty, compareTypes, defaultConfiguration, defaultConfigurationDevelopment, defaultConfigurationElements, defaultConfigurationGlobal, defaultConfigurationNetwork, defaultConfigurationSpace, defaultShortcuts, defaultTreePlane, directions, internationalization, keyModifiers, layoutNames, protocols, shortcutsNames };