@defold-typescript/types 0.5.5 → 0.6.0

package/scripts/ref-doc-delta.ts

@@ -0,0 +1,143 @@
+import { parseDefoldApiDoc } from "../src/api-doc";
+import {
+  type ApiTarget,
+  loadApiTargets,
+  type ResolveTargetOptions,
+  resolveTargetModules,
+} from "./regen";
+
+export interface RefDocDeltaArgs {
+  target: string;
+  namespace: string;
+  present: string[];
+  absent: string[];
+  json: boolean;
+}
+
+export interface RefDocDeltaReport {
+  ok: boolean;
+  targetId: string;
+  version: string;
+  namespace: string;
+  provenance: string | null;
+  missingPresent: string[];
+  unexpectedPresent: string[];
+}
+
+export interface VerifyRefDocDeltaInput {
+  target: ApiTarget;
+  namespace: string;
+  present: readonly string[];
+  absent: readonly string[];
+  resolveOpts?: ResolveTargetOptions;
+}
+
+export function collectElementNames(doc: unknown): Set<string> {
+  const module = parseDefoldApiDoc(doc);
+  const names = new Set<string>([module.namespace]);
+  for (const collection of [
+    module.functions,
+    module.constants,
+    module.variables,
+    module.properties,
+  ]) {
+    for (const item of collection) {
+      if (item.name.length > 0) names.add(item.name);
+    }
+  }
+  return names;
+}
+
+export function parseRefDocDeltaArgs(argv: readonly string[]): RefDocDeltaArgs {
+  const args: RefDocDeltaArgs = { target: "", namespace: "", present: [], absent: [], json: false };
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (arg === "--json") {
+      args.json = true;
+      continue;
+    }
+    if (arg === "--target" || arg === "--namespace" || arg === "--present" || arg === "--absent") {
+      const value = argv[++i];
+      if (!value) throw new Error(`${arg} requires a value`);
+      if (arg === "--target") args.target = value;
+      else if (arg === "--namespace") args.namespace = value;
+      else if (arg === "--present") args.present.push(value);
+      else args.absent.push(value);
+      continue;
+    }
+    throw new Error(`unknown argument: ${arg}`);
+  }
+  if (!args.target) throw new Error("--target is required");
+  if (!args.namespace) throw new Error("--namespace is required");
+  if (args.present.length === 0 && args.absent.length === 0) {
+    throw new Error("at least one --present or --absent assertion is required");
+  }
+  return args;
+}
+
+export function selectRefDocDeltaTarget(
+  targets: readonly ApiTarget[],
+  targetId: string,
+): ApiTarget {
+  const target = targets.find((item) => item.id === targetId);
+  if (!target) throw new Error(`target "${targetId}" not found`);
+  if ((target.source ?? null)?.kind !== "ref-doc") {
+    throw new Error(`target "${targetId}" is not ref-doc sourced`);
+  }
+  return target;
+}
+
+export async function verifyRefDocDelta(input: VerifyRefDocDeltaInput): Promise<RefDocDeltaReport> {
+  const source = input.target.source ?? null;
+  if (source?.kind !== "ref-doc") {
+    throw new Error(`target "${input.target.id}" is not ref-doc sourced`);
+  }
+  const modules = await resolveTargetModules(input.target, input.resolveOpts);
+  const module = modules.find((entry) => entry.namespace === input.namespace);
+  if (!module) {
+    throw new Error(`target "${input.target.id}" has no namespace "${input.namespace}"`);
+  }
+  const names = collectElementNames(module.doc);
+  const missingPresent = input.present.filter((name) => !names.has(name));
+  const unexpectedPresent = input.absent.filter((name) => names.has(name));
+  return {
+    ok: missingPresent.length === 0 && unexpectedPresent.length === 0,
+    targetId: input.target.id,
+    version: source.version,
+    namespace: input.namespace,
+    provenance: module.sourceProvenance ?? null,
+    missingPresent,
+    unexpectedPresent,
+  };
+}
+
+function renderPlainReport(report: RefDocDeltaReport): string {
+  const lines = [
+    `${report.ok ? "ok" : "drift"}: ${report.targetId}/${report.namespace} (${report.version}, ${report.provenance ?? "unknown"})`,
+  ];
+  if (report.missingPresent.length > 0) {
+    lines.push(`missing expected present: ${report.missingPresent.join(", ")}`);
+  }
+  if (report.unexpectedPresent.length > 0) {
+    lines.push(`unexpected expected absent: ${report.unexpectedPresent.join(", ")}`);
+  }
+  return lines.join("\n");
+}
+
+if (import.meta.main) {
+  try {
+    const args = parseRefDocDeltaArgs(process.argv.slice(2));
+    const target = selectRefDocDeltaTarget(loadApiTargets(), args.target);
+    const report = await verifyRefDocDelta({
+      target,
+      namespace: args.namespace,
+      present: args.present,
+      absent: args.absent,
+    });
+    console.log(args.json ? JSON.stringify(report, null, 2) : renderPlainReport(report));
+    if (!report.ok) process.exitCode = 1;
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exitCode = 1;
+  }
+}

