@vcmap/core 5.0.0-rc.2 → 5.0.0-rc.5

package/index.d.ts

@@ -14,6 +14,103 @@ export class VcsCameraPrimitive {
     show: boolean;
 }
 
+export interface AppBackedCategoryOptions extends CategoryOptions {
+    collectionName: string;
+}
+
+export class AppBackedCategory extends Category<VcsObject> {
+    constructor(options: AppBackedCategoryOptions);
+    serializeForContext(contextId: string): null;
+}
+
+/**
+ */
+export interface CategoryOptions extends VcsObjectOptions {
+    title?: string | {
+        [key: string]: string;
+    };
+    typed?: boolean;
+    featureProperty?: string | undefined;
+    layerOptions?: VectorOptions;
+    /**
+     * items are not evaluated by the constructor but passed to parseItem during deserialization.
+    */
+    items?: object[];
+    keyProperty?: string;
+}
+
+/**
+ * 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
+ * should keep track of the requested options themselves.
+ */
+export class Category<T extends Object|VcsObject> extends VcsObject {
+    constructor(options: CategoryOptions);
+    static getDefaultConfig(): CategoryOptions;
+    title: string | {
+        [key: string]: string;
+    };
+    protected _app: VcsApp;
+    protected _layer: Vector;
+    /**
+     * The collection of this category.
+     */
+    readonly collection: OverrideCollection<T>;
+    /**
+     * Returns the layer of this collection. Caution, do not use the layer API to add or remove items.
+     * When adding items to the collection, the features are added to the layer async (timeout of 0), since there is weird behavior
+     * when removing and adding a feature with the same id in the same sync call.
+     */
+    layer: Vector | null;
+    protected _itemAdded(item: T): void;
+    protected _itemRemoved(item: T): void;
+    protected _itemReplaced(item: T): void;
+    protected _itemMoved(item: T): void;
+    /**
+     * Throws if typed, featureProperty and keyProperty do not match. Merges other options.
+     * Only merges: style, highlightStyle, zIndex & vectorProperties from layerOptions.
+     */
+    mergeOptions(options: CategoryOptions): void;
+    /**
+     * When setting the category, it MUST use the same unqiueKey as the previous collection (default is "name").
+     * All items in the current collection _will be destroyed_ and the current collection will be destroyed. The category will take
+     * complete ownership of the collection and destroy it once the category is destroyed. The collection will
+     * be turned into an {@see OverrideCollection}.
+     */
+    setCollection(collection: Collection<T>): void;
+    setApp(app: VcsApp): void;
+    protected _serializeItem(item: T): object[];
+    serializeForContext(contextId: string): CategoryOptions | null;
+    /**
+     * unique Name
+     */
+    readonly name: string;
+    properties: any;
+    readonly className: string;
+}
+
+export class CategoryCollection extends IndexedCollection<Category<Object|VcsObject>> {
+    constructor(app: VcsApp);
+    /**
+     * Do not call add directly. Use request category for adding categories.
+     */
+    add(category: Category<object | VcsObject>): number | null;
+    /**
+     * Categories should be static. Removing them can lead to undefined behavior.
+     */
+    remove(category: Category<object | VcsObject>): void;
+    /**
+     * 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>;
+    /**
+     * Add categories with this API.
+     */
+    requestCategory(options: CategoryOptions): Promise<Category<object | VcsObject>>;
+}
+
 export class ClassRegistry {
     logger: import("@vcsuite/logger").Logger;
     /**
@@ -36,6 +133,26 @@ export class ClassRegistry {
 
 export const VcsClassRegistry: ClassRegistry;
 
+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[];
+}
+
+export class Context {
+    constructor(config: VcsAppConfig);
+    readonly id: string;
+    readonly checkSum: string;
+    readonly config: VcsAppConfig;
+}
+
 export class VcsEvent<T extends any> {
     /**
      * The number of listeners
@@ -1567,6 +1684,13 @@ export interface FeatureStoreChangesValues {
     changed: boolean;
 }
 
+export interface CommitAction {
+    action: string;
+    feature: import("ol/format/GeoJSON").GeoJSONFeature;
+    original: import("ol").Feature<import("ol/geom/Geometry").default>;
+    success: (...params: any[]) => any;
+}
+
 /**
  * do not construct directly, use the layers .changeTracker instead
  */
@@ -3124,7 +3248,7 @@ export function sampleCesiumTerrain(terrainProvider: import("@vcmap/cesium").Ces
  * changes input coordinate Array in place, new height can also be accessed by coordinates[x][2]
  * @param [optSourceProjection] - if input is not WGS84
  */
-export function getHeightFromTerrainProvider(terrainProvider: import("@vcmap/cesium").CesiumTerrainProvider, coordinates: import("ol/coordinate").Coordinate[], optSourceProjection?: Projection | import("ol/proj/Projection").default, result?: import("ol/coordinate").Coordinate[]): Promise<import("ol/coordinate").Coordinate[]>;
+export function getHeightFromTerrainProvider(terrainProvider: import("@vcmap/cesium").CesiumTerrainProvider, coordinates: import("ol/coordinate").Coordinate[], optSourceProjection?: Projection, result?: import("ol/coordinate").Coordinate[]): Promise<import("ol/coordinate").Coordinate[]>;
 
 /**
  * checks, whether a terrain tile is available at given position or not
@@ -4731,7 +4855,7 @@ export interface CameraLimiterOptions {
 /**
  * Enumeration of camera limiter modes.
  */
-export const enum Mode {
+export const enum CameraLimiterMode {
     HEIGHT,
     DISTANCE
 }
@@ -4745,7 +4869,7 @@ export class CameraLimiter {
     /**
      * The mode to use. When using DISTANCE mode, be sure to have a terrainProvider set.
      */
-    mode: Mode;
+    mode: CameraLimiterMode;
     /**
      * The minimum height/distance to the terrain the camera must maintain
      */
@@ -5158,7 +5282,7 @@ export class Oblique extends BaseOLMap {
     switchThreshold: any;
     mapChangeEvent: any;
     readonly collection: ObliqueCollection;
-    readonly imageChanged: import("@vcmap/cesium").Event;
+    readonly imageChanged: VcsEvent<ObliqueImage>;
     readonly currentImage: ObliqueImage | null;
     getExtentOfCurrentImage(): Extent;
     getCurrentImage(): ObliqueImage;
@@ -5365,9 +5489,14 @@ export interface ObliqueVersion {
     buildNumber: number;
 }
 
-export interface ObliqueCollectionOptions {
-    name?: string | undefined;
-    dataSets: ObliqueDataSet[];
+export interface ObliqueDataSetOptions {
+    url: string;
+    projection?: ProjectionOptions;
+    terrainProvider?: TerrainProviderOptions;
+}
+
+export interface ObliqueCollectionOptions extends VcsObjectOptions {
+    dataSets?: (ObliqueDataSet | ObliqueDataSetOptions)[];
     maxZoom?: number | undefined;
     minZoom?: number | undefined;
     scaleFactor?: number | undefined;
@@ -5376,16 +5505,13 @@ export interface ObliqueCollectionOptions {
 
 export class ObliqueCollection {
     constructor(options: ObliqueCollectionOptions);
-    /**
-     * The unique name of the collection
-     */
-    name: string;
+    static getDefaultOptions(): ObliqueCollectionOptions;
     viewOptions: ObliqueViewOptions;
 
     /**
      * Event raised when images are loaded. Is passed an Array of ObliqueImages as its only argument.
      */
-    imagesLoaded: import("@vcmap/cesium").Event;
+    imagesLoaded: VcsEvent<ObliqueImage[]>;
     readonly dataSets: ObliqueDataSet[];
     /**
      * Indicates, that this collection has been loaded
@@ -5476,6 +5602,20 @@ export class ObliqueCollection {
      * Destroys all data sets and all images and any image/tile features for this collection
      */
     destroy(): void;
+    toJSON(): ObliqueCollectionOptions;
+}
+
+/**
+ */
+export interface ObliqueDataSetImagesLoaded {
+    /**
+     * the loaded images
+    */
+    images: ObliqueImage[];
+    /**
+     * an optional tile coordinate
+    */
+    tileCoordinate?: string;
 }
 
 /**
@@ -5490,16 +5630,14 @@ export const enum DataState {
 export function getStateFromStatesArray(states: DataState[]): DataState;
 
 export class ObliqueDataSet {
-    constructor(url: string, projection: import("ol/proj/Projection").default, terrainProvider?: import("@vcmap/cesium").CesiumTerrainProvider);
+    constructor(url: string, projection: Projection | ProjectionOptions, terrainProviderOptions?: TerrainProviderOptions);
     url: string;
     baseUrl: string;
-    projection: import("ol/proj/Projection").default;
-    terrainProvider: import("@vcmap/cesium").CesiumTerrainProvider | undefined;
+    projection: Projection;
     /**
-     * Event raised when images are loaded. Is passed an Array of ObliqueImages as the first argument and optionally
-     * a string representing the tile coordinate ("z/x/y"), if the images where loaded for a tile.
+     * Event raised when images are loaded.
      */
-    imagesLoaded: import("@vcmap/cesium").Event;
+    imagesLoaded: VcsEvent<ObliqueDataSetImagesLoaded>;
 
 
 
@@ -5513,6 +5651,7 @@ export class ObliqueDataSet {
      * reflect the state of loaded tiles.
      */
     readonly state: DataState;
+    readonly terrainProvider: import("@vcmap/cesium").CesiumTerrainProvider | undefined;
     /**
      * Loads the data set.
      */
@@ -5546,6 +5685,7 @@ export class ObliqueDataSet {
      * Loads all the tiles for a given extent.
      */
     loadDataForExtent(extent: import("ol/extent").Extent): Promise<void>;
+    toJSON(): ObliqueDataSetOptions;
 }
 
 export interface ObliqueImageOptions {
@@ -5558,7 +5698,7 @@ export interface ObliqueImageOptions {
     projectionCenter?: import("@vcmap/cesium").Cartesian3 | undefined;
     pToRealworld?: import("@vcmap/cesium").Matrix3 | undefined;
     pToImage?: import("@vcmap/cesium").Matrix4 | undefined;
-    projection?: import("ol/proj/Projection").default | undefined;
+    projection?: Projection | undefined;
     terrainProvider?: import("@vcmap/cesium").CesiumTerrainProvider | undefined;
 }
 
@@ -5624,7 +5764,7 @@ export interface ObliqueImageMetaOptions {
     size: import("ol/size").Size;
     tileSize: import("ol/size").Size;
     tileResolution: number[];
-    projection: import("ol/proj/Projection").default;
+    projection: Projection;
     url: string;
     terrainProvider: import("@vcmap/cesium").CesiumTerrainProvider;
     name: string;
@@ -5657,7 +5797,7 @@ export class ObliqueImageMeta {
     /**
      * The world projection of the images associated with this meta
      */
-    projection: import("ol/proj/Projection").default;
+    projection: Projection;
     url: string;
     /**
      * An optional terrain provider
@@ -5692,7 +5832,7 @@ export class ObliqueProvider {
     /**
      * Event raised once a new image is set on the provider. Will be passed the new image as the only argument.
      */
-    imageChanged: import("@vcmap/cesium").Event;
+    imageChanged: VcsEvent<ObliqueImage>;
     /**
      * Whether the post render handler should switch on image edge. Setting
      * this to false will suspend all post render handler switches.
@@ -5821,7 +5961,7 @@ export interface ImageTransformationOptions {
     /**
      * the projection of the input/output coordinates, assumes image source projection
     */
-    dataProjection?: import("ol/proj/Projection").default | undefined;
+    dataProjection?: Projection | undefined;
     /**
      * the transformToWorld process iterativly calculates a new Height Value from the terrainProvider until the difference to the new height value is smaller
     */
@@ -5858,17 +5998,12 @@ export function transformFromImage(image: ObliqueImage, imageCoordinate: import(
 
 export function hasSameOrigin(url: string): boolean;
 
-/**
- * destroys a cesium Event Emitter, (removes all listeners)
- */
-export function destroyCesiumEvent(cesiumEvent: import("@vcmap/cesium").Event): void;
-
 /**
  * @returns version
  */
 export function getVersionFromImageJson(json: any): ObliqueVersion;
 
-export function parseImageMeta(json: ObliqueImageJson, url: string, projection?: import("ol/proj/Projection").default | null, terrainProvider?: import("@vcmap/cesium").CesiumTerrainProvider): ObliqueImageMeta[];
+export function parseImageMeta(json: ObliqueImageJson, url: string, projection?: Projection, terrainProvider?: import("@vcmap/cesium").CesiumTerrainProvider): ObliqueImageMeta[];
 
 export function parseImageData(json: ObliqueImageJson, imageMetas: ObliqueImageMeta[]): ObliqueImage[];
 
@@ -6168,11 +6303,16 @@ export class ExclusiveManager {
 
 /**
  */
-export interface ExtentOptions extends ProjectionOptions {
+export interface ExtentOptions {
+    type?: string;
     /**
      * if not specified, the extent of the projection is used
     */
     coordinates?: import("ol/extent").Extent | undefined;
+    /**
+     * if not specified the default projection is assumed
+    */
+    projection?: ProjectionOptions;
 }
 
 /**
@@ -6181,6 +6321,7 @@ export interface ExtentOptions extends ProjectionOptions {
  */
 export class Extent {
     constructor(options?: ExtentOptions);
+    static className: string;
     projection: Projection;
     extent: import("ol/extent").Extent | null;
     getCoordinatesInProjection(destination: Projection, result?: import("ol/extent").Extent): import("ol/extent").Extent;
@@ -6388,7 +6529,7 @@ export class WMSFeatureProvider extends AbstractFeatureProvider {
      * The feature response projection, if not present in the response format.
      */
     projection: Projection;
-    featureResponseCallback(response: import("axios").AxiosResponse<any>, coordinate: import("ol/coordinate").Coordinate): import("ol").Feature<import("ol/geom/Geometry").default>[];
+    featureResponseCallback(data: import("ol/format/GeoJSON").GeoJSONObject, coordinate: import("ol/coordinate").Coordinate): import("ol").Feature<import("ol/geom/Geometry").default>[];
     /**
      * The layer name of the associated layer
      */
@@ -6424,69 +6565,6 @@ export function validateCircle(circle: import("ol/geom/Circle").default): boolea
 
 export function getStylesArray(style: void | import("ol/style/Style").StyleLike, feature: import("ol").Feature<import("ol/geom/Geometry").default>, resolution?: number): import("ol/style/Style").default[];
 
-/**
- * Create an empty extent.
- * @returns Empty extent.
- */
-export function createEmpty3D(): number[];
-
-/**
- * Create a new extent or update the provided extent.
- * @param minX - Minimum X.
- * @param minY - Minimum Y.
- * @param minZ - Minimum Z.
- * @param maxX - Maximum X.
- * @param maxY - Maximum Y.
- * @param maxZ - Maximum Z.
- * @param [optExtent] - Destination extent.
- * @returns Extent.
- */
-export function createOrUpdate3D(minX: number, minY: number, minZ: number, maxX: number, maxY: number, maxZ: number, optExtent?: number[]): number[];
-
-/**
- * @param extent - Extent.
- * @param x - X.
- * @param y - Y.
- * @param z - Z.
- */
-export function extendXYZ(extent: number[], x: number, y: number, z: number): void;
-
-/**
- * @param extent - Extent.
- * @param x - X.
- * @param y - Y.
- */
-export function extendXY(extent: number[], x: number, y: number): void;
-
-/**
- * @param extent - Extent.
- * @param z - Z.
- */
-export function extendZ(extent: number[], z: number): void;
-
-/**
- * @param extent - Extent.
- * @param flatCoordinates - Flat coordinates.
- * @param stride - Stride.
- * @returns Extent.
- */
-export function extendFlatCoordinates(extent: number[], flatCoordinates: number[], stride: number): number[];
-
-/**
- * @param geometry - Geometry.
- * @param [optExtent] - Extent.
- * @returns Extent.
- */
-export function createOrUpdateFromGeometry(geometry: import("ol/geom/Geometry").default, optExtent?: number[]): number[];
-
-export function createOrUpdateFromHeightInfo(heightInfo: VectorHeightInfo, optExtent: number[]): void;
-
-/**
- * @param extent - Extent.
- * @returns Extent.
- */
-export function make2D(extent: number[]): import("ol/extent").Extent;
-
 export function getMaterialAppearance(scene: import("@vcmap/cesium").Scene, fill: import("ol/style/Fill").default, feature: import("ol").Feature<import("ol/geom/Geometry").default>): import("@vcmap/cesium").MaterialAppearance;
 
 export function createClassificationPrimitive(options: any, geometries: import("@vcmap/cesium").Geometry[], color: import("@vcmap/cesium").Color, classificationType: import("@vcmap/cesium").ClassificationType): import("@vcmap/cesium").ClassificationPrimitive;
@@ -6549,6 +6627,12 @@ export function getCartesian3AndWGS84FromCoordinates(coordinates: import("ol/coo
  */
 export function validatePolygon(polygon: import("ol/geom/Polygon").default): boolean;
 
+export function requestUrl(url: string, init?: RequestInit): Promise<Response>;
+
+export function requestJson(url: string, init?: RequestInit): Promise<any>;
+
+export function requestArrayBuffer(url: string, init?: RequestInit): Promise<ArrayBuffer>;
+
 export function getFlatCoordinatesFromSimpleGeometry(geometry: import("ol/geom/SimpleGeometry").default): import("ol/coordinate").Coordinate[];
 
 export function getFlatCoordinatesFromGeometry(geometry: import("ol/geom/Geometry").default, inputCoordinates?: any[]): import("ol/coordinate").Coordinate[];
@@ -6578,6 +6662,11 @@ export class IndexedCollection<T extends any> extends Collection<T> {
      * Event raised if an item is relocated within the collection. Is passed the moved item.
      */
     moved: VcsEvent<T>;
+    /**
+     * Get the symbol which is attached to an item prior to its removal. If an item is removed, the current index of the item
+     * is set on the item with this symbol.
+     */
+    readonly previousIndexSymbol: symbol;
     /**
      * Returns an item at index.
      */
@@ -6589,6 +6678,7 @@ export class IndexedCollection<T extends any> extends Collection<T> {
      * @returns the index at which the item was inserted
      */
     add(item: T, index?: number): number | null;
+    remove(item: T): void;
     protected _move(item: T, itemIndex: number, targetIndex: number): number;
     /**
      * Lowers an item within the array
@@ -6626,6 +6716,12 @@ export class LayerCollection extends IndexedCollection<Layer> {
      * The exclusive manager for this collection. Layers within this collection are automatically added and tracked.
      */
     exclusiveManager: ExclusiveManager;
+    /**
+     * A symbol to describe the local z index of a layer. The local z index must not equal the layers z index, but is
+     * always consistent in comparison to the neighbouring layers. If a layer is moved other then by z index, the collection
+     * ensures consistency by setting a new local z index if needed.
+     */
+    readonly zIndexSymbol: symbol;
     /**
      * Adds a layer to the collection. Can optionally be passed an index at which to insert the layer.
      * @returns returns the layer index or null, if the layers name is not unique
@@ -6742,9 +6838,24 @@ export function cartesian2DDistance(point0: import("ol/coordinate").Coordinate,
 
 export function cartesian3DDistance(p1: import("ol/coordinate").Coordinate, p2: import("ol/coordinate").Coordinate): number;
 
+/**
+ * A symbol added to override collections.
+ */
+export const isOverrideCollection: symbol;
+
+/**
+ * @param getDynamicContextId - function to get the current dynamic context id
+ * @param [serializeItem] - optional function to serialize an item, defaults to returning item.toJSON or item: i => (i.toJSON || i)
+ * @param [deserializeItem] - optional desirialization 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 interface ProjectionOptions {
+    type?: string;
     /**
      * EPSG of the projection, for example: "EPSG:4326" if not specified, uses the framework projection
     */
@@ -6757,6 +6868,10 @@ export interface ProjectionOptions {
      * aliases to define
     */
     alias?: string[] | undefined | null;
+    /**
+     * an alternate prefix to use for custom projection
+    */
+    prefix?: string | undefined;
 }
 
 /**
@@ -6770,6 +6885,7 @@ export function setDefaultProjectionOptions(options: ProjectionOptions): void;
  */
 export class Projection {
     constructor(options: ProjectionOptions);
+    static className: any;
     /**
      * epsg code in the format "EPSG:25832"
      */
@@ -6951,7 +7067,7 @@ export function getShapeFromOptions(options: VectorStyleItemImage): import("ol/s
 
 export const shapeCategory: any;
 
-export function getStyleOrDefaultStyle(styleOptions?: Reference | DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem | string, defaultStyle?: VectorStyleItem | DeclarativeStyleItem): StyleItem;
+export function getStyleOrDefaultStyle(styleOptions?: Reference | DeclarativeStyleItemOptions | VectorStyleItemOptions | StyleItem | string, defaultStyle?: StyleItem): StyleItem;
 
 export interface FontObject {
     fontStyle: string;
@@ -7432,4 +7548,80 @@ export class ViewPoint extends VcsObject {
     readonly className: string;
 }
 
+export class VcsApp {
+    readonly id: string;
+    readonly maps: OverrideMapCollection;
+    readonly layers: OverrideLayerCollection;
+    readonly obliqueCollections: OverrideCollection<ObliqueCollection>;
+    readonly viewPoints: OverrideCollection<ViewPoint>;
+    readonly styles: OverrideCollection<StyleItem>;
+    readonly categories: CategoryCollection;
+    readonly destroyed: VcsEvent<void>;
+    readonly contextAdded: any;
+    readonly contextRemoved: any;
+    getContextById(id: string): Context;
+    protected _parseContext(context: Context): Promise<void>;
+    protected _setContextState(context: Context): Promise<void>;
+    addContext(context: Context): Promise<void>;
+    protected _removeContext(contextId: string): Promise<void>;
+    removeContext(contextId: string): Promise<void>;
+}
+
+export function getVcsAppById(id: string): VcsApp;
+
+export const contextIdSymbol: symbol;
+
+/**
+ * returns a constructor of a type.
+ */
+export function getObjectFromOptions(options: any, ...args: any[]): Promise<object | null>;
+
+export function deserializeMap(vcsApp: VcsApp, mapConfig: VcsMapOptions): Promise<VcsMap | null>;
+
+export function deserializeViewPoint(viewPointObject: ViewPointOptions): Promise<null | ViewPoint>;
+
+export function serializeLayer(vcsApp: VcsApp, layer: Layer): Promise<LayerOptions | null>;
+
+export function getLayerIndex(current: Layer, previous: Layer, currentIndex: number): number | null;
+
+export function destroyCollection(collection: Collection<any>): void;
+
+
+
+
+export interface OverrideCollectionInterface<T extends any> {
+    replaced: VcsEvent<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[];
+}
+
+export class OverrideCollection<T extends any> extends Collection<T> implements OverrideCollectionInterface<T> {
+    replaced: VcsEvent<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[];
+}
+
+export class OverrideLayerCollection extends LayerCollection implements OverrideCollectionInterface<Layer> {
+    replaced: VcsEvent<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[];
+}
+
+export class OverrideMapCollection extends MapCollection implements OverrideCollectionInterface<VcsMap> {
+    replaced: VcsEvent<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[];
+}
 

package/index.js

@@ -6,7 +6,11 @@ import './src/cesium/cesium3DTilePointFeature.js';
 import './src/cesium/cesium3DTileFeature.js';
 import './src/cesium/cesiumVcsCameraPrimitive.js';
 
+export { default as AppBackedCategory } from './src/vcs/vcm/category/appBackedCategory.js';
+export { default as Category } from './src/vcs/vcm/category/category.js';
+export { default as CategoryCollection } from './src/vcs/vcm/category/categoryCollection.js';
 export { VcsClassRegistry, default as ClassRegistry } from './src/vcs/vcm/classRegistry.js';
+export { default as Context } from './src/vcs/vcm/context.js';
 export { default as VcsEvent } from './src/vcs/vcm/event/vcsEvent.js';
 export { styleCollection, obliqueCollectionCollection } from './src/vcs/vcm/globalCollections.js';
 export { default as AbstractInteraction } from './src/vcs/vcm/interaction/abstractInteraction.js';
@@ -84,7 +88,7 @@ export { default as WMS } from './src/vcs/vcm/layer/wms.js';
 export { getWMSSource } from './src/vcs/vcm/layer/wmsHelpers.js';
 export { default as WMTS } from './src/vcs/vcm/layer/wmts.js';
 export { default as BaseOLMap } from './src/vcs/vcm/maps/baseOLMap.js';
-export { Mode, default as CameraLimiter } from './src/vcs/vcm/maps/cameraLimiter.js';
+export { CameraLimiterMode, default as CameraLimiter } from './src/vcs/vcm/maps/cameraLimiter.js';
 export { default as CesiumMap } from './src/vcs/vcm/maps/cesium.js';
 export { default as VcsMap } from './src/vcs/vcm/maps/map.js';
 export { default as MapState } from './src/vcs/vcm/maps/mapState.js';
@@ -98,7 +102,7 @@ export { default as ObliqueImageMeta } from './src/vcs/vcm/oblique/ObliqueImageM
 export { default as ObliqueProvider } from './src/vcs/vcm/oblique/ObliqueProvider.js';
 export { default as ObliqueView } from './src/vcs/vcm/oblique/ObliqueView.js';
 export { ObliqueViewDirection, obliqueViewDirectionNames, getDirectionName } from './src/vcs/vcm/oblique/ObliqueViewDirection.js';
-export { sortRealWordEdgeCoordinates, checkLineIntersection, transformCWIFC, transformToImage, transformFromImage, hasSameOrigin, destroyCesiumEvent } from './src/vcs/vcm/oblique/helpers.js';
+export { sortRealWordEdgeCoordinates, checkLineIntersection, transformCWIFC, transformToImage, transformFromImage, hasSameOrigin } from './src/vcs/vcm/oblique/helpers.js';
 export { getVersionFromImageJson, parseImageMeta, parseImageData, parseLegacyImageData } from './src/vcs/vcm/oblique/parseImageJson.js';
 export { default as ClippingObject } from './src/vcs/vcm/util/clipping/clippingObject.js';
 export { default as ClippingObjectManager } from './src/vcs/vcm/util/clipping/clippingObjectManager.js';
@@ -114,11 +118,12 @@ export { default as TileProviderFeatureProvider } from './src/vcs/vcm/util/featu
 export { getFormat, default as WMSFeatureProvider } from './src/vcs/vcm/util/featureProvider/wmsFeatureProvider.js';
 export { validateCircle, default as circleToCesium } from './src/vcs/vcm/util/featureconverter/circleToCesium.js';
 export { getStylesArray, default as convert } from './src/vcs/vcm/util/featureconverter/convert.js';
-export { createEmpty3D, createOrUpdate3D, extendXYZ, extendXY, extendZ, extendFlatCoordinates, createOrUpdateFromGeometry, createOrUpdateFromHeightInfo, make2D } from './src/vcs/vcm/util/featureconverter/extent3d.js';
+export { default as Extent3D } from './src/vcs/vcm/util/featureconverter/extent3D.js';
 export { getMaterialAppearance, createClassificationPrimitive, createPrimitive, createOutlinePrimitive, createLinePrimitive, getMinHeightOrGroundLevel, getStoreyHeights, validateStoreys, getHeightAboveGround, getHeightInfo, getStoreyOptions, addPrimitivesToContext } from './src/vcs/vcm/util/featureconverter/featureconverterHelper.js';
 export { validateLineString, default as lineStringToCesium } from './src/vcs/vcm/util/featureconverter/lineStringToCesium.js';
 export { getBillboardOptions, getLabelOptions, getModelOptions, validatePoint, getCartesian3AndWGS84FromCoordinates, default as pointToCesium } from './src/vcs/vcm/util/featureconverter/pointToCesium.js';
 export { validatePolygon, default as polygonToCesium } from './src/vcs/vcm/util/featureconverter/polygonToCesium.js';
+export { requestUrl, requestJson, requestArrayBuffer } from './src/vcs/vcm/util/fetch.js';
 export { getFlatCoordinatesFromSimpleGeometry, getFlatCoordinatesFromGeometry, circleFromCenterRadius, convertGeometryToPolygon, enforceEndingVertex, removeEndingVertex, removeEndingVertexFromGeometry, enforceRightHand } from './src/vcs/vcm/util/geometryHelpers.js';
 export { default as IndexedCollection } from './src/vcs/vcm/util/indexedCollection.js';
 export { isMobile } from './src/vcs/vcm/util/isMobile.js';
@@ -126,6 +131,7 @@ export { default as LayerCollection } from './src/vcs/vcm/util/layerCollection.j
 export { getLocaleChangedEvent, detectBrowserLocale, getCurrentLocale, setCurrentLocale } from './src/vcs/vcm/util/locale.js';
 export { default as MapCollection } from './src/vcs/vcm/util/mapCollection.js';
 export { coordinateAtDistance, initialBearingBetweenCoords, cartesian2DDistance, cartesian3DDistance } from './src/vcs/vcm/util/math.js';
+export { isOverrideCollection, default as makeOverrideCollection } from './src/vcs/vcm/util/overrideCollection.js';
 export { wgs84ToMercatorTransformer, mercatorToWgs84Transformer, setDefaultProjectionOptions, getDefaultProjection, wgs84Projection, mercatorProjection, default as Projection } from './src/vcs/vcm/util/projection.js';
 export { default as SplitScreen } from './src/vcs/vcm/util/splitScreen.js';
 export { defaultDeclarativeStyle, default as DeclarativeStyleItem } from './src/vcs/vcm/util/style/declarativeStyleItem.js';
@@ -137,3 +143,5 @@ export { olcsGeometryType, vectorStyleSymbol, defaultVectorStyle, fromCesiumColo
 export { embedIconsInStyle, default as writeStyle } from './src/vcs/vcm/util/style/writeStyle.js';
 export { isSameOrigin } from './src/vcs/vcm/util/urlHelpers.js';
 export { propertyEqualsEpsilon, angleEqualsEpsilon, coordinateEqualsEpsilon, default as ViewPoint } from './src/vcs/vcm/util/viewpoint.js';
+export { getVcsAppById, default as VcsApp } from './src/vcs/vcm/vcsApp.js';
+export { contextIdSymbol, getObjectFromOptions, deserializeMap, deserializeViewPoint, serializeLayer, getLayerIndex, destroyCollection } from './src/vcs/vcm/vcsAppContextHelpers.js';