@defold-typescript/types 0.4.3 → 0.5.1

package/generated/b2d.d.ts

@@ -5,7 +5,18 @@ declare global {
   namespace b2d {
     type b2Body = Opaque<"b2Body">;
     type b2World = Opaque<"b2World">;
+    /**
+     * Get the Box2D body from a collision object
+     *
+     * @param url - the url to the game object collision component
+     * @returns the body if successful. Otherwise `nil`.
+     */
     function get_body(url: string | Hash | Url): Opaque<"b2Body">;
+    /**
+     * Get the Box2D world from the current collection
+     *
+     * @returns the world if successful. Otherwise `nil`.
+     */
     function get_world(): Opaque<"b2World">;
   }
 }

package/generated/buffer.d.ts

@@ -3,21 +3,163 @@ import type { Hash, Opaque } from "../src/core-types";
 
 declare global {
   namespace buffer {
+    /**
+     * Float, single precision, 4 bytes
+     */
     const VALUE_TYPE_FLOAT32: number & { readonly __brand: "buffer.VALUE_TYPE_FLOAT32" };
+    /**
+     * Signed integer, 2 bytes
+     */
     const VALUE_TYPE_INT16: number & { readonly __brand: "buffer.VALUE_TYPE_INT16" };
+    /**
+     * Signed integer, 4 bytes
+     */
     const VALUE_TYPE_INT32: number & { readonly __brand: "buffer.VALUE_TYPE_INT32" };
+    /**
+     * Signed integer, 8 bytes
+     */
     const VALUE_TYPE_INT64: number & { readonly __brand: "buffer.VALUE_TYPE_INT64" };
+    /**
+     * Signed integer, 1 byte
+     */
     const VALUE_TYPE_INT8: number & { readonly __brand: "buffer.VALUE_TYPE_INT8" };
+    /**
+     * Unsigned integer, 2 bytes
+     */
     const VALUE_TYPE_UINT16: number & { readonly __brand: "buffer.VALUE_TYPE_UINT16" };
+    /**
+     * Unsigned integer, 4 bytes
+     */
     const VALUE_TYPE_UINT32: number & { readonly __brand: "buffer.VALUE_TYPE_UINT32" };
+    /**
+     * Unsigned integer, 8 bytes
+     */
     const VALUE_TYPE_UINT64: number & { readonly __brand: "buffer.VALUE_TYPE_UINT64" };
+    /**
+     * Unsigned integer, 1 byte
+     */
     const VALUE_TYPE_UINT8: number & { readonly __brand: "buffer.VALUE_TYPE_UINT8" };
+    /**
+     * Copy all data streams from one buffer to another, element wise.
+     * Each of the source streams must have a matching stream in the
+     * destination buffer. The streams must match in both type and size.
+     * The source and destination buffer can be the same.
+     *
+     * @param dst - the destination buffer
+     * @param dstoffset - the offset to start copying data to
+     * @param src - the source data buffer
+     * @param srcoffset - the offset to start copying data from
+     * @param count - the number of elements to copy
+     * @example
+     * ```lua
+     * How to copy elements (e.g. vertices) from one buffer to another
+     * -- copy entire buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, 0, #srcbuffer)
+     *
+     * -- copy last 10 elements to the front of another buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, #srcbuffer - 10, 10)
+     * ```
+     */
     function copy_buffer(dst: Opaque<"buffer">, dstoffset: number, src: Opaque<"buffer">, srcoffset: number, count: number): void;
+    /**
+     * Copy a specified amount of data from one stream to another.
+     * The value type and size must match between source and destination streams.
+     * The source and destination streams can be the same.
+     *
+     * @param dst - the destination stream
+     * @param dstoffset - the offset to start copying data to (measured in value type)
+     * @param src - the source data stream
+     * @param srcoffset - the offset to start copying data from (measured in value type)
+     * @param count - the number of values to copy (measured in value type)
+     * @example
+     * ```lua
+     * How to update a texture of a sprite:
+     * -- copy entire stream
+     * local srcstream = buffer.get_stream(srcbuffer, hash("xyz"))
+     * local dststream = buffer.get_stream(dstbuffer, hash("xyz"))
+     * buffer.copy_stream(dststream, 0, srcstream, 0, #srcstream)
+     * ```
+     */
     function copy_stream(dst: Opaque<"bufferstream">, dstoffset: number, src: Opaque<"bufferstream">, srcoffset: number, count: number): void;
+    /**
+     * Create a new data buffer containing a specified set of streams. A data buffer
+     * can contain one or more streams with typed data. This is useful for managing
+     * compound data, for instance a vertex buffer could contain separate streams for
+     * vertex position, color, normal etc.
+     *
+     * @param element_count - The number of elements the buffer should hold
+     * @param declaration - A table where each entry (table) describes a stream
+  - hash | string `name`: The name of the stream
+  - constant `type`: The data type of the stream
+  - number `count`: The number of values each element should hold
+     * @returns the new buffer
+     * @example
+     * ```lua
+     * How to create and initialize a buffer
+     * function init(self)
+     *   local size = 128
+     *   self.image = buffer.create( size * size, { {name=hash("rgb"), type=buffer.VALUE_TYPE_UINT8, count=3 } })
+     *   self.imagestream = buffer.get_stream(self.image, hash("rgb"))
+     *
+     *   for y=0,self.height-1 do
+     *      for x=0,self.width-1 do
+     *          local index = y * self.width * 3 + x * 3 + 1
+     *          self.imagestream[index + 0] = self.r
+     *          self.imagestream[index + 1] = self.g
+     *          self.imagestream[index + 2] = self.b
+     *      end
+     *   end
+     * ```
+     */
     function create(element_count: number, declaration: { name?: Hash | string; type?: Opaque<"constant">; count?: number }): Opaque<"buffer">;
+    /**
+     * Get a copy of all the bytes from a specified stream as a Lua string.
+     *
+     * @param buffer - the source buffer
+     * @param stream_name - the name of the stream
+     * @returns the buffer data as a Lua string
+     */
     function get_bytes(buffer: Opaque<"buffer">, stream_name: Hash): string;
+    /**
+     * Get a named metadata entry from a buffer along with its type.
+     *
+     * @param buf - the buffer to get the metadata from
+     * @param metadata_name - name of the metadata entry
+     * @example
+     * ```lua
+     * How to get a metadata entry from a buffer
+     * -- retrieve a metadata entry named "somefloats" and its nomeric type
+     * local values, type = buffer.get_metadata(buf, hash("somefloats"))
+     * if metadata then print(#metadata.." values in 'somefloats'") end
+     * ```
+     */
     function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | unknown, Opaque<"constant"> | unknown]>;
+    /**
+     * Get a specified stream from a buffer.
+     *
+     * @param buffer - the buffer to get the stream from
+     * @param stream_name - the stream name
+     * @returns the data stream
+     */
     function get_stream(buffer: Opaque<"buffer">, stream_name: Hash | string): Opaque<"bufferstream">;
+    /**
+     * Creates or updates a metadata array entry on a buffer.
+     * The value type and count given when updating the entry should match those used when first creating it.
+     *
+     * @param buf - the buffer to set the metadata on
+     * @param metadata_name - name of the metadata entry
+     * @param values - actual metadata, an array of numeric values
+     * @param value_type - type of values when stored
+     * @example
+     * ```lua
+     * How to set a metadata entry on a buffer
+     * -- create a new metadata entry with three floats
+     * buffer.set_metadata(buf, hash("somefloats"), {1.5, 3.2, 7.9}, buffer.VALUE_TYPE_FLOAT32)
+     * -- ...
+     * -- update to a new set of values
+     * buffer.set_metadata(buf, hash("somefloats"), {-2.5, 10.0, 32.2}, buffer.VALUE_TYPE_FLOAT32)
+     * ```
+     */
     function set_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string, values: number[], value_type: Opaque<"constant">): void;
   }
 }

