@defold-typescript/types 0.25.0 → 0.27.0

package/generated/versions/defold-1.13.0/buffer.d.ts

@@ -0,0 +1,176 @@
+/** @noSelfInFile */
+import type { Hash, Opaque } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for manipulating buffers and streams
+   */
+  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
+     * ```ts
+     * // How to copy elements (e.g. vertices) from one buffer to another
+     * // copy entire buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, 0, srcbuffer.length);
+     *
+     * // copy last 10 elements to the front of another buffer
+     * buffer.copy_buffer(dstbuffer, 0, srcbuffer, srcbuffer.length - 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
+     * ```ts
+     * // How to update a texture of a sprite:
+     * // copy entire stream
+     * const srcstream = buffer.get_stream(srcbuffer, hash("xyz"));
+     * const dststream = buffer.get_stream(dstbuffer, hash("xyz"));
+     * buffer.copy_stream(dststream, 0, srcstream, 0, srcstream.length);
+     * ```
+     */
+    function copy_stream(dst: Opaque<"bufferstream"> & { [index: number]: number }, dstoffset: number, src: Opaque<"bufferstream"> & { [index: number]: number }, 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
+     * ```ts
+     * // How to create and initialize a buffer
+     * export default defineScript({
+     *   init(self) {
+     *     const 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 (let y = 0; y < self.height; y++) {
+     *       for (let x = 0; x < self.width; x++) {
+     *         const index = y * self.width * 3 + x * 3;
+     *         self.imagestream[index + 0] = self.r;
+     *         self.imagestream[index + 1] = self.g;
+     *         self.imagestream[index + 2] = self.b;
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    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
+     * ```ts
+     * // How to get a metadata entry from a buffer
+     * // retrieve a metadata entry named "somefloats" and its numeric type
+     * const [values, type] = buffer.get_metadata(buf, hash("somefloats"));
+     * if (values) print(`${values.length} values in 'somefloats'`);
+     * ```
+     */
+    function get_metadata(buf: Opaque<"buffer">, metadata_name: Hash | string): LuaMultiReturn<[number[] | undefined, Opaque<"constant"> | undefined]>;
+    /**
+     * 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"> & { [index: number]: number };
+    /**
+     * 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
+     * ```ts
+     * // 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;
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.0/camera.d.ts

@@ -0,0 +1,302 @@
+/** @noSelfInFile */
+import type { Matrix4, Url, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Messages to control camera components and camera focus.
+   */
+  namespace camera {
+    /**
+     * Computes zoom so the original display area covers the entire window while preserving aspect ratio.
+     * Equivalent to using max(window_width/width, window_height/height).
+     * The result is multiplied by the user-controlled orthographic zoom.
+     */
+    const ORTHO_MODE_AUTO_COVER: number & { readonly __brand: "camera.ORTHO_MODE_AUTO_COVER" };
+    /**
+     * Computes zoom so the original display area (game.project width/height) fits inside the window
+     * while preserving aspect ratio. Equivalent to using min(window_width/width, window_height/height).
+     * The result is multiplied by the user-controlled orthographic zoom.
+     */
+    const ORTHO_MODE_AUTO_FIT: number & { readonly __brand: "camera.ORTHO_MODE_AUTO_FIT" };
+    /**
+     * Uses the manually set orthographic zoom value (camera.set_orthographic_zoom).
+     */
+    const ORTHO_MODE_FIXED: number & { readonly __brand: "camera.ORTHO_MODE_FIXED" };
+    /**
+     * Gets the effective aspect ratio of the camera. If auto aspect ratio is enabled,
+     * returns the aspect ratio calculated from the current render target dimensions.
+     * Otherwise returns the manually set aspect ratio.
+     *
+     * @param camera - camera id
+     * @returns the effective aspect ratio.
+     */
+    function get_aspect_ratio(camera?: Url | number): number;
+    /**
+     * Returns whether auto aspect ratio is enabled. When enabled, the camera automatically
+     * calculates aspect ratio from render target dimensions. When disabled, uses the
+     * manually set aspect ratio value.
+     *
+     * @param camera - camera id
+     * @returns true if auto aspect ratio is enabled
+     */
+    function get_auto_aspect_ratio(camera?: Url | number): boolean;
+    /**
+     * This function returns a table with all the camera URLs that have been
+     * registered in the render context.
+     *
+     * @returns a table with all camera URLs
+     * @example
+     * ```ts
+     * for (const camera_id of camera.get_cameras()) {
+     *   render.set_camera(camera_id);
+     *   render.draw(predicate);
+     *   render.set_camera();
+     * }
+     * ```
+     */
+    function get_cameras(): Url[];
+    /**
+     * get enabled
+     *
+     * @param camera - camera id
+     * @returns true if the camera is enabled
+     */
+    function get_enabled(camera?: Url | number): boolean;
+    /**
+     * get far z
+     *
+     * @param camera - camera id
+     * @returns the far z.
+     */
+    function get_far_z(camera?: Url | number): number;
+    /**
+     * get field of view
+     *
+     * @param camera - camera id
+     * @returns the field of view.
+     */
+    function get_fov(camera?: Url | number): number;
+    /**
+     * get near z
+     *
+     * @param camera - camera id
+     * @returns the near z.
+     */
+    function get_near_z(camera?: Url | number): number;
+    /**
+     * Gets the orthographic zoom calculated from the current window and project dimensions
+     * in auto-fit and auto-cover modes. Returns 1.0 in fixed mode.
+     *
+     * @param camera - camera id
+     * @returns the calculated orthographic auto zoom.
+     */
+    function get_orthographic_auto_zoom(camera?: Url | number): number;
+    /**
+     * get orthographic zoom mode
+     *
+     * @param camera - camera id
+     * @returns one of camera.ORTHO_MODE_FIXED, camera.ORTHO_MODE_AUTO_FIT or
+     * camera.ORTHO_MODE_AUTO_COVER
+     */
+    function get_orthographic_mode(camera?: Url | number): number;
+    /**
+     * Gets the positive user-controlled orthographic zoom multiplier. In auto-fit and auto-cover
+     * modes, this value is multiplied with camera.get_orthographic_auto_zoom(camera).
+     *
+     * @param camera - camera id
+     * @returns the positive zoom multiplier when the camera uses orthographic projection.
+     */
+    function get_orthographic_zoom(camera?: Url | number): number;
+    /**
+     * get projection matrix
+     *
+     * @param camera - camera id
+     * @returns the projection matrix.
+     */
+    function get_projection(camera?: Url | number): Matrix4;
+    /**
+     * get view matrix
+     *
+     * @param camera - camera id
+     * @returns the view matrix.
+     */
+    function get_view(camera?: Url | number): Matrix4;
+    /**
+     * Converts a screen-space 2D point with view depth to a 3D world point.
+     * z is the view depth in world units measured from the camera plane along the camera forward axis.
+     * If a camera isn't specified, the last enabled camera is used.
+     *
+     * @param pos - Screen-space position (x, y) with z as view depth in world units
+     * @param camera - optional camera id
+     * @returns the world coordinate
+     * @example
+     * ```ts
+     * // Place objects at the touch point with a random Z position, keeping them
+     * // within the visible view zone.
+     * export default defineScript({
+     *   on_input(self, action_id, action) {
+     *     if (action_id === hash("touch")) {
+     *       if (action.pressed) {
+     *         const perspective_camera = msg.url("#perspective_camera");
+     *         const random_z = math.random(
+     *           camera.get_near_z(perspective_camera) + 0.01,
+     *           camera.get_far_z(perspective_camera) - 0.01,
+     *         );
+     *         const world_position = camera.screen_to_world(
+     *           vmath.vector3(action.screen_x, action.screen_y, random_z),
+     *           perspective_camera,
+     *         );
+     *         go.set_position(world_position, "/go1");
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function screen_to_world(pos: Vector3, camera?: Url | number): Vector3;
+    /**
+     * Converts 2D screen coordinates (x,y) to the 3D world-space point on the camera's near plane for that pixel.
+     * If a camera isn't specified, the last enabled camera is used.
+     *
+     * @param x - X coordinate on screen.
+     * @param y - Y coordinate on screen.
+     * @param camera - optional camera id
+     * @returns the world coordinate on the camera near plane
+     * @example
+     * ```ts
+     * // Place objects at the touch point.
+     * export default defineScript({
+     *   on_input(self, action_id, action) {
+     *     if (action_id === hash("touch")) {
+     *       if (action.pressed) {
+     *         const world_position = camera.screen_xy_to_world(action.screen_x, action.screen_y);
+     *         go.set_position(world_position, "/go1");
+     *       }
+     *     }
+     *   },
+     * });
+     * ```
+     */
+    function screen_xy_to_world(x: number, y: number, camera?: Url | number): Vector3;
+    /**
+     * Sets the manual aspect ratio for the camera. This value is only used when
+     * auto aspect ratio is disabled. To disable auto aspect ratio and use this
+     * manual value, call camera.set_auto_aspect_ratio(camera, false).
+     *
+     * @param camera - camera id
+     * @param aspect_ratio - the manual aspect ratio value.
+     */
+    function set_aspect_ratio(camera: Url | number | undefined, aspect_ratio: number): void;
+    /**
+     * Enables or disables automatic aspect ratio calculation. When enabled (true),
+     * the camera automatically calculates aspect ratio from render target dimensions.
+     * When disabled (false), uses the manually set aspect ratio value.
+     *
+     * @param camera - camera id
+     * @param auto_aspect_ratio - true to enable auto aspect ratio
+     */
+    function set_auto_aspect_ratio(camera: Url | number | undefined, auto_aspect_ratio: boolean): void;
+    /**
+     * set far z
+     *
+     * @param camera - camera id
+     * @param far_z - the far z.
+     */
+    function set_far_z(camera: Url | number | undefined, far_z: number): void;
+    /**
+     * set field of view
+     *
+     * @param camera - camera id
+     * @param fov - the field of view.
+     */
+    function set_fov(camera: Url | number | undefined, fov: number): void;
+    /**
+     * set near z
+     *
+     * @param camera - camera id
+     * @param near_z - the near z.
+     */
+    function set_near_z(camera: Url | number | undefined, near_z: number): void;
+    /**
+     * set orthographic zoom mode
+     *
+     * @param camera - camera id
+     * @param mode - camera.ORTHO_MODE_FIXED, camera.ORTHO_MODE_AUTO_FIT or camera.ORTHO_MODE_AUTO_COVER
+     */
+    function set_orthographic_mode(camera: Url | number | undefined, mode: number): void;
+    /**
+     * Sets the positive user-controlled orthographic zoom multiplier. In auto-fit and auto-cover
+     * modes, this value is multiplied with camera.get_orthographic_auto_zoom(camera).
+     *
+     * @param camera - camera id
+     * @param orthographic_zoom - the positive zoom multiplier when the camera uses orthographic projection.
+     */
+    function set_orthographic_zoom(camera: Url | number | undefined, orthographic_zoom: number): void;
+    /**
+     * Converts a 3D world position to screen-space coordinates with view depth.
+     * Returns a vector3 where x and y are in screen pixels and z is the view depth in world units
+     * measured from the camera plane along the camera forward axis. The returned z can be used with
+     * camera.screen_to_world to reconstruct the world position on the same pixel ray.
+     * If a camera isn't specified, the last enabled camera is used.
+     *
+     * @param world_pos - World-space position
+     * @param camera - optional camera id
+     * @returns Screen position (x,y in pixels, z is view depth)
+     * @example
+     * ```ts
+     * // Convert a game object position into a screen position.
+     * go.update_world_transform("/go1");
+     * const world_pos = go.get_world_position("/go1");
+     * const screen_pos = camera.world_to_screen(world_pos);
+     * ```
+     */
+    function world_to_screen(world_pos: Vector3, camera?: Url | number): Vector3;
+    interface properties {
+      /**
+       * The ratio between the frustum width and height. Used when calculating the
+       * projection of a perspective camera.
+       * The type of the property is number.
+       */
+      aspect_ratio: unknown;
+      /**
+       * Camera frustum far plane.
+       * The type of the property is float.
+       */
+      far_z: unknown;
+      /**
+       * Vertical field of view of the camera.
+       * The type of the property is float.
+       */
+      fov: unknown;
+      /**
+       * Camera frustum near plane.
+       * The type of the property is float.
+       */
+      near_z: unknown;
+      /**
+       * READ ONLY The zoom calculated from the current window and project dimensions
+       * in auto fit and auto cover modes. The value is 1.0 in fixed mode.
+       * The type of the property is float.
+       */
+      orthographic_auto_zoom: unknown;
+      /**
+       * Positive zoom multiplier when using an orthographic projection. In auto fit and auto cover
+       * modes, this value is multiplied with the calculated orthographic_auto_zoom value.
+       * The type of the property is float.
+       */
+      orthographic_zoom: unknown;
+      /**
+       * READ ONLY The calculated projection matrix of the camera.
+       * The type of the property is matrix4.
+       */
+      projection: unknown;
+      /**
+       * READ ONLY The calculated view matrix of the camera.
+       * The type of the property is matrix4.
+       */
+      view: unknown;
+    }
+  }
+}
+
+export {};

package/generated/versions/defold-1.13.0/collectionfactory.d.ts

@@ -0,0 +1,146 @@
+/** @noSelfInFile */
+import type { Hash, Opaque, Quaternion, Url, Vector3 } from "../../../src/core-types";
+
+declare global {
+  /**
+   * Functions for controlling collection factory components which are
+   * used to dynamically spawn collections into the runtime.
+   */
+  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
+     * ```ts
+     * // How to spawn a collection of game objects:
+     * export default defineScript({
+     *   init(self) {
+     *     // Spawn a small group of enemies.
+     *     const pos = vmath.vector3(100, 12.5, 0);
+     *     const rot = vmath.quat_rotation_z(Math.PI / 2);
+     *     const scale = 0.5;
+     *     const props = {
+     *       [hash("/enemy_leader")]: { health: 1000.0 },
+     *       [hash("/enemy_1")]: { health: 200.0 },
+     *       [hash("/enemy_2")]: { health: 400.0, color: hash("green") },
+     *     };
+     *
+     *     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.
+     *     const leader_id = self.enemy_ids[hash("/enemy_leader")];
+     *     msg.post(leader_id, "attack");
+     *   },
+     * });
+     *
+     * // 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): LuaMap<Hash, Hash>;
+    /**
+     * 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
+     * ```ts
+     * // How to load resources of a collection factory prototype.
+     * collectionfactory.load("#factory", (self, url, result) => {});
+     * ```
+     */
+    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
+     * ```ts
+     * // How to unload the previous prototype's resources, and then spawn a new collection:
+     * collectionfactory.unload("#factory"); // unload the previous resources
+     * collectionfactory.set_prototype("#factory", "/main/levels/level1.collectionc");
+     * const 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
+     * ```ts
+     * // How to unload resources of a collection factory prototype loaded with collectionfactory.load:
+     * collectionfactory.unload("#factory");
+     * ```
+     */
+    function unload(url?: string | Hash | Url): void;
+  }
+}
+
+export {};