@vcmap/core 5.0.0-rc.26 → 5.0.0-rc.28

package/index.d.ts

@@ -2,18 +2,6 @@ import olFeature from 'ol/Feature';
 import Geometry from 'ol/geom/Geometry';
 import Style from 'ol/style/Style';
 
-export interface AppBackedCategoryOptions extends CategoryOptions {
-    collectionName: string;
-}
-
-export class AppBackedCategory extends Category<VcsObject> {
-    constructor(options: AppBackedCategoryOptions);
-    protected _deserializeItem(config: VcsObjectOptions): Promise<VcsObject>;
-    setApp(app: VcsApp): void;
-    serializeForContext(contextId: string): null;
-    toJSON(): AppBackedCategoryOptions;
-}
-
 /**
  */
 export interface CategoryOptions extends VcsObjectOptions {
@@ -30,7 +18,7 @@ export interface CategoryOptions extends VcsObjectOptions {
 /**
  * A category contains user based items and is a special container. The container should not be created directly, but via
  * the requestCategory API on the categories collection. Do not use toJSON to retrieve the state of a category, since
- * categories outlive contexts and may be changed with mergeOptions to no longer reflect your initial state. Requestors
+ * categories outlive modules and may be changed with mergeOptions to no longer reflect your initial state. Requestors
  * should keep track of the requested options themselves.
  */
 export class Category<T extends Object|VcsObject> extends VcsObject {
@@ -76,7 +64,7 @@ export class Category<T extends Object|VcsObject> extends VcsObject {
      */
     protected _deserializeItem(config: any): Promise<T>;
     protected _serializeItem(item: T): any;
-    serializeForContext(contextId: string): any | null;
+    serializeModule(moduleId: string): any | null;
     /**
      * unique Name
      */
@@ -99,7 +87,7 @@ export class CategoryCollection extends IndexedCollection<Category<Object|VcsObj
      * Parses the category items. Items will only be parsed, if a category with said name exists. Otherwise,
      * they will be cached, until such a category is requested.
      */
-    parseCategoryItems(name: string, items: object[], contextId: string): Promise<void>;
+    parseCategoryItems(name: string, items: object[], moduleId: string): Promise<void>;
     /**
      * Add categories with this API.
      */
@@ -151,39 +139,6 @@ export const categoryClassRegistry: ClassRegistry<Category<any>>;
  */
 export function getObjectFromClassRegistry<T extends Object|VcsObject>(classRegistry: OverrideClassRegistry<T> | ClassRegistry<T>, options: any, ...args: any[]): T | null;
 
-export interface VcsAppConfig {
-    id?: string | undefined;
-    layers?: LayerOptions[];
-    maps?: VcsMapOptions[];
-    styles?: StyleItemOptions[];
-    viewpoints?: ViewpointOptions[];
-    startingViewpointName?: string;
-    startingMapName?: string;
-    projection?: ProjectionOptions;
-    categories?: { name: string; items: object[]; }[];
-    obliqueCollections?: ObliqueCollectionOptions[];
-}
-
-/**
- * The id of the volatile context. Objects with this id shall never be serialized.
- */
-export const volatileContextId: string;
-
-/**
- * This marks an object as "volatile". This ensures, that an object added to the {@see VcsApp}
- * will never be serialized into a context, regardless of the current dynamic context. Typical use case is a scratch layer
- * which represents temporary features.
- * @param object - the object to mark as volatile
- */
-export function markVolatile(object: VcsObject | any): void;
-
-export class Context {
-    constructor(config: VcsAppConfig);
-    readonly id: string;
-    readonly checkSum: string;
-    readonly config: VcsAppConfig;
-}
-
 /**
  */
 export interface AbstractFeatureProviderOptions extends VcsObjectOptions {
@@ -560,9 +515,9 @@ export class EventHandler {
      * Add a dynamic interaction to the interaction chain. This is the default methodology for
      * user map interactions, such as drawing or measuring. If another exclusive interaction is added,
      * this interaction is removed and a provided callback is called. Use the id parameter to add multiple interactions
-     * from the same source (if you don't wish to provide an {@link InteractionChain}
+     * from the same source (if you don't wish to provide an {@link InteractionChain})
      * @param removed - the callback for when the interaction is forcefully removed.
-     * @param [index = 3] - the position at which to push the interaction
+     * @param [index] - the position at which to push the interaction. If no index is provided, the interaction is pushed at the end and therefore is executed last.
      * @param [id] - an id to allow for multiple interactions to belong to the same exclusive registerer
      * @returns function to remove the interaction with. returns number of removed interactions (0|1)
      */
@@ -2208,7 +2163,7 @@ export interface HiddenObject {
  * GlobalHider globally hides features existing within a layer of a {@link LayerCollection}.
  * Features can be defined as hidden by {@link VcsAppConfig} or {@link LayerOptions}.
  * Hiding will be performed, when a {@link Context} is loaded, a {@link Layer} is activated or GlobalHider API is called.
- * A feature can be hidden multiple times by different actors, e.g. contexts, layers, which is handled by this class.
+ * A feature can be hidden multiple times by different actors, e.g. modules, layers, which is handled by this class.
  * A feature will be shown again, when a {@link Context} is removed, a {@link Layer} is deactivated or GlobalHider API is called.
  */
 export class GlobalHider {
@@ -2256,6 +2211,10 @@ export interface VcsMeta extends VectorPropertiesOptions {
     screenSpaceError?: number | undefined;
     flightOptions?: any | undefined;
     baseUrl?: string | undefined;
+    /**
+     * the layers properties bag
+    */
+    layerProperties?: any | undefined;
 }
 
 /**
@@ -6302,15 +6261,15 @@ export class OverrideClassRegistry<T extends Object|VcsObject> {
     removed: VcsEvent<string>;
     getClassNames(): string[];
     /**
-     * Register a class for a given context by name. If the class already exists, it will be replaced and replaced called with the classeName.
+     * Register a class for a given module by name. If the class already exists, it will be replaced and replaced called with the classeName.
      */
-    registerClass(contextId: string, className: string, ctor: (...params: any[]) => any): void;
+    registerClass(moduleId: string, className: string, ctor: (...params: any[]) => any): void;
     /**
      * Unregister a previously registered class. You can only unregister classes added to this registry, not the underlying core registry.
      * If when registering this class you have replaced class, it will be re-instated and replaced called.
      * If there is no previously registered class, it will be removed and removed will be called.
      */
-    unregisterClass(contextId: string, className: string): void;
+    unregisterClass(moduleId: string, className: string): void;
     /**
      * Gets the constructor for a registered class or undefined, if no such class was registerd
      */
@@ -6327,10 +6286,10 @@ export class OverrideClassRegistry<T extends Object|VcsObject> {
      */
     createFromTypeOptions(options: any, ...args: any[]): T;
     /**
-     * Removes all classes registered from within a certain context. Will re-instate classes overwritten by the context
+     * Removes all classes registered from within a certain module. Will re-instate classes overwritten by the module
      * and call the appropriate events, outlined in unregisterClass.
      */
-    removeContext(contextId: string): void;
+    removeModule(moduleId: string): void;
     /**
      * Destroys the override class registry
      */
@@ -6348,6 +6307,10 @@ export interface ArcStyleOptions extends ArrowStyleOptions {
      * number of segments to interpolate the arc by
     */
     numberOfSegments?: number;
+    /**
+     * offset in m(mercator) from the arc end and arc start to the start/end points Is only rendered if offset * 2 < distance between start and endpoint
+    */
+    offset?: number;
 }
 
 /**
@@ -6377,6 +6340,7 @@ export const featureArcStruct: unique symbol;
 export class ArcStyle extends ArrowStyle {
     constructor(options?: ArcStyleOptions);
     numberOfSegments: any;
+    offset: any;
     arcFactor: any;
     primitiveOptions: VectorPropertiesPrimitiveOptions;
     end: ArrowEnd;
@@ -7086,33 +7050,58 @@ export function startCreateFeatureSession(app: VcsApp, layer: VectorLayer, geome
 /**
  */
 export interface EditFeaturesSession extends EditorSession {
-    featureSelection: SelectMultiFeatureInteraction;
     /**
      * read only access to the current mode
     */
     mode: TransformationMode;
+    /**
+     * Function for rotating features. Takes angle in radians as parameter.
+    */
+    rotate: (...params: any[]) => any;
+    /**
+     * Function for translating features. Takes Δx, Δy, Δz as parameters.
+    */
+    translate: (...params: any[]) => any;
+    /**
+     * Function for scaling features. Takes sx, sy as parameters.
+    */
+    scale: (...params: any[]) => any;
     setMode: (...params: any[]) => any;
     modeChanged: VcsEvent<TransformationMode>;
+    /**
+     * Sets the features for the edit session.
+    */
+    setFeatures: (...params: any[]) => any;
+    /**
+     * Gets the features of the edit session.
+    */
+    features: import("ol").Feature[];
 }
 
 /**
  * Creates an editor session to select, translate, rotate & scale the feature on a given layer
+ * @param [interactionId] - id for registering mutliple exclusive interaction. Needed to run a selection session at the same time as a edit features session.
  */
-export function startEditFeaturesSession(app: VcsApp, layer: VectorLayer, initialMode?: TransformationMode, highlightStyle?: import("ol/style").Style): EditFeaturesSession;
+export function startEditFeaturesSession(app: VcsApp, layer: VectorLayer, interactionId?: string, initialMode?: TransformationMode): EditFeaturesSession;
 
 /**
  */
 export interface EditGeometrySession extends EditorSession {
     /**
-     * the feature selection for this session.
+     * Sets the feature for the edit session.
+    */
+    setFeature: (...params: any[]) => any;
+    /**
+     * Gets the current feature of the edit session.
     */
-    featureSelection: SelectSingleFeatureInteraction;
+    feature: import("ol").Feature | null;
 }
 
 /**
  * Creates the edit geometry session.
+ * @param [interactionId] - id for registering mutliple exclusive interaction. Needed to run a selection session at the same time as a edit features session.
  */
-export function startEditGeometrySession(app: VcsApp, layer: VectorLayer): EditGeometrySession;
+export function startEditGeometrySession(app: VcsApp, layer: VectorLayer, interactionId?: string): EditGeometrySession;
 
 export function createVertex(coordinate: import("ol/coordinate").Coordinate): Vertex;
 
@@ -7173,7 +7162,8 @@ export interface EditorSession {
 export enum SessionType {
     CREATE,
     EDIT_GEOMETRY,
-    EDIT_FEATURES
+    EDIT_FEATURES,
+    SELECT
 }
 
 /**
@@ -7206,6 +7196,11 @@ export const vertexIndex: unique symbol;
  */
 export const handlerSymbol: unique symbol;
 
+/**
+ * Symbol to identify which was the last editor mouse over handler that edited the cursor style.
+ */
+export const mouseOverSymbol: unique symbol;
+
 
 
 /**
@@ -7349,14 +7344,8 @@ export class CreatePolygonInteraction extends AbstractInteraction implements Cre
 
 /**
  * A class to handle mouse over effects on features for editor sessions.
- * @param layerName - the layer name of the currently editing layer
  */
 export class EditFeaturesMouseOverInteraction extends AbstractInteraction {
-    constructor(layerName: string, selectMultiFeatureInteraction: SelectMultiFeatureInteraction);
-    /**
-     * The layer name to react to
-     */
-    layerName: string;
     cursorStyle: CSSStyleDeclaration;
     /**
      * Reset the cursorStyle to auto
@@ -7380,21 +7369,12 @@ export class EditFeaturesMouseOverInteraction extends AbstractInteraction {
     pointerKey: number;
 }
 
-/**
- * only exported for tests
- */
 export const cursorMap: any;
 
 /**
  * A class to handle mouse over effects on features for editor sessions.
- * @param layerName - the layer name of the currently editing layer
  */
 export class EditGeometryMouseOverInteraction extends AbstractInteraction {
-    constructor(layerName: string);
-    /**
-     * The layer name to react to
-     */
-    layerName: string;
     cursorStyle: CSSStyleDeclaration;
     /**
      * Reset the cursorStyle to auto
@@ -7422,9 +7402,10 @@ export class EditGeometryMouseOverInteraction extends AbstractInteraction {
  * This interaction ensure a potential handler is dragged in 3D when it is obscured by a transparent feature.
  * It uses drillPick on MOVE if: the map is 3D, there is a feature at said position, there is a feature selected in
  * the feature selection & the feature at the position is _not_ a handler
+ * @param selectedFeatures - Reference to the selected features.
  */
 export class EnsureHandlerSelectionInteraction {
-    constructor(selectMultiFeatureInteraction: SelectMultiFeatureInteraction);
+    constructor(selectedFeatures: import("ol").Feature[]);
     pipe(event: InteractionEvent): Promise<InteractionEvent>;
 }
 
@@ -7488,6 +7469,51 @@ export class RemoveVertexInteraction extends AbstractInteraction {
     pointerKey: number;
 }
 
+/**
+ * Enumeration of editor selection modes.
+ */
+export enum SelectionMode {
+    SINGLE,
+    MULTI
+}
+
+/**
+ * A class to handle mouse over effects on features for select sessions.
+ * @param layerName - Name of the layer for which the mouse over effect should accur.
+ * @param selectFeatureInteraction - The select feature interaction that handles the feature selection. Supports both, single and multi selection.
+ */
+export class SelectFeatureMouseOverInteraction extends AbstractInteraction {
+    constructor(layerName: string, selectFeatureInteraction: SelectSingleFeatureInteraction | SelectMultiFeatureInteraction);
+
+    selectionMode: SelectionMode;
+    /**
+     * The layer name to react to
+     */
+    layerName: string;
+    /**
+     * Reset the cursorStyle to auto
+     */
+    reset(): void;
+    /**
+     * A unique identifier for this interaction
+     */
+    id: string;
+    /**
+     * The current active bitmask for {@link EventType}
+     */
+    active: number;
+    /**
+     * The current active {@link ModificationKeyType}
+     */
+    modificationKey: number;
+    /**
+     * The currently active {@link PointerKeyType}
+     */
+    pointerKey: number;
+}
+
+
+
 /**
  * Interaction to create a selection set from the given layer.
  * Will use CTRL modifier key to add more features to the set.
@@ -7495,15 +7521,18 @@ export class RemoveVertexInteraction extends AbstractInteraction {
  * Creates a new set when clicking a feature
  * FeatureStore features will be converted to their dynamic state on selection.
  */
-export class SelectMultiFeatureInteraction extends AbstractInteraction {
+export class SelectMultiFeatureInteraction extends AbstractInteraction implements SelectFeatureInteraction {
     constructor(layer: VectorLayer);
     /**
      * Event raised when the feature selection changes. Will be called with an array of features or an empty array, when no feature is selected
      */
     readonly featuresChanged: VcsEvent<import("ol").Feature[]>;
-    selectedFeatures: any;
-    hasFeatureId(featureId: string): boolean;
-    setSelectionSet(features: (import("ol").Feature | import("@vcmap-cesium/engine").Cesium3DTileFeature | import("@vcmap-cesium/engine").Cesium3DTilePointFeature | import("@vcmap-cesium/engine").Entity)[]): Promise<void>;
+    selected: any;
+    /**
+     * Checks if a feature with a spicific id is selected.
+     */
+    hasFeatureId(id: string | number): boolean;
+    setSelected(features: (import("ol").Feature | import("@vcmap-cesium/engine").Cesium3DTileFeature | import("@vcmap-cesium/engine").Cesium3DTilePointFeature | import("@vcmap-cesium/engine").Entity)[] | import("ol").Feature | import("@vcmap-cesium/engine").Cesium3DTileFeature | import("@vcmap-cesium/engine").Cesium3DTilePointFeature | import("@vcmap-cesium/engine").Entity): Promise<void>;
     /**
      * Clears the interaction, removing all features and calling the featureChange event with an empty array
      */
@@ -7526,22 +7555,28 @@ export class SelectMultiFeatureInteraction extends AbstractInteraction {
     pointerKey: number;
 }
 
+
+
 /**
  * Class to select features for editing.
  * Static FeatureStore features will be converted into their dynamic form
  */
-export class SelectSingleFeatureInteraction extends AbstractInteraction {
+export class SelectSingleFeatureInteraction extends AbstractInteraction implements SelectFeatureInteraction {
     constructor(layer: VectorLayer);
     /**
      * Event called when the feature changes. Called with null if the selection is cleared.
      */
     featureChanged: VcsEvent<import("ol").Feature | null>;
-    selectedFeature: any;
+    selected: any;
     /**
      * Selects the given feature. if passed in a tiled feature store feature, it will be converted. Do not pass in uneditable features (feature which do not
      * belong to the layer for which this interaction was created)
      */
-    selectFeature(feature: import("ol").Feature | import("@vcmap-cesium/engine").Cesium3DTileFeature | import("@vcmap-cesium/engine").Cesium3DTilePointFeature): Promise<void>;
+    setSelected(feature: (import("ol").Feature | import("@vcmap-cesium/engine").Cesium3DTileFeature | import("@vcmap-cesium/engine").Cesium3DTilePointFeature | import("@vcmap-cesium/engine").Entity)[] | import("ol").Feature | import("@vcmap-cesium/engine").Cesium3DTileFeature | import("@vcmap-cesium/engine").Cesium3DTilePointFeature | import("@vcmap-cesium/engine").Entity): Promise<void>;
+    /**
+     * Checks if a feature with a spicific id is selected.
+     */
+    hasFeatureId(id: string | number): boolean;
     /**
      * Clears the current selection, if there is one.
      */
@@ -7588,6 +7623,52 @@ export class TranslateVertexInteraction extends AbstractInteraction {
     pointerKey: number;
 }
 
+/**
+ */
+export interface SelectionHighlightManager {
+    /**
+     * Currently highlighted features.
+    */
+    highlightedFeatures: import("ol").Feature[];
+    /**
+     * Sets the new features to be highlighted. All currently highlighted features that are not part of the new features are unhighlighted. Features that are not on the highlight layer are ignored.
+    */
+    update: (...params: any[]) => any;
+    /**
+     * Stops all listeners, unhighlights all features.
+    */
+    destroy: (...params: any[]) => any;
+}
+
+export function getDefaultHighlightStyle(): import("ol/style").Style;
+
+/**
+ */
+export interface SelectFeaturesSession extends EditorSession {
+    currentFeatures: import("ol").Feature[];
+    firstFeature: import("ol").Feature;
+    featuresChanged: VcsEvent<import("ol").Feature[]>;
+    mode: SelectionMode;
+    /**
+     * Sets the selection mode. Raises modeChanged event, throws error when invalid selection mode input.
+    */
+    setMode: (...params: any[]) => any;
+    modeChanged: VcsEvent<SelectionMode>;
+    /**
+     * Promise that resolves when features are set.
+    */
+    setCurrentFeatures: (...params: any[]) => any;
+    /**
+     * Deselects all features.
+    */
+    clearSelection: (...params: any[]) => any;
+}
+
+/**
+ * @param [interactionId] - id for registering mutliple exclusive interaction.
+ */
+export function startSelectFeaturesSession(app: VcsApp, layer: VectorLayer, interactionId?: string, initialMode?: SelectionMode, highlightStyle?: import("ol/style").Style): SelectFeaturesSession;
+
 /**
  * A class to handle events on a {@see TransformationHandler}. Should be used with {@see TransformationHandler} created for mode TransformationMode.EXTRUDE.
  * If the Z handler is dragged, the extruded event will be raised with a delta in Z direction. This
@@ -7737,6 +7818,10 @@ export interface TransformationHandler {
      * readonly value indicating whether the handlers are showing (proxy for: features are selected)
     */
     showing: boolean;
+    /**
+     * Sets transformation handle features. The handler is located in the center of the features.
+    */
+    setFeatures: (...params: any[]) => any;
     /**
      * destroy the handler and any resources created by it
     */
@@ -8028,6 +8113,11 @@ export class IndexedCollection<T extends any> extends Collection<T> {
     add(item: T, index?: number): number | null;
     remove(item: T): void;
     protected _move(item: T, itemIndex: number, targetIndex: number): number;
+    /**
+     * Moves an item to a provided index
+     * @returns the new index of the item
+     */
+    moveTo(item: T, targetIndex: number): number | null;
     /**
      * Lowers an item within the array
      * @param [steps = 1] - an integer number to lower by
@@ -8077,9 +8167,9 @@ export class LayerCollection extends IndexedCollection<Layer> {
      */
     readonly zIndexSymbol: symbol;
     /**
-     * Set global hider for these maps.
+     * The current global hider of these layers
      */
-    globalHider: any;
+    globalHider: GlobalHider;
     locale: any;
     /**
      * Adds a layer to the collection. Can optionally be passed an index at which to insert the layer.
@@ -8235,13 +8325,13 @@ export function getCartesianPitch(p1: import("ol/coordinate").Coordinate, p2: im
 export const isOverrideCollection: unique symbol;
 
 /**
- * @param getDynamicContextId - function to get the current dynamic context id
+ * @param getDynamicModuleId - function to get the current dynamic module id
  * @param [serializeItem] - optional function to serialize an item, defaults to returning item.toJSON or item: i => (i.toJSON || i)
  * @param [deserializeItem] - optional deserialization function. defaults to returning the passed object: i => i
  * @param [ctor] - optional constructor to validate deserialized items against. if passed, deserializeItem must be an instance of ctor.
  * @param [determineShadowIndex] - return the index where a shadow should be inserted. only has relevance, if the collection is indexed. previous and current index may be null.
  */
-export function makeOverrideCollection<T extends any>(collection: Collection<T>, getDynamicContextId: (...params: any[]) => any, serializeItem?: (...params: any[]) => any, deserializeItem?: (...params: any[]) => any, ctor?: any, determineShadowIndex?: ((...params: any[]) => any) | null): OverrideCollection<T>;
+export function makeOverrideCollection<T extends any>(collection: Collection<T>, getDynamicModuleId: (...params: any[]) => any, serializeItem?: (...params: any[]) => any, deserializeItem?: (...params: any[]) => any, ctor?: any, determineShadowIndex?: ((...params: any[]) => any) | null): OverrideCollection<T>;
 
 /**
  */
@@ -8487,7 +8577,7 @@ export class Viewpoint extends VcsObject {
     readonly className: string;
 }
 
-export const defaultDynamicContextId: string;
+export const defaultDynamicModuleId: string;
 
 export class VcsApp {
     readonly id: string;
@@ -8504,11 +8594,11 @@ export class VcsApp {
     readonly styles: OverrideCollection<StyleItem>;
     readonly categories: CategoryCollection;
     readonly destroyed: VcsEvent<void>;
-    readonly contexts: Context[];
-    readonly contextAdded: any;
-    readonly contextRemoved: any;
-    readonly dynamicContextId: string;
-    readonly dynamicContextIdChanged: VcsEvent<string>;
+    readonly modules: VcsModule[];
+    readonly moduleAdded: any;
+    readonly moduleRemoved: any;
+    readonly dynamicModuleId: string;
+    readonly dynamicModuleIdChanged: VcsEvent<string>;
     readonly mapClassRegistry: OverrideClassRegistry<VcsMap>;
     readonly layerClassRegistry: OverrideClassRegistry<Layer>;
     readonly styleClassRegistry: OverrideClassRegistry<StyleItem>;
@@ -8516,20 +8606,21 @@ export class VcsApp {
     readonly categoryItemClassRegistry: OverrideClassRegistry<any>;
     readonly tileProviderClassRegistry: OverrideClassRegistry<TileProvider>;
     readonly featureProviderClassRegistry: OverrideClassRegistry<AbstractFeatureProvider>;
-    getContextById(id: string): Context;
-    protected _parseContext(context: Context): Promise<void>;
-    protected _setContextState(context: Context): Promise<void>;
-    addContext(context: Context): Promise<void>;
+    getModuleById(id: string): VcsModule;
+    protected _parseModule(module: VcsModule): Promise<void>;
+    protected _setModuleState(module: VcsModule): Promise<void>;
+    addModule(module: VcsModule): Promise<void>;
+    serializeModule(moduleId: string): VcsModuleConfig;
     /**
-     * sets the given context as the dynamic
+     * sets the given module as the dynamic
      */
-    setDynamicContext(context: Context): void;
+    setDynamicModule(module: VcsModule): void;
     /**
-     * resets the dynamic Context to the "defaultDynamicContext"
+     * resets the dynamic VcsModule to the "defaultDynamicModule"
      */
-    resetDynamicContext(): void;
-    protected _removeContext(contextId: string): Promise<void>;
-    removeContext(contextId: string): Promise<void>;
+    resetDynamicModule(): void;
+    protected _removeModule(moduleId: string): Promise<void>;
+    removeModule(moduleId: string): Promise<void>;
     /**
      * Destroys the app and all its collections, their content and ui managers.
      */
@@ -8538,26 +8629,6 @@ export class VcsApp {
 
 export function getVcsAppById(id: string): VcsApp;
 
-export const contextIdSymbol: unique symbol;
-
-export interface ContextLayerOptions extends LayerOptions {
-    style?: string | StyleItemOptions;
-    tileProvider?: TileProviderOptions;
-    featureProvider?: AbstractFeatureProviderOptions;
-}
-
-export function deserializeMap(vcsApp: VcsApp, mapConfig: VcsMapOptions): VcsMap | null;
-
-export function deserializeViewpoint(viewpointObject: ViewpointOptions): null | Viewpoint;
-
-export function deserializeLayer(vcsApp: VcsApp, layerConfig: ContextLayerOptions): Layer | null;
-
-export function serializeLayer(vcsApp: VcsApp, layer: Layer): ContextLayerOptions;
-
-export function getLayerIndex(current: Layer, previous: Layer, currentIndex: number): number | null;
-
-export function destroyCollection(collection: Collection<any>): void;
-
 export class VcsEvent<T extends any> {
     /**
      * The number of listeners
@@ -8585,6 +8656,70 @@ export class VcsEvent<T extends any> {
     destroy(): void;
 }
 
+export interface VcsModuleConfig {
+
+    name?: string | undefined;
+    description?: string | undefined;
+    layers?: LayerOptions[];
+    maps?: VcsMapOptions[];
+    styles?: StyleItemOptions[];
+    viewpoints?: ViewpointOptions[];
+    startingViewpointName?: string;
+    startingMapName?: string;
+    projection?: ProjectionOptions;
+    categories?: { name: string; items: object[]; }[];
+    obliqueCollections?: ObliqueCollectionOptions[];
+}
+
+/**
+ * The id of the volatile module. Objects with this id shall never be serialized.
+ */
+export const volatileModuleId: string;
+
+/**
+ * This marks an object as "volatile". This ensures, that an object added to the {@see VcsApp}
+ * will never be serialized into a module, regardless of the current dynamic module. Typical use case is a scratch layer
+ * which represents temporary features.
+ * @param object - the object to mark as volatile
+ */
+export function markVolatile(object: VcsObject | any): void;
+
+export class VcsModule {
+    constructor(config: VcsModuleConfig);
+    name: string;
+    description: string;
+    startingViewpointName: string;
+    startingMapName: string;
+    projection: Projection | undefined;
+    readonly _id: string;
+    readonly config: VcsModuleConfig;
+    /**
+     * Sets the config object by serializing all runtime objects of the current app.
+     */
+    setConfigFromApp(app: VcsApp): void;
+    toJSON(): VcsModuleConfig;
+}
+
+export const moduleIdSymbol: unique symbol;
+
+export interface ModuleLayerOptions extends LayerOptions {
+    style?: string | StyleItemOptions;
+    tileProvider?: TileProviderOptions;
+    featureProvider?: AbstractFeatureProviderOptions;
+}
+
+export function deserializeMap(vcsApp: VcsApp, mapConfig: VcsMapOptions): VcsMap | null;
+
+export function deserializeViewpoint(viewpointObject: ViewpointOptions): null | Viewpoint;
+
+export function deserializeLayer(vcsApp: VcsApp, layerConfig: ModuleLayerOptions): Layer | null;
+
+export function serializeLayer(vcsApp: VcsApp, layer: Layer): ModuleLayerOptions;
+
+export function getLayerIndex(current: Layer, previous: Layer, currentIndex: number): number | null;
+
+export function destroyCollection(collection: Collection<any>): void;
+
 /**
  */
 export interface VcsObjectOptions {
@@ -8630,36 +8765,40 @@ export interface OverrideCollectionInterface<T extends any> {
     replaced: VcsEvent<ReplacedEvent<T>>;
     shadowMap: Map<string, object[]>;
     override: (item: T) => T;
-    parseItems: (items: object[], contextId: string) => Promise<void>;
-    removeContext: (contextId: string) => Promise<void>;
-    serializeContext: (contextId: string) => object[];
+    parseItems: (items: object[], moduleId: string) => Promise<void>;
+    getSerializedByKey: (key: string) => object;
+    removeModule: (moduleId: string) => Promise<void>;
+    serializeModule: (moduleId: string) => object[];
 }
 
 export class OverrideCollection<T extends any> extends Collection<T> implements OverrideCollectionInterface<T> {
     replaced: VcsEvent<ReplacedEvent<T>>;
     shadowMap: Map<string, object[]>;
     override: (item: T) => T;
-    parseItems: (items: object[], contextId: string) => Promise<void>;
-    removeContext: (contextId: string) => Promise<void>;
-    serializeContext: (contextId: string) => object[];
+    parseItems: (items: object[], moduleId: string) => Promise<void>;
+    getSerializedByKey: (key: string) => object;
+    removeModule: (moduleId: string) => Promise<void>;
+    serializeModule: (moduleId: string) => object[];
 }
 
 export class OverrideLayerCollection extends LayerCollection implements OverrideCollectionInterface<Layer> {
     replaced: VcsEvent<ReplacedEvent<Layer>>;
     shadowMap: Map<string, object[]>;
     override: (item: Layer) => Layer;
-    parseItems: (items: object[], contextId: string) => Promise<void>;
-    removeContext: (contextId: string) => Promise<void>;
-    serializeContext: (contextId: string) => object[];
+    parseItems: (items: object[], moduleId: string) => Promise<void>;
+    getSerializedByKey: (key: string) => object;
+    removeModule: (moduleId: string) => Promise<void>;
+    serializeModule: (moduleId: string) => object[];
 }
 
 export class OverrideMapCollection extends MapCollection implements OverrideCollectionInterface<VcsMap> {
     replaced: VcsEvent<ReplacedEvent<VcsMap>>;
     shadowMap: Map<string, object[]>;
     override: (item: VcsMap) => VcsMap;
-    parseItems: (items: object[], contextId: string) => Promise<void>;
-    removeContext: (contextId: string) => Promise<void>;
-    serializeContext: (contextId: string) => object[];
+    parseItems: (items: object[], moduleId: string) => Promise<void>;
+    getSerializedByKey: (key: string) => object;
+    removeModule: (moduleId: string) => Promise<void>;
+    serializeModule: (moduleId: string) => object[];
 }
 
 
@@ -8683,6 +8822,12 @@ export interface CreateInteraction<T extends import("ol/geom").Geometry> {
 
 export type Vertex = import("ol").Feature<import("ol/geom").Point>;
 
+export interface SelectFeatureInteraction extends AbstractInteraction {
+    readonly selected: Array<import("ol").Feature>;
+    setSelected(features: Array<import("ol").Feature|import("@vcmap-cesium/engine").Cesium3DTileFeature|import("@vcmap-cesium/engine").Cesium3DTilePointFeature|import("@vcmap-cesium/engine").Entity> | import("ol").Feature|import("@vcmap-cesium/engine").Cesium3DTileFeature|import("@vcmap-cesium/engine").Cesium3DTilePointFeature|import("@vcmap-cesium/engine").Entity ):void;
+    hasFeatureId(id: string): boolean;
+}
+
 declare module "@vcmap-cesium/engine" {
     interface Entity {
         getId():number|string;