factorio-types 1.2.54 → 1.2.56

package/src/lualib/collision-mask-defaults.d.ts

@@ -0,0 +1,181 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/collision-mask-defaults.lua
+declare module "collision-mask-defaults" {
+    interface MaskType {
+        ["agricultural-tower"]: prototype.CollisionMaskConnector,
+        ["ammo-turret"]: prototype.CollisionMaskConnector,
+        ["arithmetic-combinator"]: prototype.CollisionMaskConnector,
+        ["artillery-turret"]: prototype.CollisionMaskConnector,
+        ["assembling-machine"]: prototype.CollisionMaskConnector,
+        ["asteroid-chunk"]: prototype.CollisionMaskConnector,
+        ["asteroid-collector"]: prototype.CollisionMaskConnector,
+        ["asteroid"]: prototype.CollisionMaskConnector,
+        ["beacon"]: prototype.CollisionMaskConnector,
+        ["boiler"]: prototype.CollisionMaskConnector,
+        ["burner-generator"]: prototype.CollisionMaskConnector,
+        ["decider-combinator"]: prototype.CollisionMaskConnector,
+        ["electric-energy-interface"]: prototype.CollisionMaskConnector,
+        ["electric-turret"]: prototype.CollisionMaskConnector,
+        ["fluid-turret"]: prototype.CollisionMaskConnector,
+        ["furnace"]: prototype.CollisionMaskConnector,
+        ["generator"]: prototype.CollisionMaskConnector,
+        ["heat-interface"]: prototype.CollisionMaskConnector,
+        ["infinity-pipe"]: prototype.CollisionMaskConnector,
+        ["inserter"]: prototype.CollisionMaskConnector,
+        ["lab"]: prototype.CollisionMaskConnector,
+        ["market"]: prototype.CollisionMaskConnector,
+        ["mining-drill"]: prototype.CollisionMaskConnector,
+        ["offshore-pump"]: prototype.CollisionMaskConnector,
+        ["pipe-to-ground"]: prototype.CollisionMaskConnector,
+        ["pipe"]: prototype.CollisionMaskConnector,
+        ["plant"]: prototype.CollisionMaskConnector,
+        ["fusion-generator"]: prototype.CollisionMaskConnector,
+        ["fusion-reactor"]: prototype.CollisionMaskConnector,
+        ["power-switch"]: prototype.CollisionMaskConnector,
+        ["programmable-speaker"]: prototype.CollisionMaskConnector,
+        ["pump"]: prototype.CollisionMaskConnector,
+        ["radar"]: prototype.CollisionMaskConnector,
+        ["reactor"]: prototype.CollisionMaskConnector,
+        ["rocket-silo-rocket-shadow"]: prototype.CollisionMaskConnector,
+        ["rocket-silo-rocket"]: prototype.CollisionMaskConnector,
+        ["selector-combinator"]: prototype.CollisionMaskConnector,
+        ["simple-entity-with-force"]: prototype.CollisionMaskConnector,
+        ["simple-entity-with-owner"]: prototype.CollisionMaskConnector,
+        ["simple-entity"]: prototype.CollisionMaskConnector,
+        ["storage-tank"]: prototype.CollisionMaskConnector,
+        ["thruster"]: prototype.CollisionMaskConnector,
+        ["tree"]: prototype.CollisionMaskConnector,
+        ["turret"]: prototype.CollisionMaskConnector,
+        ["unit-spawner"]: prototype.CollisionMaskConnector,
+        ["valve"]: prototype.CollisionMaskConnector,
+        ["wall"]: prototype.CollisionMaskConnector,
+        ["display-panel"]: prototype.CollisionMaskConnector,
+
+        ["accumulator"]: prototype.CollisionMaskConnector,
+        ["cargo-pod"]: prototype.CollisionMaskConnector,
+        ["constant-combinator"]: prototype.CollisionMaskConnector,
+        ["electric-pole"]: prototype.CollisionMaskConnector,
+        ["lamp"]: prototype.CollisionMaskConnector,
+        ["solar-panel"]: prototype.CollisionMaskConnector,
+        ["train-stop"]: prototype.CollisionMaskConnector,
+
+        ["cargo-bay"]: prototype.CollisionMaskConnector,
+        ["cargo-landing-pad"]: prototype.CollisionMaskConnector,
+        ["lightning-attractor"]: prototype.CollisionMaskConnector,
+        ["roboport"]: prototype.CollisionMaskConnector,
+        ["rocket-silo"]: prototype.CollisionMaskConnector,
+        ["space-platform-hub"]: prototype.CollisionMaskConnector,
+
+        ["container"]: prototype.CollisionMaskConnector,
+        ["infinity-container"]: prototype.CollisionMaskConnector,
+        ["linked-container"]: prototype.CollisionMaskConnector,
+        ["proxy-container"]: prototype.CollisionMaskConnector,
+        ["logistic-container"]: prototype.CollisionMaskConnector,
+        ["temporary-container"]: prototype.CollisionMaskConnector,
+
+        ["linked-belt"]: prototype.CollisionMaskConnector,
+        ["loader-1x1"]: prototype.CollisionMaskConnector,
+        ["loader"]: prototype.CollisionMaskConnector,
+        ["splitter"]: prototype.CollisionMaskConnector,
+        ["lane-splitter"]: prototype.CollisionMaskConnector,
+        ["transport-belt"]: prototype.CollisionMaskConnector,
+        ["underground-belt"]: prototype.CollisionMaskConnector,
+
+        ["curved-rail-a"]: prototype.CollisionMaskConnector,
+        ["curved-rail-b"]: prototype.CollisionMaskConnector,
+        ["half-diagonal-rail"]: prototype.CollisionMaskConnector,
+        ["legacy-curved-rail"]: prototype.CollisionMaskConnector,
+        ["legacy-straight-rail"]: prototype.CollisionMaskConnector,
+        ["straight-rail"]: prototype.CollisionMaskConnector,
+
+        ["rail-ramp"]: prototype.CollisionMaskConnector,
+        ["rail-ramp/allow_on_deep_oil_ocean"]: prototype.CollisionMaskConnector,
+
+        ["rail-support"]: prototype.CollisionMaskConnector,
+        ["rail-support/allow_on_deep_oil_ocean"]: prototype.CollisionMaskConnector,
+
+        ["elevated-curved-rail-a"]: prototype.CollisionMaskConnector,
+        ["elevated-curved-rail-b"]: prototype.CollisionMaskConnector,
+        ["elevated-half-diagonal-rail"]: prototype.CollisionMaskConnector,
+        ["elevated-straight-rail"]: prototype.CollisionMaskConnector,
+
+        ["rail-chain-signal"]: prototype.CollisionMaskConnector,
+        ["rail-signal"]: prototype.CollisionMaskConnector,
+
+        ["rail-chain-signal/elevated"]: prototype.CollisionMaskConnector,
+        ["rail-signal/elevated"]: prototype.CollisionMaskConnector,
+
+        ["artillery-wagon"]: prototype.CollisionMaskConnector,
+        ["infinity-cargo-wagon"]: prototype.CollisionMaskConnector,
+        ["cargo-wagon"]: prototype.CollisionMaskConnector,
+        ["fluid-wagon"]: prototype.CollisionMaskConnector,
+        ["locomotive"]: prototype.CollisionMaskConnector,
+
+        ["artillery-wagon/transition"]: prototype.CollisionMaskConnector,
+        ["infinity-cargo-wagon/transition"]: prototype.CollisionMaskConnector,
+        ["cargo-wagon/transition"]: prototype.CollisionMaskConnector,
+        ["fluid-wagon/transition"]: prototype.CollisionMaskConnector,
+        ["locomotive/transition"]: prototype.CollisionMaskConnector,
+
+        ["artillery-wagon/elevated"]: prototype.CollisionMaskConnector,
+        ["infinity-cargo-wagon/elevated"]: prototype.CollisionMaskConnector,
+        ["cargo-wagon/elevated"]: prototype.CollisionMaskConnector,
+        ["fluid-wagon/elevated"]: prototype.CollisionMaskConnector,
+        ["locomotive/elevated"]: prototype.CollisionMaskConnector,
+
+        ["gate"]: prototype.CollisionMaskConnector,
+        ["gate/opened"]: prototype.CollisionMaskConnector,
+
+        ["arrow"]: prototype.CollisionMaskConnector,
+        ["artillery-flare"]: prototype.CollisionMaskConnector,
+        ["artillery-projectile"]: prototype.CollisionMaskConnector,
+        ["beam"]: prototype.CollisionMaskConnector,
+        ["capture-robot"]: prototype.CollisionMaskConnector,
+        ["character-corpse"]: prototype.CollisionMaskConnector,
+        ["combat-robot"]: prototype.CollisionMaskConnector,
+        ["construction-robot"]: prototype.CollisionMaskConnector,
+        ["explosion"]: prototype.CollisionMaskConnector,
+        ["fire"]: prototype.CollisionMaskConnector,
+        ["highlight-box"]: prototype.CollisionMaskConnector,
+        ["item-request-proxy"]: prototype.CollisionMaskConnector,
+        ["leaf-particle"]: prototype.CollisionMaskConnector,
+        ["lightning"]: prototype.CollisionMaskConnector,
+        ["logistic-robot"]: prototype.CollisionMaskConnector,
+        ["particle-source"]: prototype.CollisionMaskConnector,
+        ["particle"]: prototype.CollisionMaskConnector,
+        ["projectile"]: prototype.CollisionMaskConnector,
+        ["projectile/hit"]: prototype.CollisionMaskConnector,
+        ["smoke-with-trigger"]: prototype.CollisionMaskConnector,
+        ["smoke"]: prototype.CollisionMaskConnector,
+        ["speech-bubble"]: prototype.CollisionMaskConnector,
+        ["sticker"]: prototype.CollisionMaskConnector,
+        ["stream"]: prototype.CollisionMaskConnector,
+        ["tile"]: prototype.CollisionMaskConnector,
+
+        ["car"]: prototype.CollisionMaskConnector,
+        ["character"]: prototype.CollisionMaskConnector,
+        ["character/flying"]: prototype.CollisionMaskConnector,
+        ["cliff"]: prototype.CollisionMaskConnector,
+        ["corpse"]: prototype.CollisionMaskConnector,
+        ["deconstructible-tile-proxy"]: prototype.CollisionMaskConnector,
+        ["entity-ghost"]: prototype.CollisionMaskConnector,
+        ["fish"]: prototype.CollisionMaskConnector,
+        ["heat-pipe"]: prototype.CollisionMaskConnector,
+        ["item-entity"]: prototype.CollisionMaskConnector,
+        ["land-mine"]: prototype.CollisionMaskConnector,
+        ["player-port"]: prototype.CollisionMaskConnector,
+        ["rail-remnants"]: prototype.CollisionMaskConnector,
+        ["resource"]: prototype.CollisionMaskConnector,
+        ["spider-leg"]: prototype.CollisionMaskConnector,
+        ["spider-unit"]: prototype.CollisionMaskConnector,
+        ["spider-vehicle"]: prototype.CollisionMaskConnector,
+        ["tile-ghost"]: prototype.CollisionMaskConnector,
+        ["unit"]: prototype.CollisionMaskConnector,
+        ["segment"]: prototype.CollisionMaskConnector,
+        ["segmented-unit"]: prototype.CollisionMaskConnector,
+        ["decorative"]: prototype.CollisionMaskConnector,
+    }
+
+    const masks: MaskType;
+
+    export default masks;
+}