package/generated/collectionfactory.d.ts

@@ -3,13 +3,131 @@ import type { Hash, Opaque, Quaternion, Url, Vector3 } from "../src/core-types";
 
 declare global {
   namespace collectionfactory {
+    /**
+     * loaded
+     */
     const STATUS_LOADED: number & { readonly __brand: "collectionfactory.STATUS_LOADED" };
+    /**
+     * loading
+     */
     const STATUS_LOADING: number & { readonly __brand: "collectionfactory.STATUS_LOADING" };
+    /**
+     * unloaded
+     */
     const STATUS_UNLOADED: number & { readonly __brand: "collectionfactory.STATUS_UNLOADED" };
+    /**
+     * The URL identifies the collectionfactory component that should do the spawning.
+     * Spawning is instant, but spawned game objects get their first update calls the following frame. The supplied parameters for position, rotation and scale
+     * will be applied to the whole collection when spawned.
+     * Script properties in the created game objects can be overridden through
+     * a properties-parameter table. The table should contain game object ids
+     * (hash) as keys and property tables as values to be used when initiating each
+     * spawned game object.
+     * See go.property for more information on script properties.
+     * The function returns a table that contains a key for each game object
+     * id (hash), as addressed if the collection file was top level, and the
+     * corresponding spawned instance id (hash) as value with a unique path
+     * prefix added to each instance.
+     * Calling collectionfactory.create create on a collection factory that is marked as dynamic without having loaded resources
+     * using collectionfactory.load will synchronously load and create resources which may affect application performance.
+     *
+     * @param url - the collection factory component to be used
+     * @param position - position to assign to the newly spawned collection
+     * @param rotation - rotation to assign to the newly spawned collection
+     * @param properties - table of script properties to propagate to any new game object instances
+     * @param scale - uniform scaling to apply to the newly spawned collection (must be greater than 0).
+     * @returns a table mapping the id:s from the collection to the new instance id:s
+     * @example
+     * ```lua
+     * How to spawn a collection of game objects:
+     * function init(self)
+     *   -- Spawn a small group of enemies.
+     *   local pos = vmath.vector3(100, 12.5, 0)
+     *   local rot = vmath.quat_rotation_z(math.pi / 2)
+     *   local scale = 0.5
+     *   local props = {}
+     *   props[hash("/enemy_leader")] = { health = 1000.0 }
+     *   props[hash("/enemy_1")] = { health = 200.0 }
+     *   props[hash("/enemy_2")] = { health = 400.0, color = hash("green") }
+     *
+     *   local self.enemy_ids = collectionfactory.create("#enemyfactory", pos, rot, props, scale)
+     *   -- enemy_ids now map to the spawned instance ids:
+     *   --
+     *   -- pprint(self.enemy_ids)
+     *   --
+     *   -- DEBUG:SCRIPT:
+     *   -- {
+     *   --   hash: [/enemy_leader] = hash: [/collection0/enemy_leader],
+     *   --   hash: [/enemy_1] = hash: [/collection0/enemy_1],
+     *   --   hash: [/enemy_2] = hash: [/collection0/enemy_2]
+     *   -- }
+     *
+     *   -- Send "attack" message to the leader. First look up its instance id.
+     *   local leader_id = self.enemy_ids[hash("/enemy_leader")]
+     *   msg.post(leader_id, "attack")
+     * end
+     *
+     * How to delete a spawned collection:
+     * go.delete(self.enemy_ids)
+     * ```
+     */
     function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: Record<string | number, unknown>, scale?: number | Vector3): Record<string | number, unknown>;
+    /**
+     * This returns status of the collection factory.
+     * Calling this function when the factory is not marked as dynamic loading always returns COMP_COLLECTION_FACTORY_STATUS_LOADED.
+     *
+     * @param url - the collection factory component to get status from
+     * @returns status of the collection factory component
+  - `collectionfactory.STATUS_UNLOADED`
+  - `collectionfactory.STATUS_LOADING`
+  - `collectionfactory.STATUS_LOADED`
+     */
     function get_status(url?: string | Hash | Url): Opaque<"constant">;
+    /**
+     * Resources loaded are referenced by the collection factory component until the existing (parent) collection is destroyed or collectionfactory.unload is called.
+     * Calling this function when the factory is not marked as dynamic loading does nothing.
+     *
+     * @param url - the collection factory component to load
+     * @param complete_function - function to call when resources are loaded.
+  `self`
+  object The current object.
+  `url`
+  url url of the collection factory component
+  `result`
+  boolean True if resource were loaded successfully
+     * @example
+     * ```lua
+     * How to load resources of a collection factory prototype.
+     * collectionfactory.load("#factory", function(self, url, result) end)
+     * ```
+     */
     function load(url?: string | Hash | Url, complete_function?: (self: unknown, url: unknown, result: unknown) => void): void;
+    /**
+     * Changes the prototype for the collection factory.
+     * Setting the prototype to "nil" will revert back to the original prototype.
+     *
+     * @param url - the collection factory component
+     * @param prototype - the path to the new prototype, or `nil`
+     * @example
+     * ```lua
+     * How to unload the previous prototypes resources, and then spawn a new collection
+     * collectionfactory.unload("#factory") -- unload the previous resources
+     * collectionfactory.set_prototype("#factory", "/main/levels/level1.collectionc")
+     * local ids = collectionfactory.create("#factory", go.get_world_position(), vmath.quat())
+     * ```
+     */
     function set_prototype(url?: string | Hash | Url, prototype?: string): void;
+    /**
+     * This decreases the reference count for each resource loaded with collectionfactory.load. If reference is zero, the resource is destroyed.
+     * Calling this function when the factory is not marked as dynamic loading does nothing.
+     *
+     * @param url - the collection factory component to unload
+     * @example
+     * ```lua
+     * How to unload resources of a collection factory prototype loaded with collectionfactory.load
+     * collectionfactory.unload("#factory")
+     * ```
+     */
     function unload(url?: string | Hash | Url): void;
   }
 }

