@adobe/data-gpu 0.9.69

package/dist/graphics/scene/scene-plugin.d.ts

@@ -0,0 +1,461 @@
+import { Database } from "@adobe/data/ecs";
+/**
+ * The complete authored scene — spatial hierarchy, models, camera, lighting,
+ * and the GPU uniform buffer that ties them together for rendering.
+ *
+ * Combines:
+ *   - `Node.plugin`           (node data + transform system)
+ *   - `model`                 (Geometry + Model archetypes)
+ *   - `SceneUniforms.plugin`  (camera resource + light resource + GPU uniform packing)
+ *
+ * Add a camera controller (e.g. `Orbit.plugin`), animation, and a renderer
+ * (`pbrIblRender`) to get a working interactive scene.
+ */
+export declare const scene: Database.Plugin<{
+    readonly visible: {
+        readonly type: "boolean";
+        readonly const: true;
+        readonly default: true;
+    };
+    readonly position: {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly precision: 1;
+            readonly default: number;
+        };
+        readonly minItems: 3;
+        readonly maxItems: 3;
+        readonly default: readonly [0, 0, 0];
+    };
+    readonly rotation: {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly precision: 1;
+            readonly default: number;
+        };
+        readonly minItems: 4;
+        readonly maxItems: 4;
+        readonly default: readonly [0, 0, 0, 1];
+        readonly interpolators: {
+            readonly linear: (q1: any, q2: any, t: number) => any;
+        };
+    };
+    readonly scale: {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly precision: 1;
+            readonly default: number;
+        };
+        readonly minItems: 3;
+        readonly maxItems: 3;
+        readonly default: readonly [0, 0, 0];
+    };
+    readonly parent: {
+        readonly type: "integer";
+        readonly minimum: -2147483648;
+        readonly maximum: 2147483647;
+        readonly default: number;
+    };
+    readonly _worldMatrix: {
+        readonly type: "array";
+        readonly items: {
+            readonly type: "number";
+            readonly precision: 1;
+            readonly default: number;
+        };
+        readonly minItems: 16;
+        readonly maxItems: 16;
+        readonly default: readonly [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+    };
+    readonly _worldBounds: {
+        readonly type: "object";
+        readonly properties: {
+            readonly min: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly precision: 1;
+                    readonly default: number;
+                };
+                readonly minItems: 3;
+                readonly maxItems: 3;
+                readonly default: readonly [0, 0, 0];
+            };
+            readonly max: {
+                readonly type: "array";
+                readonly items: {
+                    readonly type: "number";
+                    readonly precision: 1;
+                    readonly default: number;
+                };
+                readonly minItems: 3;
+                readonly maxItems: 3;
+                readonly default: readonly [0, 0, 0];
+            };
+        };
+        readonly required: readonly ["min", "max"];
+        readonly additionalProperties: false;
+        readonly default: {
+            readonly min: readonly [0, 0, 0];
+            readonly max: readonly [0, 0, 0];
+        };
+    };
+} & {} & {
+    readonly modelUrl: {
+        readonly type: "string";
+    };
+    readonly geometry: {
+        readonly type: "integer";
+        readonly minimum: -2147483648;
+        readonly maximum: 2147483647;
+        readonly default: number;
+    };
+}, {} & {
+    readonly light: {
+        readonly default: import("./light/public.js");
+    };
+} & {
+    readonly frameTime: {
+        readonly default: import("../../core/frame-time/public.js");
+        readonly transient: true;
+    };
+} & {
+    readonly schedulerState: {
+        readonly default: import("@adobe/data/ecs").SchedulerState;
+    };
+} & {
+    readonly device: {
+        readonly default: GPUDevice | null;
+        readonly transient: true;
+    };
+    readonly commandEncoder: {
+        readonly default: GPUCommandEncoder | null;
+        readonly transient: true;
+    };
+} & {
+    readonly renderPassEncoder: {
+        readonly default: GPURenderPassEncoder | null;
+        readonly transient: true;
+    };
+    readonly depthTexture: {
+        readonly default: GPUTexture | null;
+        readonly transient: true;
+    };
+    readonly clearColor: {
+        readonly default: readonly [number, number, number, number];
+        readonly transient: true;
+    };
+    readonly canvas: {
+        readonly default: HTMLCanvasElement | null;
+        readonly transient: true;
+    };
+    readonly canvasContext: {
+        readonly default: GPUCanvasContext | null;
+        readonly transient: true;
+    };
+    readonly canvasFormat: {
+        readonly default: GPUTextureFormat;
+        readonly transient: true;
+    };
+    readonly depthFormat: {
+        readonly default: GPUTextureFormat;
+        readonly transient: true;
+    };
+} & {
+    readonly camera: {
+        readonly default: import("../camera/public.js");
+    };
+} & {
+    readonly _sceneUniformsBuffer: {
+        readonly default: GPUBuffer | null;
+        readonly transient: true;
+    };
+}, {
+    readonly Node: readonly ["position", "rotation", "scale", "parent", "visible"];
+} & {} & {} & {
+    readonly Geometry: readonly ["modelUrl"];
+    readonly Model: readonly ["geometry", "position", "rotation", "scale", "visible", "parent"];
+}, {} & {} & {
+    readonly insertGeometry: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        readonly modelUrl: {
+            readonly type: "string";
+        };
+        readonly geometry: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+    } & {
+        readonly visible: {
+            readonly type: "boolean";
+            readonly const: true;
+            readonly default: true;
+        };
+        readonly position: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly precision: 1;
+                readonly default: number;
+            };
+            readonly minItems: 3;
+            readonly maxItems: 3;
+            readonly default: readonly [0, 0, 0];
+        };
+        readonly rotation: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly precision: 1;
+                readonly default: number;
+            };
+            readonly minItems: 4;
+            readonly maxItems: 4;
+            readonly default: readonly [0, 0, 0, 1];
+            readonly interpolators: {
+                readonly linear: (q1: any, q2: any, t: number) => any;
+            };
+        };
+        readonly scale: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly precision: 1;
+                readonly default: number;
+            };
+            readonly minItems: 3;
+            readonly maxItems: 3;
+            readonly default: readonly [0, 0, 0];
+        };
+        readonly parent: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+        readonly _worldMatrix: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly precision: 1;
+                readonly default: number;
+            };
+            readonly minItems: 16;
+            readonly maxItems: 16;
+            readonly default: readonly [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+        };
+        readonly _worldBounds: {
+            readonly type: "object";
+            readonly properties: {
+                readonly min: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly precision: 1;
+                        readonly default: number;
+                    };
+                    readonly minItems: 3;
+                    readonly maxItems: 3;
+                    readonly default: readonly [0, 0, 0];
+                };
+                readonly max: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly precision: 1;
+                        readonly default: number;
+                    };
+                    readonly minItems: 3;
+                    readonly maxItems: 3;
+                    readonly default: readonly [0, 0, 0];
+                };
+            };
+            readonly required: readonly ["min", "max"];
+            readonly additionalProperties: false;
+            readonly default: {
+                readonly min: readonly [0, 0, 0];
+                readonly max: readonly [0, 0, 0];
+            };
+        };
+    } & {}>, import("@adobe/data/schema").FromSchemas<{}>, {
+        readonly Geometry: readonly ["modelUrl"];
+        readonly Model: readonly ["geometry", "position", "rotation", "scale", "visible", "parent"];
+    } & {
+        readonly Node: readonly ["position", "rotation", "scale", "parent", "visible"];
+    } & {}, {} & {} & {}>, args: {
+        modelUrl: string;
+    }) => number;
+    readonly insertModel: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{
+        readonly modelUrl: {
+            readonly type: "string";
+        };
+        readonly geometry: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+    } & {
+        readonly visible: {
+            readonly type: "boolean";
+            readonly const: true;
+            readonly default: true;
+        };
+        readonly position: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly precision: 1;
+                readonly default: number;
+            };
+            readonly minItems: 3;
+            readonly maxItems: 3;
+            readonly default: readonly [0, 0, 0];
+        };
+        readonly rotation: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly precision: 1;
+                readonly default: number;
+            };
+            readonly minItems: 4;
+            readonly maxItems: 4;
+            readonly default: readonly [0, 0, 0, 1];
+            readonly interpolators: {
+                readonly linear: (q1: any, q2: any, t: number) => any;
+            };
+        };
+        readonly scale: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly precision: 1;
+                readonly default: number;
+            };
+            readonly minItems: 3;
+            readonly maxItems: 3;
+            readonly default: readonly [0, 0, 0];
+        };
+        readonly parent: {
+            readonly type: "integer";
+            readonly minimum: -2147483648;
+            readonly maximum: 2147483647;
+            readonly default: number;
+        };
+        readonly _worldMatrix: {
+            readonly type: "array";
+            readonly items: {
+                readonly type: "number";
+                readonly precision: 1;
+                readonly default: number;
+            };
+            readonly minItems: 16;
+            readonly maxItems: 16;
+            readonly default: readonly [1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1];
+        };
+        readonly _worldBounds: {
+            readonly type: "object";
+            readonly properties: {
+                readonly min: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly precision: 1;
+                        readonly default: number;
+                    };
+                    readonly minItems: 3;
+                    readonly maxItems: 3;
+                    readonly default: readonly [0, 0, 0];
+                };
+                readonly max: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "number";
+                        readonly precision: 1;
+                        readonly default: number;
+                    };
+                    readonly minItems: 3;
+                    readonly maxItems: 3;
+                    readonly default: readonly [0, 0, 0];
+                };
+            };
+            readonly required: readonly ["min", "max"];
+            readonly additionalProperties: false;
+            readonly default: {
+                readonly min: readonly [0, 0, 0];
+                readonly max: readonly [0, 0, 0];
+            };
+        };
+    } & {}>, import("@adobe/data/schema").FromSchemas<{}>, {
+        readonly Geometry: readonly ["modelUrl"];
+        readonly Model: readonly ["geometry", "position", "rotation", "scale", "visible", "parent"];
+    } & {
+        readonly Node: readonly ["position", "rotation", "scale", "parent", "visible"];
+    } & {}, {} & {} & {}>, args: {
+        geometry: number;
+        position?: readonly [number, number, number];
+        rotation?: import("@adobe/data/math").Quat;
+        scale?: readonly [number, number, number];
+        parent?: number;
+    }) => number;
+} & {
+    readonly setLight: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
+        readonly light: {
+            readonly default: import("./light/public.js");
+        };
+    }>, {}, {}>, args: Partial<import("./light/public.js")>) => void;
+} & {} & {} & {
+    readonly setCanvas: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
+        readonly renderPassEncoder: {
+            readonly default: GPURenderPassEncoder | null;
+            readonly transient: true;
+        };
+        readonly depthTexture: {
+            readonly default: GPUTexture | null;
+            readonly transient: true;
+        };
+        readonly clearColor: {
+            readonly default: readonly [number, number, number, number];
+            readonly transient: true;
+        };
+        readonly canvas: {
+            readonly default: HTMLCanvasElement | null;
+            readonly transient: true;
+        };
+        readonly canvasContext: {
+            readonly default: GPUCanvasContext | null;
+            readonly transient: true;
+        };
+        readonly canvasFormat: {
+            readonly default: GPUTextureFormat;
+            readonly transient: true;
+        };
+        readonly depthFormat: {
+            readonly default: GPUTextureFormat;
+            readonly transient: true;
+        };
+    } & {
+        readonly frameTime: {
+            readonly default: import("../../core/frame-time/public.js");
+            readonly transient: true;
+        };
+    } & {
+        readonly schedulerState: {
+            readonly default: import("@adobe/data/ecs").SchedulerState;
+        };
+    } & {
+        readonly device: {
+            readonly default: GPUDevice | null;
+            readonly transient: true;
+        };
+        readonly commandEncoder: {
+            readonly default: GPUCommandEncoder | null;
+            readonly transient: true;
+        };
+    }>, {}, {}>, canvas: HTMLCanvasElement | null) => void;
+} & {} & {}, "transformCreateWorldMatrix" | "transformSystem" | "update" | "_frameTime" | "schedulerSystem" | "input" | "preUpdate" | "postUpdate" | "physics" | "preRender" | "render" | "postRender" | "configureCanvas" | "beginRenderPass" | "endRenderPass" | "updateCameraAspect" | "sceneUniformsSystem", {}, {}, {}, {} & {} & {} & {}>;

