@juun-roh/cesium-utils 0.0.3 → 0.0.5

package/dist/index.d.ts

@@ -1,839 +1,6 @@
-import { BillboardCollection, DataSourceCollection, EntityCollection, ImageryLayerCollection, LabelCollection, PointPrimitiveCollection, PolylineCollection, PrimitiveCollection, Billboard, DataSource, Entity, ImageryLayer, Label, PointPrimitive, Polyline, Primitive, Cesium3DTileset, GroundPrimitive, TilingScheme, TerrainProvider, Rectangle, Request, TerrainData, Credit, TileAvailability, Viewer, Color } from 'cesium';
-
-type CesiumCollection = BillboardCollection | DataSourceCollection | EntityCollection | ImageryLayerCollection | LabelCollection | PointPrimitiveCollection | PolylineCollection | PrimitiveCollection;
-type Primitives = Primitive | Cesium3DTileset | GroundPrimitive;
-type CesiumCollectionItem = Billboard | DataSource | Entity | ImageryLayer | Label | PointPrimitive | Polyline | Primitives;
-type Tag = string | number;
-interface WithTag {
-    [key: symbol]: Tag;
-}
-/**
- * Collection event types
- */
-type CollectionEventType = 'add' | 'remove' | 'update' | 'clear';
-/**
- * Event handler function type
- */
-type EventHandler<I> = (event: {
-    type: CollectionEventType;
-    items?: I[];
-    tag?: Tag;
-}) => void;
-/**
- * @class
- * Abstract class that enhances Cesium collection objects with tagging functionality.
- * This class provides a consistent API for working with different types of Cesium collections
- * and allows grouping and manipulating collection items by custom tags.
- *
- * @template C - The type of Cesium collection (e.g., EntityCollection, PrimitiveCollection)
- * @template I - The type of items in the collection (e.g., Entity, Primitive)
- *
- * @example
- * // Creating a specialized collection for entities
- * class MyEntities extends Collection<EntityCollection, Entity> {
- *   constructor(viewer) {
- *     super({ collection: viewer.entities, tag: 'myEntities' });
- *   }
- *
- *   get values() {
- *     return this.collection.values;
- *   }
- * }
- *
- * const entities = new MyEntities(viewer);
- * entities.add(new Entity({ ... }), 'buildings');
- * entities.add(new Entity({ ... }), 'roads');
- *
- * // Later, show only buildings
- * entities.show('buildings');
- * entities.hide('roads');
- */
-declare class Collection<C extends CesiumCollection, I extends CesiumCollectionItem> {
-    /**
-     * Symbol used as a property key to store tags on collection items.
-     * Using a Symbol ensures no property naming conflicts with the item's own properties.
-     * @readonly
-     */
-    static readonly symbol: unique symbol;
-    /**
-     * Default tag used when adding items without specifying a tag.
-     * @protected
-     */
-    protected tag: Tag;
-    /**
-     * The underlying Cesium collection being wrapped.
-     * @protected
-     */
-    protected collection: C;
-    /**
-     * Cache for values array to improve performance
-     * @private
-     */
-    private _valuesCache;
-    /**
-     * Tag to items map for faster lookups
-     * @private
-     */
-    private _tagMap;
-    /**
-     * Event listeners
-     * @private
-     */
-    private _eventListeners;
-    /**
-     * Creates a new Collection instance.
-     *
-     * @param options - Configuration options
-     * @param options.collection - The Cesium collection to wrap
-     * @param options.tag - The default tag to use for items (defaults to 'default')
-     */
-    constructor({ collection, tag }: {
-        collection: C;
-        tag?: Tag;
-    });
-    /**
-     * Emits an event to all registered listeners.
-     *
-     * @private
-     * @param type - The event type
-     * @param data - Additional event data
-     */
-    private _emit;
-    /**
-     * Adds an item to the internal tag map for quick lookups.
-     *
-     * @private
-     * @param item - The item to add
-     * @param tag - The tag to associate with the item
-     */
-    private _addToTagMap;
-    /**
-     * Removes an item from the internal tag map.
-     *
-     * @private
-     * @param item - The item to remove
-     */
-    private _removeFromTagMap;
-    /**
-     * Invalidates the values cache when collection changes.
-     *
-     * @private
-     */
-    private _invalidateCache;
-    /**
-     * Registers an event listener for collection events.
-     *
-     * @param type - The event type to listen for
-     * @param handler - The callback function
-     * @returns The collection instance for method chaining
-     */
-    addEventListener(type: CollectionEventType, handler: EventHandler<I>): this;
-    /**
-     * Removes an event listener.
-     *
-     * @param type - The event type
-     * @param handler - The callback function to remove
-     * @returns The collection instance for method chaining
-     */
-    removeEventListener(type: CollectionEventType, handler: EventHandler<I>): this;
-    /**
-     * Adds a single item with a tag to the collection.
-     *
-     * @param item - The item to add to the collection
-     * @param tag - Tag to associate with this item (defaults to the collection's default tag)
-     * @param index - The index to add the item at (if supported by the collection)
-     * @returns The added item for chaining
-     *
-     * @example
-     * const entity = collection.add(new Entity({ ... }), 'landmarks');
-     */
-    add(item: I, tag?: Tag, index?: number): I;
-    /**
-     * Adds multiple items with the same tag to the collection.
-     *
-     * @param items - The array of items to add to the collection
-     * @param tag - Tag to associate with this item (defaults to the collection's default tag)
-     * @returns The array of added items
-     *
-     * @example
-     * // Add multiple entities with the same tag
-     * const entities = [new Entity({ ... }), new Entity({ ... })];
-     * const addedEntities = collection.add(entities, 'buildings');
-     */
-    add(items: I[], tag?: Tag): I[];
-    /**
-     * Returns true if the provided item is in this collection, false otherwise.
-     *
-     * @param item - The item to check for
-     * @returns True if the item is in the collection, false otherwise
-     */
-    contains(item: I): boolean;
-    /**
-     * Removes an item from the collection.
-     *
-     * @param item - The item to remove
-     * @returns True if the item was removed, false if it wasn't found
-     */
-    remove(item: I & WithTag): boolean;
-    /**
-     * Removes all items from the collection.
-     */
-    removeAll(): void;
-    /**
-     * Gets all item instances in the collection.
-     * This array should not be modified directly.
-     *
-     * @returns An array of all items in the collection
-     */
-    get values(): I[];
-    /**
-     * Gets the number of items in the collection.
-     *
-     * @returns The item count
-     */
-    get length(): number;
-    /**
-     * Gets all items with the specified tag from the collection.
-     * Uses an optimized internal map for faster lookups.
-     *
-     * @param tag - The tag to filter by
-     * @returns An array of items with the specified tag, or an empty array if none found
-     *
-     * @example
-     * // Get all buildings
-     * const buildings = collection.getByTag('buildings');
-     */
-    getByTag(tag: Tag): I[];
-    /**
-     * Gets the first item matching the tag. More efficient than getByTag when
-     * you only need one item, especially for large collections.
-     *
-     * @param tag - The tag to search for
-     * @returns The first matching item or undefined if none found
-     *
-     * @example
-     * // Get the first building
-     * const firstBuilding = collection.getFirstByTag('buildings');
-     */
-    getFirstByTag(tag: Tag): I | undefined;
-    /**
-     * Gets all unique tags currently in use in the collection.
-     *
-     * @returns An array of all unique tags
-     *
-     * @example
-     * // Get all tags
-     * const tags = collection.getTags();
-     * console.log(`Collection has these tags: ${tags.join(', ')}`);
-     */
-    getTags(): Tag[];
-    /**
-     * Checks if the collection has any items with the specified tag.
-     *
-     * @param tag - The tag to check for
-     * @returns True if items with the tag exist, false otherwise
-     *
-     * @example
-     * if (collection.hasTag('temporary')) {
-     *   console.log('Temporary items exist');
-     * }
-     */
-    hasTag(tag: Tag): boolean;
-    /**
-     * Updates the tag for all items with the specified tag.
-     *
-     * @param oldTag - The tag to replace
-     * @param newTag - The new tag to assign
-     * @returns The number of items updated
-     *
-     * @example
-     * // Rename a tag
-     * const count = collection.updateTag('temp', 'temporary');
-     * console.log(`Updated ${count} items`);
-     */
-    updateTag(oldTag: Tag, newTag: Tag): number;
-    /**
-     * Removes all items with the specified tag from the collection.
-     *
-     * @param tag - The tag identifying which items to remove
-     * @returns The number of items removed
-     *
-     * @example
-     * // Remove all temporary markers
-     * const count = collection.removeByTag('temporary');
-     * console.log(`Removed ${count} items`);
-     */
-    removeByTag(tag: Tag): number;
-    /**
-     * Removes all items with the array of tags from the collection.
-     *
-     * @param tag - The tags identifying which items to remove
-     * @returns The number of items removed
-     *
-     * @example
-     * // Remove all items containing tags
-     * const count = collection.removeByTag('temporary', 'default', 'tag');
-     * console.log(`Removed ${count} items`);
-     */
-    removeByTag(tag: Tag[]): number;
-    /**
-     * Makes all items with the specified tag visible.
-     * Only affects items that have a 'show' property.
-     *
-     * @param tag - The tag identifying which items to show
-     * @returns The number of items affected
-     *
-     * @example
-     * // Show all buildings
-     * collection.show('buildings');
-     */
-    show(tag: Tag): number;
-    /**
-     * Hides all items with the specified tag.
-     * Only affects items that have a 'show' property.
-     *
-     * @param tag - The tag identifying which items to hide
-     * @returns The number of items affected
-     *
-     * @example
-     * // Hide all buildings
-     * collection.hide('buildings');
-     */
-    hide(tag: Tag): number;
-    /**
-     * Toggles visibility of all items with the specified tag.
-     * Only affects items that have a 'show' property.
-     *
-     * @param tag - The tag identifying which items to toggle
-     * @returns The number of items affected
-     *
-     * @example
-     * // Toggle visibility of all buildings
-     * collection.toggle('buildings');
-     */
-    toggle(tag: Tag): number;
-    /**
-     * Sets a property value on all items with the specified tag.
-     *
-     * @param tag - The tag identifying which items to update
-     * @param property - The property name to set
-     * @param value - The value to set
-     * @returns The number of items updated
-     *
-     * @example
-     * // Change color of all buildings to red
-     * collection.setProperty('buildings', 'color', Color.RED);
-     */
-    setProperty<K extends string, V>(tag: Tag, property: K, value: V): number;
-    /**
-     * Filters items in the collection based on a predicate function.
-     * Optionally only filters items with a specific tag.
-     *
-     * @param predicate - Function that tests each item
-     * @param tag - Optional tag to filter by before applying the predicate
-     * @returns Array of items that pass the test
-     *
-     * @example
-     * // Get all buildings taller than 100 meters
-     * const tallBuildings = collection.filter(
-     *   entity => entity.properties?.height?.getValue() > 100,
-     *   'buildings'
-     * );
-     */
-    filter(predicate: (item: I) => boolean, tag?: Tag): I[];
-    /**
-     * Executes a callback function for each item in the collection.
-     * Optionally filters items by tag before execution.
-     *
-     * @param callback - Function to execute for each item
-     * @param tag - Optional tag to filter items (if not provided, processes all items)
-     *
-     * @example
-     * // Highlight all buildings
-     * collection.forEach((entity) => {
-     *   if (entity.polygon) {
-     *     entity.polygon.material = new ColorMaterialProperty(Color.YELLOW);
-     *   }
-     * }, 'buildings');
-     */
-    forEach(callback: (item: I, index: number) => void, tag?: Tag): void;
-}
-
-/** A range of tiles from `start` to `end` */
-type TileRange = {
-    /** Top Left tile coordinates */
-    start: {
-        x: number;
-        y: number;
-    };
-    /** Bottom Right tile coordinates */
-    end: {
-        x: number;
-        y: number;
-    };
-};
-/** A `TileRange` map with specific levels as their keys. */
-type TileRanges = Map<number, TileRange>;
-/**
- * @class
- * Defines the geographic boundaries for a terrain area and handles tile availability checks.
- */
-declare class TerrainBounds {
-    private _rectangle;
-    private _tilingScheme;
-    private _tileRanges;
-    private _levels;
-    /**
-     * Creates a new instance of TerrainBounds.
-     * @param options {@link TerrainBounds.ConstructorOptions}
-     * @param tilingScheme (optional) The tiling scheme to use for coordinate calculations.
-     */
-    constructor(options: TerrainBounds.ConstructorOptions, tilingScheme?: TilingScheme);
-    /**
-     * Checks if the specified tile coordinates are within the bounds.
-     * @param x The tile X coordinate.
-     * @param y The tile Y coordinate.
-     * @param level The tile level.
-     * @returns `true` if the tile is within bounds, `false` otherwise.
-     */
-    contains(x: number, y: number, level: number): boolean;
-    /**
-     *
-     * Configures a terrain provider's availability based on these bounds.
-     * @see WARNING This method is accessing private property of {@link https://cesium.com/learn/csiumjs/ref-doc/TileAvailability.html `TileAvailability`}.
-     * @param provider The terrain provider to configure.
-     */
-    configureAvailability(provider: TerrainProvider): void;
-    /**
-     * Gets the rectangle representing these bounds.
-     */
-    get rectangle(): Rectangle;
-    /** Gets the tiling scheme used by these bounds. */
-    get tilingScheme(): TilingScheme;
-    /** Gets the tile ranges defined for these bounds. */
-    get tileRanges(): TileRanges;
-    /** Gets the levels for which tile ranges are defined. */
-    get levels(): Set<number>;
-    /**
-     * Calculates a bounding rectangle that encompasses all the specified tile ranges.
-     * @private
-     */
-    private _calculateRectangleFromTileRanges;
-}
-/**
- * @namespace
- * Contains types and factory methods for creating `TerrainBounds` instances.
- */
-declare namespace TerrainBounds {
-    /** Initialization options for Terrain Bounds constructor */
-    interface ConstructorOptions {
-        /** Type of bounds definition. */
-        type: 'tileRange' | 'rectangle';
-        /**
-         * Tile ranges by level when using tileRange type.
-         * Keys are zoom levels, values define the range of tiles at that level.
-         * Can be provided either as a Map or as a plain object with numeric keys.
-         */
-        tileRanges?: Map<number, TileRange> | Record<string | number, TileRange>;
-        /** Rectangle bounds when using rectangle type. */
-        rectangle?: Rectangle;
-    }
-    /**
-     * Creates `TerrainBounds` from tile coordinates at a specific level.
-     * @param x The tile X coordinate.
-     * @param y The tile Y coordinate.
-     * @param level The tile level.
-     * @param tilingScheme The tiling scheme to use.
-     * @returns A new `TerrainBounds` instance for the specified tile.
-     */
-    function fromTile(x: number, y: number, level: number, tilingScheme?: TilingScheme): TerrainBounds;
-    /**
-     * Creates `TerrainBounds` from a rectangle.
-     * @param rectangle The rectangle defining the bounds.
-     * @param tilingScheme The tiling scheme to use.
-     * @returns A new `TerrainBounds` instance for the specified rectangle.
-     */
-    function fromRectangle(rectangle: Rectangle, tilingScheme?: TilingScheme): TerrainBounds;
-}
-
-/**
- * @class
- * Represents a geographic area with a specific terrain provider.
- * `TerrainArea` pairs a provider with geographic bounds and level constraints.
- */
-declare class TerrainArea {
-    private _provider;
-    private _bounds;
-    private _levels;
-    private _ready;
-    private _credit;
-    private _isCustom;
-    /**
-     * Creates a new instance of `TerrainArea`.
-     * @param options Object describing initialization options
-     * @private Use {@link TerrainArea.create} instead.
-     */
-    private constructor();
-    /**
-     * Asynchronously creates a new instance of `TerrainArea`.
-     * @param options {@link TerrainArea.ConstructorOptions}
-     * @returns A promise that resolves to a new `TerrainArea` instance.
-     */
-    static create(options: TerrainArea.ConstructorOptions): Promise<TerrainArea>;
-    /**
-     * @see {@link TerrainBounds.contains}
-     */
-    contains(x: number, y: number, level: number): boolean;
-    /**
-     * Requests the geometry for a given tile. The result must include terrain data and
-     * may optionally include a water mask and an indication of which child tiles are available.
-     * @param x - The X coordinate of the tile for which to request geometry.
-     * @param y - The Y coordinate of the tile for which to request geometry.
-     * @param level - The level of the tile for which to request geometry.
-     * @param [request] - The request object. Intended for internal use only.
-     * @returns A promise for the requested geometry.  If this method
-     *          returns undefined instead of a promise, it is an indication that too many requests are already
-     *          pending and the request will be retried later.
-     */
-    requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<Awaited<TerrainData>> | undefined;
-    /**
-     * Determines whether data for a tile is available to be loaded.
-     * @param x - The X coordinate of the tile for which to request geometry.
-     * @param y - The Y coordinate of the tile for which to request geometry.
-     * @param level - The level of the tile for which to request geometry.
-     * @returns Undefined if not supported by the terrain provider, otherwise true or false.
-     * @see {@link TerrainProvider.getTileDataAvailable} */
-    getTileDataAvailable(x: number, y: number, level: number): boolean;
-    /** Checks if this terrain provider is marked as a custom provider. */
-    get isCustom(): boolean;
-    /** Gets the credit associated with this terrain area. */
-    get credit(): string | Credit;
-    /** Gets the terrain provider for this terrain area. */
-    get provider(): TerrainProvider | undefined;
-    /** Gets the terrain bounds for this terrain area. */
-    get bounds(): TerrainBounds;
-    /** Gets available zoom levels set with this terrain area. */
-    get levels(): Set<number>;
-    /** Gets if this terrain area is ready. */
-    get ready(): boolean;
-}
-/**
- * @namespace
- * Contains types and factory methods for creating `TerrainArea` instances.
- */
-declare namespace TerrainArea {
-    /** Initialization options for `TerrainArea` constructor. */
-    interface ConstructorOptions {
-        /** The terrain provider for this area or a URL to create one from. */
-        provider: TerrainProvider | string;
-        /** The geographic bounds of this terrain area. */
-        bounds: TerrainBounds | TerrainBounds.ConstructorOptions;
-        /**
-         * The zoom levels this terrain area applies to.
-         * If empty, the area applies to all levels.
-         */
-        levels?: number[];
-        /**
-         * Credit to associate with this terrain provider.
-         * Used to identify custom terrain providers.
-         * @default custom
-         */
-        credit?: string | Credit;
-        /**
-         * Whether this is a custom terrain provider.
-         * @default true
-         */
-        isCustom?: boolean;
-    }
-    /**
-     * Creates a `TerrainArea` from a URL and tile ranges.
-     * @param url The URL to create the terrain provider from.
-     * @param tileRanges Tile ranges by level.
-     * @param levels The zoom levels this area applies to.
-     * @param credit Credit to associate with this terrain provider.
-     * @returns A promise resolving to a new `TerrainArea`
-     */
-    function fromUrl(url: string, tileRanges: TileRanges, levels?: number[], credit?: string | Credit): Promise<Awaited<TerrainArea>>;
-}
-
-/**
- * @class
- * Provides terrain by delegating requests to different terrain providers
- * based on geographic regions and zoom levels. This allows combining
- * multiple terrain sources into a single seamless terrain.
- *
- * @example
- * ``` typescript
- * const hybridTerrain = await HybridTerrainProvider.create({
- *   terrainAreas: [
- *     provider: 'custom-terrain-url',
- *     bounds: {
- *       type: 'tileRange',
- *       tileRanges: {
- *         15: {
- *           start: { x: 55852, y: 9556 },
- *           end: { x: 55871, y: 9575 },
- *         },
- *       },
- *       levels: [15],
- *     }
- *   ],
- *   terrainProvider: 'default-terrain-url',
- *   fallbackProvider: new EllipsoidTerrainProvider(),
- * });
- *
- * viewer.terrainProvider = hybridTerrain;
- * ```
- */
-declare class HybridTerrainProvider implements TerrainProvider {
-    private _terrainAreas;
-    private _terrainProvider;
-    private _fallbackProvider;
-    private _tilingScheme;
-    private _ready;
-    private _availability?;
-    /**
-     * Creates a new `HybridTerrainProvider`. Use the {@link HybridTerrainProvider.create}
-     * instead of the constructor for async initialization.
-     * @param terrainProvider The initialized default terrain provider
-     * @param fallbackProvider The initialized fallback terrain provider
-     * @param terrainAreas The array of initialized terrain areas
-     * @private - Use {@link HybridTerrainProvider.create} instead.
-     */
-    private constructor();
-    /**
-     * Asynchronously creates a new `HybridTerrainProvider`.
-     * @param options {@link HybridTerrainProvider.ConstructorOptions}
-     * @returns A promise that resolves to a new `HybridTerrainProvider` instance.
-     */
-    static create(options: HybridTerrainProvider.ConstructorOptions): Promise<HybridTerrainProvider>;
-    /**
-     * Gets a value indicating whether or not the provider is ready for use,
-     * or a promise that resolves when the provider becomes ready.
-     */
-    get ready(): boolean;
-    /**
-     * Gets the tiling scheme used by this provider.
-     */
-    get tilingScheme(): TilingScheme;
-    /**
-     * Gets an object that can be used to determine availability of terrain from this provider.
-     */
-    get availability(): TileAvailability | undefined;
-    /**
-     * Gets the list of terrain areas managed by this provider.
-     */
-    get terrainAreas(): readonly TerrainArea[];
-    /**
-     * Gets the default terrain provider.
-     */
-    get defaultProvider(): TerrainProvider;
-    /**
-     * Gets the fallback terrain provider.
-     */
-    get fallbackProvider(): TerrainProvider;
-    /**
-     * @see {@link TerrainProvider.credit}
-     */
-    get credit(): any;
-    /**
-     * @see {@link TerrainProvider.errorEvent}
-     */
-    get errorEvent(): any;
-    /**
-     * @see {@link TerrainProvider.hasWaterMask}
-     */
-    get hasWaterMask(): boolean;
-    /**
-     * @see {@link TerrainProvider.hasVertexNormals}
-     */
-    get hasVertexNormals(): boolean;
-    /**
-     * @see {@link TerrainProvider.loadTileDataAvailability}
-     */
-    loadTileDataAvailability(x: number, y: number, level: number): Promise<void> | undefined;
-    /**
-     * @see {@link TerrainProvider.getLevelMaximumGeometricError}
-     */
-    getLevelMaximumGeometricError(level: number): number;
-    /**
-     * Requests the terrain for a given tile coordinate.
-     * @param x The X coordinate of the tile.
-     * @param y The Y coordinate of the tile.
-     * @param level The zoom level of the tile.
-     * @param request The request.
-     * @returns A promise for the requested terrain.
-     */
-    requestTileGeometry(x: number, y: number, level: number, request?: Request): Promise<Awaited<TerrainData>> | undefined;
-    /**
-     * @see {@link TerrainProvider.getTileDataAvailable}
-     * @param x
-     * @param y
-     * @param level
-     */
-    getTileDataAvailable(x: number, y: number, level: number): boolean | undefined;
-}
-/**
- * @namespace
- * Contains types and factory methods for creating `HybridTerrainProvider` instance.
- */
-declare namespace HybridTerrainProvider {
-    /**
-     * Initialization options for `HybridTerrainProvider` constructor.
-     */
-    interface ConstructorOptions {
-        /** An array of terrain areas to include in the hybrid terrain. */
-        terrainAreas: TerrainArea.ConstructorOptions[];
-        /** Default provider to use outside of specified terrain areas.  */
-        terrainProvider: TerrainProvider | string;
-        /** Optional fallback provider when data is not available from default provider. @default EllipsoidTerrainProvider */
-        fallbackProvider?: TerrainProvider | string;
-    }
-    /**
-     * Creates a `HybridTerrainProvider` with a custom terrain area overlaid on a base terrain.
-     * @param customTerrainUrl URL to the custom terrain.
-     * @param baseTerrainUrl URL to the base terrain.
-     * @param tileRanges Tile ranges defining the custom terrain area.
-     * @param levels Levels to apply the custom terrain.
-     * @returns A promise resolving to a new `HybridTerrainProvider`.
-     */
-    function createOverlay(customTerrainUrl: string, baseTerrainUrl: string, tileRanges: TileRanges, levels?: number[]): Promise<Awaited<HybridTerrainProvider>>;
-}
-
-/**
- * Copies configuration and state from one Cesium Viewer to another.
- * @param source - The source viewer to copy properties from
- * @param container - DOM element ID or element for the new viewer
- * @param options - Optional override options for the new viewer
- * @returns A new Viewer instance with copied properties
- */
-declare function cloneViewer(source: Viewer, container: Element | string, options?: Viewer.ConstructorOptions): Viewer;
-/**
- * Copies camera state from source viewer to destination viewer.
- * @param source The source viewer to copy camera states from.
- * @param dest The destination viewer to apply camera properties from the source.
- */
-declare function syncCameraState(source: Viewer, dest: Viewer): void;
-
-/**
- * @class
- * Utility class for visualizing terrain provider boundaries and debugging terrain loading.
- */
-declare class TerrainVisualizer {
-    private _viewer;
-    private _collection;
-    private _hybridTerrain?;
-    private _visible;
-    private _level;
-    private _tileCoordinatesLayer;
-    private _colors;
-    /**
-     * Creates a new `TerrainVisualizer`.
-     * @param viewer The Cesium viewer instance
-     * @param options {@link TerrainVisualizer.ConstructorOptions}
-     */
-    constructor(viewer: Viewer, options?: TerrainVisualizer.ConstructorOptions);
-    /**
-     * Sets the terrain provider to visualize.
-     * @param terrainProvider The terrain provider to visualize.
-     */
-    setTerrainProvider(terrainProvider: HybridTerrainProvider): void;
-    /**
-     * Updates all active visualizations.
-     */
-    update(): void;
-    /**
-     * Clears all visualizations.
-     */
-    clear(): void;
-    /**
-     * Shows a grid of tiles at the specified level.
-     * @param level The zoom level to visualize
-     */
-    show(level?: number): void;
-    /**
-     * Hides the tile grid.
-     */
-    hide(): void;
-    /**
-     * Sets the colors used for visualization.
-     * @param colors Map of role names to colors
-     */
-    setColors(colors: Record<string, Color>): void;
-    /**
-     * Flies the camera to focus on a terrain area.
-     * @param area The terrain area to focus on.
-     * @param options {@link Viewer.flyTo}
-     */
-    flyTo(area: TerrainArea, options?: {
-        duration?: number;
-    }): void;
-    /**
-     * Gets the rectangle representing the current view.
-     * @returns The current view rectangle or undefined.
-     * @private
-     */
-    private _getVisibleRectangle;
-    /** The current zoom level set on the visualizer. */
-    get level(): number;
-    /** Set zoom level on the visualizer. */
-    set level(level: number);
-    /** Whether the grid is currently visible. */
-    get visible(): boolean;
-    /** The collection used in the visualizer. */
-    get collection(): Collection<EntityCollection, Entity>;
-    /** The viewer used in the visualizer */
-    get viewer(): Viewer;
-}
-/**
- * @namespace
- * Contains types, utility functions, and constants for terrain visualization.
- */
-declare namespace TerrainVisualizer {
-    /** Initialization options for `TerrainVisualizer` constructor. */
-    interface ConstructorOptions {
-        /** Colors to use for different visualization elements */
-        colors?: Record<string, Color>;
-        /** Whether to show boundaries initially. */
-        boundaries?: boolean;
-        /** Whether to show tile grid initially. */
-        tile?: boolean;
-        /** Initial zoom level to use for visualizations. */
-        activeLevel?: number;
-        /** Terrain provider to visualize. */
-        terrainProvider?: HybridTerrainProvider;
-    }
-    /** Tag constants for entity collection management. */
-    const tag: {
-        default: string;
-        boundary: string;
-        grid: string;
-    };
-    /**
-     * Creates a ground-clamped rectangle entity for visualization.
-     * @param rectangle The rectangle to visualize
-     * @param color The color to use
-     * @returns A new entity
-     */
-    function createRectangle(rectangle: Rectangle, color: Color): Entity;
-    /** Options for {@link TerrainVisualizer.visualize} */
-    interface Options {
-        color?: Color;
-        show?: boolean;
-        maxTilesToShow?: number;
-        levels?: number[];
-        tag?: string;
-        alpha?: number;
-        tileAlpha?: number;
-    }
-    /**
-     * Visualizes a specific terrain area in a viewer.
-     * @param terrain The terrain area to visualize.
-     * @param viewer The Cesium viewer.
-     * @param options Visualization options.
-     * @returns Collection of created entities.
-     */
-    function visualize(terrain: TerrainArea | TerrainBounds, viewer: Viewer, options?: Options): Collection<EntityCollection, Entity>;
-}
-
-export { Collection, HybridTerrainProvider, TerrainArea, TerrainBounds, TerrainVisualizer, cloneViewer, syncCameraState };
+export { CesiumCollection, CesiumCollectionItem, Collection, CollectionEventType, EventHandler, Primitives, Tag, WithTag } from './collection/index.js';
+export { H as HybridTerrainProvider, T as TerrainArea, a as TerrainBounds, b as TileRange, c as TileRanges } from './hybrid-terrain-provider-C6aXdtyo.js';
+export { TerrainAreas } from './terrain/index.js';
+export { TerrainVisualizer, syncCamera } from './utils/index.js';
+export { cloneViewer } from './viewer/index.js';
+import 'cesium';