@faclon-labs/app-sdk 0.1.0 → 0.3.0

package/vendor/map-engine/testing/mock-provider.d.ts

@@ -0,0 +1,97 @@
+import type { Position, SpatialObject, SpatialQuery, TimeRange, Track, TrackPoint, Unsubscribe } from '../core/types.js';
+import type { AuthAware, AuthContext, DataCapabilities, DatasetCatalog, DatasetInfo, JournalEntry, JournalProvider, Link, LinkProvider, RealtimeProvider, SpatialPatch, TrackProvider, WritableSpatialProvider } from '../data/contracts.js';
+export interface MockRecord {
+    object: SpatialObject;
+    ontologyType?: string;
+}
+export interface MockProviderOptions {
+    /** Simulated network latency per call. */
+    latencyMs?: number;
+    capabilities?: Partial<DataCapabilities>;
+}
+/**
+ * In-memory provider for tests and io-maps. It plays the role of an already-authorized server runtime
+ * (it does no authorization itself), including realtime: every write notifies the subscriptions it affects,
+ * asynchronously, like a stream would.
+ */
+export declare class MockSpatialProvider implements WritableSpatialProvider, RealtimeProvider, TrackProvider, DatasetCatalog, LinkProvider, JournalProvider, AuthAware {
+    readonly capabilities: DataCapabilities;
+    private readonly records;
+    private latencyMs;
+    private failures;
+    /** Every query received, for assertions. */
+    readonly queries: SpatialQuery[];
+    private readonly subscriptions;
+    private readonly datasetMeta;
+    /**
+     * Every write as a journal entry (doc 29 §7), so replay can rebuild whole objects — per object, the newest
+     * JOURNAL_CAP kept. Writing is cheap (the stored object is shared, changes are worked out when read): live
+     * feeds write thousands of times a second.
+     */
+    private readonly journal;
+    private readonly linkList;
+    /** The identity the engine handed over (doc 28 G13). */
+    auth: AuthContext | null;
+    private deniedTypes;
+    private redaction;
+    /** Position history per object (kept after removal, so replay can still show it). */
+    private readonly history;
+    constructor(records?: Array<MockRecord | SpatialObject>, options?: MockProviderOptions);
+    setAuth(auth: AuthContext | null): void;
+    /** Test and demo hook: queries for these types are refused (ACCESS_DENIED), as a server would for this user. */
+    denyTypes(types: string[]): void;
+    /** Test and demo hook: these properties are removed (and listed in `redacted`) unless the user has the role. */
+    redactFields(fields: string[], unlessRole?: string): void;
+    private visible;
+    private refuse;
+    setLatency(ms: number): void;
+    /** The next query (or getCurrentState) rejects with this error. */
+    failNext(error?: Error): void;
+    query(query: SpatialQuery, signal?: AbortSignal): Promise<SpatialObject[]>;
+    private matches;
+    getCurrentState(objectIds: string[], signal?: AbortSignal): Promise<SpatialObject[]>;
+    upsert(object: SpatialObject, meta?: {
+        ontologyType?: string;
+    }): Promise<void>;
+    remove(objectId: string): Promise<void>;
+    /** The stored record is a private copy and is replaced (never changed) on the next write, so it is shared here. */
+    private write;
+    private addEntry;
+    /** Adds journal entries (demos and tests): past states and changes, merged with what writes recorded. */
+    seedJournal(entries: Array<JournalEntry & {
+        ontologyType?: string;
+    }>): void;
+    getJournal(query: SpatialQuery, range: TimeRange, signal?: AbortSignal): Promise<JournalEntry[]>;
+    /** Adds links between objects (demos and tests). */
+    seedLinks(links: Link[]): void;
+    getLinks(objectIds: string[], types: string[] | undefined, signal?: AbortSignal): Promise<Link[]>;
+    /** Labels a dataset for the catalog, or hides it (e.g. app-internal draft types). */
+    describeDataset(ontologyType: string, meta: {
+        label?: string;
+        source?: string;
+        hidden?: boolean;
+        altitude?: DatasetInfo['altitude'];
+    }): void;
+    /** Every ontology type held, with geometry, count and property schema — discovered from the records. */
+    listDatasets(signal?: AbortSignal): Promise<DatasetInfo[]>;
+    /** Replaces every object of a type (an import, a re-sync). Subscribers see the removals and upserts. */
+    setDataset(ontologyType: string, objects: SpatialObject[]): Promise<void>;
+    removeDataset(ontologyType: string): Promise<void>;
+    /** Convenience for simulations: move a point and stamp the observation time. */
+    move(objectId: string, position: Position, observedAt?: string): Promise<void>;
+    subscribe(query: SpatialQuery, onPatch: (p: SpatialPatch) => void, onError?: (e: Error) => void): Unsubscribe;
+    /** Test hook: break every open stream (the engine should reconnect with a fresh snapshot). */
+    failStreams(error?: Error): void;
+    subscriptionCount(): number;
+    private notify;
+    /** Adds past positions for an object (demos and tests). Points merge with recorded history by time. */
+    seedHistory(objectId: string, points: TrackPoint[], meta?: {
+        ontologyType?: string;
+        properties?: Record<string, unknown>;
+    }): void;
+    getTracks(query: SpatialQuery, range: TimeRange, signal?: AbortSignal): Promise<Track[]>;
+    /** Every point position with a timestamp becomes history. */
+    private record;
+    /** Synchronous view for tests. Not part of any provider contract. */
+    size(): number;
+}