package/src/lualib/collision-mask-util.d.ts

@@ -0,0 +1,23 @@
+declare module "collision-mask-util" {
+    export function get_default_mask(this: void, type: string): prototype.CollisionMaskConnector;
+
+    export function get_mask(
+        this: void,
+        entity_prototpe: { collision_mask: prototype.CollisionMaskConnector, type: string }): prototype.CollisionMaskConnector;
+
+    export function masks_collide(this: void, mask1: prototype.CollisionMaskConnector, mask2: prototype.CollisionMaskConnector): boolean;
+
+    export function masks_are_same(this: void, mask1: prototype.CollisionMaskConnector, mask2: prototype.CollisionMaskConnector): boolean;
+
+    export function collect_prototypes_with_mask(this: void, mask: prototype.CollisionMaskConnector): prototype.AnyPrototype[];
+
+    export function collect_prototypes_with_layer(this: void, layer: prototype.CollisionLayerID): prototype.AnyPrototype[];
+
+    export function collect_prototypes_colliding_with_mask(this: void, mask: prototype.CollisionMaskConnector): prototype.AnyPrototype[];
+
+    export function replace_layer_in_all_prototypes(this: void, old_name: prototype.CollisionLayerID, new_name: prototype.CollisionLayerID): void;
+
+    export function new_mask(this: void): prototype.CollisionMaskConnector;
+
+    export function migrate_from_before_1_2_0(this: void, old_mask: Record<prototype.CollisionLayerID, true>): prototype.CollisionMaskConnector; 
+}

