@miris-inc/core 0.0.8-655ef21 → 0.0.8-6acf41c

package/dist/core.d.ts

@@ -0,0 +1,690 @@
+export declare const AssetFormat: {
+    readonly GaussianSplats: 1;
+    readonly GES: 2;
+};
+
+declare interface AttributeInfo extends EmbindObject {
+    readonly dataType: number;
+    readonly componentCount: number;
+    readonly dataPtr: number;
+    readonly dataByteLength: number;
+    readonly clientSideId: bigint;
+    readonly maxValue: { x: number; y: number; z: number };
+}
+
+export declare class AttributeNames {
+    static readonly SPARK_PACKED_SPLAT: string;
+    static readonly SPARK_EXTENDED_SPLAT_LOW: string;
+    static readonly SPARK_EXTENDED_SPLAT_HIGH: string;
+    static readonly SPARK_PACKED_SH1: string;
+    static readonly SPARK_PACKED_SH2: string;
+    static readonly SPARK_PACKED_SH3: string;
+    static readonly SPARK_EXTENDED_SH1: string;
+    static readonly SPARK_EXTENDED_SH2: string;
+    static readonly SPARK_EXTENDED_SH3_A: string;
+    static readonly SPARK_EXTENDED_SH3_B: string;
+    static readonly UNUSED: string;
+    static readonly SHARK_ELLIPSOIDS: string;
+    static readonly SHARK_ELLIPSOIDS_COMPRESSED: string;
+    static readonly SHARK_SPHERICAL_HARMONICS: string;
+    static readonly COLOR: string;
+    static readonly OCTANT_OFFSETS: string;
+}
+
+declare type CachedAttribute = {
+    paddedData: Uint32Array<ArrayBuffer>;
+    originalSizeInUints: number;
+};
+
+export declare class Camera {
+    #private;
+    readonly id: number;
+    update(): void;
+    get viewportHeight(): number;
+    set viewportHeight(viewportHeight: number);
+    get aspect(): number;
+    set aspect(aspect: number);
+    get fov(): number;
+    set fov(fov: number);
+    get near(): number;
+    set near(near: number);
+    get far(): number;
+    set far(far: number);
+    get matrix(): Matrix4x4Tuple;
+    set matrix(matrix: Matrix4x4Tuple);
+    readonly engine: Engine;
+    readonly miris: Miris;
+    readonly scene: Scene;
+    constructor({ aspect, fov, near, far, matrix, scene, viewportHeight, }: CameraInit);
+}
+
+export declare type CameraInit = {
+    aspect: number;
+    fov: number;
+    near: number;
+    far: number;
+    matrix: Matrix4x4Tuple;
+    scene: Scene;
+    viewportHeight?: number;
+};
+
+export declare class Change {
+    readonly type: ChangeInit["type"];
+    readonly lod: ChangeInit["lod"];
+    constructor({ type, lod }: ChangeInit);
+}
+
+export declare type ChangeInit = {
+    type: "created" | "activated" | "modified" | "deactivated" | "deleted" | "remasked";
+    lod: Lod;
+};
+
+declare class Client {
+    #private;
+    readonly engine: Engine;
+    readonly handle: AquaClientHandle;
+    get viewerKey(): string | null;
+    set viewerKey(key: string | null);
+    constructor({ engine, context }: ClientInit);
+    dispose(): void;
+    addStreamById(...args: ClientMethodParameters["addStreamById"]): number;
+    destroyClient(...args: ClientMethodParameters["destroyClient"]): AquaStatus;
+    getAssetsAsync(...args: ClientMethodParameters["getAssetsAsync"]): AssetInfo[];
+    getAttribute(...args: ClientMethodParameters["getAttribute"]): AquaStatus;
+    getDefaultCameraId(...args: ClientMethodParameters["getDefaultCameraId"]): number;
+    getViewingVolumeId(...args: ClientMethodParameters["getViewingVolumeId"]): number;
+    getLocalBoundingBox(...args: ClientMethodParameters["getLocalBoundingBox"]): AquaStatus;
+    getWorldBoundingBox(...args: ClientMethodParameters["getWorldBoundingBox"]): AquaStatus;
+    getLodIndex(...args: ClientMethodParameters["getLodIndex"]): number;
+    getSceneChanges(...args: ClientMethodParameters["getSceneChanges"]): void;
+    getSceneChangesCounts(...args: ClientMethodParameters["getSceneChangesCounts"]): void;
+    getSceneMetadata(...args: ClientMethodParameters["getSceneMetadata"]): number;
+    getSceneObjectParent(...args: ClientMethodParameters["getSceneObjectParent"]): number;
+    getSceneObjectType(...args: ClientMethodParameters["getSceneObjectType"]): SceneObjectType;
+    getDrawnOctantMask(...args: ClientMethodParameters["getDrawnOctantMask"]): number;
+    getLocalTransform(...args: ClientMethodParameters["getLocalTransform"]): AquaStatus;
+    getWorldTransform(...args: ClientMethodParameters["getWorldTransform"]): AquaStatus;
+    hasAttribute(...args: ClientMethodParameters["hasAttribute"]): boolean;
+    isSceneObjectAncestorOf(...args: ClientMethodParameters["isSceneObjectAncestorOf"]): boolean;
+    lockScene(...args: ClientMethodParameters["lockScene"]): boolean;
+    removeStream(...args: ClientMethodParameters["removeStream"]): boolean;
+    setAssetViewerKey(...args: ClientMethodParameters["setAssetViewerKey"]): AquaStatus;
+    setClientSpatialFormat(...args: ClientMethodParameters["setClientSpatialFormat"]): AquaStatus;
+    setRuntimeSettings(...args: ClientMethodParameters["setRuntimeSettings"]): AquaStatus;
+    setMainCameraTransform(...args: ClientMethodParameters["setMainCameraTransform"]): AquaStatus;
+    setMainCameraViewFrustum(...args: ClientMethodParameters["setMainCameraViewFrustum"]): AquaStatus;
+    setSceneObjectTransform(...args: ClientMethodParameters["setSceneObjectTransform"]): AquaStatus;
+    hasFeature(...args: ClientMethodParameters["hasFeature"]): boolean;
+    getFeatureVersion(...args: ClientMethodParameters["getFeatureVersion"]): number;
+    getFeatureState(...args: ClientMethodParameters["getFeatureState"]): number;
+    getAssetFormatVersion(...args: ClientMethodParameters["getAssetFormatVersion"]): number;
+    getName(...args: ClientMethodParameters["getName"]): string;
+    setVariantSelection(...args: ClientMethodParameters["setVariantSelection"]): AquaStatus;
+    takeAttribute(...args: ClientMethodParameters["takeAttribute"]): AquaStatus;
+    takeEvictedClientSideAttributeIds(...args: ClientMethodParameters["takeEvictedClientSideAttributeIds"]): EmbindVector<bigint>;
+    takeRenderRequired(...args: ClientMethodParameters["takeRenderRequired"]): boolean;
+    unlockScene(...args: ClientMethodParameters["unlockScene"]): boolean;
+    updateSceneExecution(...args: ClientMethodParameters["updateSceneExecution"]): AquaStatus;
+}
+
+declare type ClientInit = {
+    engine: Engine;
+    context?: AquaContextHandle;
+};
+
+declare type ClientMethodParameters<Parameters extends EngineMethodParameters = EngineMethodParameters> = {
+    [Key in keyof Parameters]: Parameters[Key] extends [any, ...infer Rest] ? Rest : [];
+};
+
+declare interface EmbindObject {
+    delete(): void;
+}
+
+declare interface EmbindVector<T> extends EmbindObject {
+    size(): number;
+    get(index: number): T;
+    push_back(value: T): void;
+}
+
+/**
+ * The main Aqua wrapper.
+ *
+ * @remarks
+ * The engine is asynchronously initialized, meaning synchronous operations may
+ * fail if is not ready. To ensure the engine is ready, await `engine.ready`
+ * or check `engine.pending`.
+ */
+declare class Engine {
+    #private;
+    static AquaStatus: {
+        readonly Success: 0;
+        readonly Failure: 1;
+    };
+    static SceneObjectType: {
+        readonly ModelRoot: 0;
+        readonly SceneObject: 1;
+        readonly StreamObject: 2;
+        readonly GaussianSplats: 3;
+        readonly PointsObject: 4;
+        readonly Camera: 5;
+        readonly LodOctree: 6;
+        readonly VariantSetCollection: 7;
+        readonly VariantSet: 8;
+        readonly VariantSetOption: 9;
+    };
+    static Feature: {
+        readonly DrMap: 0;
+        readonly ReflMesh: 1;
+        readonly GlassMesh: 2;
+    };
+    static FeatureState: {
+        readonly NotLoaded: 0;
+        readonly Pending: 1;
+        readonly Loaded: 2;
+        readonly Failed: 3;
+    };
+    readonly ready: Promise<this>;
+    readonly pending: boolean;
+    get module(): MainModule;
+    constructor(moduleOptions?: Record<string, unknown>);
+    get AttributeInfo(): new () => AttributeInfo;
+    get Handedness(): {
+        Right: number;
+        Left: number;
+    };
+    get heapF32(): Float32Array<ArrayBuffer>;
+    get heapU8(): Uint8Array<ArrayBuffer>;
+    get MatrixOrder(): {
+        ColumnMajor: number;
+        RowMajor: number;
+    };
+    get SceneChangeIds(): new () => SceneChangeIds;
+    get SceneMetadata(): new () => SceneMetadata;
+    get RuntimeSettings(): new () => RuntimeSettings;
+    get SpatialFormat(): new () => SpatialFormat;
+    get StringVector(): new () => StringVector;
+    get UpAxis(): {
+        X: number;
+        Y: number;
+        Z: number;
+    };
+    activatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
+    addStreamById(...args: [
+    handle: AquaClientHandle,
+    streamName: string,
+    assetId: string,
+    doNotRefine: boolean
+    ]): number;
+    allocateSceneChangesArrays(...args: [sceneChangeIds: SceneChangeIds]): void;
+    createContext(...args: []): AquaContextHandle;
+    destroyContext(...args: [handle: AquaContextHandle]): AquaStatus;
+    createClient(context?: AquaContextHandle, ...args: []): AquaClientHandle;
+    createdObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
+    deletedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
+    dataPtrView(...args: [attributeInfo: AttributeInfo]): Uint32Array;
+    deactivatedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
+    remaskedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
+    getDrawnOctantMask(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
+    destroyClient(...args: [handle: AquaClientHandle]): AquaStatus;
+    free(...args: [size: number]): number;
+    getAssetsAsync(...args: [handle: AquaClientHandle, tags: StringVector]): AssetInfo[];
+    getAttribute(...args: [
+    handle: AquaClientHandle,
+    sceneObjectId: number,
+    attributeName: string,
+    attributeInfo: AttributeInfo
+    ]): AquaStatus;
+    getDefaultCameraId(...args: [handle: AquaClientHandle, streamObjectId: number]): number;
+    getViewingVolumeId(...args: [handle: AquaClientHandle, streamObjectId: number]): number;
+    getLocalBoundingBox(...args: [handle: AquaClientHandle, sceneObjectId: number, boxData: number]): AquaStatus;
+    getWorldBoundingBox(...args: [handle: AquaClientHandle, sceneObjectId: number, boxData: number]): AquaStatus;
+    getLodIndex(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
+    getSceneChanges(...args: [handle: AquaClientHandle, sceneChangeIds: SceneChangeIds]): void;
+    getSceneChangesCounts(...args: [handle: AquaClientHandle, sceneChangeIds: SceneChangeIds]): void;
+    getSceneMetadata(...args: [handle: AquaClientHandle, metadata: SceneMetadata]): number;
+    getSceneObjectParent(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
+    getSceneObjectType(...args: [handle: AquaClientHandle, sceneObjectId: number]): SceneObjectType;
+    getLocalTransform(...args: [
+    handle: AquaClientHandle,
+    sceneObjectId: number,
+    transform: number
+    ]): AquaStatus;
+    getWorldTransform(...args: [
+    handle: AquaClientHandle,
+    sceneObjectId: number,
+    transform: number
+    ]): AquaStatus;
+    hasAttribute(...args: [
+    handle: AquaClientHandle,
+    sceneObjectId: number,
+    attributeName: string
+    ]): boolean;
+    isSceneObjectAncestorOf(...args: [
+    handle: AquaClientHandle,
+    sceneObjectId: number,
+    descendantObjectId: number
+    ]): boolean;
+    lockScene(...args: [handle: AquaClientHandle]): boolean;
+    malloc(...args: [size: number]): number;
+    modifiedObjectIdsView(...args: [sceneChangeIds: SceneChangeIds]): Uint32Array;
+    onWorkerResult(...args: [
+    requestIdLow: number,
+    requestIdHigh: number,
+    bufferPtr: number,
+    bufferSize: number,
+    httpStatus: number,
+    duration: number,
+    ttfb: number,
+    success: boolean,
+    dataType: number,
+    errorPtr: string,
+    responseHeadersJson: string,
+    contextPtr: number
+    ]): void;
+    removeStream(...args: [handle: AquaClientHandle, streamObjectId: number]): boolean;
+    setAssetViewerKey(...args: [handle: AquaClientHandle, key: string]): AquaStatus;
+    setClientSpatialFormat(...args: [handle: AquaClientHandle, spatialFormat: SpatialFormat]): AquaStatus;
+    setRuntimeSettings(...args: [handle: AquaClientHandle, settings: RuntimeSettings]): AquaStatus;
+    setMainCameraTransform(...args: [handle: AquaClientHandle, cameraTransform: number]): AquaStatus;
+    setMainCameraViewFrustum(...args: [
+    handle: AquaClientHandle,
+    aspectRatio: number,
+    verticalFov: number,
+    nearPlane: number,
+    farPlane: number,
+    viewportHeightPixels: number
+    ]): AquaStatus;
+    setMaxCacheSize(...args: [maxSizeBytes: number]): void;
+    setPreferSharkEncodingProfiles(...args: [preferShark: boolean]): void;
+    setSceneObjectTransform(...args: [
+    handle: AquaClientHandle,
+    sceneObjectId: number,
+    transform: number
+    ]): AquaStatus;
+    hasFeature(...args: [handle: AquaClientHandle, sceneObjectId: number, feature: number]): boolean;
+    getFeatureVersion(...args: [handle: AquaClientHandle, sceneObjectId: number, feature: number]): number;
+    getFeatureState(...args: [handle: AquaClientHandle, sceneObjectId: number, feature: number]): number;
+    getAssetFormatVersion(...args: [handle: AquaClientHandle, sceneObjectId: number]): number;
+    getName(...args: [handle: AquaClientHandle, sceneObjectId: number]): string;
+    setVariantSelection(...args: [handle: AquaClientHandle, sceneObjectId: number]): AquaStatus;
+    takeAttribute(...args: [
+    handle: AquaClientHandle,
+    sceneObjectId: number,
+    attributeName: string,
+    clientSideId: bigint
+    ]): AquaStatus;
+    takeEvictedClientSideAttributeIds(...args: [handle: AquaClientHandle]): EmbindVector<bigint>;
+    getActiveClientSideIdsCheckSum(): number;
+    unlockScene(...args: [handle: AquaClientHandle]): boolean;
+    updateSceneExecution(...args: [handle: AquaClientHandle]): AquaStatus;
+    takeRenderRequired(...args: [handle: AquaClientHandle]): boolean;
+    /**
+     * Advances the runtime by one frame and recomputes the streaming budget. Call once per
+     * displayed frame per context, before the per-client updateSceneExecution() calls.
+     * `previousFrameTimeMs` is how long the previous frame took; pass 0 when there is no plausible
+     * measurement (first frame, or a resume from a stall) and the frame advances without recording
+     * one.
+     */
+    beginFrame(...args: [contextHandle: AquaContextHandle, previousFrameTimeMs: number]): AquaStatus;
+    createDeserializeWorker(_url: string, _workerUrl: string, poolSize: number): boolean;
+    cancelRequest(requestIdLow: number, requestIdHigh: number): boolean;
+    submitToWorker(requestIdLow: number, requestIdHigh: number, descriptorBuffer: ArrayBuffer, contextPtr: number): boolean;
+    terminateWorker(): void;
+    requestWorkerHeapSnapshots(topN: number): Promise<(string | null)[]>;
+    setWorkerHeapTrackingEnabled(enabled: boolean): Promise<void>;
+    resetWorkerHeapTracking(): Promise<void>;
+}
+
+declare type EngineMethodParameters<E extends Engine = Engine> = {
+    [Key in keyof E]: E[Key] extends (...args: any[]) => any ? Parameters<E[Key]> : never;
+};
+
+export declare class Lod {
+    #private;
+    readonly id: LodInit["id"];
+    readonly store: LodStore;
+    get key(): unknown;
+    set key(key: unknown);
+    readonly modelRoot: ModelRoot;
+    set bounds(bounds: Float32Array<ArrayBuffer> | null);
+    /**
+     * Retrieves the cached world bounds of this object
+     *
+     * @deprecated Retrieve the local bounds and transform as needed
+     */
+    get bounds(): Float32Array<ArrayBuffer> | null;
+    /**
+     * Sets the local bounds of this lod
+     */
+    set localBounds(bounds: Float32Array<ArrayBuffer> | null);
+    /**
+     * Retrieves the local bounds of this lod
+     */
+    get localBounds(): Float32Array<ArrayBuffer> | null;
+    set lodIndex(index: number);
+    get lodIndex(): number | null;
+    set paddingSplatsCount(count: number);
+    get paddingSplatsCount(): number;
+    set transform(transform: Float32Array<ArrayBuffer> | null);
+    get transform(): Float32Array<ArrayBuffer> | null;
+    get _drawnOctantMask(): number;
+    set _drawnOctantMask(mask: number);
+    get _octantOffsets(): Uint32Array<ArrayBuffer> | null;
+    get _hasOctantOffsets(): boolean;
+    _readOctantOffsets(engine: Engine): void;
+    hasAttribute(attributeName: string): boolean;
+    getDataFromAttribute(engine: Engine, attributeName: string, attributeInfo: AttributeInfo): CachedAttribute | null;
+    dispose(): void;
+    constructor({ id, modelRoot, lodStore, client }: LodInit);
+}
+
+export declare type LodInit = {
+    id: number;
+    modelRoot: ModelRoot;
+    lodStore: LodStore;
+    client: Client;
+};
+
+export declare class LodStore {
+    #private;
+    forKey(key: unknown): Lod | undefined;
+    forId(id: number): Lod | undefined;
+    setKey(key: unknown, lod: Lod): void;
+    setId(id: number, lod: Lod): Map<number, Lod>;
+    delete(lod: Lod): void;
+    deleteKey(key: unknown): void;
+    deleteId(id: number): void;
+}
+
+declare interface MainModule {
+    AttributeInfo: new () => AttributeInfo;
+    Handedness: { Right: number; Left: number };
+    HEAPF32: Float32Array<ArrayBuffer>;
+    HEAPU8: Uint8Array<ArrayBuffer>;
+    HEAPU32: Uint32Array<ArrayBuffer>;
+    MatrixOrder: { ColumnMajor: number; RowMajor: number };
+    SceneChangeIds: new () => SceneChangeIds;
+    SceneMetadata: new () => SceneMetadata;
+    RuntimeSettings: new () => RuntimeSettings;
+    SpatialFormat: new () => SpatialFormat;
+    StringVector: new () => StringVector;
+    UpAxis: { X: number; Y: number; Z: number };
+    ENV: Record<string, string>;
+
+    ccall(
+    ident: string,
+    returnType: string | null,
+    argTypes: string[],
+    args: unknown[],
+    ): number;
+
+    activatedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
+    AllocateSceneChangesArrays(sceneChangeIds: SceneChangeIds): void;
+    createdObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
+    dataPtrView(attributeInfo: AttributeInfo): Uint32Array;
+    deactivatedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
+    remaskedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
+    deletedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
+    GetDrawnOctantMask(handle: number, sceneObjectId: number): number;
+    GetAssetsAsync(handle: number, tags: StringVector): unknown[];
+    GetSceneChanges(handle: number, sceneChangeIds: SceneChangeIds): void;
+    GetSceneChangesCounts(handle: number, sceneChangeIds: SceneChangeIds): void;
+    GetSceneMetadata(handle: number, metadata: SceneMetadata): { value: number };
+    GetName(handle: number, sceneObjectId: number): string;
+    HasFeature(handle: number, sceneObjectId: number, feature: number): boolean;
+    GetFeatureVersion(handle: number, sceneObjectId: number, feature: number): number;
+    GetFeatureState(handle: number, sceneObjectId: number, feature: number): number;
+    GetAssetFormatVersion(handle: number, sceneObjectId: number): number;
+    SetClientSpatialFormat(handle: number, spatialFormat: SpatialFormat): { value: number };
+    SetRuntimeSettings(handle: number, settings: RuntimeSettings): { value: number };
+    TakeEvictedClientSideAttributeIds(handle: number): EmbindVector<bigint>;
+    GetActiveClientSideIdsCheckSum(): number;
+    TakeRenderRequired(handle: number): boolean;
+    BeginFrame(contextHandle: number, previousFrameTimeMs: number): number;
+    modifiedObjectIdsView(sceneChangeIds: SceneChangeIds): Uint32Array;
+    setMaxCacheSize(maxSizeBytes: number): void;
+    SetPreferSharkEncodingProfiles(prefer: boolean): void;
+}
+
+/**
+ * The main Miris application.
+ *
+ * @remarks
+ * This class is initialized asynchronously, so synchronous operations may
+ * fail if Miris is not ready. To ensure Miris is ready, await `miris.ready`
+ * or get `miris.pending`.
+ */
+export declare class Miris {
+    #private;
+    static tryUseShark: boolean;
+    static _instance: Miris;
+    static instance<T extends typeof Miris>(this: T): Promise<InstanceType<T>>;
+    readonly engine: Engine;
+    readonly ready: Promise<this>;
+    readonly pending: boolean;
+    get sharedContext(): number | undefined;
+    get viewerKey(): string | null | undefined;
+    set viewerKey(viewerKey: string | null | undefined);
+    get scenes(): Set<Scene>;
+    get useSphericalHarmonics(): boolean;
+    set useSphericalHarmonics(value: boolean);
+    constructor();
+    dispose(): void;
+    updateParentedTransform(_modelTransform: Float32Array<ArrayBuffer>, _parentTransform: Float32Array<ArrayBuffer>): Float32Array<ArrayBuffer> | undefined;
+    protected _xrModeActive: boolean;
+    protected _xrSession: XRSession | null;
+    protected _requestAnimationFrame: RequestAnimationFrameFn | null;
+    signalResumeFromIdle(): void;
+    get _splatCountBudget(): number;
+    /**
+     * Why 43? Because the AVP throttles down to 45Hz :(
+     */
+    static readonly _XR_TARGET_FRAME_RATE = 43;
+    /* Excluded from this release type: _XR_SPLAT_COUNT_BUDGET */
+    /* Excluded from this release type: _setTargetFrameRate */
+    /* Excluded from this release type: _setXRModeActive */
+    /* Excluded from this release type: _setSplatCountBudgetOverride */
+    /* Excluded from this release type: _update */
+    getLocalTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
+    getWorldTransform(client: Client, sceneObjectId: number): Float32Array<ArrayBuffer> | undefined;
+    /* Excluded from this release type: _updateForScene */
+    applyChanges(_entries: Change[]): void;
+    _computeAdditionalRenderNeeded(): boolean;
+    onColorSpaceDetected(_isLinear: boolean): void;
+    add(scene: Scene): void;
+    delete(scene: Scene): void;
+}
+
+export declare class ModelRoot {
+    #private;
+    static forKey(key: unknown): ModelRoot | undefined;
+    static forId(id: number): ModelRoot | undefined;
+    readonly id: ModelRootInit["id"];
+    get key(): unknown;
+    set key(key: unknown);
+    get lods(): Set<Lod>;
+    set transform(transform: Float32Array<ArrayBuffer>);
+    get transform(): Float32Array<ArrayBuffer>;
+    readonly stream: Stream;
+    constructor({ id, stream }: ModelRootInit);
+    add(lod: Lod): void;
+    dispose(): void;
+}
+
+export declare type ModelRootInit = {
+    id: number;
+    stream: Stream;
+};
+
+declare type RequestAnimationFrameFn = ((callback: FrameRequestCallback) => number) | ((callback: XRFrameRequestCallback) => void);
+
+declare interface RuntimeSettings extends EmbindObject {
+    maxBandwidthBitsPerSecond: number;
+    maxConcurrentRequests: number;
+    targetFramesPerSecond: number;
+    xrModeActive: boolean;
+    splatCountBudget: number;
+}
+
+export declare class Scene extends EventTarget {
+    #private;
+    get camera(): Camera | null;
+    set camera(camera: Camera | null);
+    static forId(id: number): Scene | undefined;
+    static forKey(key: unknown): Scene | undefined;
+    readonly id: number;
+    get key(): unknown;
+    set key(key: unknown);
+    /* Excluded from this release type: _assetFormat */
+    get viewerKey(): string | null;
+    set viewerKey(viewerKey: string | null);
+    get streams(): Set<Stream>;
+    get lods(): LodStore;
+    readonly miris: Miris;
+    readonly engine: Engine;
+    readonly client: Client;
+    readonly handle?: number;
+    constructor({ miris, viewerKey }: SceneInit);
+    /**
+     * Drives a frame and answers whether *this* scene's canvas needs repainting. Call it once per
+     * displayed frame from the host's animation loop, and render when it returns true.
+     *
+     * Every scene on the page calls this from its own loop. The first call in a displayed frame
+     * drives one engine tick for all of them; the rest recognise the frame and reuse it.
+     *
+     * @param ts the host's frame timestamp. Optional - the document timeline supplies one, and it
+     *   reads the same for every scene in a displayed frame. Pass it when the host runs its own
+     *   clock, as an immersive XR session does, because XRFrame time is not the document timeline.
+     */
+    update(ts?: DOMHighResTimeStamp): boolean;
+    dispose(): void;
+    fetchAssets(tags?: string | Iterable<string>): Promise<{
+        name: string;
+        thumbnailUrl: string;
+        uuid: string;
+        tags: string[];
+    }[]>;
+    add(stream: Stream): void;
+    getStreamForId(streamObjectId: number): Stream | undefined;
+    getStreamForDescendentId(descendentObjectId: number): Stream | null;
+    getModelRootForDescendentId(descendentObjectId: number): ModelRoot | null;
+    _recordAssetFormat(modelRoot: ModelRoot, formatVersion: number): void;
+    /* Excluded from this release type: _getFeatureMesh */
+    /* Excluded from this release type: _getDrMap */
+    /* Excluded from this release type: _onFeatureData */
+    /* Excluded from this release type: _onSceneLoaded */
+    delete(stream: Stream): void;
+    close(): void;
+}
+
+declare interface SceneChangeIds extends EmbindObject {
+    readonly createdObjectsCount: number;
+    readonly activatedObjectsCount: number;
+    readonly modifiedObjectsCount: number;
+    readonly deactivatedObjectsCount: number;
+    readonly deletedObjectsCount: number;
+    readonly remaskedObjectsCount: number;
+}
+
+export declare type SceneInit = {
+    miris: Miris;
+    viewerKey?: string | null;
+};
+
+declare interface SceneMetadata extends EmbindObject {
+    readonly inputColorSpace: string;
+}
+
+declare type SparkAttributeInfo = {
+    elementsPerSplat: number;
+    discard: boolean;
+};
+
+export declare const sparkAttributeList: Record<string, SparkAttributeInfo>;
+
+declare interface SpatialFormat extends EmbindObject {
+    metersPerUnit: number;
+    upAxis: number;
+    matrixOrder: number;
+    handedness: number;
+}
+
+export declare class Stream extends EventTarget {
+    #private;
+    static readonly _idMap: Map<number, Stream>;
+    static readonly _keyMap: Map<unknown, Stream>;
+    static forId(id?: number): Stream | undefined;
+    static forKey(key: unknown): Stream | undefined;
+    readonly id: number;
+    readonly scene: Scene;
+    readonly miris: Miris;
+    readonly client: Client;
+    readonly engine: Engine;
+    /* Excluded from this release type: _addVariantCollection */
+    /* Excluded from this release type: _findAndAddToVariantSet */
+    /* Excluded from this release type: _addVariant */
+    /* Excluded from this release type: _exportVariantHierarchies */
+    /* Excluded from this release type: _setVariantSelection */
+    get key(): unknown;
+    set key(key: unknown);
+    get matrix(): Matrix4x4Tuple;
+    set matrix(matrix: Matrix4x4Tuple);
+    get opacity(): number;
+    set opacity(opacity: number);
+    get boundingBox(): {
+        min: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        max: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        size: {
+            x: number;
+            y: number;
+            z: number;
+        };
+        center: {
+            x: number;
+            y: number;
+            z: number;
+        };
+    } | undefined;
+    get modelRoots(): Set<ModelRoot>;
+    /**
+     * @deprecated Use `modelRoots` instead.
+     */
+    get chunks(): Set<ModelRoot>;
+    constructor(options: StreamInit);
+    _initStream({ uuid }: StreamInit): void;
+    /* Excluded from this release type: _onStreamLoaded */
+    getDefaultCameraTransform(): Float32Array<ArrayBuffer> | null | undefined;
+    /* Excluded from this release type: _getViewingVolumeObb */
+    /* Excluded from this release type: _onRootLoaded */
+    add(modelRoot: ModelRoot): void;
+    end(): void;
+}
+
+export declare type StreamInit = {
+    uuid: string;
+    scene: Scene;
+    authToken?: string;
+    drmKey?: string;
+};
+
+declare type StringVector = EmbindVector<string>;
+
+/** Recursive variant tree node from WASM. */
+export declare type VariantNode = {
+    id: number;
+    name?: string;
+    type?: string;
+    children?: VariantNode[];
+    options?: VariantNode[];
+    nestedSets?: VariantNode[];
+};
+
+export { }