package/vendor/map-engine/testing/mock-provider.js

@@ -0,0 +1,369 @@
+import { MapEngineError } from '../core/errors.js';
+import { describeProperties } from '../data/schema.js';
+import { geometryFamily } from '../core/geometry-family.js';
+import { validateGeometry } from '../spatial/geometry.js';
+import { boundsContainPosition, geometryBounds, unionBounds } from '../spatial/geometry.js';
+import { matchesQuery, rankByRelation } from '../spatial/query.js';
+/** Journal entries kept per object (the newest). */
+const JOURNAL_CAP = 2000;
+function diffProps(a, b) {
+    const out = {};
+    const x = a ?? {};
+    const y = b ?? {};
+    for (const k of new Set([...Object.keys(x), ...Object.keys(y)]))
+        if (JSON.stringify(x[k]) !== JSON.stringify(y[k]))
+            out[k] = [x[k], y[k]];
+    return out;
+}
+const abortError = () => Object.assign(new Error('The operation was aborted.'), { name: 'AbortError' });
+function delay(ms, signal) {
+    if (signal?.aborted)
+        return Promise.reject(abortError());
+    if (ms <= 0)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(resolve, ms);
+        signal?.addEventListener('abort', () => {
+            clearTimeout(t);
+            reject(abortError());
+        }, { once: true });
+    });
+}
+/**
+ * In-memory provider for tests and io-maps. It plays the role of an already-authorized server runtime
+ * (it does no authorization itself), including realtime: every write notifies the subscriptions it affects,
+ * asynchronously, like a stream would.
+ */
+export class MockSpatialProvider {
+    capabilities;
+    records = new Map();
+    latencyMs;
+    failures = [];
+    /** Every query received, for assertions. */
+    queries = [];
+    subscriptions = new Set();
+    datasetMeta = new Map();
+    /**
+     * Every write as a journal entry (doc 29 §7), so replay can rebuild whole objects — per object, the newest
+     * JOURNAL_CAP kept. Writing is cheap (the stored object is shared, changes are worked out when read): live
+     * feeds write thousands of times a second.
+     */
+    journal = new Map();
+    linkList = [];
+    /** The identity the engine handed over (doc 28 G13). */
+    auth = null;
+    deniedTypes = new Set();
+    redaction = null;
+    /** Position history per object (kept after removal, so replay can still show it). */
+    history = new Map();
+    constructor(records = [], options = {}) {
+        this.latencyMs = options.latencyMs ?? 0;
+        this.capabilities = { supportsSpatialQuery: true, supportsHistoricalQuery: true, supportsRealtime: true, supportsWrite: true, ...options.capabilities };
+        for (const r of records) {
+            const rec = 'object' in r ? r : { object: r };
+            this.records.set(rec.object.objectId, structuredClone(rec));
+            this.record(rec);
+            this.write(rec, undefined, rec.object.observedAt ?? '1970-01-01T00:00:00.000Z');
+        }
+    }
+    // ---------------------------------------------------------------- identity (doc 28 G13)
+    setAuth(auth) {
+        this.auth = auth ? structuredClone(auth) : null;
+    }
+    /** Test and demo hook: queries for these types are refused (ACCESS_DENIED), as a server would for this user. */
+    denyTypes(types) {
+        this.deniedTypes = new Set(types);
+    }
+    /** Test and demo hook: these properties are removed (and listed in `redacted`) unless the user has the role. */
+    redactFields(fields, unlessRole) {
+        this.redaction = fields.length ? { fields: [...fields], ...(unlessRole ? { unlessRole } : {}) } : null;
+    }
+    visible(o) {
+        const r = this.redaction;
+        if (!r || (r.unlessRole && this.auth?.roles?.includes(r.unlessRole)))
+            return o;
+        const hidden = r.fields.filter((f) => o.properties && f in o.properties);
+        if (!hidden.length)
+            return o;
+        const properties = { ...o.properties };
+        for (const f of hidden)
+            delete properties[f];
+        return { ...o, properties, redacted: [...new Set([...(o.redacted ?? []), ...hidden])] };
+    }
+    refuse(ontologyType) {
+        if (ontologyType && this.deniedTypes.has(ontologyType))
+            throw new MapEngineError('ACCESS_DENIED', `${ontologyType} is not available to this user`, { ontologyType });
+    }
+    setLatency(ms) {
+        this.latencyMs = ms;
+    }
+    /** The next query (or getCurrentState) rejects with this error. */
+    failNext(error = new Error('mock provider failure')) {
+        this.failures.push(error);
+    }
+    async query(query, signal) {
+        this.queries.push(structuredClone(query));
+        await delay(this.latencyMs, signal);
+        const failure = this.failures.shift();
+        if (failure)
+            throw failure;
+        if (!this.capabilities.supportsSpatialQuery && (query.spatial || query.bounds)) {
+            throw new Error('this provider cannot evaluate spatial predicates (supportsSpatialQuery: false)');
+        }
+        this.refuse(query.ontologyType);
+        const hits = [...this.records.values()].filter((r) => this.matches(r, query) && !(r.ontologyType && this.deniedTypes.has(r.ontologyType))).map((r) => r.object);
+        return rankByRelation(hits, query).map((o) => structuredClone(this.visible(o)));
+    }
+    matches(r, query) {
+        return (!query.ontologyType || r.ontologyType === query.ontologyType) && matchesQuery(r.object, query);
+    }
+    async getCurrentState(objectIds, signal) {
+        await delay(this.latencyMs, signal);
+        const failure = this.failures.shift();
+        if (failure)
+            throw failure;
+        return objectIds.flatMap((id) => {
+            const r = this.records.get(id);
+            return r && !(r.ontologyType && this.deniedTypes.has(r.ontologyType)) ? [structuredClone(this.visible(r.object))] : [];
+        });
+    }
+    async upsert(object, meta) {
+        const v = validateGeometry(object.geometry);
+        if (!v.valid)
+            throw new MapEngineError('INVALID_GEOMETRY', `${object.objectId}: ${v.reason}`, { objectId: object.objectId });
+        const prev = this.records.get(object.objectId);
+        const ontologyType = meta?.ontologyType ?? prev?.ontologyType;
+        const record = structuredClone(ontologyType !== undefined ? { object, ontologyType } : { object });
+        this.records.set(object.objectId, record);
+        this.record(record);
+        this.write(record, prev, object.observedAt ?? new Date().toISOString());
+        this.notify(object.objectId, record);
+    }
+    async remove(objectId) {
+        const prev = this.records.get(objectId);
+        if (!prev)
+            return;
+        this.records.delete(objectId);
+        this.addEntry({ at: new Date().toISOString(), objectId, kind: 'removed', ...(prev.ontologyType ? { ontologyType: prev.ontologyType } : {}) });
+        this.notify(objectId, undefined);
+    }
+    /** The stored record is a private copy and is replaced (never changed) on the next write, so it is shared here. */
+    write(record, prev, at) {
+        this.addEntry({ at, objectId: record.object.objectId, kind: prev ? 'updated' : 'created', object: record.object, ...(record.ontologyType ? { ontologyType: record.ontologyType } : {}) });
+    }
+    addEntry(e) {
+        let list = this.journal.get(e.objectId);
+        if (!list)
+            this.journal.set(e.objectId, (list = []));
+        list.push(e);
+        if (list.length > JOURNAL_CAP)
+            list.splice(0, list.length - JOURNAL_CAP);
+    }
+    // ---------------------------------------------------------------- journal (doc 29 §7) and links (doc 28 G4)
+    /** Adds journal entries (demos and tests): past states and changes, merged with what writes recorded. */
+    seedJournal(entries) {
+        for (const e of entries)
+            this.addEntry(structuredClone({ ...e, ontologyType: e.ontologyType ?? this.records.get(e.objectId)?.ontologyType }));
+    }
+    async getJournal(query, range, signal) {
+        await delay(this.latencyMs, signal);
+        this.refuse(query.ontologyType);
+        const from = Date.parse(range.start);
+        const to = Date.parse(range.end);
+        const out = [];
+        for (const [objectId, all] of this.journal) {
+            if (query.objectIds && !query.objectIds.includes(objectId))
+                continue;
+            const list = all.filter((e) => !query.ontologyType || e.ontologyType === query.ontologyType).sort((a, b) => Date.parse(a.at) - Date.parse(b.at));
+            if (!list.length)
+                continue;
+            const before = [...list].reverse().find((e) => Date.parse(e.at) < from);
+            if (before && before.kind !== 'removed' && before.object)
+                out.push({ at: range.start, objectId, kind: 'snapshot', object: structuredClone(this.visible(before.object)) });
+            let prev = before?.object;
+            for (const e of list) {
+                const t = Date.parse(e.at);
+                if (t < from)
+                    continue;
+                if (t > to)
+                    break;
+                const { ontologyType: _t, ...entry } = e;
+                // What changed since the entry before, worked out now (writes stay cheap).
+                const changes = entry.changes ?? (prev && entry.object ? diffProps(prev.properties, entry.object.properties) : undefined);
+                out.push(structuredClone({ ...entry, ...(entry.object ? { object: this.visible(entry.object) } : {}), ...(changes && Object.keys(changes).length ? { changes } : {}) }));
+                if (entry.object)
+                    prev = entry.object;
+            }
+        }
+        return out;
+    }
+    /** Adds links between objects (demos and tests). */
+    seedLinks(links) {
+        this.linkList.push(...structuredClone(links));
+    }
+    async getLinks(objectIds, types, signal) {
+        await delay(this.latencyMs, signal);
+        const ids = new Set(objectIds);
+        return this.linkList.filter((k) => (ids.has(k.fromId) || ids.has(k.toId)) && (!types || (k.type !== undefined && types.includes(k.type)))).map((k) => structuredClone(k));
+    }
+    /** Labels a dataset for the catalog, or hides it (e.g. app-internal draft types). */
+    describeDataset(ontologyType, meta) {
+        this.datasetMeta.set(ontologyType, { ...this.datasetMeta.get(ontologyType), ...meta });
+    }
+    /** Every ontology type held, with geometry, count and property schema — discovered from the records. */
+    async listDatasets(signal) {
+        await delay(this.latencyMs, signal);
+        const groups = new Map();
+        for (const r of this.records.values()) {
+            if (r.ontologyType === undefined || this.datasetMeta.get(r.ontologyType)?.hidden)
+                continue;
+            let list = groups.get(r.ontologyType);
+            if (!list)
+                groups.set(r.ontologyType, (list = []));
+            list.push(r.object);
+        }
+        // History means movement over time: at least two observations of one object.
+        const historyTypes = new Set([...this.history.values()].filter((h) => h.points.length >= 2).map((h) => h.ontologyType));
+        return [...groups.entries()]
+            .map(([ontologyType, objects]) => {
+            const kinds = new Set(objects.map((o) => o.geometry.type));
+            const families = new Set(objects.map((o) => geometryFamily(o.geometry.type)));
+            const meta = this.datasetMeta.get(ontologyType);
+            const info = {
+                ontologyType,
+                geometryType: kinds.size === 1 ? [...kinds][0] : 'Mixed',
+                geometryFamily: families.size === 1 ? [...families][0] : 'mixed',
+                count: objects.length,
+                properties: describeProperties(objects),
+                hasHistory: historyTypes.has(ontologyType),
+                live: this.capabilities.supportsRealtime,
+            };
+            const bounds = unionBounds(objects.map((o) => geometryBounds(o.geometry)));
+            if (bounds)
+                info.bounds = bounds;
+            if (meta?.label)
+                info.label = meta.label;
+            if (meta?.source)
+                info.source = meta.source;
+            if (meta?.altitude)
+                info.altitude = meta.altitude;
+            return info;
+        })
+            .sort((a, b) => a.ontologyType.localeCompare(b.ontologyType));
+    }
+    /** Replaces every object of a type (an import, a re-sync). Subscribers see the removals and upserts. */
+    async setDataset(ontologyType, objects) {
+        const keep = new Set(objects.map((o) => o.objectId));
+        for (const [id, r] of [...this.records])
+            if (r.ontologyType === ontologyType && !keep.has(id))
+                await this.remove(id);
+        for (const o of objects)
+            await this.upsert(o, { ontologyType });
+    }
+    async removeDataset(ontologyType) {
+        for (const [id, r] of [...this.records])
+            if (r.ontologyType === ontologyType)
+                await this.remove(id);
+        this.datasetMeta.delete(ontologyType);
+    }
+    /** Convenience for simulations: move a point and stamp the observation time. */
+    async move(objectId, position, observedAt = new Date().toISOString()) {
+        const r = this.records.get(objectId);
+        if (!r)
+            throw new MapEngineError('PROVIDER_ERROR', `unknown object ${objectId}`);
+        await this.upsert({ ...r.object, geometry: { type: 'Point', coordinates: position }, observedAt });
+    }
+    subscribe(query, onPatch, onError) {
+        const sub = { query: structuredClone(query), onPatch, onError, members: new Set() };
+        for (const r of this.records.values())
+            if (this.matches(r, sub.query))
+                sub.members.add(r.object.objectId);
+        this.subscriptions.add(sub);
+        return () => {
+            this.subscriptions.delete(sub);
+        };
+    }
+    /** Test hook: break every open stream (the engine should reconnect with a fresh snapshot). */
+    failStreams(error = new Error('stream disconnected')) {
+        for (const sub of [...this.subscriptions])
+            queueMicrotask(() => sub.onError?.(error));
+    }
+    subscriptionCount() {
+        return this.subscriptions.size;
+    }
+    notify(objectId, record) {
+        for (const sub of this.subscriptions) {
+            const now = record !== undefined && this.matches(record, sub.query);
+            const had = sub.members.has(objectId);
+            let patch = null;
+            if (now) {
+                sub.members.add(objectId);
+                patch = { upserted: [structuredClone(record.object)] };
+            }
+            else if (had) {
+                sub.members.delete(objectId);
+                patch = { removed: [objectId] };
+            }
+            if (patch) {
+                const p = patch;
+                queueMicrotask(() => {
+                    if (this.subscriptions.has(sub))
+                        sub.onPatch(p);
+                });
+            }
+        }
+    }
+    /** Adds past positions for an object (demos and tests). Points merge with recorded history by time. */
+    seedHistory(objectId, points, meta = {}) {
+        const h = this.history.get(objectId) ?? { ontologyType: meta.ontologyType ?? this.records.get(objectId)?.ontologyType, properties: meta.properties ?? this.records.get(objectId)?.object.properties, points: [] };
+        h.points = [...h.points, ...points.map((p) => ({ ...p }))].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp));
+        this.history.set(objectId, h);
+    }
+    async getTracks(query, range, signal) {
+        await delay(this.latencyMs, signal);
+        const failure = this.failures.shift();
+        if (failure)
+            throw failure;
+        const from = Date.parse(range.start);
+        const to = Date.parse(range.end);
+        const out = [];
+        for (const [objectId, h] of this.history) {
+            if (query.ontologyType && h.ontologyType !== query.ontologyType)
+                continue;
+            if (query.objectIds && !query.objectIds.includes(objectId))
+                continue;
+            const props = this.records.get(objectId)?.object.properties ?? h.properties;
+            if (query.filter && !matchesQuery({ objectId, geometry: { type: 'Point', coordinates: { latitude: 0, longitude: 0 } }, ...(props ? { properties: props } : {}) }, { filter: query.filter }))
+                continue;
+            // In range, plus the last point before it so positions can be interpolated from the range start.
+            const before = [...h.points].reverse().find((p) => Date.parse(p.timestamp) < from);
+            const inRange = h.points.filter((p) => Date.parse(p.timestamp) >= from && Date.parse(p.timestamp) <= to);
+            const points = before ? [before, ...inRange] : inRange;
+            if (!points.length)
+                continue;
+            if (query.bounds && !points.some((p) => boundsContainPosition(query.bounds, p)))
+                continue;
+            out.push({ objectId, points: structuredClone(points), ...(props ? { properties: structuredClone(props) } : {}) });
+        }
+        return out;
+    }
+    /** Every point position with a timestamp becomes history. */
+    record(r) {
+        const g = r.object.geometry;
+        if (g.type !== 'Point')
+            return;
+        const ts = r.object.observedAt ?? new Date().toISOString();
+        const h = this.history.get(r.object.objectId) ?? { ontologyType: r.ontologyType, properties: r.object.properties, points: [] };
+        h.ontologyType = r.ontologyType ?? h.ontologyType;
+        h.properties = r.object.properties ?? h.properties;
+        const heading = typeof r.object.properties?.heading === 'number' ? { heading: r.object.properties.heading } : {};
+        const last = h.points[h.points.length - 1];
+        if (!last || Date.parse(ts) >= Date.parse(last.timestamp))
+            h.points.push({ timestamp: ts, latitude: g.coordinates.latitude, longitude: g.coordinates.longitude, ...heading });
+        this.history.set(r.object.objectId, h);
+    }
+    /** Synchronous view for tests. Not part of any provider contract. */
+    size() {
+        return this.records.size;
+    }
+}