package/src/lualib/crash-site.d.ts

@@ -0,0 +1,35 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/crash-site.lua
+declare module "crash-site" {
+    export interface ShipPart {
+        name: string;
+        angle_deviation: number;
+        variations?: number;
+        max_distance?: number;
+        min_separation?: number;
+        fire_count?: number;
+        explosion_count?: number;
+        repeat_count?: number;
+        scale_lifetime?: boolean;
+    }
+
+    export function create_crash_site(
+        this: void,
+        surface: runtime.LuaSurface,
+        position: runtime.MapPosition,
+        ship_items: runtime.ItemStackIdentification[],
+        part_items: runtime.ItemStackIdentification[],
+        ship_parts: ShipPart[]): void;
+
+    export function create_cutscene(
+        this: void,
+        player: runtime.LuaPlayer,
+        goal_position: runtime.MapPosition): void
+    
+    export function is_crash_site_cutscene(this: void, event: runtime.on_cutscene_waypoint_reached): boolean;
+
+    export function on_player_display_refresh(
+        this: void,
+        event: runtime.on_player_display_resolution_changed | runtime.on_player_display_scale_changed): void;
+
+    export function default_ship_parts(): ShipPart[];
+}

package/src/lualib/data-duplicate-checker.d.ts

@@ -0,0 +1,6 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/data-duplicate-checker.lua
+declare module "data-duplicate-checker" {
+    export function check_for_duplicates(this: void, prototypes: Record<string, prototype.AnyPrototype>, overwrite: prototype.AnyPrototype): void;
+
+    export function check_for_overwrites(this: void, prototypes: Record<string, prototype.AnyPrototype>, overwrite: prototype.AnyPrototype): void;
+}