package/dist/graphics/scene/scene-plugin.js

@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+import { Database } from "@adobe/data/ecs";
+import { plugin as nodePlugin } from "./node/node-plugin.js";
+import { model } from "./model/model-plugin.js";
+import { SceneUniforms } from "./scene-uniforms/scene-uniforms.js";
+/**
+ * The complete authored scene — spatial hierarchy, models, camera, lighting,
+ * and the GPU uniform buffer that ties them together for rendering.
+ *
+ * Combines:
+ *   - `Node.plugin`           (node data + transform system)
+ *   - `model`                 (Geometry + Model archetypes)
+ *   - `SceneUniforms.plugin`  (camera resource + light resource + GPU uniform packing)
+ *
+ * Add a camera controller (e.g. `Orbit.plugin`), animation, and a renderer
+ * (`pbrIblRender`) to get a working interactive scene.
+ */
+export const scene = Database.Plugin.combine(nodePlugin, model, SceneUniforms.plugin);
+//# sourceMappingURL=scene-plugin.js.map

package/dist/graphics/scene/scene-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scene-plugin.js","sourceRoot":"","sources":["../../../src/graphics/scene/scene-plugin.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAC7D,OAAO,EAAE,KAAK,EAAE,MAAM,yBAAyB,CAAC;AAChD,OAAO,EAAE,aAAa,EAAE,MAAM,oCAAoC,CAAC;AAEnE;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,QAAQ,CAAC,MAAM,CAAC,OAAO,CAAC,UAAU,EAAE,KAAK,EAAE,aAAa,CAAC,MAAM,CAAC,CAAC"}