package/vendor/map-engine/testing/test-renderer.d.ts

@@ -0,0 +1,72 @@
+import type { BasemapConfig, MapConfig, MapLayer, MapViewport, RendererCapabilities, TerrainConfig, Position, SceneObject, ScenePatch, SceneState, Size, Unsubscribe } from '../core/types.js';
+import type { MapClickEvent, PickEvent, Renderer, RendererOptions } from '../render/renderer.js';
+type Listener<T> = (v: T) => void;
+/**
+ * A headless Renderer that records what it is told and lets tests play user input back.
+ * Its `objects` map is what a real renderer would be drawing: render() plus every update() applied.
+ */
+export declare class TestRenderer implements Renderer {
+    initialized: boolean;
+    destroyed: boolean;
+    options: RendererOptions | undefined;
+    readonly renders: SceneState[];
+    readonly patches: ScenePatch[];
+    readonly viewportsSet: MapViewport[];
+    readonly objects: Map<string, SceneObject>;
+    layers: MapLayer[];
+    size: Size;
+    /** When true, setViewport echoes back through onViewportChange, like MapLibre's moveend. */
+    echoViewport: boolean;
+    failInitialize: Error | null;
+    private readonly listeners;
+    readonly capabilities: RendererCapabilities;
+    /** Projections and terrains set after initialize (null = terrain off). */
+    readonly projections: Array<NonNullable<MapConfig['projection']>>;
+    readonly terrains: Array<TerrainConfig | null>;
+    private readonly ground;
+    constructor(options?: {
+        size?: Size;
+        echoViewport?: boolean;
+        setBasemap?: boolean;
+        capabilities?: RendererCapabilities;
+        ground?: (p: Position) => number | null;
+    });
+    initializeCount: number;
+    /** Basemaps swapped in with setBasemap(). */
+    readonly basemaps: BasemapConfig[];
+    /** Present unless constructed with `setBasemap: false` (then the runtime has to remount to change basemap). */
+    setBasemap?: (basemap: BasemapConfig) => Promise<void>;
+    initialize(_container: HTMLElement, options: RendererOptions): Promise<void>;
+    setViewport(viewport: MapViewport): void;
+    render(scene: SceneState): void;
+    update(patch: ScenePatch): void;
+    resizeCount: number;
+    resize(): void;
+    getSize(): Size;
+    /** Test projection: the last viewport set, 1 degree = 1000 px from the centre (not a real projection). */
+    project(position: {
+        latitude: number;
+        longitude: number;
+    }): {
+        x: number;
+        y: number;
+    } | null;
+    setProjection(projection: NonNullable<MapConfig['projection']>): void;
+    setTerrain(terrain: TerrainConfig | null): void;
+    /** Heights from the `ground` function given to the constructor (a test terrain). */
+    sampleElevation(positions: Position[]): Promise<Array<number | null>>;
+    destroy(): void;
+    onViewportChange(l: Listener<MapViewport>): Unsubscribe;
+    onPick(l: Listener<PickEvent>): Unsubscribe;
+    onMapClick(l: Listener<MapClickEvent>): Unsubscribe;
+    onHover(l: Listener<PickEvent | null>): Unsubscribe;
+    onError(l: Listener<Error>): Unsubscribe;
+    simulateViewportChange(v: MapViewport): void;
+    simulatePick(objectId: string, layerId: string, position?: Position): void;
+    simulateMapClick(position: Position): void;
+    simulateHover(e: PickEvent | null): void;
+    simulateError(e: Error): void;
+    listenerCount(): number;
+    private add;
+}
+export {};