package/scripts/regen.ts

@@ -6,7 +6,12 @@ import { emitDeclarations } from "../src/emit-dts";
 import { emitBuiltinMessages, parseMessagesDoc } from "../src/emit-messages";
 import type { TranslationStore } from "../src/example-store";
 import { wrapAsAmbientGlobal } from "../src/publish-dts";
-import { type DownloadRefDoc, refDocCacheDir, resolveRefDoc } from "./doc-source";
+import {
+  type DocSourceProvenance,
+  type DownloadRefDoc,
+  refDocCacheDir,
+  resolveRefDoc,
+} from "./doc-source";
 import { loadTranslations } from "./example-store-io";
 import { type readZip, SYNC_MANIFEST, type SyncManifestEntry } from "./sync-api-docs";
 
@@ -75,6 +80,7 @@ export interface ModuleManifestEntry {
   readonly outFile: string;
   readonly skipFunctions?: readonly string[];
   readonly importsFrom?: string;
+  readonly sourceProvenance?: DocSourceProvenance;
 }
 
 export interface ResolveTargetOptions {
@@ -97,7 +103,7 @@ export async function resolveTargetModules(
   if (source == null) {
     return loadTargetModules(target, opts.packageRoot);
   }
-  const { zip } = await resolveRefDoc({
+  const { zip, provenance } = await resolveRefDoc({
     version: source.version,
     cacheDir: opts.cacheDir ?? refDocCacheDir(),
     ...(opts.download ? { download: opts.download } : {}),
@@ -116,6 +122,7 @@ export async function resolveTargetModules(
       doc: JSON.parse(zip.read(sync.zipEntry)),
       outFile: module.outFile,
       importsFrom: target.coreTypesImport,
+      sourceProvenance: provenance,
     };
     return module.skipFunctions ? { ...entry, skipFunctions: module.skipFunctions } : entry;
   });
@@ -212,6 +219,7 @@ export const RESTRICTED_NAMESPACES: Readonly<Record<string, string>> = {
 
 const UNIVERSAL_EXTRA_IMPORTS: readonly string[] = [
   "../builtin-messages",
+  "../../src/engine-globals",
   "../../src/msg-overloads",
   "../../src/message-guard",
   "../../src/go-overloads",
@@ -220,12 +228,13 @@ const UNIVERSAL_EXTRA_IMPORTS: readonly string[] = [
 export interface KindManifestEntry {
   readonly kind: string;
   readonly restricted?: string;
+  readonly factory: string;
 }
 
 export const KIND_MODULE_MANIFEST: readonly KindManifestEntry[] = [
-  { kind: "script" },
-  { kind: "gui-script", restricted: "gui" },
-  { kind: "render-script", restricted: "render" },
+  { kind: "script", factory: "defineScript" },
+  { kind: "gui-script", restricted: "gui", factory: "defineGuiScript" },
+  { kind: "render-script", restricted: "render", factory: "defineRenderScript" },
 ];
 
 export function generateKindIndex(kind: string): string {
@@ -234,11 +243,11 @@ export function generateKindIndex(kind: string): string {
   const universalNamespaces = MODULE_MANIFEST.filter(
     (m) => !Object.hasOwn(RESTRICTED_NAMESPACES, m.namespace),
   ).map((m) => `../${m.outFile.replace(/\.d\.ts$/, "")}`);
-  const lines = [...UNIVERSAL_EXTRA_IMPORTS, ...universalNamespaces]
-    .sort()
-    .map((path) => `import "${path}";`);
+  const lines = [
+    ...new Set([...universalNamespaces.sort(), ...[...UNIVERSAL_EXTRA_IMPORTS].sort()]),
+  ].map((path) => `import "${path}";`);
   if (entry.restricted) lines.push(`import "../${entry.restricted}";`);
-  return `${lines.join("\n")}\n\nexport {};\n`;
+  return `${lines.join("\n")}\n\nexport { ${entry.factory} } from "../../src/lifecycle";\nexport type { ScriptProperties, ScriptProperty } from "../../src/lifecycle";\n`;
 }
 
 export function generateVersionIndex(

package/src/core-types.ts

@@ -78,6 +78,20 @@ export interface Hash {
 }
 
 declare const OpaqueBrand: unique symbol;
+/**
+ * A nominal handle to an engine value you may hold and pass back to the API but
+ * must never inspect or construct — a Defold `node`, `texture`, `render_target`,
+ * `userdata`, etc. The `Name` parameter mints a distinct, mutually-incompatible
+ * brand per kind, so TypeScript's structural typing can't silently swap a
+ * `render_target` for a `constant`, and a plain object can't stand in for either.
+ *
+ * @remarks
+ * The brand is a phantom `unique symbol` property: it exists only in the type
+ * system (erased at transpile, never present at runtime). Because the symbol is
+ * not exported, consumer code cannot fabricate an `Opaque` — the engine API is
+ * the only source. Contrast with a `LuaTable` alias, which says the opposite:
+ * "inspect freely, the shape just isn't modeled."
+ */
 export interface Opaque<Name extends string> {
   readonly [OpaqueBrand]: Name;
 }

package/src/emit-dts.ts

@@ -82,8 +82,11 @@ export const TS_RESERVED_NAMES = new Set([
   "extends",
 ]);
 
-// Element names whose `table` slot is a genuinely-arbitrary lua table by design
-// — the serialization/JSON passthrough functions. Their emitted
+// Element names whose `table` slot is a genuinely-arbitrary lua table by design.
+// Two kinds: the serialization/JSON passthrough functions (Defold-internal — the
+// engine round-trips an arbitrary lua value), and the platform/OS-sourced opaque
+// blobs (external — the shape is set by the host OS or invoking app, not by
+// Defold, so there is no documented field list). Their emitted
 // `Record<string | number, unknown>` is the faithful "any lua table" type, not a
 // `recordTables` fidelity loss, so the audit consults this set to avoid counting
 // them. A new ref-doc function with an opaque table must be added here
@@ -95,6 +98,9 @@ export const ARBITRARY_TABLE_SLOTS = new Set([
   "sys.load",
   "sys.serialize",
   "sys.deserialize",
+  "iac.set_listener",
+  "push.get_scheduled",
+  "push.get_all_scheduled",
 ]);
 
 // Element names whose `table` slot is a prose-only `a table mapping X to Y`
@@ -131,6 +137,157 @@ export const HOMOGENEOUS_ARRAY_SLOTS: ReadonlyMap<string, string | readonly stri
   ["sound.get_groups", "hash"],
   ["iap.list", "string"],
   ["go.delete", ["string", "hash", "url"]],
+  // push.register's `notifications` is a prose-only array of push.NOTIFICATION_*
+  // bitmask constants (the ref example sums NOTIFICATION_BADGE/SOUND/ALERT). The
+  // vendored push_doc.json fixture declares no NOTIFICATION_* constant elements, so
+  // no brand exists to reference; `number` is the faithful element token for these
+  // numeric constants, mirroring the vmath.vector/buffer.* number entries.
+  ["push.register", "number"],
+]);
+
+// A `mapping` curation whose value is itself a single-level mapping, emitted
+// `LuaMap<Kouter, LuaMap<Kinner, Vinner>>` — the nested-row-map shape
+// (`tilemap.get_tiles` → `tiles[row][col]`).
+export type NestedMapping = { key: string; value: string };
+
+export type TableSlotCuration =
+  | { kind: "mapping"; key: string; value: string | readonly TableField[] | NestedMapping }
+  | { kind: "array"; element: string | readonly string[] }
+  | { kind: "object"; fields: readonly TableField[] }
+  | { kind: "array-object"; fields: readonly TableField[] };
+
+const SOCKET_HANDLE_TOKENS = ["client", "master", "unconnected"] as const;
+
+export const TABLE_SLOT_CURATIONS: ReadonlyMap<string, TableSlotCuration> = new Map([
+  ["collectionfactory.create:return:ids", { kind: "mapping", key: "hash", value: "hash" }],
+  // iap.finish and iap.acknowledge take the same Defold IAP transaction object —
+  // the table handed to the iap.set_listener callback. The ref-doc fixture
+  // describes it in prose only (no field list), so the shape is curated from the
+  // Defold iap reference. As a param-side object curation every field emits `?`,
+  // which is faithful: original_trans/signature/user_id are platform-specific.
+  [
+    "iap.finish:param:transaction",
+    {
+      kind: "object",
+      fields: [
+        { name: "ident", types: ["string"] },
+        { name: "state", types: ["number"] },
+        { name: "trans_ident", types: ["string"] },
+        { name: "date", types: ["string"] },
+        { name: "original_trans", types: ["string"] },
+        { name: "receipt", types: ["string"] },
+        { name: "signature", types: ["string"] },
+        { name: "user_id", types: ["string"] },
+      ],
+    },
+  ],
+  [
+    "iap.acknowledge:param:transaction",
+    {
+      kind: "object",
+      fields: [
+        { name: "ident", types: ["string"] },
+        { name: "state", types: ["number"] },
+        { name: "trans_ident", types: ["string"] },
+        { name: "date", types: ["string"] },
+        { name: "original_trans", types: ["string"] },
+        { name: "receipt", types: ["string"] },
+        { name: "signature", types: ["string"] },
+        { name: "user_id", types: ["string"] },
+      ],
+    },
+  ],
+  // iap.buy's `options` is documented in the fixture as prose only ("optional
+  // parameters as properties"), so the field set is curated from the Defold iap
+  // reference: a Facebook-only custom `request_id` and a Google-Play-only
+  // subscription-offer `token`. Both are platform-specific, hence param-side
+  // optional fields.
+  [
+    "iap.buy:param:options",
+    {
+      kind: "object",
+      fields: [
+        { name: "request_id", types: ["string"] },
+        { name: "token", types: ["string"] },
+      ],
+    },
+  ],
+  [
+    "liveupdate.get_mounts:return:mounts",
+    {
+      kind: "array-object",
+      fields: [
+        { name: "name", types: ["string"] },
+        { name: "uri", types: ["string"] },
+        { name: "priority", types: ["number"] },
+      ],
+    },
+  ],
+  [
+    "model.get_aabb:return:aabb",
+    {
+      kind: "object",
+      fields: [
+        { name: "min", types: ["vector3"] },
+        { name: "max", types: ["vector3"] },
+      ],
+    },
+  ],
+  [
+    "model.get_mesh_aabb:return:aabb",
+    {
+      kind: "mapping",
+      key: "hash",
+      value: [
+        { name: "min", types: ["vector3"] },
+        { name: "max", types: ["vector3"] },
+      ],
+    },
+  ],
+  ["physics.raycast:param:groups", { kind: "array", element: "hash" }],
+  ["physics.raycast_async:param:groups", { kind: "array", element: "hash" }],
+  // push.schedule's `notification_settings` is documented in the fixture as prose
+  // only ("Table with notification and platform specific fields"), so the field
+  // set is curated from the Defold push reference: an iOS `action`, an iOS
+  // `badge_count`, and an Android `priority`. Each is platform-specific, hence
+  // param-side optional fields.
+  [
+    "push.schedule:param:notification_settings",
+    {
+      kind: "object",
+      fields: [
+        { name: "action", types: ["string"] },
+        { name: "badge_count", types: ["number"] },
+        { name: "priority", types: ["number"] },
+      ],
+    },
+  ],
+  ["socket.select:param:recvt", { kind: "array", element: SOCKET_HANDLE_TOKENS }],
+  ["socket.select:param:sendt", { kind: "array", element: SOCKET_HANDLE_TOKENS }],
+  ["socket.select:return:sockets_r", { kind: "array", element: SOCKET_HANDLE_TOKENS }],
+  ["socket.select:return:sockets_w", { kind: "array", element: SOCKET_HANDLE_TOKENS }],
+  [
+    "tilemap.get_tile_info:return:tile_info",
+    {
+      kind: "object",
+      fields: [
+        { name: "index", types: ["number"] },
+        { name: "h_flip", types: ["boolean"] },
+        { name: "v_flip", types: ["boolean"] },
+        { name: "rotate_90", types: ["boolean"] },
+      ],
+    },
+  ],
+  // tilemap.get_tiles returns a sparse table of rows iterated `tiles[row][col]`,
+  // the keys being tile positions offset by tilemap.get_bounds() (not a dense
+  // 0..n run). The faithful shape is the nested LuaMap idiom
+  // `LuaMap<number, LuaMap<number, number>>` — the keys are plain `number` tile
+  // positions, not a branded `Hash`, and a non-string-keyed Lua table is `LuaMap`,
+  // never a `Record` (which would imply a dense index object).
+  [
+    "tilemap.get_tiles:return:tiles",
+    { kind: "mapping", key: "number", value: { key: "number", value: "number" } },
+  ],
 ]);
 
 /**
@@ -482,6 +639,7 @@ export function emitDeclarations(module: ApiModule, options?: EmitOptions): stri
   const decl = hasAliases ? "export " : "";
 
   const lines: string[] = [];
+  for (const docLine of namespaceDocLines(module)) lines.push(docLine);
   lines.push(`declare namespace ${module.namespace} {`);
 
   for (const t of typedefs) {
@@ -653,6 +811,15 @@ function summaryDocLines(brief: string, description: string, indent: string): st
   return indentDocLines({ summary: htmlToDocText(summaryFor(brief, description)) }, indent);
 }
 
+function namespaceDocLines(module: ApiModule): string[] {
+  const official = summaryFor(module.brief, module.description).trim();
+  const summary =
+    official.length > 0
+      ? htmlToDocText(official)
+      : `(synthesized)\nDefold \`${module.namespace}\` API namespace.`;
+  return indentDocLines({ summary }, "");
+}
+
 function indentDocLines(parts: DocCommentParts, indent: string): string[] {
   return renderDocComment(parts).map((line) => `${indent}${line}`);
 }
@@ -690,7 +857,7 @@ function emitParameter(
   const concrete = p.types.filter((t) => t !== "nil");
   const ts =
     concrete.length > 0
-      ? mapSlotUnion(concrete, p.doc, mapType, true, resolver, elementName)
+      ? mapSlotUnion(concrete, p.doc, mapType, true, resolver, elementName, "param", p.name)
       : "unknown";
   return `${name}${optional ? "?" : ""}: ${ts}`;
 }
@@ -708,7 +875,7 @@ function emitReturn(
     // typescript-to-lua erases to `local a, b = fn()`.
     const slots = returnValues.map((rv) =>
       rv.types.length > 0
-        ? mapSlotUnion(rv.types, rv.doc, mapType, false, resolver, elementName)
+        ? mapSlotUnion(rv.types, rv.doc, mapType, false, resolver, elementName, "return", rv.name)
         : "unknown",
     );
     return { type: `LuaMultiReturn<[${slots.join(", ")}]>`, trailing: "" };
@@ -717,7 +884,16 @@ function emitReturn(
   if (!first) return { type: "void", trailing: "" };
   const ts =
     first.types.length > 0
-      ? mapSlotUnion(first.types, first.doc, mapType, false, resolver, elementName)
+      ? mapSlotUnion(
+          first.types,
+          first.doc,
+          mapType,
+          false,
+          resolver,
+          elementName,
+          "return",
+          first.name,
+        )
       : "unknown";
   return { type: ts, trailing: "" };
 }
@@ -742,22 +918,38 @@ function mapSlotUnion(
   optionalFields: boolean,
   resolver: TableDocResolver,
   elementName: string,
+  slotKind?: "param" | "return",
+  slotName?: string,
 ): string {
   const mapped: string[] = [];
   const seen = new Set<string>();
   for (const token of types) {
     let ts: string;
     if (token === "table") {
-      const mapping = MAPPING_TABLE_SLOTS.get(elementName);
-      const element = HOMOGENEOUS_ARRAY_SLOTS.get(elementName);
+      const curation =
+        slotKind !== undefined && slotName !== undefined
+          ? TABLE_SLOT_CURATIONS.get(tableSlotKey(elementName, slotKind, slotName))
+          : undefined;
+      const mapping =
+        curation?.kind === "mapping" ? curation : MAPPING_TABLE_SLOTS.get(elementName);
+      const element =
+        curation?.kind === "array" ? curation.element : HOMOGENEOUS_ARRAY_SLOTS.get(elementName);
       if (mapping !== undefined) {
-        ts = `LuaMap<${mapType(mapping.key)}, ${mapType(mapping.value)}>`;
+        let value: string;
+        if (typeof mapping.value === "string") {
+          value = mapType(mapping.value);
+        } else if (Array.isArray(mapping.value)) {
+          value = inlineTableType(mapping.value, mapType, optionalFields);
+        } else {
+          const nested = mapping.value as NestedMapping;
+          value = `LuaMap<${mapType(nested.key)}, ${mapType(nested.value)}>`;
+        }
+        ts = `LuaMap<${mapType(mapping.key)}, ${value}>`;
       } else if (element !== undefined) {
-        const tokens = typeof element === "string" ? [element] : element;
-        ts =
-          tokens.length > 1
-            ? `(${unionFromTokens(tokens, mapType)})[]`
-            : `${mapType(tokens[0] as string)}[]`;
+        ts = arrayTypeFromTokens(element, mapType);
+      } else if (curation?.kind === "object" || curation?.kind === "array-object") {
+        const object = inlineTableType(curation.fields, mapType, optionalFields);
+        ts = curation.kind === "array-object" ? `${object}[]` : object;
       } else {
         const fields = parseTableFields(doc, resolver);
         if (fields !== null) {
@@ -777,6 +969,20 @@ function mapSlotUnion(
   return mapped.join(" | ");
 }
 
+function tableSlotKey(elementName: string, slotKind: "param" | "return", slotName: string): string {
+  return `${elementName}:${slotKind}:${slotName}`;
+}
+
+function arrayTypeFromTokens(
+  element: string | readonly string[],
+  mapType: (t: string) => string,
+): string {
+  const tokens = typeof element === "string" ? [element] : element;
+  return tokens.length > 1
+    ? `(${unionFromTokens(tokens, mapType)})[]`
+    : `${mapType(tokens[0] as string)}[]`;
+}
+
 export function inlineTableType(
   fields: readonly TableField[],
   mapType: (t: string) => string,

package/src/engine-globals.d.ts

@@ -1,7 +1,9 @@
+/** @noSelfInFile */
 import type * as Core from "./core-types";
 
 declare global {
   type Hash = Core.Hash;
+  function hash(s: string): Core.Hash;
   type Opaque<Name extends string> = Core.Opaque<Name>;
   type Url = Core.Url;
   type Vector = Core.Vector;

package/src/go-overloads.d.ts

@@ -1,6 +1,11 @@
 /** @noSelfInFile */
+
 import type { Hash, Opaque, Quaternion, Url, Vector3, Vector4 } from "./core-types";
 
+interface ScriptProperty<TValue> {
+  readonly __defoldScriptProperty: TValue;
+}
+
 declare global {
   namespace go {
     interface GoPropertyOptions {
@@ -61,5 +66,43 @@ declare global {
       value: number | boolean | Hash | Url | Vector3 | Vector4 | Quaternion | Opaque<"resource">,
       options?: GoPropertyOptions,
     ): void;
+    /**
+     * Registers a Defold editor script property (deprecated escape hatch).
+     *
+     * @deprecated Don't call `go.property` yourself. Declare the property in
+     * `defineScript({ properties })` — that is the only form that types it onto
+     * `self`; the transpiler emits the `go.property(...)` registration for you.
+     * A direct call still registers, but `self.<name>` stays untyped.
+     *
+     * @param name - editor property id to register.
+     * @param value - default value for the registered property.
+     * @returns a phantom descriptor used only for TypeScript self typing.
+     * @example
+     * ```ts
+     * // Declare it as a field — the key is the name, the value is the default:
+     * export default defineScript({
+     *   properties: { speed: 450 },
+     *   update(self) {
+     *     self.speed; // number
+     *   },
+     * });
+     * // The transpiler emits, at chunk scope:  go.property("speed", 450)
+     * ```
+     */
+    function property(name: string, value: number): ScriptProperty<number>;
+    /** @deprecated Declare booleans via the `defineScript({ properties })` field. */
+    function property(name: string, value: boolean): ScriptProperty<boolean>;
+    /** @deprecated Declare hashes via the `defineScript({ properties })` field. */
+    function property(name: string, value: Hash): ScriptProperty<Hash>;
+    /** @deprecated Declare URLs via the `defineScript({ properties })` field. */
+    function property(name: string, value: Url): ScriptProperty<Url>;
+    /** @deprecated Declare vector3s via the `defineScript({ properties })` field. */
+    function property(name: string, value: Vector3): ScriptProperty<Vector3>;
+    /** @deprecated Declare vector4s via the `defineScript({ properties })` field. */
+    function property(name: string, value: Vector4): ScriptProperty<Vector4>;
+    /** @deprecated Declare quaternions via the `defineScript({ properties })` field. */
+    function property(name: string, value: Quaternion): ScriptProperty<Quaternion>;
+    /** @deprecated Declare resources via the `defineScript({ properties })` field. */
+    function property(name: string, value: Opaque<"resource">): ScriptProperty<Opaque<"resource">>;
   }
 }

package/src/index.ts

@@ -17,11 +17,16 @@ export {
   defineRenderScript,
   defineScript,
   type GuiScriptHooks,
+  type GuiScriptHooksWithProperties,
   type InputAction,
   type InputTouch,
   type RenderScriptHooks,
+  type RenderScriptHooksWithProperties,
   SCRIPT_HOOK_NAMES,
   type ScriptHookName,
   type ScriptHooks,
+  type ScriptHooksWithProperties,
+  type ScriptProperties,
+  type ScriptProperty,
 } from "./lifecycle";
 export { type WrapOptions, wrapAsAmbientGlobal } from "./publish-dts";