package/dist/graphics/scene/scene-uniforms/create-bind-group-layout.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Bind group layout for the SceneUniforms uniform buffer. Stable across the
+ * renderer pipeline (consumer) and `_sceneUniforms` system (producer).
+ * WebGPU compares layouts structurally, so creating two layout objects from
+ * this descriptor is safe.
+ */
+export declare function createBindGroupLayout(device: GPUDevice): GPUBindGroupLayout;

package/dist/graphics/scene/scene-uniforms/create-bind-group-layout.js

@@ -0,0 +1,19 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+/**
+ * Bind group layout for the SceneUniforms uniform buffer. Stable across the
+ * renderer pipeline (consumer) and `_sceneUniforms` system (producer).
+ * WebGPU compares layouts structurally, so creating two layout objects from
+ * this descriptor is safe.
+ */
+export function createBindGroupLayout(device) {
+    return device.createBindGroupLayout({
+        entries: [
+            {
+                binding: 0,
+                visibility: GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT,
+                buffer: { type: "uniform" },
+            },
+        ],
+    });
+}
+//# sourceMappingURL=create-bind-group-layout.js.map

package/dist/graphics/scene/scene-uniforms/create-bind-group-layout.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-bind-group-layout.js","sourceRoot":"","sources":["../../../../src/graphics/scene/scene-uniforms/create-bind-group-layout.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD;;;;;GAKG;AACH,MAAM,UAAU,qBAAqB,CAAC,MAAiB;IACnD,OAAO,MAAM,CAAC,qBAAqB,CAAC;QAChC,OAAO,EAAE;YACL;gBACI,OAAO,EAAE,CAAC;gBACV,UAAU,EAAE,cAAc,CAAC,MAAM,GAAG,cAAc,CAAC,QAAQ;gBAC3D,MAAM,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE;aAC9B;SACJ;KACJ,CAAC,CAAC;AACP,CAAC"}