package/src/lualib/event_handler.d.ts

@@ -0,0 +1,16 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/event_handler.lua
+declare module "event_handler" {
+    // Looking at the implementation of these functions, the objects seem close to LuaBootstrap as they have many of the same members
+    // on_configuration_changed, on_init, on_load, etc
+    // they also have a few additional fields not mentioned elsewhere
+    // hopefull this type is close enough
+    export type Library = Partial<runtime.LuaBootstrap> & {
+        add_remote_interface?: (this: void) => void;
+        add_commands?: (this: void) => void;
+        events: Record<string, runtime.LuaEventType>;
+    }
+
+    export function add_lib(this: void, lib: Library): void;
+
+    export function add_libraries(this: void, libs: Record<string, Library>): void;
+}

package/src/lualib/index.d.ts

@@ -0,0 +1,22 @@
+// Type definitions for Factorio modding API
+// Factorio API reference https://lua-api.factorio.com/latest/index.html
+// src mappings manually written to cover aspects not in the machine-readable API spec
+// Definition source https://github.com/sguest/factorio-types
+
+/// <reference path="./autoplace_utils.d.ts" />
+/// <reference path="./collision-mask-defaults.d.ts" />
+/// <reference path="./collision-mask-util.d.ts" />
+/// <reference path="./crash-site.d.ts" />
+/// <reference path="./data-duplicate-checker.d.ts" />
+/// <reference path="./event_handler.d.ts" />
+/// <reference path="./kill-score.d.ts" />
+/// <reference path="./math2d.d.ts" />
+/// <reference path="./math3d.d.ts" />
+/// <reference path="./meld.d.ts" />
+/// <reference path="./mod-gui.d.ts" />
+/// <reference path="./production-score.d.ts" />
+/// <reference path="./resource-autoplace.d.ts" />
+/// <reference path="./silo-script.d.ts" />
+/// <reference path="./space-finish-script.d.ts" />
+/// <reference path="./surface-render-parameter-effects.d.ts" />
+/// <reference path="./util.d.ts" />