package/generated/collectionproxy.d.ts

@@ -3,10 +3,62 @@ import type { Hash, Url } from "../src/core-types";
 
 declare global {
   namespace collectionproxy {
+    /**
+     * It's impossible to change the collection if the collection is already loaded.
+     */
     const RESULT_ALREADY_LOADED: number & { readonly __brand: "collectionproxy.RESULT_ALREADY_LOADED" };
+    /**
+     * It's impossible to change the collection while the collection proxy is loading.
+     */
     const RESULT_LOADING: number & { readonly __brand: "collectionproxy.RESULT_LOADING" };
+    /**
+     * It's impossible to change the collection for a proxy that isn't excluded.
+     */
     const RESULT_NOT_EXCLUDED: number & { readonly __brand: "collectionproxy.RESULT_NOT_EXCLUDED" };
+    /**
+     * return an indexed table of resources for a collection proxy where the
+     * referenced collection has been excluded using LiveUpdate. Each entry is a
+     * hexadecimal string that represents the data of the specific resource.
+     * This representation corresponds with the filename for each individual
+     * resource that is exported when you bundle an application with LiveUpdate
+     * functionality.
+     *
+     * @param collectionproxy - the collectionproxy to check for resources.
+     * @returns the resources, or an empty list if the
+  collection was not excluded.
+     * @example
+     * ```lua
+     * local function print_resources(self, cproxy)
+     *     local resources = collectionproxy.get_resources(cproxy)
+     *     for _, v in ipairs(resources) do
+     *         print("Resource: " .. v)
+     *     end
+     * end
+     * ```
+     */
     function get_resources(collectionproxy: Url): Record<string | number, unknown>;
+    /**
+     * The collection should be loaded by the collection proxy.
+     * Setting the collection to "nil" will revert it back to the original collection.
+     * The collection proxy shouldn't be loaded and should have the 'Exclude' checkbox checked.
+     * This functionality is designed to simplify the management of Live Update resources.
+     *
+     * @param url - the collection proxy component
+     * @param prototype - the path to the new collection, or `nil`
+     * @example
+     * ```lua
+     * The example assume the script belongs to an instance with collection-proxy-component with id "proxy".
+     * local ok, error = collectionproxy.set_collection("/go#collectionproxy", "/LU/3.collectionc")
+     *  if ok then
+     *      print("The collection has been changed to /LU/3.collectionc")
+     *  else
+     *      print("Error changing collection to /LU/3.collectionc ", error)
+     *  end
+     *  msg.post("/go#collectionproxy", "load")
+     *  msg.post("/go#collectionproxy", "init")
+     *  msg.post("/go#collectionproxy", "enable")
+     * ```
+     */
     function set_collection(url?: string | Hash | Url, prototype?: string): LuaMultiReturn<[boolean, number]>;
   }
 }