package/dist/graphics/scene/scene-uniforms/public.d.ts

@@ -0,0 +1,3 @@
+export * from "./schema.js";
+export { createBindGroupLayout } from "./create-bind-group-layout.js";
+export { plugin } from "./scene-uniforms-plugin.js";

package/dist/graphics/scene/scene-uniforms/public.js

@@ -0,0 +1,5 @@
+// © 2026 Adobe. MIT License. See /LICENSE for details.
+export * from "./schema.js";
+export { createBindGroupLayout } from "./create-bind-group-layout.js";
+export { plugin } from "./scene-uniforms-plugin.js";
+//# sourceMappingURL=public.js.map

package/dist/graphics/scene/scene-uniforms/public.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"public.js","sourceRoot":"","sources":["../../../../src/graphics/scene/scene-uniforms/public.ts"],"names":[],"mappings":"AAAA,uDAAuD;AAEvD,cAAc,aAAa,CAAC;AAC5B,OAAO,EAAE,qBAAqB,EAAE,MAAM,+BAA+B,CAAC;AACtE,OAAO,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/graphics/scene/scene-uniforms/scene-uniforms-plugin.d.ts

@@ -0,0 +1,137 @@
+import { Light } from "../light/light.js";
+import { Camera } from "../../camera/camera.js";
+/**
+ * sceneUniforms
+ *   query: —
+ *   read:
+ *     camera
+ *     light
+ *   write:
+ *     _sceneUniformsBuffer: GPUBuffer
+ */
+export declare const plugin: {
+    readonly components: {};
+    readonly resources: {
+        readonly light: {
+            readonly default: Light;
+        };
+    } & {
+        readonly frameTime: {
+            readonly default: import("../../../core/frame-time/public.js");
+            readonly transient: true;
+        };
+    } & {
+        readonly schedulerState: {
+            readonly default: import("@adobe/data/ecs").SchedulerState;
+        };
+    } & {
+        readonly device: {
+            readonly default: GPUDevice | null;
+            readonly transient: true;
+        };
+        readonly commandEncoder: {
+            readonly default: GPUCommandEncoder | null;
+            readonly transient: true;
+        };
+    } & {
+        readonly renderPassEncoder: {
+            readonly default: GPURenderPassEncoder | null;
+            readonly transient: true;
+        };
+        readonly depthTexture: {
+            readonly default: GPUTexture | null;
+            readonly transient: true;
+        };
+        readonly clearColor: {
+            readonly default: readonly [number, number, number, number];
+            readonly transient: true;
+        };
+        readonly canvas: {
+            readonly default: HTMLCanvasElement | null;
+            readonly transient: true;
+        };
+        readonly canvasContext: {
+            readonly default: GPUCanvasContext | null;
+            readonly transient: true;
+        };
+        readonly canvasFormat: {
+            readonly default: GPUTextureFormat;
+            readonly transient: true;
+        };
+        readonly depthFormat: {
+            readonly default: GPUTextureFormat;
+            readonly transient: true;
+        };
+    } & {
+        readonly camera: {
+            readonly default: Camera;
+        };
+    } & {
+        readonly _sceneUniformsBuffer: {
+            readonly default: GPUBuffer | null;
+            readonly transient: true;
+        };
+    };
+    readonly archetypes: {};
+    readonly transactions: {
+        readonly setLight: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
+            readonly light: {
+                readonly default: Light;
+            };
+        }>, {}, {}>, args: Partial<Light>) => void;
+    } & {} & {} & {
+        readonly setCanvas: (t: import("@adobe/data/ecs").TransactionContext<import("@adobe/data/schema").FromSchemas<{}>, import("@adobe/data/schema").FromSchemas<{
+            readonly renderPassEncoder: {
+                readonly default: GPURenderPassEncoder | null;
+                readonly transient: true;
+            };
+            readonly depthTexture: {
+                readonly default: GPUTexture | null;
+                readonly transient: true;
+            };
+            readonly clearColor: {
+                readonly default: readonly [number, number, number, number];
+                readonly transient: true;
+            };
+            readonly canvas: {
+                readonly default: HTMLCanvasElement | null;
+                readonly transient: true;
+            };
+            readonly canvasContext: {
+                readonly default: GPUCanvasContext | null;
+                readonly transient: true;
+            };
+            readonly canvasFormat: {
+                readonly default: GPUTextureFormat;
+                readonly transient: true;
+            };
+            readonly depthFormat: {
+                readonly default: GPUTextureFormat;
+                readonly transient: true;
+            };
+        } & {
+            readonly frameTime: {
+                readonly default: import("../../../core/frame-time/public.js");
+                readonly transient: true;
+            };
+        } & {
+            readonly schedulerState: {
+                readonly default: import("@adobe/data/ecs").SchedulerState;
+            };
+        } & {
+            readonly device: {
+                readonly default: GPUDevice | null;
+                readonly transient: true;
+            };
+            readonly commandEncoder: {
+                readonly default: GPUCommandEncoder | null;
+                readonly transient: true;
+            };
+        }>, {}, {}>, canvas: HTMLCanvasElement | null) => void;
+    } & {} & {};
+    readonly systems: import("@adobe/data/ecs").SystemDeclarations<"update" | "_frameTime" | "schedulerSystem" | "input" | "preUpdate" | "postUpdate" | "physics" | "preRender" | "render" | "postRender" | "configureCanvas" | "beginRenderPass" | "endRenderPass" | "updateCameraAspect" | "sceneUniformsSystem">;
+    readonly actions: {};
+    readonly services: {};
+    readonly computed: {};
+    readonly indexes: {};
+};