package/src/lualib/kill-score.d.ts

@@ -0,0 +1,8 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/kill-score.lua
+declare module "kill-score" {
+    export function generate_entity_prices(this: void, param?: { prices?: Record<string,number>, item_prices?: Record<string, number> }): Record<string, number>
+
+    export function get_kill_scores(this: void, price_list?: Record<string, number>): Record<string, number>;
+
+    export function get_default_prices(this: void): Record<string, number>;
+}

package/src/lualib/math2d.d.ts

@@ -0,0 +1,41 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/math2d.lua
+declare module "math2d" {
+    export const projection_constant = 0.7071067811865;
+
+    export const vector: {
+        from_orientation(this: void, orientation: number, length: number): runtime.Vector;
+        to_orientation(this: void, vec: runtime.Vector): number;
+        length(this: void, vec: runtime.Vector): number;
+        projected(this: void, vec: runtime.Vector): runtime.Vector;
+    }
+
+    export const position: {
+        /**
+         * Takes a position that might be either a two element array, or a table
+         * with x and y keys, and returns a position with x and y keys.
+         */
+        ensure_xy(this: void, pos: runtime.MapPosition): { x: number, y: number };
+        distance_squared(this: void, p1: runtime.MapPosition, p2: runtime.MapPosition): number;
+        distance(this: void, p1: runtime.MapPosition, p2: runtime.MapPosition): number;
+        rotate_vector(this: void, vector: runtime.Vector, angle_in_deg: number): runtime.Vector;
+        subtract(this: void, p1: runtime.MapPosition, p2: runtime.MapPosition): runtime.MapPosition;
+        add(this: void, p1: runtime.MapPosition, p2: runtime.MapPosition): runtime.MapPosition;
+        multiply_scalar(this: void, vec: runtime.Vector, scalar: number): runtime.Vector;
+        divide_scalar(this: void, vec: runtime.Vector, scalar: number): runtime.Vector;
+        vector_length(this: void, vec: runtime.Vector): number;
+        get_normalized(this: void, vec: runtime.Vector): runtime.Vector;
+    }
+
+    export const bounding_box: {
+        /**
+         * Takes a bounding box with positions that might be either two element arrays, or tables
+         * with x and y keys, and returns a bounding box with positions with x and y keys
+         */
+        ensure_xy(this: void, bounding_box: runtime.BoundingBox): {left_top: {x : number, y: number}, right_bottom: {x: number, y: number}};
+        get_centre(this: void, box: runtime.BoundingBox): runtime.MapPosition;
+        contains_point(this: void, box: runtime.BoundingBox, point: runtime.MapPosition): boolean;
+        contains_box(this: void, box: runtime.BoundingBox, other: runtime.BoundingBox): boolean;
+        collides_with(this: void, box1: runtime.BoundingBox, box2: runtime.BoundingBox): boolean;
+        create_from_centre(this: void, centre: runtime.MapPosition, width: number, height: number): runtime.BoundingBox;
+    }
+}

package/src/lualib/math3d.d.ts