package/generated/crash.d.ts

@@ -1,29 +1,138 @@
 /** @noSelfInFile */
 declare global {
   namespace crash {
+    /**
+     * android build fingerprint
+     */
     const SYSFIELD_ANDROID_BUILD_FINGERPRINT: number & { readonly __brand: "crash.SYSFIELD_ANDROID_BUILD_FINGERPRINT" };
+    /**
+     * system device language as reported by sys.get_sys_info
+     */
     const SYSFIELD_DEVICE_LANGUAGE: number & { readonly __brand: "crash.SYSFIELD_DEVICE_LANGUAGE" };
+    /**
+     * device model as reported by sys.get_sys_info
+     */
     const SYSFIELD_DEVICE_MODEL: number & { readonly __brand: "crash.SYSFIELD_DEVICE_MODEL" };
+    /**
+     * engine version as hash
+     */
     const SYSFIELD_ENGINE_HASH: number & { readonly __brand: "crash.SYSFIELD_ENGINE_HASH" };
+    /**
+     * engine version as release number
+     */
     const SYSFIELD_ENGINE_VERSION: number & { readonly __brand: "crash.SYSFIELD_ENGINE_VERSION" };
+    /**
+     * system language as reported by sys.get_sys_info
+     */
     const SYSFIELD_LANGUAGE: number & { readonly __brand: "crash.SYSFIELD_LANGUAGE" };
+    /**
+     * device manufacturer as reported by sys.get_sys_info
+     */
     const SYSFIELD_MANUFACTURER: number & { readonly __brand: "crash.SYSFIELD_MANUFACTURER" };
+    /**
+     * The max number of sysfields.
+     */
     const SYSFIELD_MAX: number & { readonly __brand: "crash.SYSFIELD_MAX" };
+    /**
+     * system name as reported by sys.get_sys_info
+     */
     const SYSFIELD_SYSTEM_NAME: number & { readonly __brand: "crash.SYSFIELD_SYSTEM_NAME" };
+    /**
+     * system version as reported by sys.get_sys_info
+     */
     const SYSFIELD_SYSTEM_VERSION: number & { readonly __brand: "crash.SYSFIELD_SYSTEM_VERSION" };
+    /**
+     * system territory as reported by sys.get_sys_info
+     */
     const SYSFIELD_TERRITORY: number & { readonly __brand: "crash.SYSFIELD_TERRITORY" };
+    /**
+     * The max number of user fields.
+     */
     const USERFIELD_MAX: number & { readonly __brand: "crash.USERFIELD_MAX" };
+    /**
+     * The max size of a single user field.
+     */
     const USERFIELD_SIZE: number & { readonly __brand: "crash.USERFIELD_SIZE" };
+    /**
+     * A table is returned containing the addresses of the call stack.
+     *
+     * @param handle - crash dump handle
+     * @returns table containing the backtrace
+     */
     function get_backtrace(handle: number): Record<string | number, unknown>;
+    /**
+     * The format of read text blob is platform specific
+     * and not guaranteed
+     * but can be useful for manual inspection.
+     *
+     * @param handle - crash dump handle
+     * @returns string with the platform specific data
+     */
     function get_extra_data(handle: number): string;
+    /**
+     * The function returns a table containing entries with sub-tables that
+     * have fields 'name' and 'address' set for all loaded modules.
+     *
+     * @param handle - crash dump handle
+     * @returns module table
+     */
     function get_modules(handle: number): Record<string | number, unknown>;
+    /**
+     * read signal number from a crash report
+     *
+     * @param handle - crash dump handle
+     * @returns signal number
+     */
     function get_signum(handle: number): number;
+    /**
+     * reads a system field from a loaded crash dump
+     *
+     * @param handle - crash dump handle
+     * @param index - system field enum. Must be less than crash.SYSFIELD_MAX
+     * @returns value recorded in the crash dump, or `nil` if it didn't exist
+     */
     function get_sys_field(handle: number, index: number): string | unknown;
+    /**
+     * reads user field from a loaded crash dump
+     *
+     * @param handle - crash dump handle
+     * @param index - user data slot index
+     * @returns user data value recorded in the crash dump
+     */
     function get_user_field(handle: number, index: number): string;
+    /**
+     * The crash dump will be removed from disk upon a successful
+     * load, so loading is one-shot.
+     *
+     * @returns handle to the loaded dump, or `nil` if no dump was found
+     */
     function load_previous(): number | unknown;
+    /**
+     * releases a previously loaded crash dump
+     *
+     * @param handle - handle to loaded crash dump
+     */
     function release(handle: number): void;
+    /**
+     * Crashes occuring before the path is set will be stored to a default engine location.
+     *
+     * @param path - file path to use
+     */
     function set_file_path(path: string): void;
+    /**
+     * Store a user value that will get written to a crash dump when
+     * a crash occurs. This can be user id:s, breadcrumb data etc.
+     * There are 32 slots indexed from 0. Each slot stores at most 255 characters.
+     *
+     * @param index - slot index. 0-indexed
+     * @param value - string value to store
+     */
     function set_user_field(index: number, value: string): void;
+    /**
+     * Performs the same steps as if a crash had just occured but
+     * allows the program to continue.
+     * The generated dump can be read by crash.load_previous
+     */
     function write_dump(): void;
   }
 }

