/**
 * Parent object for structure classes
 */ interface Structure extends RoomObject { readonly prototype : Structure ; /**
     * The current amount of hit points of the structure.
     */ hits : number ; /**
     * The total amount of hit points of the structure.
     */ hitsMax : number ; /**
     * A unique object identifier. You can use Game.getObjectById method to retrieve an object instance by its id.
     */ id : string ; /**
     * If you can get an instance of a Structure, you can see it.
     * If you can see the Structure, you can see the room it's in.
     */ room : Room ; /**
     * One of the STRUCTURE_* constants.
     */ structureType : string ; /**
     * Destroy this structure immediately.
     */ destroy ( ) : number ; /**
     * Check whether this structure can be used. If the room controller level is not enough, then this method will return false, and the structure will be highlighted with red in the game.
     */ isActive ( ) : boolean ; param enabled notifyWhenAttacked ( enabled ) : number ; } interface StructureConstructor extends _Constructor < Structure > , _ConstructorById < Structure > { } declare const Structure ; /**
 * The base prototype for a structure that has an owner. Such structures can be
 * found using `FIND_MY_STRUCTURES` and `FIND_HOSTILE_STRUCTURES` constants.
 */ interface OwnedStructure extends Structure { readonly prototype : OwnedStructure ; /**
     * Whether this is your own structure. Walls and roads don't have this property as they are considered neutral structures.
     */ my : boolean ; /**
     * An object with the structure’s owner info (if present) containing the following properties: username
     */ owner : Owner ; /**
     * The link to the Room object. Is always present because owned structures give visibility.
     */ room : Room ; } interface OwnedStructureConstructor extends _Constructor < OwnedStructure > , _ConstructorById < OwnedStructure > { } declare const OwnedStructure ; /**
 * Claim this structure to take control over the room. The controller structure
 * cannot be damaged or destroyed. It can be addressed by `Room.controller`
 * property.
 */ interface StructureController extends OwnedStructure { readonly prototype : StructureController ; /**
     * Current controller level, from 0 to 8.
     */ level : number ; /**
     * The current progress of upgrading the controller to the next level.
     */ progress : number ; /**
     * The progress needed to reach the next level.
     */ progressTotal : number ; /**
     * An object with the controller reservation info if present: username, ticksToEnd
     */ reservation : ReservationDefinition ; /**
     * How many ticks of safe mode are remaining, or undefined.
     */ safeMode : number | undefined ; /**
     * Safe mode activations available to use.
     */ safeModeAvailable : number ; /**
     * During this period in ticks new safe mode activations will be blocked, undefined if cooldown is inactive.
     */ safeModeCooldown : number | undefined ; /**
     * An object with the controller sign info if present
     */ sign : SignDefinition ; /**
     * The amount of game ticks when this controller will lose one level. This timer can be reset by using Creep.upgradeController.
     */ ticksToDowngrade : number ; /**
     * The amount of game ticks while this controller cannot be upgraded due to attack.
     */ upgradeBlocked : number ; returns activateSafeMode ( ) : number ; /**
     * Make your claimed controller neutral again.
     */ unclaim ( ) : number ; } interface StructureControllerConstructor extends _Constructor < StructureController > , _ConstructorById < StructureController > { } declare const StructureController ; /**
 * Contains energy which can be spent on spawning bigger creeps. Extensions can
 * be placed anywhere in the room, any spawns will be able to use them regardless
 * of distance.
 */ interface StructureExtension extends OwnedStructure { readonly prototype : StructureExtension ; /**
     * The amount of energy containing in the extension.
     */ energy : number ; /**
     * The total amount of energy the extension can contain.
     */ energyCapacity : number ; deprecated param target param amount transferEnergy ( target , amount ? ) : number ; } interface StructureExtensionConstructor extends _Constructor < StructureExtension > , _ConstructorById < StructureExtension > { } declare const StructureExtension ; /**
 * Remotely transfers energy to another Link in the same room.
 */ interface StructureLink extends OwnedStructure { readonly prototype : StructureLink ; /**
     * The amount of game ticks the link has to wait until the next transfer is possible.
     */ cooldown : number ; /**
     * The amount of energy containing in the link.
     */ energy : number ; /**
     * The total amount of energy the link can contain.
     */ energyCapacity : number ; param target param amount transferEnergy ( target , amount ? ) : number ; } interface StructureLinkConstructor extends _Constructor < StructureLink > , _ConstructorById < StructureLink > { } declare const StructureLink ; /**
 * Non-player structure. Spawns NPC Source Keepers that guards energy sources
 * and minerals in some rooms. This structure cannot be destroyed.
 */ interface StructureKeeperLair extends OwnedStructure { readonly prototype : StructureKeeperLair ; /**
     * Time to spawning of the next Source Keeper.
     */ ticksToSpawn : number | undefined ; } interface StructureKeeperLairConstructor extends _Constructor < StructureKeeperLair > , _ConstructorById < StructureKeeperLair > { } declare const StructureKeeperLair ; /**
 * Provides visibility into a distant room from your script.
 */ interface StructureObserver extends OwnedStructure { readonly prototype : StructureObserver ; param roomName observeRoom ( roomName ) : number ; } interface StructureObserverConstructor extends _Constructor < StructureObserver > , _ConstructorById < StructureObserver > { } declare const StructureObserver ; /**
 *
 */ interface StructurePowerBank extends OwnedStructure { readonly prototype : StructurePowerBank ; /**
     * The amount of power containing.
     */ power : number ; /**
     * The amount of game ticks when this structure will disappear.
     */ ticksToDecay : number ; } interface StructurePowerBankConstructor extends _Constructor < StructurePowerBank > , _ConstructorById < StructurePowerBank > { } declare const StructurePowerBank ; /**
 * Non-player structure. Contains power resource which can be obtained by
 * destroying the structure. Hits the attacker creep back on each attack.
 */ interface StructurePowerSpawn extends OwnedStructure { readonly prototype : StructurePowerSpawn ; /**
     * The amount of energy containing in this structure.
     */ energy : number ; /**
     * The total amount of energy this structure can contain.
     */ energyCapacity : number ; /**
     * The amount of power containing in this structure.
     */ power : number ; /**
     * The total amount of power this structure can contain.
     */ powerCapacity : number ; param name createPowerCreep ( name ) : number ; /**
     * Register power resource units into your account. Registered power allows to develop power creeps skills. Consumes 1 power resource unit and 50 energy resource units.
     */ processPower ( ) : number ; deprecated param target param amount transferEnergy ( target , amount ? ) : number ; } interface StructurePowerSpawnConstructor extends _Constructor < StructurePowerSpawn > , _ConstructorById < StructurePowerSpawn > { } declare const StructurePowerSpawn ; /**
 * Blocks movement of hostile creeps, and defends your creeps and structures on
 * the same tile. Can be used as a controllable gate.
 */ interface StructureRampart extends OwnedStructure { readonly prototype : StructureRampart ; /**
     * The amount of game ticks when this rampart will lose some hit points.
     */ ticksToDecay : number ; /**
     * If false (default), only your creeps can step on the same square. If true, any hostile creeps can pass through.
     */ isPublic : boolean ; param isPublic setPublic ( isPublic ) : void ; } interface StructureRampartConstructor extends _Constructor < StructureRampart > , _ConstructorById < StructureRampart > { } declare const StructureRampart ; /**
 * Decreases movement cost to 1. Using roads allows creating creeps with less
 * `MOVE` body parts.
 */ interface StructureRoad extends Structure { readonly prototype : StructureRoad ; /**
     * The amount of game ticks when this road will lose some hit points.
     */ ticksToDecay : number ; } interface StructureRoadConstructor extends _Constructor < StructureRoad > , _ConstructorById < StructureRoad > { } declare const StructureRoad ; /**
 * A structure that can store huge amount of resource units. Only one structure
 * per room is allowed that can be addressed by `Room.storage` property.
 */ interface StructureStorage extends OwnedStructure { readonly prototype : StructureStorage ; /**
     * An object with the storage contents.
     */ store : StoreDefinition ; /**
     * The total amount of resources the storage can contain.
     */ storeCapacity : number ; param target param resourceType param amount transfer ( target , resourceType , amount ? ) : number ; deprecated param target param amount deprecated transferEnergy ( target , amount ? ) : number ; } interface StructureStorageConstructor extends _Constructor < StructureStorage > , _ConstructorById < StructureStorage > { } declare const StructureStorage ; /**
 * Remotely attacks or heals creeps, or repairs structures. Can be targeted to
 * any object in the room. However, its effectiveness highly depends on the
 * distance. Each action consumes energy.
 */ interface StructureTower extends OwnedStructure { readonly prototype : StructureTower ; /**
     * The amount of energy containing in this structure.
     */ energy : number ; /**
     * The total amount of energy this structure can contain.
     */ energyCapacity : number ; param target attack ( target ) : number ; param target heal ( target ) : number ; param target repair ( target ) : number ; deprecated param target param amount transferEnergy ( target , amount ? ) : number ; } interface StructureTowerConstructor extends _Constructor < StructureTower > , _ConstructorById < StructureTower > { } declare const StructureTower ; /**
 * Blocks movement of all creeps.
 */ interface StructureWall extends Structure { readonly prototype : StructureWall ; /**
     * The amount of game ticks when the wall will disappear (only for automatically placed border walls at the start of the game).
     */ ticksToLive : number ; } interface StructureWallConstructor extends _Constructor < StructureWall > , _ConstructorById < StructureWall > { } declare const StructureWall ; /**
 * Allows to harvest mineral deposits.
 */ interface StructureExtractor extends OwnedStructure { readonly prototype : StructureExtractor ; /**
     * The amount of game ticks until the next harvest action is possible.
     */ cooldown : number ; } interface StructureExtractorConstructor extends _Constructor < StructureExtractor > , _ConstructorById < StructureExtractor > { } declare const StructureExtractor ; /**
 * Produces mineral compounds from base minerals and boosts creeps.
 */ interface StructureLab extends OwnedStructure { readonly prototype : StructureLab ; /**
     * The amount of game ticks the lab has to wait until the next reaction is possible.
     */ cooldown : number ; /**
     * The amount of energy containing in the lab. Energy is used for boosting creeps.
     */ energy : number ; /**
     * The total amount of energy the lab can contain.
     */ energyCapacity : number ; /**
     * The amount of mineral resources containing in the lab.
     */ mineralAmount : number ; /**
     * The type of minerals containing in the lab. Labs can contain only one mineral type at the same time.
     */ mineralType : string ; /**
     * The total amount of minerals the lab can contain.
     */ mineralCapacity : number ; param creep param bodyPartsCount boostCreep ( creep , bodyPartsCount ? ) : number ; param lab1 param lab2 runReaction ( lab1 , lab2 ) : number ; param target param resourceType param amount transfer ( target , resourceType , amount ? ) : number ; } interface StructureLabConstructor extends _Constructor < StructureLab > , _ConstructorById < StructureLab > { } declare const StructureLab ; /**
 * Sends any resources to a Terminal in another room.
 */ interface StructureTerminal extends OwnedStructure { readonly prototype : StructureTerminal ; /**
     * The remaining amount of ticks while this terminal cannot be used to make StructureTerminal.send or Game.market.deal calls.
     */ cooldown : number ; /**
     * An object with the storage contents. Each object key is one of the RESOURCE_* constants, values are resources amounts.
     */ store : any ; /**
     * The total amount of resources the storage can contain.
     */ storeCapacity : number ; param resourceType param amount param destination param description send ( resourceType , amount , destination , description ? ) : number ; param target param resourceType param amount transfer ( target , resourceType , amount ? ) : number ; } interface StructureTerminalConstructor extends _Constructor < StructureTerminal > , _ConstructorById < StructureTerminal > { } declare const StructureTerminal ; /**
 * Contains up to 2,000 resource units. Can be constructed in neutral rooms. Decays for 5,000 hits per 100 ticks.
 */ interface StructureContainer extends Structure { readonly prototype : StructureContainer ; /**
     * An object with the structure contents. Each object key is one of the RESOURCE_* constants, values are resources
     * amounts. Use _.sum(structure.store) to get the total amount of contents
     */ store : any ; /**
     * The total amount of resources the structure can contain.
     */ storeCapacity : number ; /**
     * The amount of game ticks when this container will lose some hit points.
     */ ticksToDecay : number ; param target param resourceType param amount transfer ( target , resourceType , amount ? ) : number ; } interface StructureContainerConstructor extends _Constructor < StructureContainer > , _ConstructorById < StructureContainer > { } declare const StructureContainer ; /**
 * Launches a nuke to another room dealing huge damage to the landing area.
 * Each launch has a cooldown and requires energy and ghodium resources. Launching
 * creates a Nuke object at the target room position which is visible to any player
 * until it is landed. Incoming nuke cannot be moved or cancelled. Nukes cannot
 * be launched from or to novice rooms.
 */ interface StructureNuker extends OwnedStructure { readonly prototype : StructureNuker ; /**
     * The amount of energy contained in this structure.
     */ energy : number ; /**
     * The total amount of energy this structure can contain.
     */ energyCapacity : number ; /**
     * The amount of ghodium contained in this structure.
     */ ghodium : number ; /**
     * The total amount of ghodium this structure can contain.
     */ ghodiumCapacity : number ; /**
     * The amount of game ticks the nuker has to wait until the next launch is possible.
     */ cooldown : number ; param pos launchNuke ( pos ) : number ; } interface StructureNukerConstructor extends _Constructor < StructureNuker > , _ConstructorById < StructureNuker > { } declare const StructureNuker ; /**
 * A non-player structure.
 * Instantly teleports your creeps to a distant room acting as a room exit tile.
 * Portals appear randomly in the central room of each sector.
 */ interface StructurePortal extends Structure { readonly prototype : StructurePortal ; /**
     * The position object in the destination room.
     */ destination : RoomPosition ; /**
     * The amount of game ticks when the portal disappears, or undefined when the portal is stable.
     */ ticksToDecay : number ; } interface StructurePortalConstructor extends _Constructor < StructurePortal > , _ConstructorById < StructurePortal > { } declare const StructurePortal ;