@@ -0,0 +1,64 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/math3d.lua
+
+// The Vector4 type doesn't exist at runtime so the vector4 references it from prototype instead of runtime like the rest of the file
+// However, this is all just math and the Vector/Vector3D types are all equivalent between prototype and runtime stages
+// Therefore this is a case where mixing and matching prototype and runtime stage members is OK
+declare module "math3d" {
+    export const projection_constant = 0.7071067811865;
+
+    export function project_vec3(this: void, vec3: runtime.Vector3D): runtime.Vector;
+
+    export const vector4: {
+        zero: [0, 0, 0, 0];
+        dot_product(this: void, u: prototype.Vector4f, v: prototype.Vector4f): number;
+        add(this: void, u: prototype.Vector4f, v: prototype.Vector4f): prototype.Vector4f;
+        sub(this: void, u: prototype.Vector4f, v: prototype.Vector4f): prototype.Vector4f;
+        from_vec3(this: void, u: prototype.Vector3D): prototype.Vector4f;
+    }
+
+    export const vector3: {
+        zero: [0, 0, 0];
+        dot_product(this: void, u: runtime.Vector3D, v: runtime.Vector3D): number;
+        add(this: void, u: runtime.Vector3D, v: runtime.Vector3D): runtime.Vector3D;
+        sub(this: void, u: runtime.Vector3D, v: runtime.Vector3D): runtime.Vector3D;
+        mul(this: void, u: runtime.Vector3D, v: runtime.Vector3D): runtime.Vector3D;
+        cross_product(this: void, u: runtime.Vector3D, v: runtime.Vector3D): runtime.Vector3D;
+        angle(this: void, u: runtime.Vector3D, v: runtime.Vector3D): number;
+    }
+
+    export const vector2: {
+        zero: [0, 0];
+        dot_product(this: void, u: runtime.Vector, v: runtime.Vector): number;
+        add(this: void, u: runtime.Vector, v: runtime.Vector): runtime.Vector;
+        sub(this: void, u: runtime.Vector, v: runtime.Vector): runtime.Vector;
+        mul(this: void, u: runtime.Vector, k: runtime.Vector): runtime.Vector;
+        rotate(this: void, v: runtime.Vector, phi: number): runtime.Vector;
+    }
+
+    export type Matrix4x4 = [
+        [number, number, number, number],
+        [number, number, number, number],
+        [number, number, number, number],
+        [number, number, number, number],
+    ];
+
+    export const matrix4x4: {
+        identity: [
+            [1, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, 1],
+        ];
+        rotation_x(this: void, phi: number): Matrix4x4;
+        rotation_y(this: void, phi: number): Matrix4x4;
+        rotation_z(this: void, phi: number): Matrix4x4;
+        translation(this: void, x: number, y: number, z: number): Matrix4x4;
+        translation_vec3(this: void, vec3: runtime.Vector3D): Matrix4x4;
+        scale(this: void, x: number, y: number, z: number): Matrix4x4;
+        column(this: void, mat: Matrix4x4, index: number): [number, number, number, number];
+        transpose(this: void, mat: Matrix4x4): Matrix4x4;
+        mul_mat(this: void, m1: Matrix4x4, m2: Matrix4x4): Matrix4x4;
+        mul_vec3(this: void, mat: Matrix4x4, vec: runtime.Vector3D): runtime.Vector3D;
+        compose(this: void, list: Matrix4x4[]): Matrix4x4;
+    }
+}

package/src/lualib/meld.d.ts

@@ -0,0 +1,33 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/meld.lua
+
+// Lots of "any" types in this declaration - it's not immediately obvious what it's supposed to do and not many example usages in the base mod
+declare module "meld" {
+
+    export const control_marker: {};
+
+    export const controler_handlers: {
+        delete(this: void, target: any, k: string, v: any): void;
+        overwrite(this: void, target: any, k: string, v: any): any;
+        invoke(this: void, target: any, k: string, v: any): any;
+        append(this: void, target: any, k: string, v: any): void;
+    };
+
+    function _delete(this: void): void;
+    export { _delete as delete };
+
+    export function overwrite(this: void, _new: any): any;
+
+    export function invoke(this: void, fct: any): any;
+
+    export function append(this: void, data: any): any;
+
+    /**
+     * recursive table merge but it reuses target table (this: void, does not deepcopy it). When target is not to be reused or more than
+     *  2 tables are to be merged, consider using util.merge. When there is conflict of 2 values, a value from the source will
+     *  win overwriting the existing value. There are also control structures available for extra operations that would not
+     *  be possible under normal merge rules
+     */
+    export function meld(this: void, target: Table, source: Table): Table
+}
+
+declare function meld(this: Table, target: Table, source: Table): void;

package/src/lualib/mod-gui.d.ts

@@ -0,0 +1,25 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/mod-gui.lua
+
+/*
+Hello script explorer, if you are looking to upgrade your mod to use the mod gui, its pretty simple.
+
+Typically you will have something like:
+player.gui.left.add{...}
+
+All you will need to do, is change it to:
+mod_gui.get_frame_flow(player).add{...}
+
+And for buttons its just the same:
+mod_gui.get_button_flow(player).add{...}
+
+It should be as simple as find and replace.
+
+Any other questions please feel free to ask on the modding help forum.
+*/
+declare module "mod-gui" {
+    export const button_style = "mod_gui_button";
+    export const frame_style = "non_draggable_frame"
+
+    export function get_button_flow(this: void, player: runtime.LuaPlayer): runtime.LuaGuiElement;
+    export function get_frame_flow(this: void, player: runtime.LuaPlayer): runtime.LuaGuiElement;
+}

