@defold-typescript/types 0.50.0 → 0.51.0

package/generated/window.d.ts

@@ -161,7 +161,7 @@ declare global {
      * });
      * ```
      */
-    function set_listener(callback: ((self: unknown, event: (typeof window)[Extract<keyof typeof window, `WINDOW_EVENT_${string}`>], data: Record<string | number, unknown>) => void) | undefined): void;
+    function set_listener(callback: ((self: unknown, event: (typeof window)[Extract<keyof typeof window, `WINDOW_EVENT_${string}`>], data: window.event_data) => void) | undefined): void;
     /**
      * Set the locking state for current mouse cursor on a PC platform.
      * This function locks or unlocks the mouse cursor to the center point of the window. While the cursor is locked,

package/identity-vocabulary.json

@@ -539,11 +539,48 @@
         "undefined"
       ]
     },
+    "collectionfactory.create": {
+      "pins": [["table"], ["table<hash, hash>"]],
+      "replaces": ["LuaTable<Hash, Hash> & { get: LuaTableGetMethod<string, Hash> }"]
+    },
+    "collectionproxy.set_collection": {
+      "pins": [["number"], ["collectionproxy.RESULT"]],
+      "adds": ["nil"],
+      "slot": "code"
+    },
+    "factory.create": { "pins": [["hash"]], "adds": ["nil"] },
+    "gui.clone_tree": {
+      "pins": [["table"], ["table<hash, node>"]],
+      "replaces": [
+        "LuaTable<Hash, Opaque<\"node\">> & { get: LuaTableGetMethod<string, Opaque<\"node\">> }"
+      ]
+    },
+    "gui.get_tree": {
+      "pins": [["table"], ["table<hash, node>"]],
+      "replaces": [
+        "LuaTable<Hash, Opaque<\"node\">> & { get: LuaTableGetMethod<string, Opaque<\"node\">> }"
+      ]
+    },
     "gui.new_texture": {
       "pins": [["number"]],
       "replaces": ["number", "undefined"],
       "slot": "code"
     },
+    "image.get_astc_header": {
+      "pins": [["table", "nil"], ["image.astc_header", "nil"]],
+      "removes": ["nil"]
+    },
+    "physics.raycast": {
+      "pins": [
+        ["table", "nil"],
+        ["message.physics.ray_cast_response[]", "message.physics.ray_cast_response", "nil"]
+      ],
+      "replaces": [
+        "Omit<BuiltinMessages[\"ray_cast_response\"], \"request_id\">[]",
+        "Omit<BuiltinMessages[\"ray_cast_response\"], \"request_id\">",
+        "undefined"
+      ]
+    },
     "render.predicate": {
       "pins": [["number"], ["render_predicate"]],
       "replaces": ["Opaque<\"render_predicate\">"]
@@ -557,6 +594,15 @@
     "socket.protect": {
       "pins": [["function(function())"], ["fun(...:any):any"]],
       "replaces": ["(...args: unknown[]) => LuaMultiReturn<[unknown, string | undefined]>"]
+    },
+    "tilemap.get_tile": { "pins": [["number"], ["integer"]], "adds": ["nil"] },
+    "tilemap.get_tile_info": {
+      "pins": [["table"], ["{ index:integer, h_flip:boolean, v_flip:boolean, rotate_90:boolean }"]],
+      "adds": ["nil"]
+    },
+    "tilemap.get_tiles": {
+      "pins": [["table"], ["table<integer, table<integer, integer>>"]],
+      "adds": ["nil"]
     }
   }
 }

package/index.d.ts

@@ -5,6 +5,7 @@ import "./src/custom-messages";
 import "./src/msg-overloads";
 import "./src/message-guard";
 import "./src/window-event-guard";
+import "./src/physics-event-guard";
 import "./src/message-dispatch";
 import "./src/scene-addresses";
 import "./src/engine-globals";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/types",
-  "version": "0.50.0",
+  "version": "0.51.0",
   "description": "TypeScript types for the Defold engine's Lua APIs.",
   "license": "MIT",
   "repository": {
@@ -93,6 +93,7 @@
     "!scripts/example-typecheck.ts",
     "!scripts/example-variant-drift.ts",
     "!scripts/engine-binding-extract.ts",
+    "!scripts/binding-pin.ts",
     "!scripts/sync-engine-bindings.ts",
     "!scripts/engine-binding-diff.ts",
     "!scripts/engine-binding-verdicts.ts",

package/scripts/generate-api-availability.ts

@@ -108,7 +108,11 @@ export function identityCorrections(): IdentityCorrections {
         element,
         {
           pins: correctionPins(correction),
-          replaces: union(correction.ts),
+          ...(correction.ts !== undefined
+            ? { replaces: union(correction.ts) }
+            : correction.nullable
+              ? { adds: ["nil"] }
+              : { removes: ["nil"] }),
           ...(correction.slot === undefined ? {} : { slot: correction.slot }),
         },
       ]),

package/scripts/generate-api-signatures.ts

@@ -4,6 +4,7 @@ import type { SlotTypes } from "../src/emit-dts";
 import { selectCompleteVersionSurfaces, versionOf } from "./generate-api-availability";
 import {
   type ApiTarget,
+  type GenerateOptions,
   generateModuleSignatures,
   loadApiTargets,
   loadTargetModules,
@@ -28,10 +29,15 @@ export interface SignaturesArtifact {
 export interface BuildSignaturesOptions {
   readonly packageRoot?: string;
   readonly registryPath?: string;
-  // The constants each target's engine registers, which gate the undocumented
-  // constant back-fill. Omitted, every target is emitted ungated. Supplied by the
-  // in-repo callers only: the vendored bindings it reads are not published.
-  readonly registeredConstantsOf?: (target: ApiTarget) => ReadonlySet<string> | undefined;
+  // What each target's engine source decides for its emit (`targetBindingOptions`):
+  // the constants it registers, which gate the undocumented constant back-fill,
+  // and the binding-pinned return corrections whose pin holds there. Omitted,
+  // every target is emitted ungated and with no binding-pinned correction.
+  // Supplied by the in-repo callers only: the vendored bindings it reads are not
+  // published.
+  readonly emitOptionsOf?: (
+    target: ApiTarget,
+  ) => Pick<GenerateOptions, "registeredConstants" | "bindingEvidence">;
 }
 
 // The authored replacement for a symbol the skip filter withheld, read from the
@@ -79,12 +85,9 @@ export function buildSignaturesArtifact(options: BuildSignaturesOptions = {}): S
     const version = versionOf(target);
     const perSymbol: Record<string, string> = {};
     const perSymbolSlots: Record<string, SlotTypes> = {};
-    const registeredConstants = options.registeredConstantsOf?.(target);
+    const emitOptions = options.emitOptionsOf?.(target);
     for (const entry of loadTargetModules(target, packageRoot)) {
-      for (const signature of generateModuleSignatures(
-        entry,
-        registeredConstants ? { registeredConstants } : undefined,
-      )) {
+      for (const signature of generateModuleSignatures(entry, emitOptions)) {
         const key = symbolIdentityKey(signature.identity);
         perSymbol[key] = signature.tsSignature;
         if (Object.keys(signature.slotTypes).length > 0) {
@@ -129,8 +132,10 @@ export function serializeSignaturesArtifact(artifact: SignaturesArtifact): strin
 }
 
 if (import.meta.main) {
-  const { registeredConstantFqns } = await import("./engine-binding-extract");
-  const artifact = buildSignaturesArtifact({ registeredConstantsOf: registeredConstantFqns });
+  const { targetBindingOptions } = await import("./binding-pin");
+  const artifact = buildSignaturesArtifact({
+    emitOptionsOf: (target) => targetBindingOptions(target),
+  });
   if (process.argv.includes("--write")) {
     Bun.write(SIGNATURES_PATH, serializeSignaturesArtifact(artifact));
     const count = Object.values(artifact.versions).reduce((n, v) => n + Object.keys(v).length, 0);

package/scripts/materialize-version.ts

@@ -2,6 +2,7 @@ import { mkdirSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import {
   type ApiTarget,
+  type GenerateOptions,
   generateBuiltinMessagesDeclaration,
   generateModuleDeclaration,
   generateVersionIndex,
@@ -91,6 +92,11 @@ export interface BuildVersionedSurfaceOptions {
   // Defaults to reading them from the types package on disk; a caller with no
   // filesystem (a Worker) supplies the bytes and gets an identical file map.
   readonly augmentations?: readonly VersionedSurfaceFile[];
+  // What the target's own engine source decides for its emit
+  // (`targetBindingOptions`). Only an in-repo caller rebuilding a vendored
+  // target's committed surface passes it; a published install vendors no engine
+  // source, and the ref-doc targets it materializes have none to read.
+  readonly emitOptions?: Pick<GenerateOptions, "registeredConstants" | "bindingEvidence">;
 }
 
 export interface MaterializeVersionedSurfaceOptions extends BuildVersionedSurfaceOptions {
@@ -148,7 +154,7 @@ export async function buildVersionedSurfaceFiles(
     (surface) =>
       surface.map((entry) => ({
         path: entry.outFile,
-        contents: generateModuleDeclaration(entry, { surface }).contents,
+        contents: generateModuleDeclaration(entry, { ...opts.emitOptions, surface }).contents,
       })),
   );
 

package/scripts/regen.ts

@@ -2,6 +2,7 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import messagesDoc from "../fixtures/messages_doc.json" with { type: "json" };
 import {
+  type ApiFunction,
   type ApiModule,
   parseDefoldApiDoc,
   type SkipOverloadRule,
@@ -15,10 +16,10 @@ import {
   type SymbolSignature,
 } from "../src/emit-dts";
 import {
-  applyMessageDeprecations,
-  applyMessageFieldCorrections,
+  applyMessageOverlays,
   type EmitBuiltinMessagesOptions,
   emitBuiltinMessages,
+  type MessageCatalog,
   parseMessagesDoc,
 } from "../src/emit-messages";
 import type { TranslationStore } from "../src/example-store";
@@ -399,21 +400,24 @@ export interface MessagesManifestEntry {
 
 // Unlike MODULE_MANIFEST, this surface is hand-maintained: Defold ships no
 // machine-readable export for built-in message ids, so refresh fixtures/
-// messages_doc.json by hand from the Defold API reference. The
-// message-payload-drift test guards the payload shapes against drift.
+// messages_doc.json by hand from the default target's API reference. The
+// message-payload-drift test holds its message ids, field names and optionality
+// to that reference in both directions; what only the engine states is
+// MESSAGE_ENGINE_CORRECTIONS.
 export const MESSAGES_MANIFEST: MessagesManifestEntry = {
   doc: messagesDoc,
   outFile: "builtin-messages.d.ts",
 };
 
+export function builtinMessagesCatalog(entry: MessagesManifestEntry): MessageCatalog {
+  return applyMessageOverlays(parseMessagesDoc(entry.doc));
+}
+
 export function generateBuiltinMessagesDeclaration(
   entry: MessagesManifestEntry,
   opts: EmitBuiltinMessagesOptions = {},
 ): string {
-  return emitBuiltinMessages(
-    applyMessageFieldCorrections(applyMessageDeprecations(parseMessagesDoc(entry.doc))),
-    opts,
-  );
+  return emitBuiltinMessages(builtinMessagesCatalog(entry), opts);
 }
 
 export interface GenerateResult {
@@ -456,6 +460,7 @@ export interface GenerateOptions {
   translations?: TranslationStore;
   urlParameters?: UrlParameterTable;
   registeredConstants?: ReadonlySet<string>;
+  bindingEvidence?: ReadonlySet<string>;
   // The modules the entry is emitted beside, the entry among them. Routing
   // reads this set instead of looking the entry up in a committed manifest, so
   // a surface built with its own import root still routes as a whole.
@@ -468,9 +473,11 @@ interface PreparedGeneratedModule {
   translations: TranslationStore;
   urlParameters: UrlParameterTable;
   registeredConstants: ReadonlySet<string> | undefined;
+  bindingEvidence: ReadonlySet<string> | undefined;
   typeLeaves: Readonly<Record<string, string>> | undefined;
   declaredTypes: ReadonlyMap<string, string> | undefined;
   dropped: string[];
+  withheldFunctions: ApiFunction[];
 }
 
 // Parse a manifest entry, apply its `skipFunctions` and `skipOverloads` filters, and resolve the
@@ -482,7 +489,7 @@ function prepareGeneratedModule(
   options?: GenerateOptions,
 ): PreparedGeneratedModule {
   const routed = routedModuleOf(entry, options?.surface);
-  const { module, dropped } = routed?.prepared ?? withheldApiModule(entry);
+  const { module, dropped, withheldFunctions } = routed?.prepared ?? withheldApiModule(entry);
   const knownConstantFqns = options?.knownConstantFqns ?? collectConstantFqns();
   const translations = options?.translations ?? loadTranslations();
   const urlParameters = options?.urlParameters ?? committedUrlParameters();
@@ -492,14 +499,16 @@ function prepareGeneratedModule(
     translations,
     urlParameters,
     registeredConstants: options?.registeredConstants,
+    bindingEvidence: options?.bindingEvidence,
     typeLeaves: entry.typeLeaves,
     declaredTypes: routed?.declaredTypes,
     dropped,
+    withheldFunctions,
   };
 }
 
 interface RoutedSurface {
-  readonly modules: ReadonlyMap<ModuleManifestEntry, { module: ApiModule; dropped: string[] }>;
+  readonly modules: ReadonlyMap<ModuleManifestEntry, WithheldModule>;
   readonly declaredTypes: ReadonlyMap<string, string>;
 }
 
@@ -513,10 +522,7 @@ function routeSurface(entries: readonly ModuleManifestEntry[]): RoutedSurface {
     modules: new Map(
       entries.map((member, index) => [
         member,
-        {
-          module: routed[index] as ApiModule,
-          dropped: (withheld[index] as { dropped: string[] }).dropped,
-        },
+        { ...(withheld[index] as WithheldModule), module: routed[index] as ApiModule },
       ]),
     ),
     declaredTypes: declaredTypePaths(routed),
@@ -534,7 +540,7 @@ function routedModuleOf(
   callerSurface?: readonly ModuleManifestEntry[],
 ):
   | {
-      prepared: { module: ApiModule; dropped: string[] };
+      prepared: WithheldModule;
       declaredTypes: ReadonlyMap<string, string>;
     }
   | undefined {
@@ -622,8 +628,14 @@ function committedSurfaceOf(
   };
 }
 
+interface WithheldModule {
+  module: ApiModule;
+  dropped: string[];
+  withheldFunctions: ApiFunction[];
+}
+
 // The parsed module with the entry's `skipFunctions` and `skipOverloads` applied.
-function withheldApiModule(entry: ModuleManifestEntry): { module: ApiModule; dropped: string[] } {
+function withheldApiModule(entry: ModuleManifestEntry): WithheldModule {
   let module = parseDefoldApiDoc(entry.doc);
   const prefix = `${module.namespace}.`;
   const dropped: string[] = [];
@@ -651,7 +663,8 @@ function withheldApiModule(entry: ModuleManifestEntry): { module: ApiModule; dro
     }
     return withheld(name);
   };
-  module.functions = module.functions.filter((fn) => !withheld(fn.name));
+  const withheldFunctions = module.functions.filter((fn) => withheld(fn.name));
+  module.functions = module.functions.filter((fn) => !withheldFunctions.includes(fn));
   module.variables = module.variables.filter((v) => !withheld(v.name));
   const withheldConstants = new Set<string>();
   module.constants = module.constants.filter((c) => {
@@ -667,7 +680,7 @@ function withheldApiModule(entry: ModuleManifestEntry): { module: ApiModule; dro
   if (module.structs) module.structs = module.structs.filter((s) => !withheldType(s.name));
   module.typedefs = module.typedefs.filter((t) => t.aliasOf === undefined || !withheldType(t.name));
   module = withholdOverloads(module, entry.skipOverloads ?? []);
-  return { module, dropped };
+  return { module, dropped, withheldFunctions };
 }
 
 // The field corrections one target's runtime entries leave inert: every entry is
@@ -739,15 +752,19 @@ export function generateModuleDeclaration(
     translations,
     urlParameters,
     registeredConstants,
+    bindingEvidence,
     typeLeaves,
     declaredTypes,
     dropped,
+    withheldFunctions,
   } = prepareGeneratedModule(entry, options);
   const emitted = emitDeclarations(module, {
     knownConstantFqns,
     translations,
     urlParameters,
+    withheldFunctions,
     ...(registeredConstants ? { registeredConstants } : {}),
+    ...(bindingEvidence ? { bindingEvidence } : {}),
     ...(typeLeaves ? { typeLeaves } : {}),
     ...(declaredTypes ? { declaredTypes } : {}),
     ...(entry.indexBaseSource ? { indexBaseSource: entry.indexBaseSource } : {}),
@@ -772,6 +789,7 @@ export function generateModuleSignatures(
     knownConstantFqns,
     urlParameters,
     registeredConstants,
+    bindingEvidence,
     typeLeaves,
     declaredTypes,
   } = prepareGeneratedModule(entry, options);
@@ -779,6 +797,7 @@ export function generateModuleSignatures(
     knownConstantFqns,
     urlParameters,
     ...(registeredConstants ? { registeredConstants } : {}),
+    ...(bindingEvidence ? { bindingEvidence } : {}),
     ...(typeLeaves ? { typeLeaves } : {}),
     ...(declaredTypes ? { declaredTypes } : {}),
   });
@@ -857,6 +876,7 @@ const UNIVERSAL_EXTRA_IMPORTS: readonly UniversalExtraImport[] = [
   { specifier: "../../src/msg-overloads" },
   { specifier: "../../src/message-guard" },
   { specifier: "../../src/window-event-guard" },
+  { specifier: "../../src/physics-event-guard" },
   { specifier: "../../src/scene-addresses" },
   { specifier: "../../src/go-overloads" },
   { specifier: "../../src/component-properties" },
@@ -1127,14 +1147,12 @@ export async function regenerate(
 
   // Imported here rather than at module scope: the vendored engine bindings are
   // not published, and `resolve` loads this module from an installed package.
-  const { registeredConstantFqns } = await import("./engine-binding-extract");
+  const { targetBindingOptions } = await import("./binding-pin");
   const generated = resolve(import.meta.dir, "..", "generated");
   io.mkdir(resolve(generated, "editor-vm"));
-  const defaultRegistered = registeredConstantFqns(DEFAULT_TARGET);
+  const defaultBinding = targetBindingOptions(DEFAULT_TARGET);
   for (const entry of MODULE_MANIFEST) {
-    const { contents, dropped } = generateModuleDeclaration(entry, {
-      ...(defaultRegistered ? { registeredConstants: defaultRegistered } : {}),
-    });
+    const { contents, dropped } = generateModuleDeclaration(entry, defaultBinding);
     if (dropped.length > 0) {
       io.log(`note: dropped skipped member(s) from ${entry.namespace}: ${dropped.join(", ")}`);
     }
@@ -1183,10 +1201,9 @@ export async function regenerate(
   };
   for (const entry of VERSIONED_MODULE_MANIFEST) {
     const target = versionedTargets.find((t) => t.id === entry.versionId);
-    const registeredConstants = target ? registeredConstantFqns(target) : undefined;
     const { contents, dropped } = generateModuleDeclaration(
       entry,
-      registeredConstants ? { registeredConstants } : undefined,
+      target ? targetBindingOptions(target) : undefined,
     );
     if (dropped.length > 0) {
       io.log(

package/src/component-properties.d.ts

@@ -1,24 +1,121 @@
 /** @noSelfInFile */
 
-import type { Hash } from "./core-types";
+import type { Hash, Vector3 } from "./core-types";
 
-// Component property keys upstream examples read through `go.get` while no
-// ref-doc catalog declares them. Only evidenced keys belong here.
+// Property keys the engine handles while no ref-doc catalog declares them. Each
+// key comes from the component's `GetProperty` / `SetProperty` branches in the
+// engine source, or from an upstream example that reads it, and cites that
+// evidence. A key the engine reads but never writes is `readonly`.
 declare global {
+  namespace go {
+    interface properties {
+      /** The position's x component. `gameobject.cpp:GetProperty` reads one float. */
+      "position.x": number;
+      /** The position's y component. `gameobject.cpp:GetProperty` reads one float. */
+      "position.y": number;
+      /** The position's z component. `gameobject.cpp:GetProperty` reads one float. */
+      "position.z": number;
+      /** The rotation quaternion's x component. `gameobject.cpp:GetProperty` reads one float. */
+      "rotation.x": number;
+      /** The rotation quaternion's y component. `gameobject.cpp:GetProperty` reads one float. */
+      "rotation.y": number;
+      /** The rotation quaternion's z component. `gameobject.cpp:GetProperty` reads one float. */
+      "rotation.z": number;
+      /** The rotation quaternion's w component. `gameobject.cpp:GetProperty` reads one float. */
+      "rotation.w": number;
+      /** The euler rotation's x angle, in degrees. `gameobject.cpp:GetProperty` reads one float. */
+      "euler.x": number;
+      /** The euler rotation's y angle, in degrees. `gameobject.cpp:GetProperty` reads one float. */
+      "euler.y": number;
+      /** The euler rotation's z angle, in degrees. `gameobject.cpp:GetProperty` reads one float. */
+      "euler.z": number;
+      /** The scale's x component. `gameobject.cpp:GetProperty` reads one float. */
+      "scale.x": number;
+      /** The scale's y component. `gameobject.cpp:GetProperty` reads one float. */
+      "scale.y": number;
+      /** The scale's z component. `gameobject.cpp:GetProperty` reads one float. */
+      "scale.z": number;
+      /**
+       * The scale's x and y components. `gameobject.cpp:GetProperty` reads a
+       * vector3 whose z is always 1. `go.set` also takes a number, which it
+       * applies to both x and y.
+       */
+      "scale.xy": Vector3;
+    }
+  }
+
   namespace sprite {
     interface properties {
       /**
        * The texture bound to the sprite's first sampler. Not in the sprite
        * ref-doc; `resource.set`'s example reads it with
-       * `go.get("#sprite", "texture0")`.
+       * `go.get("#sprite", "texture0")`. Read-only:
+       * `comp_sprite.cpp:CompSpriteSetProperty` has no branch for it.
        */
-      texture0: Hash;
+      readonly texture0: Hash;
+    }
+  }
+
+  namespace model {
+    interface properties {
+      /**
+       * The material resource the model renders with.
+       * `comp_model.cpp:CompModelGetProperty` and `CompModelSetProperty` read
+       * and write it as a resource path hash.
+       */
+      material: Hash;
+      /**
+       * The skin the model's rig uses. `comp_model.cpp:CompModelGetProperty` and
+       * `CompModelSetProperty` read and write it as a hash.
+       */
+      skin: Hash;
+    }
+  }
+
+  namespace physics {
+    interface properties {
+      /**
+       * Whether the body runs continuous collision detection as a fast-moving
+       * bullet. Box2D only: `comp_collision_object_box2d.cpp` reads and writes
+       * it, while Bullet3D logs a warning and reports the property as not found.
+       */
+      bullet: boolean;
+    }
+  }
+
+  namespace factory {
+    /**
+     * Factory component properties. Upstream's factory reference declares none.
+     */
+    interface properties {
+      /**
+       * The path hash of the prototype the factory spawns. Read-only:
+       * `comp_factory.cpp:CompFactoryGetProperty` reads it and the component
+       * registers no set handler.
+       */
+      readonly prototype: Hash;
+    }
+  }
+
+  namespace collectionfactory {
+    /**
+     * Collection factory component properties. Upstream's collectionfactory
+     * reference declares none.
+     */
+    interface properties {
+      /**
+       * The path hash of the collection prototype the factory spawns.
+       * Read-only: `comp_collection_factory.cpp:CompCollectionFactoryGetProperty`
+       * reads it and the component registers no set handler.
+       */
+      readonly prototype: Hash;
     }
   }
 
   /**
    * Mesh component properties. Upstream ships no mesh API module, so this
-   * catalog holds only the keys upstream examples read.
+   * catalog holds the keys `comp_mesh.cpp:CompMeshGetProperty` and
+   * `CompMeshSetProperty` handle.
    */
   namespace mesh {
     interface properties {
@@ -28,6 +125,40 @@ declare global {
        * `go.get("#mesh", "vertices")`.
        */
       vertices: Hash;
+      /** The material resource the mesh renders with, as a resource path hash. */
+      material: Hash;
+      /** The texture on unit 0, as a resource path hash. The engine holds units 0-15. */
+      texture0: Hash;
+      /** The texture on unit 1, as a resource path hash. */
+      texture1: Hash;
+      /** The texture on unit 2, as a resource path hash. */
+      texture2: Hash;
+      /** The texture on unit 3, as a resource path hash. */
+      texture3: Hash;
+      /** The texture on unit 4, as a resource path hash. */
+      texture4: Hash;
+      /** The texture on unit 5, as a resource path hash. */
+      texture5: Hash;
+      /** The texture on unit 6, as a resource path hash. */
+      texture6: Hash;
+      /** The texture on unit 7, as a resource path hash. */
+      texture7: Hash;
+      /** The texture on unit 8, as a resource path hash. */
+      texture8: Hash;
+      /** The texture on unit 9, as a resource path hash. */
+      texture9: Hash;
+      /** The texture on unit 10, as a resource path hash. */
+      texture10: Hash;
+      /** The texture on unit 11, as a resource path hash. */
+      texture11: Hash;
+      /** The texture on unit 12, as a resource path hash. */
+      texture12: Hash;
+      /** The texture on unit 13, as a resource path hash. */
+      texture13: Hash;
+      /** The texture on unit 14, as a resource path hash. */
+      texture14: Hash;
+      /** The texture on unit 15, as a resource path hash. */
+      texture15: Hash;
     }
   }
 }