factorio-types 1.0.0 → 1.2.0

package/README.md

@@ -10,7 +10,7 @@ Intended to be used with [Typescript to Lua](https://github.com/TypeScriptToLua/
 
 ## Configuration
 
-This library includes [tsconfig.base.json](./tsconfig.base.json) in the root of the package with recommended configuration. This can be used as follows
+This library includes [tsconfig.base.json](https://github.com/sguest/factorio-types/blob/master/tsconfig.base.json) in the root of the package with recommended configuration. This can be used as follows
 
 `tsconfig.json`:
 
@@ -21,30 +21,90 @@ This library includes [tsconfig.base.json](./tsconfig.base.json) in the root of
 }
 ```
 
+## Stages
+
+Factorio mods and the api go through [three distinct stages](https://lua-api.factorio.com/latest/). Types are organized into namespaces `runtime`, `prototype`, and `settings` representing the types to be used in each stage. These types, and therefore their corresponding namespaces, are a compile-time-only feature as lua does not have types, however using a type from the wrong namespace during the wrong stage is likely to result in a runtime error as you will be attempting to access something Factorio does not let you access at that time.
+
+Note there is some overlap between the types for the Settings and Prototype phases since both regularly provide prototype data to `data.extend()`, and in fact the settings-phase prototypes extend `prototype.PrototypeBase`. However, you should only be providing types from the `settings` namespace during the settings phase, and from the `prototype` namespace during the prototype phase.
+
 ## Examples
 
 A very minimal proof-of-concept showing basic toolchain setup can be found [Here](https://github.com/sguest/factorio-fire-armor-typescript)
 
-## Noise library
+A slightly more in-depth and realistic mode can be found [Here](https://github.com/sguest/basic-seablock)
 
-A note on using the `noise` library from within Factorio: Several mods (typically those that deal with terrain generation) will `require('noise')`. While this seems to work, this is not an officially documented part of the Factorio modding API and is not expressed in these types. If you want to use it, you'll want to add the following to your configuration
+## Lualib
 
-`tsconfig.json`:
+Factorio makes various lua functions available to mods via [LuaLib](https://github.com/wube/factorio-data/tree/master/core/lualib)
+
+Unlike the main parts of the factorio API, these do not exist as ambient globals but instead must be imported
+
+```typescript
+import * as noise from "noise";
+let x = noise.var_get('x');
+```
+
+Also unlike the main factorio API, these types are not documented in a machine-readable way and therefore are not generated here along with the main API types. Instead, they are hand-written as needed and as a result are incomplete and more likely to be wrong. See the [existing declarations](https://github.com/sguest/factorio-types/tree/master/src/lualib).
+
+If there are types of lualib that you need but do not exist, either open an issue asking for it, or write the type definitions and open a pull request. If you would like to continue working with these types while they do not exist in `factorio-types`, you can add the import path to `tstl.noResolvePaths` in tsconfig.json, and then `require()` the paths, which will be typed as `any`.
+
+`tsconfig.json`
 
 ```json
 {
     "tstl": {
-        "noResolvePaths": ["noise"]
+        "noResolvePaths": ["math2d"]
     }
 }
 ```
 
-Then, include a definition file at the root of your project
-
-`noise.d.ts`:
+`some-file.ts`
 
 ```typescript
-declare module 'noise' {
-    // declare any functions from the noise library that you are using
-}
+const math2d = require('math2d');
+```
+
+### Noise
+
+The `noise` module has mostly-complete type definitions. A couple notes on usage due to the limitations of typescript
+
+The `noise.var` function is named `noise.var_get` since `var` is a reserved word in typscript. It will be emitted as `noise.var` thanks to a [@customName compiler annotation](https://typescripttolua.github.io/docs/advanced/compiler-annotations/#customname).
+
+typescript
+
+```ts
+import * as noise from "noise";
+let x = noise.var_get('x');
+```
+
+output lua
+
+```lua
+local noise = require("noise")
+local x = noise.var("x")
+```
+
+Noise values have operator overloads for common arithmetic operations, however Typescript does not support operator overloading. These are implemented as [Operator map types](https://typescripttolua.github.io/docs/advanced/language-extensions#operator-map-types) in the noise library, which will emit as regular operators in lua. Available operators are named following lua conventions for overloaded operators without the preceding double-underscore:
+
+- Addition: `noise.add`
+- Subraction: `noise.sub`
+- Multiplication: `noise.mul`
+- Division: `noise.div`
+- Unary Negation: `noise.unm`
+- Exponentiation: `noise.pow`
+
+typescript
+
+```ts
+let x = noise.var_get('x');
+let y = noise.var_get('y');
+let sum = noise.add(x, y);
+```
+
+Output lua
+
+```lua
+local x = noise.var("x")
+local y = noise.var("y")
+local sum = x + y;
 ```

package/dist/prototypes.d.ts

@@ -10105,5 +10105,5 @@ interface WindSound {
     type: 'wind-sound'
 }
 
-type dataExtendType = ({ type: 'accumulator' } & AccumulatorPrototype) | ({ type: 'achievement' } & AchievementPrototype) | ({ type: 'active-defense-equipment' } & ActiveDefenseEquipmentPrototype) | ({ type: 'ambient-sound' } & AmbientSound) | ({ type: 'ammo-category' } & AmmoCategory) | ({ type: 'ammo' } & AmmoItemPrototype) | ({ type: 'ammo-turret' } & AmmoTurretPrototype) | ({ type: 'animation' } & AnimationPrototype) | ({ type: 'arithmetic-combinator' } & ArithmeticCombinatorPrototype) | ({ type: 'armor' } & ArmorPrototype) | ({ type: 'arrow' } & ArrowPrototype) | ({ type: 'artillery-flare' } & ArtilleryFlarePrototype) | ({ type: 'artillery-projectile' } & ArtilleryProjectilePrototype) | ({ type: 'artillery-turret' } & ArtilleryTurretPrototype) | ({ type: 'artillery-wagon' } & ArtilleryWagonPrototype) | ({ type: 'assembling-machine' } & AssemblingMachinePrototype) | ({ type: 'autoplace-control' } & AutoplaceControl) | ({ type: 'battery-equipment' } & BatteryEquipmentPrototype) | ({ type: 'beacon' } & BeaconPrototype) | ({ type: 'beam' } & BeamPrototype) | ({ type: 'belt-immunity-equipment' } & BeltImmunityEquipmentPrototype) | ({ type: 'blueprint-book' } & BlueprintBookPrototype) | ({ type: 'blueprint' } & BlueprintItemPrototype) | ({ type: 'boiler' } & BoilerPrototype) | ({ type: 'build-entity-achievement' } & BuildEntityAchievementPrototype) | ({ type: 'burner-generator' } & BurnerGeneratorPrototype) | ({ type: 'capsule' } & CapsulePrototype) | ({ type: 'car' } & CarPrototype) | ({ type: 'cargo-wagon' } & CargoWagonPrototype) | ({ type: 'character-corpse' } & CharacterCorpsePrototype) | ({ type: 'character' } & CharacterPrototype) | ({ type: 'cliff' } & CliffPrototype) | ({ type: 'combat-robot-count' } & CombatRobotCountAchievementPrototype) | ({ type: 'combat-robot' } & CombatRobotPrototype) | ({ type: 'constant-combinator' } & ConstantCombinatorPrototype) | ({ type: 'construct-with-robots-achievement' } & ConstructWithRobotsAchievementPrototype) | ({ type: 'construction-robot' } & ConstructionRobotPrototype) | ({ type: 'container' } & ContainerPrototype) | ({ type: 'copy-paste-tool' } & CopyPasteToolPrototype) | ({ type: 'corpse' } & CorpsePrototype) | ({ type: 'curved-rail' } & CurvedRailPrototype) | ({ type: 'custom-input' } & CustomInputPrototype) | ({ type: 'damage-type' } & DamageType) | ({ type: 'decider-combinator' } & DeciderCombinatorPrototype) | ({ type: 'deconstruct-with-robots-achievement' } & DeconstructWithRobotsAchievementPrototype) | ({ type: 'deconstructible-tile-proxy' } & DeconstructibleTileProxyPrototype) | ({ type: 'deconstruction-item' } & DeconstructionItemPrototype) | ({ type: 'optimized-decorative' } & DecorativePrototype) | ({ type: 'deliver-by-robots-achievement' } & DeliverByRobotsAchievementPrototype) | ({ type: 'dont-build-entity-achievement' } & DontBuildEntityAchievementPrototype) | ({ type: 'dont-craft-manually-achievement' } & DontCraftManuallyAchievementPrototype) | ({ type: 'dont-use-entity-in-energy-production-achievement' } & DontUseEntityInEnergyProductionAchievementPrototype) | ({ type: 'editor-controller' } & EditorControllerPrototype) | ({ type: 'electric-energy-interface' } & ElectricEnergyInterfacePrototype) | ({ type: 'electric-pole' } & ElectricPolePrototype) | ({ type: 'electric-turret' } & ElectricTurretPrototype) | ({ type: 'unit-spawner' } & EnemySpawnerPrototype) | ({ type: 'energy-shield-equipment' } & EnergyShieldEquipmentPrototype) | ({ type: 'entity-ghost' } & EntityGhostPrototype) | ({ type: 'particle' } & EntityParticlePrototype) | ({ type: 'equipment-category' } & EquipmentCategory) | ({ type: 'equipment-grid' } & EquipmentGridPrototype) | ({ type: 'explosion' } & ExplosionPrototype) | ({ type: 'finish-the-game-achievement' } & FinishTheGameAchievementPrototype) | ({ type: 'fire' } & FireFlamePrototype) | ({ type: 'fish' } & FishPrototype) | ({ type: 'flame-thrower-explosion' } & FlameThrowerExplosionPrototype) | ({ type: 'fluid' } & FluidPrototype) | ({ type: 'stream' } & FluidStreamPrototype) | ({ type: 'fluid-turret' } & FluidTurretPrototype) | ({ type: 'fluid-wagon' } & FluidWagonPrototype) | ({ type: 'flying-text' } & FlyingTextPrototype) | ({ type: 'font' } & FontPrototype) | ({ type: 'fuel-category' } & FuelCategory) | ({ type: 'furnace' } & FurnacePrototype) | ({ type: 'gate' } & GatePrototype) | ({ type: 'generator-equipment' } & GeneratorEquipmentPrototype) | ({ type: 'generator' } & GeneratorPrototype) | ({ type: 'god-controller' } & GodControllerPrototype) | ({ type: 'group-attack-achievement' } & GroupAttackAchievementPrototype) | ({ type: 'gui-style' } & GuiStyle) | ({ type: 'gun' } & GunPrototype) | ({ type: 'heat-interface' } & HeatInterfacePrototype) | ({ type: 'heat-pipe' } & HeatPipePrototype) | ({ type: 'highlight-box' } & HighlightBoxEntityPrototype) | ({ type: 'infinity-container' } & InfinityContainerPrototype) | ({ type: 'infinity-pipe' } & InfinityPipePrototype) | ({ type: 'inserter' } & InserterPrototype) | ({ type: 'item-entity' } & ItemEntityPrototype) | ({ type: 'item-group' } & ItemGroup) | ({ type: 'item' } & ItemPrototype) | ({ type: 'item-request-proxy' } & ItemRequestProxyPrototype) | ({ type: 'item-subgroup' } & ItemSubGroup) | ({ type: 'item-with-entity-data' } & ItemWithEntityDataPrototype) | ({ type: 'item-with-inventory' } & ItemWithInventoryPrototype) | ({ type: 'item-with-label' } & ItemWithLabelPrototype) | ({ type: 'item-with-tags' } & ItemWithTagsPrototype) | ({ type: 'kill-achievement' } & KillAchievementPrototype) | ({ type: 'lab' } & LabPrototype) | ({ type: 'lamp' } & LampPrototype) | ({ type: 'land-mine' } & LandMinePrototype) | ({ type: 'leaf-particle' } & LeafParticlePrototype) | ({ type: 'linked-belt' } & LinkedBeltPrototype) | ({ type: 'linked-container' } & LinkedContainerPrototype) | ({ type: 'loader-1x1' } & Loader1x1Prototype) | ({ type: 'loader' } & Loader1x2Prototype) | ({ type: 'locomotive' } & LocomotivePrototype) | ({ type: 'logistic-container' } & LogisticContainerPrototype) | ({ type: 'logistic-robot' } & LogisticRobotPrototype) | ({ type: 'map-gen-presets' } & MapGenPresets) | ({ type: 'map-settings' } & MapSettings) | ({ type: 'market' } & MarketPrototype) | ({ type: 'mining-drill' } & MiningDrillPrototype) | ({ type: 'mining-tool' } & MiningToolPrototype) | ({ type: 'module-category' } & ModuleCategory) | ({ type: 'module' } & ModulePrototype) | ({ type: 'mouse-cursor' } & MouseCursor) | ({ type: 'movement-bonus-equipment' } & MovementBonusEquipmentPrototype) | ({ type: 'noise-expression' } & NamedNoiseExpression) | ({ type: 'night-vision-equipment' } & NightVisionEquipmentPrototype) | ({ type: 'noise-layer' } & NoiseLayer) | ({ type: 'offshore-pump' } & OffshorePumpPrototype) | ({ type: 'optimized-particle' } & ParticlePrototype) | ({ type: 'particle-source' } & ParticleSourcePrototype) | ({ type: 'pipe' } & PipePrototype) | ({ type: 'pipe-to-ground' } & PipeToGroundPrototype) | ({ type: 'player-damaged-achievement' } & PlayerDamagedAchievementPrototype) | ({ type: 'player-port' } & PlayerPortPrototype) | ({ type: 'power-switch' } & PowerSwitchPrototype) | ({ type: 'produce-achievement' } & ProduceAchievementPrototype) | ({ type: 'produce-per-hour-achievement' } & ProducePerHourAchievementPrototype) | ({ type: 'programmable-speaker' } & ProgrammableSpeakerPrototype) | ({ type: 'projectile' } & ProjectilePrototype) | ({ type: 'pump' } & PumpPrototype) | ({ type: 'radar' } & RadarPrototype) | ({ type: 'rail-chain-signal' } & RailChainSignalPrototype) | ({ type: 'rail-planner' } & RailPlannerPrototype) | ({ type: 'rail-remnants' } & RailRemnantsPrototype) | ({ type: 'rail-signal' } & RailSignalPrototype) | ({ type: 'reactor' } & ReactorPrototype) | ({ type: 'recipe-category' } & RecipeCategory) | ({ type: 'recipe' } & RecipePrototype) | ({ type: 'repair-tool' } & RepairToolPrototype) | ({ type: 'research-achievement' } & ResearchAchievementPrototype) | ({ type: 'resource-category' } & ResourceCategory) | ({ type: 'resource' } & ResourceEntityPrototype) | ({ type: 'roboport-equipment' } & RoboportEquipmentPrototype) | ({ type: 'roboport' } & RoboportPrototype) | ({ type: 'rocket-silo' } & RocketSiloPrototype) | ({ type: 'rocket-silo-rocket' } & RocketSiloRocketPrototype) | ({ type: 'rocket-silo-rocket-shadow' } & RocketSiloRocketShadowPrototype) | ({ type: 'selection-tool' } & SelectionToolPrototype) | ({ type: 'shortcut' } & ShortcutPrototype) | ({ type: 'simple-entity' } & SimpleEntityPrototype) | ({ type: 'simple-entity-with-force' } & SimpleEntityWithForcePrototype) | ({ type: 'simple-entity-with-owner' } & SimpleEntityWithOwnerPrototype) | ({ type: 'smoke' } & SimpleSmokePrototype) | ({ type: 'smoke-with-trigger' } & SmokeWithTriggerPrototype) | ({ type: 'solar-panel-equipment' } & SolarPanelEquipmentPrototype) | ({ type: 'solar-panel' } & SolarPanelPrototype) | ({ type: 'sound' } & SoundPrototype) | ({ type: 'spectator-controller' } & SpectatorControllerPrototype) | ({ type: 'speech-bubble' } & SpeechBubblePrototype) | ({ type: 'spider-leg' } & SpiderLegPrototype) | ({ type: 'spider-vehicle' } & SpiderVehiclePrototype) | ({ type: 'spidertron-remote' } & SpidertronRemotePrototype) | ({ type: 'splitter' } & SplitterPrototype) | ({ type: 'sprite' } & SpritePrototype) | ({ type: 'sticker' } & StickerPrototype) | ({ type: 'storage-tank' } & StorageTankPrototype) | ({ type: 'straight-rail' } & StraightRailPrototype) | ({ type: 'technology' } & TechnologyPrototype) | ({ type: 'tile-effect' } & TileEffectDefinition) | ({ type: 'tile-ghost' } & TileGhostPrototype) | ({ type: 'tile' } & TilePrototype) | ({ type: 'tips-and-tricks-item' } & TipsAndTricksItem) | ({ type: 'tips-and-tricks-item-category' } & TipsAndTricksItemCategory) | ({ type: 'tool' } & ToolPrototype) | ({ type: 'train-path-achievement' } & TrainPathAchievementPrototype) | ({ type: 'train-stop' } & TrainStopPrototype) | ({ type: 'transport-belt' } & TransportBeltPrototype) | ({ type: 'tree' } & TreePrototype) | ({ type: 'trigger-target-type' } & TriggerTargetType) | ({ type: 'trivial-smoke' } & TrivialSmokePrototype) | ({ type: 'turret' } & TurretPrototype) | ({ type: 'tutorial' } & TutorialDefinition) | ({ type: 'underground-belt' } & UndergroundBeltPrototype) | ({ type: 'unit' } & UnitPrototype) | ({ type: 'upgrade-item' } & UpgradeItemPrototype) | ({ type: 'utility-constants' } & UtilityConstants) | ({ type: 'utility-sounds' } & UtilitySounds) | ({ type: 'utility-sprites' } & UtilitySprites) | ({ type: 'virtual-signal' } & VirtualSignalPrototype) | ({ type: 'wall' } & WallPrototype) | ({ type: 'wind-sound' } & WindSound) | PrototypeBase
+type dataExtendType = ({ type: 'accumulator' } & AccumulatorPrototype) | ({ type: 'achievement' } & AchievementPrototype) | ({ type: 'active-defense-equipment' } & ActiveDefenseEquipmentPrototype) | ({ type: 'ambient-sound' } & AmbientSound) | ({ type: 'ammo-category' } & AmmoCategory) | ({ type: 'ammo' } & AmmoItemPrototype) | ({ type: 'ammo-turret' } & AmmoTurretPrototype) | ({ type: 'animation' } & AnimationPrototype) | ({ type: 'arithmetic-combinator' } & ArithmeticCombinatorPrototype) | ({ type: 'armor' } & ArmorPrototype) | ({ type: 'arrow' } & ArrowPrototype) | ({ type: 'artillery-flare' } & ArtilleryFlarePrototype) | ({ type: 'artillery-projectile' } & ArtilleryProjectilePrototype) | ({ type: 'artillery-turret' } & ArtilleryTurretPrototype) | ({ type: 'artillery-wagon' } & ArtilleryWagonPrototype) | ({ type: 'assembling-machine' } & AssemblingMachinePrototype) | ({ type: 'autoplace-control' } & AutoplaceControl) | ({ type: 'battery-equipment' } & BatteryEquipmentPrototype) | ({ type: 'beacon' } & BeaconPrototype) | ({ type: 'beam' } & BeamPrototype) | ({ type: 'belt-immunity-equipment' } & BeltImmunityEquipmentPrototype) | ({ type: 'blueprint-book' } & BlueprintBookPrototype) | ({ type: 'blueprint' } & BlueprintItemPrototype) | ({ type: 'boiler' } & BoilerPrototype) | ({ type: 'build-entity-achievement' } & BuildEntityAchievementPrototype) | ({ type: 'burner-generator' } & BurnerGeneratorPrototype) | ({ type: 'capsule' } & CapsulePrototype) | ({ type: 'car' } & CarPrototype) | ({ type: 'cargo-wagon' } & CargoWagonPrototype) | ({ type: 'character-corpse' } & CharacterCorpsePrototype) | ({ type: 'character' } & CharacterPrototype) | ({ type: 'cliff' } & CliffPrototype) | ({ type: 'combat-robot-count' } & CombatRobotCountAchievementPrototype) | ({ type: 'combat-robot' } & CombatRobotPrototype) | ({ type: 'constant-combinator' } & ConstantCombinatorPrototype) | ({ type: 'construct-with-robots-achievement' } & ConstructWithRobotsAchievementPrototype) | ({ type: 'construction-robot' } & ConstructionRobotPrototype) | ({ type: 'container' } & ContainerPrototype) | ({ type: 'copy-paste-tool' } & CopyPasteToolPrototype) | ({ type: 'corpse' } & CorpsePrototype) | ({ type: 'curved-rail' } & CurvedRailPrototype) | ({ type: 'custom-input' } & CustomInputPrototype) | ({ type: 'damage-type' } & DamageType) | ({ type: 'decider-combinator' } & DeciderCombinatorPrototype) | ({ type: 'deconstruct-with-robots-achievement' } & DeconstructWithRobotsAchievementPrototype) | ({ type: 'deconstructible-tile-proxy' } & DeconstructibleTileProxyPrototype) | ({ type: 'deconstruction-item' } & DeconstructionItemPrototype) | ({ type: 'optimized-decorative' } & DecorativePrototype) | ({ type: 'deliver-by-robots-achievement' } & DeliverByRobotsAchievementPrototype) | ({ type: 'dont-build-entity-achievement' } & DontBuildEntityAchievementPrototype) | ({ type: 'dont-craft-manually-achievement' } & DontCraftManuallyAchievementPrototype) | ({ type: 'dont-use-entity-in-energy-production-achievement' } & DontUseEntityInEnergyProductionAchievementPrototype) | ({ type: 'editor-controller' } & EditorControllerPrototype) | ({ type: 'electric-energy-interface' } & ElectricEnergyInterfacePrototype) | ({ type: 'electric-pole' } & ElectricPolePrototype) | ({ type: 'electric-turret' } & ElectricTurretPrototype) | ({ type: 'unit-spawner' } & EnemySpawnerPrototype) | ({ type: 'energy-shield-equipment' } & EnergyShieldEquipmentPrototype) | ({ type: 'entity-ghost' } & EntityGhostPrototype) | ({ type: 'particle' } & EntityParticlePrototype) | ({ type: 'equipment-category' } & EquipmentCategory) | ({ type: 'equipment-grid' } & EquipmentGridPrototype) | ({ type: 'explosion' } & ExplosionPrototype) | ({ type: 'finish-the-game-achievement' } & FinishTheGameAchievementPrototype) | ({ type: 'fire' } & FireFlamePrototype) | ({ type: 'fish' } & FishPrototype) | ({ type: 'flame-thrower-explosion' } & FlameThrowerExplosionPrototype) | ({ type: 'fluid' } & FluidPrototype) | ({ type: 'stream' } & FluidStreamPrototype) | ({ type: 'fluid-turret' } & FluidTurretPrototype) | ({ type: 'fluid-wagon' } & FluidWagonPrototype) | ({ type: 'flying-text' } & FlyingTextPrototype) | ({ type: 'font' } & FontPrototype) | ({ type: 'fuel-category' } & FuelCategory) | ({ type: 'furnace' } & FurnacePrototype) | ({ type: 'gate' } & GatePrototype) | ({ type: 'generator-equipment' } & GeneratorEquipmentPrototype) | ({ type: 'generator' } & GeneratorPrototype) | ({ type: 'god-controller' } & GodControllerPrototype) | ({ type: 'group-attack-achievement' } & GroupAttackAchievementPrototype) | ({ type: 'gui-style' } & GuiStyle) | ({ type: 'gun' } & GunPrototype) | ({ type: 'heat-interface' } & HeatInterfacePrototype) | ({ type: 'heat-pipe' } & HeatPipePrototype) | ({ type: 'highlight-box' } & HighlightBoxEntityPrototype) | ({ type: 'infinity-container' } & InfinityContainerPrototype) | ({ type: 'infinity-pipe' } & InfinityPipePrototype) | ({ type: 'inserter' } & InserterPrototype) | ({ type: 'item-entity' } & ItemEntityPrototype) | ({ type: 'item-group' } & ItemGroup) | ({ type: 'item' } & ItemPrototype) | ({ type: 'item-request-proxy' } & ItemRequestProxyPrototype) | ({ type: 'item-subgroup' } & ItemSubGroup) | ({ type: 'item-with-entity-data' } & ItemWithEntityDataPrototype) | ({ type: 'item-with-inventory' } & ItemWithInventoryPrototype) | ({ type: 'item-with-label' } & ItemWithLabelPrototype) | ({ type: 'item-with-tags' } & ItemWithTagsPrototype) | ({ type: 'kill-achievement' } & KillAchievementPrototype) | ({ type: 'lab' } & LabPrototype) | ({ type: 'lamp' } & LampPrototype) | ({ type: 'land-mine' } & LandMinePrototype) | ({ type: 'leaf-particle' } & LeafParticlePrototype) | ({ type: 'linked-belt' } & LinkedBeltPrototype) | ({ type: 'linked-container' } & LinkedContainerPrototype) | ({ type: 'loader-1x1' } & Loader1x1Prototype) | ({ type: 'loader' } & Loader1x2Prototype) | ({ type: 'locomotive' } & LocomotivePrototype) | ({ type: 'logistic-container' } & LogisticContainerPrototype) | ({ type: 'logistic-robot' } & LogisticRobotPrototype) | ({ type: 'map-gen-presets' } & MapGenPresets) | ({ type: 'map-settings' } & MapSettings) | ({ type: 'market' } & MarketPrototype) | ({ type: 'mining-drill' } & MiningDrillPrototype) | ({ type: 'mining-tool' } & MiningToolPrototype) | ({ type: 'module-category' } & ModuleCategory) | ({ type: 'module' } & ModulePrototype) | ({ type: 'mouse-cursor' } & MouseCursor) | ({ type: 'movement-bonus-equipment' } & MovementBonusEquipmentPrototype) | ({ type: 'noise-expression' } & NamedNoiseExpression) | ({ type: 'night-vision-equipment' } & NightVisionEquipmentPrototype) | ({ type: 'noise-layer' } & NoiseLayer) | ({ type: 'offshore-pump' } & OffshorePumpPrototype) | ({ type: 'optimized-particle' } & ParticlePrototype) | ({ type: 'particle-source' } & ParticleSourcePrototype) | ({ type: 'pipe' } & PipePrototype) | ({ type: 'pipe-to-ground' } & PipeToGroundPrototype) | ({ type: 'player-damaged-achievement' } & PlayerDamagedAchievementPrototype) | ({ type: 'player-port' } & PlayerPortPrototype) | ({ type: 'power-switch' } & PowerSwitchPrototype) | ({ type: 'produce-achievement' } & ProduceAchievementPrototype) | ({ type: 'produce-per-hour-achievement' } & ProducePerHourAchievementPrototype) | ({ type: 'programmable-speaker' } & ProgrammableSpeakerPrototype) | ({ type: 'projectile' } & ProjectilePrototype) | ({ type: 'pump' } & PumpPrototype) | ({ type: 'radar' } & RadarPrototype) | ({ type: 'rail-chain-signal' } & RailChainSignalPrototype) | ({ type: 'rail-planner' } & RailPlannerPrototype) | ({ type: 'rail-remnants' } & RailRemnantsPrototype) | ({ type: 'rail-signal' } & RailSignalPrototype) | ({ type: 'reactor' } & ReactorPrototype) | ({ type: 'recipe-category' } & RecipeCategory) | ({ type: 'recipe' } & RecipePrototype) | ({ type: 'repair-tool' } & RepairToolPrototype) | ({ type: 'research-achievement' } & ResearchAchievementPrototype) | ({ type: 'resource-category' } & ResourceCategory) | ({ type: 'resource' } & ResourceEntityPrototype) | ({ type: 'roboport-equipment' } & RoboportEquipmentPrototype) | ({ type: 'roboport' } & RoboportPrototype) | ({ type: 'rocket-silo' } & RocketSiloPrototype) | ({ type: 'rocket-silo-rocket' } & RocketSiloRocketPrototype) | ({ type: 'rocket-silo-rocket-shadow' } & RocketSiloRocketShadowPrototype) | ({ type: 'selection-tool' } & SelectionToolPrototype) | ({ type: 'shortcut' } & ShortcutPrototype) | ({ type: 'simple-entity' } & SimpleEntityPrototype) | ({ type: 'simple-entity-with-force' } & SimpleEntityWithForcePrototype) | ({ type: 'simple-entity-with-owner' } & SimpleEntityWithOwnerPrototype) | ({ type: 'smoke' } & SimpleSmokePrototype) | ({ type: 'smoke-with-trigger' } & SmokeWithTriggerPrototype) | ({ type: 'solar-panel-equipment' } & SolarPanelEquipmentPrototype) | ({ type: 'solar-panel' } & SolarPanelPrototype) | ({ type: 'sound' } & SoundPrototype) | ({ type: 'spectator-controller' } & SpectatorControllerPrototype) | ({ type: 'speech-bubble' } & SpeechBubblePrototype) | ({ type: 'spider-leg' } & SpiderLegPrototype) | ({ type: 'spider-vehicle' } & SpiderVehiclePrototype) | ({ type: 'spidertron-remote' } & SpidertronRemotePrototype) | ({ type: 'splitter' } & SplitterPrototype) | ({ type: 'sprite' } & SpritePrototype) | ({ type: 'sticker' } & StickerPrototype) | ({ type: 'storage-tank' } & StorageTankPrototype) | ({ type: 'straight-rail' } & StraightRailPrototype) | ({ type: 'technology' } & TechnologyPrototype) | ({ type: 'tile-effect' } & TileEffectDefinition) | ({ type: 'tile-ghost' } & TileGhostPrototype) | ({ type: 'tile' } & TilePrototype) | ({ type: 'tips-and-tricks-item' } & TipsAndTricksItem) | ({ type: 'tips-and-tricks-item-category' } & TipsAndTricksItemCategory) | ({ type: 'tool' } & ToolPrototype) | ({ type: 'train-path-achievement' } & TrainPathAchievementPrototype) | ({ type: 'train-stop' } & TrainStopPrototype) | ({ type: 'transport-belt' } & TransportBeltPrototype) | ({ type: 'tree' } & TreePrototype) | ({ type: 'trigger-target-type' } & TriggerTargetType) | ({ type: 'trivial-smoke' } & TrivialSmokePrototype) | ({ type: 'turret' } & TurretPrototype) | ({ type: 'tutorial' } & TutorialDefinition) | ({ type: 'underground-belt' } & UndergroundBeltPrototype) | ({ type: 'unit' } & UnitPrototype) | ({ type: 'upgrade-item' } & UpgradeItemPrototype) | ({ type: 'utility-constants' } & UtilityConstants) | ({ type: 'utility-sounds' } & UtilitySounds) | ({ type: 'utility-sprites' } & UtilitySprites) | ({ type: 'virtual-signal' } & VirtualSignalPrototype) | ({ type: 'wall' } & WallPrototype) | ({ type: 'wind-sound' } & WindSound) | settings.dataExtendType | PrototypeBase
 }

package/index.d.ts

@@ -3,13 +3,15 @@
 // Generated from JSON source https://lua-api.factorio.com/latest/runtime-api.json and https://lua-api.factorio.com/latest/prototype-api.json
 // Definition source https://github.com/sguest/factorio-types
 
-/// <reference path="./dist/core.d.ts" />
+/// <reference path="./src/core.d.ts" />
+/// <reference path="./src/settings.d.ts" />
+/// <reference path="./src/serpent.d.ts" />
+/// <reference path="./src/lualib/noise.d.ts" />
 /// <reference path="./dist/global.d.ts" />
 /// <reference path="./dist/classes.d.ts" />
 /// <reference path="./dist/concepts.d.ts" />
 /// <reference path="./dist/defines.d.ts" />
 /// <reference path="./dist/events.d.ts" />
-/// <reference path="./dist/serpent.d.ts" />
 /// <reference path="./dist/prototypes.d.ts" />
 /// <reference path="./dist/types.d.ts" />
 /// <reference types="lua-types/jit" />

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "factorio-types",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "Typescript declarations for the Factorio mod API",
   "main": "index.d.ts",
   "repository": "https://github.com/sguest/factorio-types.git",
@@ -8,13 +8,11 @@
   "license": "MIT",
   "scripts": {
     "validate": "tsc -p tsconfig.json",
-    "copy-source": "cpy src/*.d.ts dist",
-    "build": "ts-node json_parser/parser.ts && yarn run copy-source",
-    "rebuild": "ts-node json_parser/parser.ts -clean && yarn run copy-source"
+    "build": "ts-node json_parser/parser.ts",
+    "rebuild": "ts-node json_parser/parser.ts -clean"
   },
   "devDependencies": {
     "@types/node": "^15.12.2",
-    "cpy-cli": "^3.1.1",
     "node-html-parser": "^1.1.16",
     "ts-node": "^10.0.0",
     "typescript": "^5.4.2",
@@ -23,6 +21,7 @@
   "files": [
     "index.d.ts",
     "tsconfig.base.json",
+    "src/**/*.d.ts",
     "dist/**/*.d.ts"
   ],
   "factorioVersion": "1.1.107",
@@ -32,4 +31,4 @@
   "peerDependencies": {
     "typescript-to-lua": "^1.25.1"
   }
-}
+}

package/{dist → src}/core.d.ts

@@ -5,6 +5,7 @@
 
 declare namespace table {
     function deepcopy<T>(this: void, value: T): T;
+    function compare(this: void, table1: object | [], table2: object | []): boolean;
 }
 
 declare const data: {
@@ -12,6 +13,11 @@ declare const data: {
     extend(values: prototype.dataExtendType[]): void,
 };
 
+/**
+ * Mapping of currently loaded mods to their version. Only exists at the data stage.
+ */
+declare const mods: { [key: string] : string}
+
 declare const global: { [key: string]: any };
 
 declare function log(str: runtime.LocalisedString): void;

package/src/lualib/noise.d.ts

@@ -0,0 +1,194 @@
+/** @noSelfInFile */
+/** @noResolution */
+declare module "noise" {
+    interface tileProps {
+        x: prototype.NoiseVariable,
+        y: prototype.NoiseVariable,
+        distance: prototype.NoiseExpression,
+        tier: prototype.NoiseExpression,
+    }
+
+    interface mapProps {
+        seed: prototype.NoiseVariable
+        width: prototype.NoiseVariable
+        height: prototype.NoiseVariable
+        starting_area_radius: prototype.NoiseVariable
+        segmentation_multiplier: prototype.NoiseVariable
+        terrace_elevation_offset: prototype.NoiseVariable
+        terrace_elevation_interval: prototype.NoiseVariable
+        /**
+         * Add this to your (presumably centered around 0) elevation to correct water coverage
+         */
+        wlc_elevation_offset: prototype.NoiseVariable
+        /**
+         * minimum elevation to be applied to areas outside the starting lake *after* the offset
+         */
+        wlc_elevation_minimum: prototype.NoiseVariable
+        water_level: prototype.NoiseVariable
+        finite_water_level: prototype.NoiseVariable
+    }
+
+    type NoiseOperand = prototype.NoiseExpression | number;
+
+    /**
+     * Emitted as overloaded operator - `noise.add(x, y)` becomes `x + y`
+     */
+    const add: LuaAddition<NoiseOperand, NoiseOperand, prototype.NoiseFunctionAdd>;
+    /**
+     * Emitted as overloaded operator - `noise.sub(x, y)` becomes `x - y`
+     */
+    const sub: LuaSubtraction<NoiseOperand, NoiseOperand, prototype.NoiseFunctionSubtract>;
+    /**
+     * Emitted as overloaded operator - `noise.mul(x, y)` becomes `x * y`
+     */
+    const mul: LuaMultiplication<NoiseOperand, NoiseOperand, prototype.NoiseFunctionMultiply>;
+    /**
+     * Emitted as overloaded operator - `noise.div(x, y)` becomes `x / y`
+     */
+    const div: LuaDivision<NoiseOperand, NoiseOperand, prototype.NoiseFunctionDivide>;
+    /**
+     * Emitted as overloaded operator - `noise.unm(x)` becomes `-x`
+     */
+    const unm: LuaNegation<NoiseOperand, prototype.NoiseFunctionSubtract>;
+    /**
+     * Emitted as overloaded operator - `noise.pow(x, y)` becomes `x ^ y`
+     */
+    const pow: LuaPower<NoiseOperand, NoiseOperand, prototype.NoiseFunctionExponentiate>;
+
+    type NoiseNumberLike = prototype.NoiseNumber | number;
+
+    /**
+     * @customName var
+     * @noSelf
+     * This is named "var" in lua and will compile as such thanks to annotations. However, var is a reserved word in typescript
+     */
+    function var_get(name: prototype.NoiseVariable['variable_name']): prototype.NoiseVariable
+
+    /**
+     * 
+     * @param level number of levels up *from the caller* we want to take our location from, defaulting to 1.
+     */
+    function csloc(level: number): { filename: string, line_number: number }
+
+    /**
+     * 'to noise expression'
+     * turns simple values into noise expressions and adds a metatable so you can do arithmetic operations on noise expresssions
+     */
+    function to_noise_expression(v: any, sloc: string): prototype.NoiseExpression
+
+    /**
+     * Call this to...define a noise function using lua syntax.
+     * Your lua function will be passed x, y, tile properties, and map properties.
+     * The arguments are 'noise expression' objects to which arithmetic operations may be applied.
+     */
+    function define_noise_function(callback: (x: prototype.NoiseVariable, y: prototype.NoiseVariable, tileProps: tileProps, mapProps: mapProps) => void): prototype.NoiseExpression
+
+    function clamp(v: NoiseNumberLike, min: NoiseNumberLike, max: NoiseNumberLike, sloc: string): prototype.NoiseFunctionClamp
+
+    function compile_time_log(...args: NoiseNumberLike[]): prototype.NoiseFunctionCompileTimeLog
+
+    /**
+     * Useful for preventing tail-calls
+     * because we want to not lose part of the stacktrace
+     * in order that csloc() gives the desired result
+     */
+    function ident(x: prototype.NoiseExpression): prototype.NoiseExpression
+
+    function min(...args: NoiseNumberLike[]): prototype.NoiseNumber
+
+    function max(...args: NoiseNumberLike[]): prototype.NoiseNumber
+
+    function ridge(v: NoiseNumberLike, min: NoiseNumberLike, max: NoiseNumberLike, sloc: string): prototype.NoiseFunctionRidge
+
+    function terrace(v: NoiseNumberLike, offset: prototype.ConstantNoiseNumber, width: prototype.ConstantNoiseNumber, strength: NoiseNumberLike): prototype.NoiseFunctionTerrace
+
+    /**
+     * Terrace at elevations at which the game will place cliffs
+     * if change in elevation is steep enough.
+     * strength = 0: no-op; strength = 1: vertical slopes between terrace elevations
+     */
+    function terrace_for_cliffs(
+        v: NoiseNumberLike,
+        strength: NoiseNumberLike,
+        map: {
+            terrace_elevation_offset: prototype.NoiseVariable,
+            terrace_elevation_interval: prototype.NoiseVariable
+        }): prototype.NoiseExpression
+
+    function make_array(list: any[]): prototype.NoiseExpression
+
+    function make_point_list(list: any[]): prototype.NoiseArrayConstruction
+
+    function distance_from(
+        maximum_distance: prototype.ConstantNoiseNumber | undefined,
+        points: prototype.NoiseArrayConstruction,
+        x: NoiseNumberLike,
+        y: NoiseNumberLike): prototype.NoiseFunctionDistanceFromNearestPoint
+
+    function get_control_setting(name: string): prototype.NoiseExpression
+
+    function absolute_value(val: NoiseNumberLike): prototype.NoiseFunctionAbsoluteValue
+
+    function autoplace_probabililty(autoplace: prototype.NoiseLiteralObject): prototype.NoiseFunctionAutoplaceProbability
+
+    function autoplace_richness(autoplace: prototype.NoiseLiteralObject): prototype.NoiseFunctionAutoplaceRichness
+
+    function fraction(num: NoiseNumberLike, den: NoiseNumberLike): prototype.NoiseNumber
+
+    function function_application(name: string, arguments: prototype.NoiseExpression[], sloc: string): prototype.NoiseFunctionApplication
+
+    function if_else_chain(...arugments: prototype.NoiseExpression[]): prototype.NoiseIfElseChain
+
+    function literal_expression(x: prototype.NoiseExpression): prototype.NoiseLiteralExpression
+
+    function literal_object(val: prototype.AutoplaceSpecification): prototype.NoiseLiteralObject
+
+    function literal_string(str: string, sloc: string): prototype.NoiseLiteralString
+
+    function noise_layer_name_to_id(name: prototype.NoiseLiteralString): prototype.NoiseFunctionNoiseLayerNameToID
+
+    function random(amplitude: prototype.ConstantNoiseNumber): prototype.NoiseFunctionRandomPenalty
+
+    function random_between(lower: NoiseNumberLike, upper: NoiseNumberLike): prototype.NoiseFunctionRandomPenalty
+
+    function random_penalty(source: NoiseNumberLike, random_penalty_amplitude: prototype.ConstantNoiseNumber, opts: prototype.RandomPenaltyArguments): prototype.NoiseFunctionRandomPenalty
+
+    function delimit_procedure(expression: prototype.NoiseExpression): prototype.NoiseProcedureDelimiter
+
+    function log2(power: NoiseNumberLike): prototype.NoiseFunctionLog2
+
+    function fmod(lhs: NoiseNumberLike, rhs: NoiseNumberLike): prototype.NoiseFunctionModulo
+
+    function floor(value: NoiseNumberLike): prototype.NoiseFunctionFloor
+
+    function ceil(value: NoiseNumberLike): prototype.NoiseFunctionCeil
+
+    function band(...arguments: NoiseNumberLike[]): prototype.NoiseFunctionBitwiseAnd
+
+    function bor(...arguments: NoiseNumberLike[]): prototype.NoiseFunctionBitwiseOr
+
+    function bxor(...arguments: NoiseNumberLike[]): prototype.NoiseFunctionBitwiseXor
+
+    function bnot(...arguments: NoiseNumberLike[]): prototype.NoiseFunctionBitwiseNot
+
+    function sin(value: NoiseNumberLike): prototype.NoiseFunctionSin
+
+    function cos(value: NoiseNumberLike): prototype.NoiseFunctionCos
+
+    function atan2(value: NoiseNumberLike): prototype.NoiseFunctionAtan2
+
+    /**
+     * This results in a number that is '0' for 'false' or '1' for 'true'.
+     */
+    function less_than(lhs: NoiseNumberLike, rhs: NoiseNumberLike): prototype.NoiseFunctionLessThan
+
+    /**
+     * This results in a number that is '0' for 'false' or '1' for 'true'.
+     */
+    function less_or_equal(lhs: NoiseNumberLike, rhs: NoiseNumberLike): prototype.NoiseFunctionLessOrEqual
+
+    /**
+     * This results in a number that is '0' for 'false' or '1' for 'true'.
+     */
+    function equals(lhs: NoiseNumberLike, rhs: NoiseNumberLike): prototype.NoiseFunctionEquals
+}

package/src/settings.d.ts

@@ -0,0 +1,133 @@
+declare namespace settings {
+    type settingType =
+        /** This kind of seting is available in the prototype stage, and cannot be changed runtime. They have to be set to the same values for all players on a server.*/
+        'startup' |
+        /** This kind of setting is global to an entire save game and can be changed runtime. On servers, only admins can change these settings. */
+        'runtime-global' |
+        /** This kind of setting is only available runtime in the control.lua stage and each player has their own intance of this setting. When a player joins a server their local setting of "keep mod settings per save" determines if the local settings they have set are synced to the loaded save or if the save's settings are used. */
+        'runtime-per-user'
+
+    /**
+     * The base type for all settings. Defines common values
+     */
+    interface SettingBase extends prototype.PrototypeBase {
+        /**
+         * The hidden property can be used to hide mod settings from GUIs, so that they cannot be seen or changed by players.
+         * However, other mods can still access hidden settings.
+         */
+        hidden?: boolean
+        /**
+         * Determines the stage of game at which the setting is available and which tab it is shown in the mod settings menu.
+         */
+        setting_type: settingType
+    }
+
+    /**
+     * A true/false checkbox
+     */
+    interface BoolSetting extends SettingBase {
+        /**
+         * Defines the default value of the setting, in this case whether the checkbox is checked or not.
+         */
+        default_value: boolean
+        /**
+         * Only loadoed if `hidden = true`. This forces the setting to be of this value. This can be useful for mod compatibility.
+         */
+        forced_value?: boolean
+    }
+
+    /**
+     * A signed 64 bit integer textfield (or selection dropdown)
+     */
+    interface IntSetting extends SettingBase {
+        /**
+         * Defines the value of the setting.
+         */
+        default_value: number
+
+        /**
+         * Defines the lowest possible number.
+         */
+        minimum_value?: number
+
+        /**
+         * Defines the highest possible number.
+         */
+        maximum_value?: number
+
+        /**
+         * Makes it possible to force the player to choose between the defined numbers, creates a dropdown instead of a textfield.
+         * If only one allowed value is given, the setting is forced to be of that value.
+         */
+        allowed_values?: number[]
+    }
+
+    /**
+     * A double precision floating point textfield (or selection dropdown)
+     */
+    interface DoubleSetting extends SettingBase {
+        /**
+         * Defines the value of the setting.
+         */
+        default_value: number
+
+        /**
+         * Defines the lowest possible number.
+         */
+        minimum_value?: number
+
+        /**
+         * Defines the highest possible number.
+         */
+        maximum_value?: number
+
+        /**
+         * Makes it possible to force the player to choose between the defined numbers, creates a dropdown instead of a textfield.
+         * If only one allowed value is given, the setting is forced to be of that value.
+         */
+        allowed_values?: number[]
+    }
+
+    /**
+     * A string textfield (or selection dropdown)
+     */
+    interface StringSetting extends SettingBase {
+        /**
+         * Defines the default value of the setting.
+         */
+        default_value: string
+
+        /**
+         * Defines whether it's possible for the user to set the textfield to empty and apply the setting.
+         */
+        allow_blank?: boolean
+
+        /**
+         * Whether values that are input by the user should have whitespace removed from both ends of the string.
+         */
+        auto_trim?: boolean
+
+        /**
+         * Makes it possible to force the player to choose between the defined strings, creates a dropdown instead of a textfield. The strings in the dropdown can be localized (translated) and can have a tooltip
+         * If only one allowed value is given, the setting is forced to be of that value.
+         */
+        allowed_values?: string[]
+    }
+
+    /**
+     * A color picker (sliders), with whole number textfields. Includes alpha.
+     */
+    interface ColorSetting extends SettingBase {
+        /**
+         * Defines the default value of the setting.
+         */
+        default_value: prototype.Color
+    }
+
+    type dataExtendType =
+        ({ type: 'bool-setting' } & BoolSetting) |
+        ({ type: 'int-setting' } & IntSetting) |
+        ({ type: 'double-setting' } & DoubleSetting) |
+        ({ type: 'string-setting' } & StringSetting) |
+        ({ type: 'color-setting' } & ColorSetting)
+}

package/tsconfig.base.json

@@ -4,7 +4,7 @@
         "target": "esnext",
         "lib": ["esnext"],
         "strict": true,
-        "types": ["@typescript-to-lua/language-extensions"],
+        "types": ["factorio-types", "@typescript-to-lua/language-extensions"],
         "strictNullChecks": false
     },
     "tstl": {