package/generated/factory.d.ts

@@ -3,13 +3,107 @@ import type { Hash, Opaque, Quaternion, Url, Vector3 } from "../src/core-types";
 
 declare global {
   namespace factory {
+    /**
+     * loaded
+     */
     const STATUS_LOADED: number & { readonly __brand: "factory.STATUS_LOADED" };
+    /**
+     * loading
+     */
     const STATUS_LOADING: number & { readonly __brand: "factory.STATUS_LOADING" };
+    /**
+     * unloaded
+     */
     const STATUS_UNLOADED: number & { readonly __brand: "factory.STATUS_UNLOADED" };
+    /**
+     * The URL identifies which factory should create the game object.
+     * If the game object is created inside of the frame (e.g. from an update callback), the game object will be created instantly, but none of its component will be updated in the same frame.
+     * Properties defined in scripts in the created game object can be overridden through the properties-parameter below.
+     * See go.property for more information on script properties.
+     * Calling factory.create on a factory that is marked as dynamic without having loaded resources
+     * using factory.load will synchronously load and create resources which may affect application performance.
+     *
+     * @param url - the factory that should create a game object.
+     * @param position - the position of the new game object, the position of the game object calling `factory.create()` is used by default, or if the value is `nil`.
+     * @param rotation - the rotation of the new game object, the rotation of the game object calling `factory.create()` is used by default, or if the value is `nil`.
+     * @param properties - the properties defined in a script attached to the new game object.
+     * @param scale - the scale of the new game object (must be greater than 0), the scale of the game object containing the factory is used by default, or if the value is `nil`
+     * @returns the global id of the spawned game object
+     * @example
+     * ```lua
+     * How to create a new game object:
+     * function init(self)
+     *     -- create a new game object and provide property values
+     *     self.my_created_object = factory.create("#factory", nil, nil, {my_value = 1})
+     *     -- communicate with the object
+     *     msg.post(self.my_created_object, "hello")
+     * end
+     *
+     * And then let the new game object have a script attached:
+     * go.property("my_value", 0)
+     *
+     * function init(self)
+     *     -- do something with self.my_value which is now one
+     * end
+     * ```
+     */
     function create(url: string | Hash | Url, position?: Vector3, rotation?: Quaternion, properties?: Record<string | number, unknown>, scale?: number | Vector3): Hash;
+    /**
+     * This returns status of the factory.
+     * Calling this function when the factory is not marked as dynamic loading always returns
+     * factory.STATUS_LOADED.
+     *
+     * @param url - the factory component to get status from
+     * @returns status of the factory component
+  - `factory.STATUS_UNLOADED`
+  - `factory.STATUS_LOADING`
+  - `factory.STATUS_LOADED`
+     */
     function get_status(url?: string | Hash | Url): Opaque<"constant">;
+    /**
+     * Resources are referenced by the factory component until the existing (parent) collection is destroyed or factory.unload is called.
+     * Calling this function when the factory is not marked as dynamic loading does nothing.
+     *
+     * @param url - the factory component to load
+     * @param complete_function - function to call when resources are loaded.
+  `self`
+  object The current object.
+  `url`
+  url url of the factory component
+  `result`
+  boolean True if resources were loaded successfully
+     * @example
+     * ```lua
+     * How to load resources of a factory prototype.
+     * factory.load("#factory", function(self, url, result) end)
+     * ```
+     */
     function load(url?: string | Hash | Url, complete_function?: (self: unknown, url: unknown, result: unknown) => void): void;
+    /**
+     * Changes the prototype for the factory.
+     *
+     * @param url - the factory component
+     * @param prototype - the path to the new prototype, or `nil`
+     * @example
+     * ```lua
+     * How to unload the previous prototypes resources, and then spawn a new game object
+     * factory.unload("#factory") -- unload the previous resources
+     * factory.set_prototype("#factory", "/main/levels/enemyA.goc")
+     * local id = factory.create("#factory", go.get_world_position(), vmath.quat())
+     * ```
+     */
     function set_prototype(url?: string | Hash | Url, prototype?: string): void;
+    /**
+     * This decreases the reference count for each resource loaded with factory.load. If reference is zero, the resource is destroyed.
+     * Calling this function when the factory is not marked as dynamic loading does nothing.
+     *
+     * @param url - the factory component to unload
+     * @example
+     * ```lua
+     * How to unload resources of a factory prototype loaded with factory.load
+     * factory.unload("#factory")
+     * ```
+     */
     function unload(url?: string | Hash | Url): void;
   }
 }