package/src/lualib/production-score.d.ts

@@ -0,0 +1,13 @@
+declare module "production-score" {
+    export function generate_price_list(this: void, param?: {
+        seed_prices?: Record<string, number>,
+        ingedient_exponent?: number,
+        raw_resource_price?: number,
+        resource_ignore?: Record<string, string>,
+        round?: (this: void, num: number) => number,
+        energy_addition?: (this: void, recipe: runtime.LuaRecipe, cost: number) => number,
+        normalise?: (this: void, num: number) => number,
+    }): Record<string, number>;
+
+    export function get_production_scores(this: void, price_list?: Record<string,number>): Record<string, number>;
+}

package/src/lualib/resource-autoplace.d.ts

@@ -0,0 +1,35 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/resource-autoplace.lua
+declare module "resource-autoplace" {
+    /**
+     * Indicate that a patch set exists and optionally that it also needs a separate starting patch set.
+     * Call this to initialize patch sets' indexes in a more deterministic order
+     * (see resources.lua for an example) before calling resource_autoplace_settings.
+     */
+    export function initialize_patch_set(this: void, patch_set_name: string, has_starting_area_placement: boolean, autoplace_set_name: string): void
+
+    /**
+     * Creates and returns an AutoplaceSpecification that will generate spot-based ore patches.
+     * @param params.name name for the type, used as the default autoplace control name and patch set name (each of which can be overridden separately)
+     * @param params.base_density amount of stuff, on average, to be placed per tile
+     * @param params.patch_set_name name of the patch set; patches sets of the same name and seed1 will overlap; default: name
+     * @param params.autoplace_control_name name of the corresponding autoplace control; default: name
+     * @param params.random_probability probability of placement at any given tile within a patch; default: 1
+     * @param params.base_spots_per_km2 number of patches per square kilometer near the starting area
+     * @param params.has_starting_area_placement true|false|nil - yes, no, and there is no special starting area, respectively
+     * @param params.seed1 random seed to use when generating patch positions; default: 100
+     */
+    export function resource_autoplace_settings(this: void, params: {
+        name: string,
+        base_density: number,
+        patch_set_name?: string,
+        autoplace_control_name?: string,
+        random_probability?: number,
+        base_spots_per_km2?: number,
+        has_starting_area_placement?: boolean | null,
+        seed1?: number,
+    }): {
+        order: string,
+        probability_expression: string,
+        richness_expression: string,
+    }
+}

package/src/lualib/silo-script.d.ts

@@ -0,0 +1,19 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/silo-script.lua
+declare module "silo-script" {
+    export const events: { [defines.events.on_rocket_launched]: (this: void, event: runtime.on_rocket_launched) => void };
+
+    export function on_configuration_changed(this: void): void;
+
+    export function on_init(this: void): void;
+
+    export function on_load(this: void): void;
+
+    /** legacy */
+    export function get_events(this: void): { [defines.events.on_rocket_launched]: (this: void, event: runtime.on_rocket_launched) => void };
+
+    /** legacy */
+    export function add_remote_interface(this: void): void;
+
+    /** legacy */
+    export function add_commands(this: void): void;
+}

package/src/lualib/space-finish-script.d.ts

@@ -0,0 +1,10 @@
+// https://github.com/wube/factorio-data/blob/master/core/lualib/space-finish-script.lua
+declare module "space-finish-script" {
+    export const events: { [defines.events.on_space_platform_changed_state]: (this: void, event: runtime.on_space_platform_changed_state) => void }
+
+    export function on_configuration_changed(this: void): void;
+
+    export function on_init(this: void): void;
+
+    export function on_load(this: void): void;
+}

package/src/lualib/surface-render-parameter-effects.d.ts

@@ -0,0 +1,6 @@
+// github.com/wube/factorio-data/blob/master/core/lualib/surface-render-parameter-effects.lua
+declare module "surface-render-parameter-effects" {
+    export function default_clouds_effect_properties(this: void): prototype.CloudsEffectProperties;
+
+    export function default_fog_effect_properties(this: void): prototype.FogEffectProperties;
+}