@defold-typescript/types 0.44.1 → 0.45.0

package/generated/versions/defold-1.13.1/material.d.ts

@@ -108,7 +108,16 @@ declare global {
      * vmath.vector4 | vmath.matrix4 the value(s) of the constant. If the constant is an array, the value will be a table of vmath.vector4 or vmath.matrix4 if the type is `material.CONSTANT_TYPE_USER_MATRIX4`.
      * @example
      * ```ts
-     * const constants = material.get_constants(resource.material("/my_material.materialc"));
+     * // Get the shader constants from a material specified as a resource property
+     * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_material: resource.material() },
+     *
+     *   init(self) {
+     *     const constants = material.get_constants(self.my_material);
+     *   },
+     * });
      * ```
      */
     function get_constants(path: Hash | string): { name: Hash; type: number; value: Vector4 | Matrix4 }[];
@@ -159,7 +168,16 @@ declare global {
      * number the max anisotropy of the texture sampler
      * @example
      * ```ts
-     * const samplers = material.get_samplers(resource.material("/my_material.materialc"));
+     * // Get the texture samplers from a material specified as a resource property
+     * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_material: resource.material() },
+     *
+     *   init(self) {
+     *     const samplers = material.get_samplers(self.my_material);
+     *   },
+     * });
      * ```
      */
     function get_samplers(path: Hash | string): { name: Hash; u_wrap: number; v_wrap: number; min_filter: number; mag_filter: number; max_anisotropy: number }[];
@@ -201,7 +219,16 @@ declare global {
      * - `graphics.TEXTURE_USAGE_FLAG_COLOR`
      * @example
      * ```ts
-     * const textures = material.get_textures(resource.material("/my_material.materialc"));
+     * // Get the textures from a material specified as a resource property
+     * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_material: resource.material() },
+     *
+     *   init(self) {
+     *     const textures = material.get_textures(self.my_material);
+     *   },
+     * });
      * ```
      */
     function get_textures(path: Hash | string): { path: Hash; handle: Hash; width: number; height: number; depth: number; mipmaps: number; type: number; flags: number }[];
@@ -253,7 +280,16 @@ declare global {
      * - `graphics.SEMANTIC_TYPE_MORPH_TARGET_WEIGHTS`
      * @example
      * ```ts
-     * const vertex_attributes = material.get_vertex_attributes(resource.material("/my_material.materialc"));
+     * // Get the vertex attributes from a material specified as a resource property
+     * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_material: resource.material() },
+     *
+     *   init(self) {
+     *     const vertex_attributes = material.get_vertex_attributes(self.my_material);
+     *   },
+     * });
      * ```
      */
     function get_vertex_attributes(path: Hash | string): { name: Hash; value: Vector4 | Vector3 | Matrix4 | number | number[]; normalize: boolean; data_type: number; coordinate_space: number; semantic_type: number }[];
@@ -288,7 +324,27 @@ declare global {
      * vmath.vector4 | vmath.vector3 | vmath.matrix4 | number | table the value(s) of the constant. If the shader constant is an array, the amount of values to update depends on how many values that are passed in the 'value' field.
      * @example
      * ```ts
-     * material.set_constants(resource.material("/my_material.materialc"), { tint: { value: vmath.vector4(1, 0, 0, 1) } });
+     * // Set a shader constant in a material specified as a resource property
+     * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_material: resource.material() },
+     *
+     *   init() {
+     *     return { my_view_proj: vmath.matrix4() };
+     *   },
+     *
+     *   update(self) {
+     *     // update the 'tint' constant
+     *     material.set_constants(self.my_material, {
+     *       tint: { value: vmath.vector4(1, 0, 0, 1) },
+     *     });
+     *     // change the type of the 'view_proj' constant to CONSTANT_TYPE_USER_MATRIX4 so the renderer can set our custom data
+     *     material.set_constants(self.my_material, {
+     *       view_proj: { value: self.my_view_proj, type: material.CONSTANT_TYPE_USER_MATRIX4 },
+     *     });
+     *   },
+     * });
      * ```
      */
     function set_constants(path: Hash | string, constants: Record<string, { type?: number; value?: Vector4 | Vector3 | Matrix4 | number | (Vector4 | Matrix4)[] }>): void;
@@ -337,7 +393,18 @@ declare global {
      * number the max anisotropy of the texture sampler
      * @example
      * ```ts
-     * material.set_samplers(resource.material("/my_material.materialc"), { texture_sampler: { u_wrap: graphics.TEXTURE_WRAP_REPEAT, v_wrap: graphics.TEXTURE_WRAP_MIRRORED_REPEAT } });
+     * // Configures a sampler in a material specified as a resource property
+     * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_material: resource.material() },
+     *
+     *   init(self) {
+     *     material.set_samplers(self.my_material, {
+     *       texture_sampler: { u_wrap: graphics.TEXTURE_WRAP_REPEAT, v_wrap: graphics.TEXTURE_WRAP_MIRRORED_REPEAT },
+     *     });
+     *   },
+     * });
      * ```
      */
     function set_samplers(path: Hash | string, samplers: Record<string, { u_wrap?: number; v_wrap?: number; min_filter?: number; mag_filter?: number; max_anisotropy?: number }>): void;
@@ -348,7 +415,18 @@ declare global {
      * @param textures - A table keyed by sampler name with texture resources as values.
      * @example
      * ```ts
-     * material.set_textures(resource.material("/my_material.materialc"), { my_texture: resource.texture() });
+     * // Set a texture in a material from a resource
+     * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registrations from this field, and only this field types them onto `self`.
+     *   properties: { my_material: resource.material(), my_texture: resource.texture() },
+     *
+     *   init(self) {
+     *     material.set_textures(self.my_material, {
+     *       my_texture: self.my_texture,
+     *     });
+     *   },
+     * });
      * ```
      */
     function set_textures(path: Hash | string, textures: LuaMap<string, Hash> | Record<string, Hash>): void;
@@ -398,7 +476,19 @@ declare global {
      * - `graphics.SEMANTIC_TYPE_MORPH_TARGET_WEIGHTS`
      * @example
      * ```ts
-     * material.set_vertex_attributes(resource.material("/my_material.materialc"), { tint_attribute: { value: vmath.vector4(1, 0, 0, 1), semantic_type: graphics.SEMANTIC_TYPE_COLOR } });
+     * // Configures a vertex attribute in a material specified as a resource property
+     * export default defineScript({
+     *   // Never call `go.property` yourself: the transpiler emits the chunk-scope
+     *   // registration from this field, and only this field types the property onto `self`.
+     *   properties: { my_material: resource.material() },
+     *
+     *   init(self) {
+     *     material.set_vertex_attributes(self.my_material, {
+     *       tint_attribute: { value: vmath.vector4(1, 0, 0, 1), semantic_type: graphics.SEMANTIC_TYPE_COLOR },
+     *       weights: { value: vmath.vector4(0, 1, 0, 0), semantic_type: graphics.SEMANTIC_TYPE_NONE },
+     *     });
+     *   },
+     * });
      * ```
      */
     function set_vertex_attributes(path: Hash | string, attributes: Record<string, { value?: Vector4 | Vector3 | Matrix4 | number | number[]; normalize?: boolean; data_type?: number; coordinate_space?: number; semantic_type?: number }>): void;

package/generated/versions/defold-1.13.1/model.d.ts

@@ -33,10 +33,14 @@ declare global {
      * @returns array of weight values, or empty table if the model has no morph targets
      * @example
      * ```ts
-     * const weights = model.get_blend_weights("#model");
-     * weights[1] = 0.75;
-     * weights[2] = 0.25;
-     * model.set_blend_weights("#model", weights);
+     * const w = model.get_blend_weights("#model");
+     * w.forEach((weight, i) => {
+     *   print(i + 1, weight);
+     * });
+     * // change the data in the table and then set the weights again
+     * w[0] = 0.75;
+     * w[1] = 0.25;
+     * model.set_blend_weights("#model", w);
      * ```
      */
     function get_blend_weights(url: string | Hash | Url): number[];
@@ -197,8 +201,10 @@ declare global {
      * @param weights - array of weight values (1-based indices). Omit or pass `nil` to clear the override and return morphs to animation only
      * @example
      * ```ts
+     * // set the weights for the first 4 morph targets
      * model.set_blend_weights("#model", [0, 1, 0.5, 0]);
-     * model.set_blend_weights("#model");
+     * // clear the override, animation will continue if the weights are driven by an animation
+     * model.set_blend_weights("#model"); // clear script override
      * ```
      */
     function set_blend_weights(url: string | Hash | Url, weights?: number[]): void;

package/generated/versions/defold-1.13.1/particlefx.d.ts

@@ -50,15 +50,13 @@ declare global {
      * // How to play a particle fx when a game object is created.
      * // The callback receives the hash of the path to the particlefx, the hash of the id
      * // of the emitter, and the new state of the emitter as particlefx.EMITTER_STATE_.
-     * function emitter_state_change(self: unknown, id: unknown, emitter: unknown, state: unknown) {
-     *   if (emitter === hash("exhaust") && state === particlefx.EMITTER_STATE_POSTSPAWN) {
-     *     // exhaust is done spawning particles...
-     *   }
-     * }
-     *
      * export default defineScript({
      *   init(self) {
-     *     particlefx.play("#particlefx", emitter_state_change);
+     *     particlefx.play("#particlefx", (self, id, emitter, state) => {
+     *       if (emitter === hash("exhaust") && state === particlefx.EMITTER_STATE_POSTSPAWN) {
+     *         // exhaust is done spawning particles...
+     *       }
+     *     });
      *   },
      * });
      * ```

package/generated/versions/defold-1.13.1/render.d.ts

@@ -70,11 +70,16 @@ declare global {
      * @example
      * Then use the constant buffer when drawing a predicate:
      * ```ts
-     * function draw_tinted(self: { my_pred: Opaque<"render_predicate"> }) {
-     *   const constants = render.constant_buffer();
-     *   constants.tint = vmath.vector4(1, 1, 1, 1);
-     *   render.draw(self.my_pred, { constants });
-     * }
+     * export default defineRenderScript({
+     *   init() {
+     *     return { my_pred: render.predicate([hash("my_tag")]) };
+     *   },
+     *
+     *   update(self, dt) {
+     *     const constants = render.constant_buffer();
+     *     render.draw(self.my_pred, { constants });
+     *   },
+     * });
      * ```
      * @example
      * The constant buffer also supports array values by specifying constants in a table:
@@ -449,13 +454,13 @@ declare global {
      * ```
      * @example
      * ```ts
-     * // Or enable a render target by resource id:
      * export default defineRenderScript({
      *   init() {
      *     return { my_pred: render.predicate([hash("my_tag")]) };
      *   },
      *
      *   update(self, dt) {
+     *     // enable render target by resource id
      *     render.set_render_target("my_rt_resource");
      *     render.draw(self.my_pred);
      *     render.set_render_target(render.RENDER_TARGET_DEFAULT);
@@ -469,7 +474,6 @@ declare global {
      * ```
      * @example
      * ```ts
-     * // Or bind a texture handle directly:
      * export default defineRenderScript({
      *   init() {
      *     return { my_texture_handle: resource.get_texture_info("/main/my_texture.texturec").handle };
@@ -512,15 +516,10 @@ declare global {
      * ```ts
      * export default defineRenderScript({
      *   init() {
-     *     // render target buffer parameters
      *     const color_params = {
      *       format: graphics.TEXTURE_FORMAT_RGBA,
      *       width: render.get_window_width(),
      *       height: render.get_window_height(),
-     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
      *     };
      *     return {
      *       target_right: render.render_target("right", {
@@ -554,15 +553,10 @@ declare global {
      * ```ts
      * export default defineRenderScript({
      *   init() {
-     *     // render target buffer parameters
      *     const color_params = {
      *       format: graphics.TEXTURE_FORMAT_RGBA,
      *       width: render.get_window_width(),
      *       height: render.get_window_height(),
-     *       min_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       mag_filter: graphics.TEXTURE_FILTER_LINEAR,
-     *       u_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
-     *       v_wrap: graphics.TEXTURE_WRAP_CLAMP_TO_EDGE,
      *     };
      *     return {
      *       target_right: render.render_target("right", {
@@ -1003,13 +997,13 @@ declare global {
      * ```
      * @example
      * ```ts
-     * // Or set the render target by a render target resource identifier:
      * export default defineRenderScript({
      *   init() {
      *     return { my_pred: render.predicate([hash("my_tag")]) };
      *   },
      *
      *   update(self, dt) {
+     *     // set render target by a render target resource identifier
      *     render.set_render_target("my_rt_resource");
      *
      *     // draw a predicate to the render target

package/generated/versions/defold-1.13.1/sys.d.ts

@@ -605,22 +605,20 @@ declare global {
      * string The stack traceback.
      * @example
      * ```ts
-     * // Install error handler that just prints the errors
-     * function my_error_handler(source: unknown, message: unknown, traceback: unknown) {
-     *   print(source); //> lua
-     *   print(message); //> main/my.script:10: attempt to perform arithmetic on a string value
-     *   print(traceback); //> stack traceback:
-     *   //>         main/test.script:10: in function 'boom'
-     *   //>         main/test.script:15: in function <main/my.script:13>
-     * }
-     *
      * function boom() {
      *   return 10 + "string";
      * }
      *
      * export default defineScript({
      *   init() {
-     *     sys.set_error_handler(my_error_handler);
+     *     // Install error handler that just prints the errors
+     *     sys.set_error_handler((source, message, traceback) => {
+     *       print(source); //> lua
+     *       print(message); //> main/my.script:10: attempt to perform arithmetic on a string value
+     *       print(traceback); //> stack traceback:
+     *       //>         main/test.script:10: in function 'boom'
+     *       //>         main/test.script:15: in function <main/my.script:13>
+     *     });
      *     boom();
      *   },
      * });

package/generated/versions/defold-1.13.1/window.d.ts

@@ -127,23 +127,21 @@ declare global {
      * - number `height`: The height of a resize event. nil otherwise.
      * @example
      * ```ts
-     * function window_callback(self: unknown, event: unknown, data: Record<string | number, unknown>) {
-     *   if (event === window.WINDOW_EVENT_FOCUS_LOST) {
-     *     print("window.WINDOW_EVENT_FOCUS_LOST");
-     *   } else if (event === window.WINDOW_EVENT_FOCUS_GAINED) {
-     *     print("window.WINDOW_EVENT_FOCUS_GAINED");
-     *   } else if (event === window.WINDOW_EVENT_ICONFIED) {
-     *     print("window.WINDOW_EVENT_ICONFIED");
-     *   } else if (event === window.WINDOW_EVENT_DEICONIFIED) {
-     *     print("window.WINDOW_EVENT_DEICONIFIED");
-     *   } else if (event === window.WINDOW_EVENT_RESIZED) {
-     *     print("Window resized: ", data.width, data.height);
-     *   }
-     * }
-     *
      * export default defineScript({
      *   init() {
-     *     window.set_listener(window_callback);
+     *     window.set_listener((self, event, data) => {
+     *       if (event === window.WINDOW_EVENT_FOCUS_LOST) {
+     *         print("window.WINDOW_EVENT_FOCUS_LOST");
+     *       } else if (event === window.WINDOW_EVENT_FOCUS_GAINED) {
+     *         print("window.WINDOW_EVENT_FOCUS_GAINED");
+     *       } else if (event === window.WINDOW_EVENT_ICONFIED) {
+     *         print("window.WINDOW_EVENT_ICONFIED");
+     *       } else if (event === window.WINDOW_EVENT_DEICONIFIED) {
+     *         print("window.WINDOW_EVENT_DEICONIFIED");
+     *       } else if (event === window.WINDOW_EVENT_RESIZED) {
+     *         print("Window resized: ", data.width, data.height);
+     *       }
+     *     });
      *   },
      * });
      * ```

package/generated/window.d.ts

@@ -142,23 +142,21 @@ declare global {
      * @param callback - A callback which receives info about window events. Pass an empty function or `nil` if you no longer wish to receive callbacks.
      * @example
      * ```ts
-     * function window_callback(self: unknown, event: unknown, data: Record<string | number, unknown>) {
-     *   if (event === window.WINDOW_EVENT_FOCUS_LOST) {
-     *     print("window.WINDOW_EVENT_FOCUS_LOST");
-     *   } else if (event === window.WINDOW_EVENT_FOCUS_GAINED) {
-     *     print("window.WINDOW_EVENT_FOCUS_GAINED");
-     *   } else if (event === window.WINDOW_EVENT_ICONIFIED) {
-     *     print("window.WINDOW_EVENT_ICONIFIED");
-     *   } else if (event === window.WINDOW_EVENT_DEICONIFIED) {
-     *     print("window.WINDOW_EVENT_DEICONIFIED");
-     *   } else if (event === window.WINDOW_EVENT_RESIZED) {
-     *     print("Window resized: ", data.width, data.height);
-     *   }
-     * }
-     *
      * export default defineScript({
      *   init() {
-     *     window.set_listener(window_callback);
+     *     window.set_listener((self, event, data) => {
+     *       if (event === window.WINDOW_EVENT_FOCUS_LOST) {
+     *         print("window.WINDOW_EVENT_FOCUS_LOST");
+     *       } else if (event === window.WINDOW_EVENT_FOCUS_GAINED) {
+     *         print("window.WINDOW_EVENT_FOCUS_GAINED");
+     *       } else if (event === window.WINDOW_EVENT_ICONIFIED) {
+     *         print("window.WINDOW_EVENT_ICONIFIED");
+     *       } else if (event === window.WINDOW_EVENT_DEICONIFIED) {
+     *         print("window.WINDOW_EVENT_DEICONIFIED");
+     *       } else if (event === window.WINDOW_EVENT_RESIZED) {
+     *         print("Window resized: ", data.width, data.height);
+     *       }
+     *     });
      *   },
      * });
      * ```

package/hsm/index.d.ts

@@ -23,13 +23,18 @@ export interface MachineInstance<Ctx, E extends EventObject, P extends string =
     readonly onMove: (listener: MoveListener<E, P>) => () => void;
 }
 export type MoveAction<Ctx, E extends EventObject, V extends E = E> = (ctx: Ctx, event: V, machine: MachineInstance<Ctx, E>) => void;
+interface RuleList<Rule> {
+    readonly 0: Rule;
+    readonly [index: number]: Rule;
+    readonly length: number;
+}
 /** @noSelf */
-export interface TransitionConfig<Ctx, E extends EventObject, V extends E = E> {
+export interface TransitionConfig<Ctx, E extends EventObject, V extends E = E, To extends string = string> {
     /**
      * The full path of the state to move to. A `to` naming the state the rule is on exits and
      * re-enters it, restarting its timers and `task`; a `to` below it keeps it active.
      */
-    readonly to?: string;
+    readonly to?: To;
     /**
      * The rule is taken only when this returns `true`. It must have no side effects: it is also
      * checked when the move does not happen, in guarded lists and on every `always` recheck.
@@ -51,10 +56,10 @@ export interface TransitionConfig<Ctx, E extends EventObject, V extends E = E> {
     /** Removed: a `to` naming the state the rule is on restarts it. */
     readonly reenter?: never;
 }
-export type TransitionSpec<Ctx, E extends EventObject, V extends E = E> = string | TransitionConfig<Ctx, E, V> | readonly [TransitionConfig<Ctx, E, V>, ...TransitionConfig<Ctx, E, V>[]];
+export type TransitionSpec<Ctx, E extends EventObject, V extends E = E, To extends string = string> = To | TransitionConfig<Ctx, E, V, To> | RuleList<TransitionConfig<Ctx, E, V, To>>;
 /** @noSelf */
-export interface AlwaysConfig<Ctx> {
-    readonly to: string;
+export interface AlwaysConfig<Ctx, To extends string = string> {
+    readonly to: To;
     /** Checked on every recheck, so it must have no side effects. */
     readonly when?: (ctx: Ctx) => boolean;
     /** Renamed to `to`. */
@@ -62,11 +67,11 @@ export interface AlwaysConfig<Ctx> {
     /** Renamed to `when`. */
     readonly guard?: never;
 }
-export type AlwaysSpec<Ctx> = string | AlwaysConfig<Ctx> | readonly [AlwaysConfig<Ctx>, ...AlwaysConfig<Ctx>[]];
-export type OnConfig<Ctx, E extends EventObject> = {
+export type AlwaysSpec<Ctx, To extends string = string> = To | AlwaysConfig<Ctx, To> | RuleList<AlwaysConfig<Ctx, To>>;
+export type OnConfig<Ctx, E extends EventObject, To extends string = string> = {
     readonly [K in E["type"]]?: TransitionSpec<Ctx, E, Extract<E, {
         type: K;
-    }>>;
+    }>, To>;
 };
 /**
  * Runs on every way in (`enter`) or out (`exit`) of the state: a move, `start` and `stop`. A hot
@@ -74,7 +79,7 @@ export type OnConfig<Ctx, E extends EventObject> = {
  * event; event data reaches `enter` through `ctx`, set in `run`.
  */
 export type StateHook<Ctx, E extends EventObject> = (ctx: Ctx, machine: MachineInstance<Ctx, E>) => void;
-export type UpdateHook<Ctx, E extends EventObject> = (ctx: Ctx, dt: number, machine: MachineInstance<Ctx, E>) => string | undefined;
+export type UpdateHook<Ctx, E extends EventObject, To extends string = string> = (ctx: Ctx, dt: number, machine: MachineInstance<Ctx, E>) => To | undefined;
 /**
  * Starts work that lives as long as the state. `finish` sends one event and is ignored after the
  * first call or once the state is left. The returned cleanup runs on every way out.
@@ -82,98 +87,72 @@ export type UpdateHook<Ctx, E extends EventObject> = (ctx: Ctx, dt: number, mach
  */
 export type TaskStart<Ctx, E extends EventObject> = (ctx: Ctx, finish: (event: E) => void, machine: MachineInstance<Ctx, E>) => (() => void) | void;
 /** @noSelf */
-export interface StateConfig<Ctx, E extends EventObject> {
-    readonly type?: "parallel";
-    readonly initial?: string;
-    readonly restoreDepth?: number | "all";
+export interface Machine<Ctx, E extends EventObject, P extends string = string> {
+    readonly start: (ctx: Ctx) => MachineInstance<Ctx, E, P>;
+}
+type PathDepth = [never, 0, 1, 2, 3];
+type NextCount = [never, 2, 3, 4, 5, 6];
+type TreePathsBelow<T, D extends number> = {
+    [K in keyof T & string]: K | `${K}/${D extends 1 ? keyof T[K] extends never ? never : string : TreePathsBelow<T[K], PathDepth[D]>}`;
+}[keyof T & string];
+type TreePath<T> = `/${TreePathsBelow<T, 4>}`;
+type SlotPathsBelow<T, D extends number> = unknown extends T ? string : {
+    [K in keyof T & string]: K | `${K}/${D extends 1 ? string : SlotPathsBelow<T[K], PathDepth[D]>}`;
+}[keyof T & string];
+type SlotPath<T> = `/${SlotPathsBelow<T, 4>}`;
+type TreeOf<C> = C extends {
+    readonly states: infer Children;
+} ? {
+    readonly [K in keyof Children]: TreeOf<Children[K]>;
+} : unknown;
+export type StatePath<C> = TreePath<TreeOf<C>>;
+type TreeDepth<T, D extends number> = unknown extends T ? number : [D] extends [never] ? number : 1 | ({
+    [K in keyof T]: unknown extends T[K] ? never : TreeDepth<T[K], PathDepth[D]>;
+}[keyof T] extends infer N ? N extends number ? number extends N ? number : NextCount[N] : never : never);
+type AnyChild<Ctx, E extends EventObject, T, To extends string> = unknown extends T ? {
+    readonly [name: string]: StateNode<Ctx, E, unknown, string, To>;
+} : unknown;
+/** @noSelf */
+interface StateBase<Ctx, E extends EventObject, T, Self extends string, To extends string> {
     readonly states?: {
-        readonly [name: string]: StateConfig<Ctx, E>;
-    };
-    readonly on?: OnConfig<Ctx, E>;
-    readonly after?: {
-        readonly [seconds: number]: string;
-    };
-    readonly always?: AlwaysSpec<Ctx>;
+        readonly [K in keyof T]: StateNode<Ctx, E, T[K], `${Self}/${K & string}`, To>;
+    } & NoInfer<AnyChild<Ctx, E, T, To>>;
+    readonly on?: NoInfer<OnConfig<Ctx, E, To>>;
+    readonly after?: NoInfer<{
+        readonly [seconds: number]: To;
+    }>;
+    readonly always?: AlwaysSpec<Ctx, To>;
     readonly enter?: StateHook<Ctx, E>;
     readonly exit?: StateHook<Ctx, E>;
-    readonly update?: UpdateHook<Ctx, E>;
+    readonly update?: NoInfer<UpdateHook<Ctx, E, To>>;
     /** Started on each entry; see `TaskStart`. */
     readonly task?: TaskStart<Ctx, E>;
     /** Renamed to `task`. */
     readonly invoke?: never;
 }
-export interface MachineConfig<Ctx, E extends EventObject> extends StateConfig<Ctx, E> {
-    readonly initial: string;
-    readonly states: {
-        readonly [name: string]: StateConfig<Ctx, E>;
-    };
-}
 /** @noSelf */
-export interface Machine<Ctx, E extends EventObject, P extends string = string> {
-    readonly start: (ctx: Ctx) => MachineInstance<Ctx, E, P>;
+interface CompoundState<Ctx, E extends EventObject, T, Self extends string, To extends string> extends StateBase<Ctx, E, T, Self, To> {
+    readonly type?: never;
+    readonly initial?: NoInfer<unknown extends T ? string : `${Self}/${keyof T & string}`>;
+    readonly restoreDepth?: NoInfer<TreeDepth<T, 4> | "all">;
 }
-type PathDepth = [never, 0, 1, 2, 3];
-type PathsBelow<S, D extends number> = S extends {
-    readonly states: infer Children;
-} ? {
-    [K in keyof Children & string]: K | `${K}/${D extends 1 ? Children[K] extends {
-        readonly states: object;
-    } ? string : never : PathsBelow<Children[K], PathDepth[D]>}`;
-}[keyof Children & string] : never;
-export type StatePath<C> = `/${PathsBelow<C, 4>}`;
-type NextCount = [never, 2, 3, 4, 5, 6];
-type RestoreCountBelow<Children, D extends number> = {
-    [K in keyof Children]: RestoreCount<Children[K], D>;
-}[keyof Children];
-type RestoreCount<S, D extends number> = S extends {
-    readonly states: infer Children;
-} ? [D] extends [never] ? number : S extends {
+/** @noSelf */
+interface ParallelState<Ctx, E extends EventObject, T, Self extends string, To extends string> extends StateBase<Ctx, E, T, Self, To> {
     readonly type: "parallel";
-} ? RestoreCountBelow<Children, PathDepth[D]> : 1 | (RestoreCountBelow<Children, PathDepth[D]> extends infer N ? N extends number ? number extends N ? number : NextCount[N] : never : never) : never;
-interface TransitionCheck<T> {
-    readonly to?: T;
-    readonly when?: unknown;
-    readonly run?: unknown;
+    readonly initial?: never;
+    readonly restoreDepth?: never;
 }
-type SpecCheck<T> = T | TransitionCheck<T> | readonly TransitionCheck<T>[];
-type PathCheck<S, Self extends string, All extends string, Ev extends string> = {
-    readonly type?: unknown;
-    readonly initial?: S extends {
-        readonly type: "parallel";
-    } ? never : S extends {
-        readonly states: infer Children;
-    } ? `${Self}/${keyof Children & string}` : never;
-    readonly restoreDepth?: S extends {
-        readonly type: "parallel";
-    } ? never : S extends {
-        readonly states: object;
-    } ? RestoreCount<S, 4> | "all" : never;
-    readonly states?: S extends {
-        readonly states: infer Children;
-    } ? {
-        readonly [K in keyof Children]: PathCheck<Children[K], `${Self}/${K & string}`, All, Ev>;
-    } : unknown;
-    readonly on?: S extends {
-        readonly on: infer On;
-    } ? {
-        readonly [K in keyof On]: K extends Ev ? SpecCheck<All> : never;
-    } : unknown;
-    readonly after?: S extends {
-        readonly after: infer After;
-    } ? {
-        readonly [K in keyof After]: All;
-    } : unknown;
-    readonly always?: S extends {
-        readonly always: unknown;
-    } ? SpecCheck<All> : unknown;
-    readonly enter?: unknown;
-    readonly exit?: unknown;
-    readonly update?: unknown;
-    readonly task?: unknown;
+type StateNode<Ctx, E extends EventObject, T, Self extends string, To extends string> = CompoundState<Ctx, E, T, Self, To> | ParallelState<Ctx, E, T, Self, To>;
+type RootState<Ctx, E extends EventObject, T> = CompoundState<Ctx, E, T, "", NoInfer<SlotPath<T>>> & {
+    readonly initial: string;
+    readonly states: object;
 };
-export interface MachineConfigError {
-    readonly "hsm: an initial or a to names an unknown state path, or an on key an unknown event": never;
-}
-export type DefinedMachine<Ctx, E extends EventObject, C> = C extends PathCheck<C, "", StatePath<C>, E["type"]> ? Machine<Ctx, E, StatePath<C>> : MachineConfigError;
-export declare function defineMachine<Ctx, E extends EventObject>(key?: string): <const C extends MachineConfig<Ctx, E>>(config: C) => DefinedMachine<Ctx, E, C>;
+export type StateConfig<Ctx, E extends EventObject> = StateNode<Ctx, E, unknown, string, string>;
+export type MachineConfig<Ctx, E extends EventObject> = CompoundState<Ctx, E, unknown, string, string> & {
+    readonly initial: string;
+    readonly states: {
+        readonly [name: string]: StateConfig<Ctx, E>;
+    };
+};
+export declare function defineMachine<Ctx, E extends EventObject>(key?: string): <T>(config: RootState<Ctx, E, T>) => Machine<Ctx, E, TreePath<T>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@defold-typescript/types",
-  "version": "0.44.1",
+  "version": "0.45.0",
   "description": "TypeScript types for the Defold engine's Lua APIs.",
   "license": "MIT",
   "repository": {
@@ -85,7 +85,9 @@
     "!scripts/lua-types-signature-index.ts",
     "!scripts/fidelity-audit.ts",
     "!scripts/augmentation-namespaces.ts",
+    "!scripts/example-loose-types.ts",
     "!scripts/example-pins.ts",
+    "!scripts/example-scope-parity.ts",
     "!scripts/example-semantics.ts",
     "!scripts/example-surfaces.ts",
     "!scripts/example-typecheck.ts",