@shipload/sdk 1.0.0-next.3 → 1.0.0-next.30

package/lib/shipload.d.ts

@@ -1,5 +1,5 @@
 import * as _wharfkit_antelope from '@wharfkit/antelope';
-import { Blob, ABI, Struct, Name, UInt64, Checksum256, UInt32, TimePointSec, Checksum256Type, UInt32Type, NameType, UInt64Type, Action, UInt8, Int64, UInt16, TimePoint, Bytes, Int32, UInt16Type, UInt8Type, TimePointType, Int64Type, Int32Type, Checksum512, APIClient } from '@wharfkit/antelope';
+import { Blob, ABI, Struct, Name, Asset, UInt64, Checksum256, UInt32, TimePointSec, ExtendedAsset, Checksum256Type, UInt32Type, NameType, UInt64Type, AssetType, ExtendedAssetType, Action, UInt16, UInt8, Int64, TimePoint, BlockTimestamp, Bytes, Int32, UInt16Type, UInt8Type, Int64Type, TimePointType, Int32Type, Checksum512, APIClient } from '@wharfkit/antelope';
 import * as _wharfkit_contract from '@wharfkit/contract';
 import { Contract as Contract$2, PartialBy, ContractArgs, ActionOptions, Table } from '@wharfkit/contract';
 import { ChainDefinition } from '@wharfkit/common';
@@ -7,15 +7,35 @@ import { ChainDefinition } from '@wharfkit/common';
 declare const abiBlob$1: Blob;
 declare const abi$1: ABI;
 declare namespace Types$1 {
+    class balance_row extends Struct {
+        token_contract: Name;
+        balance: Asset;
+    }
     class cleartable extends Struct {
         table_name: Name;
         scope?: Name;
         max_rows?: UInt64;
     }
+    class close extends Struct {
+        owner: Name;
+        token_contract: Name;
+        token_symbol: Asset.Symbol;
+    }
     class company_row extends Struct {
         account: Name;
         name: string;
     }
+    class debitdeposit extends Struct {
+        owner: Name;
+        token: Name;
+        locked: Asset;
+        fee_account: Name;
+        fee: Asset;
+    }
+    class depositcfg_row extends Struct {
+        token_contract: Name;
+        token_symbol: Asset.Symbol;
+    }
     class enable extends Struct {
         enabled: boolean;
     }
@@ -48,6 +68,25 @@ declare namespace Types$1 {
         meta: game_meta;
         state: game_state;
     }
+    class open extends Struct {
+        owner: Name;
+        token_contract: Name;
+        token_symbol: Asset.Symbol;
+    }
+    class relgateasset extends Struct {
+        asset_id: UInt64;
+    }
+    class relgateowner extends Struct {
+        owner: Name;
+    }
+    class setepochtime extends Struct {
+        contract: Name;
+        epochtime: UInt32;
+    }
+    class settoken extends Struct {
+        token_contract: Name;
+        token_symbol: Asset.Symbol;
+    }
     class startgame extends Struct {
         contract: Name;
         config: game_config;
@@ -57,22 +96,68 @@ declare namespace Types$1 {
     class state_row extends Struct {
         enabled: boolean;
     }
+    class unwrapcargo extends Struct {
+        game: Name;
+        owner: Name;
+        asset_id: UInt64;
+    }
+    class unwrapcust_row extends Struct {
+        asset_id: UInt64;
+        owner: Name;
+    }
+    class unwrapentity extends Struct {
+        game: Name;
+        owner: Name;
+        asset_id: UInt64;
+    }
     class updategame extends Struct {
         contract: Name;
         meta: game_meta;
     }
     class wipe extends Struct {
     }
+    class withdraw extends Struct {
+        owner: Name;
+        quantity: ExtendedAsset;
+        memo: string;
+    }
+    class wrapcargo extends Struct {
+        game: Name;
+        owner: Name;
+        entity_id: UInt64;
+        nexus_id: UInt64;
+        cargo_id: UInt64;
+        quantity: UInt64;
+    }
+    class wrapentity extends Struct {
+        game: Name;
+        owner: Name;
+        entity_id: UInt64;
+        nexus_id: UInt64;
+    }
+    class wrapgate_row extends Struct {
+        owner: Name;
+        game: Name;
+        last_asset_id: UInt64;
+    }
 }
 declare const TableMap$1: {
+    balance: typeof Types$1.balance_row;
     company: typeof Types$1.company_row;
+    depositcfg: typeof Types$1.depositcfg_row;
     games: typeof Types$1.game_row;
     state: typeof Types$1.state_row;
+    unwrapcust: typeof Types$1.unwrapcust_row;
+    wrapgate: typeof Types$1.wrapgate_row;
 };
 interface TableTypes$1 {
+    balance: Types$1.balance_row;
     company: Types$1.company_row;
+    depositcfg: Types$1.depositcfg_row;
     games: Types$1.game_row;
     state: Types$1.state_row;
+    unwrapcust: Types$1.unwrapcust_row;
+    wrapgate: Types$1.wrapgate_row;
 }
 type RowType$1<T> = T extends keyof TableTypes$1 ? TableTypes$1[T] : any;
 type TableNames$1 = keyof TableTypes$1;
@@ -99,6 +184,18 @@ declare namespace ActionParams$1 {
         scope?: NameType;
         max_rows?: UInt64Type;
     }
+    interface close {
+        owner: NameType;
+        token_contract: NameType;
+        token_symbol: Asset.SymbolType;
+    }
+    interface debitdeposit {
+        owner: NameType;
+        token: NameType;
+        locked: AssetType;
+        fee_account: NameType;
+        fee: AssetType;
+    }
     interface enable {
         enabled: boolean;
     }
@@ -110,27 +207,87 @@ declare namespace ActionParams$1 {
         account: NameType;
         name: string;
     }
+    interface open {
+        owner: NameType;
+        token_contract: NameType;
+        token_symbol: Asset.SymbolType;
+    }
+    interface relgateasset {
+        asset_id: UInt64Type;
+    }
+    interface relgateowner {
+        owner: NameType;
+    }
+    interface setepochtime {
+        contract: NameType;
+        epochtime: UInt32Type;
+    }
+    interface settoken {
+        token_contract: NameType;
+        token_symbol: Asset.SymbolType;
+    }
     interface startgame {
         contract: NameType;
         config: Type.game_config;
         meta: Type.game_meta;
         state: Type.game_state;
     }
+    interface unwrapcargo {
+        game: NameType;
+        owner: NameType;
+        asset_id: UInt64Type;
+    }
+    interface unwrapentity {
+        game: NameType;
+        owner: NameType;
+        asset_id: UInt64Type;
+    }
     interface updategame {
         contract: NameType;
         meta: Type.game_meta;
     }
     interface wipe {
     }
+    interface withdraw {
+        owner: NameType;
+        quantity: ExtendedAssetType;
+        memo: string;
+    }
+    interface wrapcargo {
+        game: NameType;
+        owner: NameType;
+        entity_id: UInt64Type;
+        nexus_id: UInt64Type;
+        cargo_id: UInt64Type;
+        quantity: UInt64Type;
+    }
+    interface wrapentity {
+        game: NameType;
+        owner: NameType;
+        entity_id: UInt64Type;
+        nexus_id: UInt64Type;
+    }
 }
 interface ActionNameParams$1 {
     cleartable: ActionParams$1.cleartable;
+    close: ActionParams$1.close;
+    debitdeposit: ActionParams$1.debitdeposit;
     enable: ActionParams$1.enable;
     enablegame: ActionParams$1.enablegame;
     foundcompany: ActionParams$1.foundcompany;
+    open: ActionParams$1.open;
+    relgateasset: ActionParams$1.relgateasset;
+    relgateowner: ActionParams$1.relgateowner;
+    setepochtime: ActionParams$1.setepochtime;
+    settoken: ActionParams$1.settoken;
     startgame: ActionParams$1.startgame;
+    unwrapcargo: ActionParams$1.unwrapcargo;
+    unwrapentity: ActionParams$1.unwrapentity;
     updategame: ActionParams$1.updategame;
     wipe: ActionParams$1.wipe;
+    withdraw: ActionParams$1.withdraw;
+    wrapcargo: ActionParams$1.wrapcargo;
+    wrapentity: ActionParams$1.wrapentity;
 }
 type ActionNames$1 = keyof ActionNameParams$1;
 declare class Contract$1 extends Contract$2 {
@@ -158,44 +315,52 @@ declare namespace platform {
 declare const abiBlob: Blob;
 declare const abi: ABI;
 declare namespace Types {
+    class packed_module extends Struct {
+        item_id: UInt16;
+        stats: UInt64;
+    }
+    class module_entry extends Struct {
+        type: UInt8;
+        installed?: packed_module;
+    }
+    class cargo_ref extends Struct {
+        item_id: UInt16;
+        stats: UInt64;
+        modules: module_entry[];
+        entity_id?: UInt64;
+    }
     class addmodule extends Struct {
-        entity_type: Name;
         entity_id: UInt64;
         module_index: UInt8;
-        module_cargo_id: UInt64;
-        target_cargo_id: UInt64;
+        module_ref: cargo_ref;
+        target_ref?: cargo_ref;
     }
     class addnexus extends Struct {
         nexus_name: string;
         x: Int64;
         y: Int64;
     }
-    class advance extends Struct {
-        reveal: string;
-        commit: Checksum256;
-    }
-    class packed_module extends Struct {
-        item_id: UInt16;
-        stats: UInt64;
-    }
-    class module_entry extends Struct {
-        type: UInt8;
-        installed?: packed_module;
+    class addoracle extends Struct {
+        oracle_id: Name;
     }
     class cargo_item extends Struct {
         item_id: UInt16;
-        quantity: UInt32;
         stats: UInt64;
         modules: module_entry[];
+        quantity: UInt32;
+        entity_id?: UInt64;
     }
     class blend extends Struct {
-        entity_type: Name;
         id: UInt64;
         inputs: cargo_item[];
     }
+    class buildplot extends Struct {
+        builder_id: UInt64;
+        plot_id: UInt64;
+    }
     class cancel extends Struct {
-        entity_type: Name;
         id: UInt64;
+        lane_key: UInt8;
         count: UInt64;
     }
     class entity_ref extends Struct {
@@ -217,18 +382,31 @@ declare namespace Types {
         quantity: UInt64;
         stats: UInt64;
         modules: module_entry[];
+        sequence_id?: UInt64;
     }
     class cargo_view extends Struct {
         item_id: UInt16;
-        quantity: UInt32;
         stats: UInt64;
         modules: module_entry[];
+        quantity: UInt32;
         id: UInt64;
+        entity_id?: UInt64;
     }
-    class claimstarter extends Struct {
-        account: Name;
+    class claim_row extends Struct {
+        owner: Name;
+    }
+    class coordinates extends Struct {
         x: Int64;
         y: Int64;
+        z?: UInt16;
+    }
+    class claimplot extends Struct {
+        builder_id: UInt64;
+        target_item_id: UInt16;
+        coords: coordinates;
+    }
+    class claimstarter extends Struct {
+        owner: Name;
     }
     class cleanrsvp extends Struct {
         epoch: UInt64;
@@ -240,6 +418,14 @@ declare namespace Types {
         max_rows?: UInt64;
     }
     class commit extends Struct {
+        oracle_id: Name;
+        epoch: UInt64;
+        commit: Checksum256;
+    }
+    class commit_row extends Struct {
+        id: UInt64;
+        epoch: UInt64;
+        oracle_id: Name;
         commit: Checksum256;
     }
     class entity_defaults extends Struct {
@@ -261,37 +447,7 @@ declare namespace Types {
     class configlog extends Struct {
         config: game_config;
     }
-    class coordinates extends Struct {
-        x: Int64;
-        y: Int64;
-        z?: UInt16;
-    }
-    class task extends Struct {
-        type: UInt8;
-        duration: UInt32;
-        cancelable: UInt8;
-        coordinates?: coordinates;
-        cargo: cargo_item[];
-        entitytarget?: entity_ref;
-        entitygroup?: UInt64;
-        energy_cost?: UInt16;
-    }
-    class schedule extends Struct {
-        started: TimePoint;
-        tasks: task[];
-    }
-    class container_row extends Struct {
-        id: UInt64;
-        owner: Name;
-        name: string;
-        coordinates: coordinates;
-        hullmass: UInt32;
-        capacity: UInt32;
-        cargomass: UInt32;
-        schedule?: schedule;
-    }
     class craft extends Struct {
-        entity_type: Name;
         id: UInt64;
         recipe_id: UInt16;
         quantity: UInt32;
@@ -299,20 +455,14 @@ declare namespace Types {
     }
     class crafter_stats extends Struct {
         speed: UInt16;
-        drain: UInt16;
+        drain: UInt32;
     }
-    class createentity extends Struct {
-        owner: Name;
-        entity_type: Name;
-        entity_name: string;
-        x: Int64;
-        y: Int64;
+    class demolish extends Struct {
+        entity_id: UInt64;
     }
     class deploy extends Struct {
-        entity_type: Name;
         id: UInt64;
-        packed_item_id: UInt16;
-        stats: UInt64;
+        ref: cargo_ref;
     }
     class descentity extends Struct {
         item_id: UInt16;
@@ -324,35 +474,52 @@ declare namespace Types {
         enabled: boolean;
     }
     class energy_stats extends Struct {
-        capacity: UInt16;
-        recharge: UInt16;
+        capacity: UInt32;
+        recharge: UInt32;
     }
     class entity_current_state extends Struct {
         coordinates: coordinates;
-        energy: UInt16;
-    }
-    class loader_stats extends Struct {
-        mass: UInt32;
-        thrust: UInt16;
-        quantity: UInt8;
+        energy: UInt32;
     }
     class movement_stats extends Struct {
         thrust: UInt32;
-        drain: UInt16;
+        drain: UInt32;
+    }
+    class warp_stats extends Struct {
+        range: UInt32;
     }
     class gatherer_stats extends Struct {
         yield: UInt16;
-        drain: UInt16;
+        drain: UInt32;
         depth: UInt16;
-        speed: UInt16;
+    }
+    class loader_stats extends Struct {
+        mass: UInt32;
+        thrust: UInt16;
+        quantity: UInt8;
     }
     class hauler_stats extends Struct {
         capacity: UInt8;
         efficiency: UInt16;
-        drain: UInt16;
+        drain: UInt32;
     }
-    class warp_stats extends Struct {
-        range: UInt32;
+    class task extends Struct {
+        type: UInt8;
+        duration: UInt32;
+        cancelable: UInt8;
+        coordinates?: coordinates;
+        cargo: cargo_item[];
+        entitytarget?: entity_ref;
+        entitygroup?: UInt64;
+        energy_cost?: UInt32;
+    }
+    class schedule extends Struct {
+        started: TimePoint;
+        tasks: task[];
+    }
+    class lane extends Struct {
+        lane_key: UInt8;
+        schedule: schedule;
     }
     class entity_info extends Struct {
         type: Name;
@@ -360,29 +527,25 @@ declare namespace Types {
         owner: Name;
         entity_name: string;
         coordinates: coordinates;
+        item_id: UInt16;
         cargomass: UInt32;
         cargo: cargo_view[];
-        loaders?: loader_stats;
         modules: module_entry[];
-        energy?: UInt16;
+        energy?: UInt32;
         hullmass?: UInt32;
+        capacity?: UInt32;
         engines?: movement_stats;
+        warp?: warp_stats;
         generator?: energy_stats;
-        capacity?: UInt32;
         gatherer?: gatherer_stats;
+        loaders?: loader_stats;
         hauler?: hauler_stats;
-        warp?: warp_stats;
         crafter?: crafter_stats;
-        is_idle: boolean;
-        current_task?: task;
-        current_task_elapsed: UInt32;
-        current_task_remaining: UInt32;
-        pending_tasks: task[];
-        idle_at?: TimePoint;
-        schedule?: schedule;
+        lanes: lane[];
     }
     class slot_def extends Struct {
         type: UInt8;
+        output_pct: UInt16;
     }
     class entity_layout extends Struct {
         entity_item_id: UInt16;
@@ -391,6 +554,22 @@ declare namespace Types {
     class entity_layouts_result extends Struct {
         entities: entity_layout[];
     }
+    class entity_row extends Struct {
+        id: UInt64;
+        owner: Name;
+        kind: Name;
+        item_id: UInt16;
+        name: string;
+        stats: UInt64;
+        coordinates: coordinates;
+        energy?: UInt32;
+        cargomass: UInt32;
+        modules: module_entry[];
+        lanes: lane[];
+    }
+    class entity_seq_row extends Struct {
+        next_id: UInt64;
+    }
     class entity_summary extends Struct {
         type: Name;
         id: UInt64;
@@ -418,20 +597,44 @@ declare namespace Types {
     class enum_result extends Struct {
         members: enum_member[];
     }
+    class epoch_row extends Struct {
+        epoch: UInt64;
+        oracle_ids: Name[];
+        threshold: UInt8;
+        seed: Checksum256;
+    }
+    class fixcargomass extends Struct {
+        entity_id: UInt64;
+    }
+    class forcereveal extends Struct {
+        epoch: UInt64;
+    }
     class gather extends Struct {
-        source: entity_ref;
-        destination: entity_ref;
+        source_id: UInt64;
+        destination_id: UInt64;
         stratum: UInt16;
         quantity: UInt32;
     }
+    class genesisfleet extends Struct {
+        entities: entity_row[];
+    }
     class getconfig extends Struct {
     }
+    class getdeposit extends Struct {
+        owner: Name;
+        asset_id: UInt64;
+    }
+    class geteligible extends Struct {
+        coords: coordinates;
+        stratum: UInt16;
+    }
+    class getentcls extends Struct {
+    }
     class getentities extends Struct {
         owner: Name;
         entity_type?: Name;
     }
     class getentity extends Struct {
-        entity_type: Name;
         entity_id: UInt64;
     }
     class getitemdata extends Struct {
@@ -440,8 +643,13 @@ declare namespace Types {
     }
     class getitems extends Struct {
     }
+    class getitemtype extends Struct {
+        item_id: UInt16;
+    }
     class getitemtypes extends Struct {
     }
+    class getkindmeta extends Struct {
+    }
     class getlocation extends Struct {
         x: Int64;
         y: Int64;
@@ -455,15 +663,20 @@ declare namespace Types {
     class getmodules extends Struct {
     }
     class getnearby extends Struct {
-        entity_type: Name;
         entity_id: UInt64;
         recharge: boolean;
     }
+    class getnftbase extends Struct {
+    }
     class getnftinfo extends Struct {
     }
     class getplayer extends Struct {
         account: Name;
     }
+    class getprojstate extends Struct {
+        entity_id: UInt64;
+        task_count?: UInt8;
+    }
     class getrecipe extends Struct {
         output_item_id: UInt16;
     }
@@ -502,9 +715,37 @@ declare namespace Types {
     class hash512 extends Struct {
         value: string;
     }
-    class init extends Struct {
+    class importcargo extends Struct {
+        row: cargo_row;
+    }
+    class importentity extends Struct {
+        row: entity_row;
+    }
+    class importgroup extends Struct {
+        row: entitygroup_row;
+    }
+    class importplayer extends Struct {
+        owner: Name;
+    }
+    class reserve_row extends Struct {
+        id: UInt64;
+        coord_id: UInt64;
+        stratum: UInt16;
+        remaining: UInt32;
+        last_block: BlockTimestamp;
+    }
+    class importreserve extends Struct {
+        epoch_scope: UInt32;
+        row: reserve_row;
+    }
+    class state_row extends Struct {
+        enabled: boolean;
+        epoch: UInt32;
         seed: Checksum256;
     }
+    class importstate extends Struct {
+        row: state_row;
+    }
     class item_id_pair extends Struct {
         id: UInt16;
         name: string;
@@ -514,8 +755,6 @@ declare namespace Types {
     }
     class recipe_input extends Struct {
         item_id: UInt16;
-        category: UInt8;
-        tier: UInt8;
         quantity: UInt32;
     }
     class stat_source extends Struct {
@@ -551,6 +790,22 @@ declare namespace Types {
     class join extends Struct {
         account: Name;
     }
+    class kind_meta_row extends Struct {
+        kind: Name;
+        classification: UInt8;
+        capability_flags: UInt8;
+        z_coord: UInt32;
+        default_label: string;
+    }
+    class template_meta_row extends Struct {
+        item_id: UInt16;
+        kind: Name;
+        display_label: string;
+    }
+    class kind_meta_result extends Struct {
+        kinds: kind_meta_row[];
+        templates: template_meta_row[];
+    }
     class location_static extends Struct {
         coords: coordinates;
         type: UInt8;
@@ -558,28 +813,14 @@ declare namespace Types {
         seed0: UInt8;
         seed1: UInt8;
     }
-    class location_epoch extends Struct {
-        active: boolean;
-        seed0: UInt8;
-        seed1: UInt8;
-    }
     class location_derived extends Struct {
         static_props: location_static;
-        epoch_props: location_epoch;
         size: UInt16;
     }
     class location_info extends Struct {
         coords: coordinates;
         is_system: boolean;
     }
-    class location_row extends Struct {
-        id: UInt64;
-        owner: Name;
-        coordinates: coordinates;
-        cargomass: UInt32;
-        cargo: cargo_item[];
-        schedule?: schedule;
-    }
     class module_info extends Struct {
         id: UInt16;
         mass: UInt32;
@@ -599,14 +840,18 @@ declare namespace Types {
         can_travel: boolean;
         current: entity_current_state;
         projected: entity_current_state;
-        max_energy: UInt16;
+        max_energy: UInt32;
         systems: nearby_system[];
     }
-    class nexus_row extends Struct {
-        id: UInt64;
-        owner: Name;
-        name: string;
-        coordinates: coordinates;
+    class nft_cargo_item extends Struct {
+        item_id: UInt16;
+        stats: UInt64;
+        modules: module_entry[];
+        quantity: UInt32;
+    }
+    class nft_item_payload extends Struct {
+        item: nft_cargo_item;
+        location?: coordinates;
     }
     class schema_field extends Struct {
         name: string;
@@ -619,12 +864,17 @@ declare namespace Types {
     class nft_template_def extends Struct {
         item_id: UInt16;
         schema_name: Name;
+        template_id: Int32;
     }
     class nftconfig_row extends Struct {
         item_id: UInt16;
         template_id: Int32;
         schema_name: Name;
     }
+    class nftimgurl extends Struct {
+        item: cargo_item;
+        location?: coordinates;
+    }
     class nftinfo_result extends Struct {
         schemas: nft_schema_def[];
         templates: nft_template_def[];
@@ -638,34 +888,66 @@ declare namespace Types {
         task: task;
         starts_at: TimePoint;
         completes_at: TimePoint;
-        new_energy?: UInt16;
+        new_energy?: UInt32;
+        lane_key: UInt8;
     }
     class notify extends Struct {
         event: task_event;
     }
-    class player_info extends Struct {
+    class oracle_config_row extends Struct {
+        threshold: UInt8;
+    }
+    class oracle_row extends Struct {
+        id: Name;
+    }
+    class placecargo extends Struct {
         owner: Name;
-        is_player: boolean;
-        company_name: string;
-        ship_count: UInt64;
-        warehouse_count: UInt64;
-        container_count: UInt64;
+        host_id: UInt64;
+        asset_id: UInt64;
+    }
+    class placeentity extends Struct {
+        owner: Name;
+        asset_id: UInt64;
+        target_nexus_id: UInt64;
+    }
+    class player_info extends Struct {
+        owner: Name;
+        is_player: boolean;
+        company_name: string;
     }
     class player_row extends Struct {
         owner: Name;
     }
+    class projected_state extends Struct {
+        owner: Name;
+        coordinates: coordinates;
+        energy?: UInt32;
+        cargomass: UInt32;
+        cargo: cargo_view[];
+        hullmass?: UInt32;
+        capacity?: UInt32;
+        engines?: movement_stats;
+        warp?: warp_stats;
+        generator?: energy_stats;
+        gatherer?: gatherer_stats;
+        loaders?: loader_stats;
+        hauler?: hauler_stats;
+        crafter?: crafter_stats;
+    }
     class recharge extends Struct {
-        entity_type: Name;
         id: UInt64;
     }
-    class reserve_row extends Struct {
+    class refrshentity extends Struct {
+        entity_id: UInt64;
+    }
+    class removeoracle extends Struct {
+        oracle_id: Name;
+    }
+    class rename extends Struct {
         id: UInt64;
-        coord_id: UInt64;
-        stratum: UInt16;
-        remaining: UInt32;
+        name: string;
     }
     class resolve extends Struct {
-        entity_type: Name;
         id: UInt64;
         count?: UInt64;
     }
@@ -691,71 +973,58 @@ declare namespace Types {
     class resources_result extends Struct {
         resources: resource_info[];
     }
+    class retarget extends Struct {
+        source_id: UInt64;
+        task_index: UInt64;
+        new_dest_id: UInt64;
+    }
+    class reveal extends Struct {
+        oracle_id: Name;
+        epoch: UInt64;
+        reveal: Checksum256;
+    }
+    class reveal_row extends Struct {
+        id: UInt64;
+        epoch: UInt64;
+        oracle_id: Name;
+        reveal: Checksum256;
+    }
     class rmmodule extends Struct {
-        entity_type: Name;
         entity_id: UInt64;
         module_index: UInt8;
-        target_cargo_id: UInt64;
+        target_ref?: cargo_ref;
     }
     class rmnftcfg extends Struct {
         item_id: UInt16;
     }
-    class salt extends Struct {
-        salt: UInt64;
-    }
-    class sequence_row extends Struct {
-        key: Name;
-        value: UInt64;
-    }
     class setnftcfg extends Struct {
         item_id: UInt16;
         template_id: Int32;
         schema_name: Name;
     }
-    class ship_row extends Struct {
-        id: UInt64;
-        owner: Name;
-        name: string;
-        stats: UInt64;
-        coordinates: coordinates;
-        hullmass?: UInt32;
-        capacity?: UInt32;
-        energy?: UInt16;
-        cargomass: UInt32;
-        engines?: movement_stats;
-        generator?: energy_stats;
-        loaders?: loader_stats;
-        gatherer?: gatherer_stats;
-        warp?: warp_stats;
-        crafter?: crafter_stats;
-        hauler?: hauler_stats;
-        modules: module_entry[];
-        schedule?: schedule;
+    class setthreshold extends Struct {
+        threshold: UInt8;
     }
-    class spawncargo extends Struct {
-        entity_id: UInt64;
-        item_id: UInt64;
-        quantity: UInt64;
+    class setwrapcost extends Struct {
+        item_type: UInt8;
+        tier: UInt8;
+        amount: UInt64;
     }
-    class spawnpacked extends Struct {
-        entity_id: UInt64;
-        item_id: UInt16;
-        hull_stats: UInt64;
-        installed: packed_module[];
+    class setwrapfee extends Struct {
+        fee_pct: UInt16;
+        fee_account: Name;
     }
-    class spawnseeded extends Struct {
+    class stowcargo extends Struct {
+        owner: Name;
         entity_id: UInt64;
-        item_id: UInt64;
+        nexus_id: UInt64;
+        cargo_id: UInt64;
         quantity: UInt64;
-        stats: UInt64;
     }
-    class state_row extends Struct {
-        enabled: boolean;
-        epoch: UInt32;
-        salt: UInt64;
-        ships: UInt32;
-        seed: Checksum256;
-        commit: Checksum256;
+    class stowentity extends Struct {
+        owner: Name;
+        entity_id: UInt64;
+        nexus_id: UInt64;
     }
     class stratum_info extends Struct {
         item_id: UInt16;
@@ -771,21 +1040,22 @@ declare namespace Types {
     class stratum_remaining extends Struct {
         stratum: UInt16;
         remaining: UInt32;
+        last_block: BlockTimestamp;
+    }
+    class swapmodule extends Struct {
+        entity_id: UInt64;
+        module_index: UInt8;
+        module_ref: cargo_ref;
     }
     class task_results extends Struct {
         entities: entity_task_info[];
     }
     class transfer extends Struct {
-        source_type: Name;
         source_id: UInt64;
-        dest_type: Name;
         dest_id: UInt64;
-        item_id: UInt16;
-        stats: UInt64;
-        quantity: UInt32;
+        items: cargo_item[];
     }
     class travel extends Struct {
-        entity_type: Name;
         id: UInt64;
         x: Int64;
         y: Int64;
@@ -796,77 +1066,76 @@ declare namespace Types {
         entity_summary_type: entity_summary;
         game_config_type: game_config;
         stratum_remaining_type: stratum_remaining;
+        nft_item_payload_type: nft_item_payload;
     }
-    class warehouse_row extends Struct {
-        id: UInt64;
-        owner: Name;
-        name: string;
-        stats: UInt64;
-        coordinates: coordinates;
-        hullmass?: UInt32;
-        capacity?: UInt32;
-        cargomass: UInt32;
-        loaders?: loader_stats;
-        modules: module_entry[];
-        schedule?: schedule;
+    class undeploy extends Struct {
+        host_id: UInt64;
+        target_id: UInt64;
     }
     class warp extends Struct {
-        entity_type: Name;
         id: UInt64;
         x: Int64;
         y: Int64;
     }
     class wipe extends Struct {
     }
-    class wipesequence extends Struct {
+    class wrapconfig_row extends Struct {
+        fee_pct: UInt16;
+        fee_account: Name;
     }
-    class wrap extends Struct {
-        owner: Name;
-        entity_type: Name;
-        entity_id: UInt64;
-        cargo_id: UInt64;
-        quantity: UInt64;
+    class wrapcost_row extends Struct {
+        item_type: UInt8;
+        tier: UInt8;
+        amount: UInt64;
     }
 }
 declare const TableMap: {
     cargo: typeof Types.cargo_row;
-    container: typeof Types.container_row;
+    claims: typeof Types.claim_row;
+    commit: typeof Types.commit_row;
+    entity: typeof Types.entity_row;
     entitygroup: typeof Types.entitygroup_row;
-    location: typeof Types.location_row;
-    nexus: typeof Types.nexus_row;
+    entityseq: typeof Types.entity_seq_row;
+    epoch: typeof Types.epoch_row;
     nftconfig: typeof Types.nftconfig_row;
+    oraclecfg: typeof Types.oracle_config_row;
+    oracles: typeof Types.oracle_row;
     player: typeof Types.player_row;
     reserve: typeof Types.reserve_row;
-    sequence: typeof Types.sequence_row;
-    ship: typeof Types.ship_row;
+    reveal: typeof Types.reveal_row;
     state: typeof Types.state_row;
     types: typeof Types.types_row;
-    warehouse: typeof Types.warehouse_row;
+    wrapconfig: typeof Types.wrapconfig_row;
+    wrapcost: typeof Types.wrapcost_row;
 };
 interface TableTypes {
     cargo: Types.cargo_row;
-    container: Types.container_row;
+    claims: Types.claim_row;
+    commit: Types.commit_row;
+    entity: Types.entity_row;
     entitygroup: Types.entitygroup_row;
-    location: Types.location_row;
-    nexus: Types.nexus_row;
+    entityseq: Types.entity_seq_row;
+    epoch: Types.epoch_row;
     nftconfig: Types.nftconfig_row;
+    oraclecfg: Types.oracle_config_row;
+    oracles: Types.oracle_row;
     player: Types.player_row;
     reserve: Types.reserve_row;
-    sequence: Types.sequence_row;
-    ship: Types.ship_row;
+    reveal: Types.reveal_row;
     state: Types.state_row;
     types: Types.types_row;
-    warehouse: Types.warehouse_row;
+    wrapconfig: Types.wrapconfig_row;
+    wrapcost: Types.wrapcost_row;
 }
 type RowType<T> = T extends keyof TableTypes ? TableTypes[T] : any;
 type TableNames = keyof TableTypes;
 declare namespace ActionParams {
     namespace Type {
-        interface cargo_item {
+        interface cargo_ref {
             item_id: UInt16Type;
-            quantity: UInt32Type;
             stats: UInt64Type;
             modules: Type.module_entry[];
+            entity_id?: UInt64Type;
         }
         interface module_entry {
             type: UInt8Type;
@@ -876,6 +1145,18 @@ declare namespace ActionParams {
             item_id: UInt16Type;
             stats: UInt64Type;
         }
+        interface cargo_item {
+            item_id: UInt16Type;
+            stats: UInt64Type;
+            modules: Type.module_entry[];
+            quantity: UInt32Type;
+            entity_id?: UInt64Type;
+        }
+        interface coordinates {
+            x: Int64Type;
+            y: Int64Type;
+            z?: UInt16Type;
+        }
         interface game_config {
             version: UInt32Type;
             defaults: Type.entity_defaults;
@@ -892,10 +1173,66 @@ declare namespace ActionParams {
             subtype: UInt8Type;
             tier: UInt8Type;
         }
+        interface entity_row {
+            id: UInt64Type;
+            owner: NameType;
+            kind: NameType;
+            item_id: UInt16Type;
+            name: string;
+            stats: UInt64Type;
+            coordinates: Type.coordinates;
+            energy?: UInt32Type;
+            cargomass: UInt32Type;
+            modules: Type.module_entry[];
+            lanes: Type.lane[];
+        }
+        interface lane {
+            lane_key: UInt8Type;
+            schedule: Type.schedule;
+        }
+        interface schedule {
+            started: TimePointType;
+            tasks: Type.task[];
+        }
+        interface task {
+            type: UInt8Type;
+            duration: UInt32Type;
+            cancelable: UInt8Type;
+            coordinates?: Type.coordinates;
+            cargo: Type.cargo_item[];
+            entitytarget?: Type.entity_ref;
+            entitygroup?: UInt64Type;
+            energy_cost?: UInt32Type;
+        }
         interface entity_ref {
             entity_type: NameType;
             entity_id: UInt64Type;
         }
+        interface cargo_row {
+            id: UInt64Type;
+            entity_id: UInt64Type;
+            item_id: UInt64Type;
+            quantity: UInt64Type;
+            stats: UInt64Type;
+            modules: Type.module_entry[];
+            sequence_id?: UInt64Type;
+        }
+        interface entitygroup_row {
+            id: UInt64Type;
+            participants: Type.entity_ref[];
+        }
+        interface reserve_row {
+            id: UInt64Type;
+            coord_id: UInt64Type;
+            stratum: UInt16Type;
+            remaining: UInt32Type;
+            last_block: BlockTimestamp;
+        }
+        interface state_row {
+            enabled: boolean;
+            epoch: UInt32Type;
+            seed: Checksum256Type;
+        }
         interface task_event {
             event_type: UInt8Type;
             owner: NameType;
@@ -905,54 +1242,44 @@ declare namespace ActionParams {
             task: Type.task;
             starts_at: TimePointType;
             completes_at: TimePointType;
-            new_energy?: UInt16Type;
-        }
-        interface task {
-            type: UInt8Type;
-            duration: UInt32Type;
-            cancelable: UInt8Type;
-            coordinates?: Type.coordinates;
-            cargo: Type.cargo_item[];
-            entitytarget?: Type.entity_ref;
-            entitygroup?: UInt64Type;
-            energy_cost?: UInt16Type;
-        }
-        interface coordinates {
-            x: Int64Type;
-            y: Int64Type;
-            z?: UInt16Type;
+            new_energy?: UInt32Type;
+            lane_key: UInt8Type;
         }
     }
     interface addmodule {
-        entity_type: NameType;
         entity_id: UInt64Type;
         module_index: UInt8Type;
-        module_cargo_id: UInt64Type;
-        target_cargo_id: UInt64Type;
+        module_ref: Type.cargo_ref;
+        target_ref?: Type.cargo_ref;
     }
     interface addnexus {
         nexus_name: string;
         x: Int64Type;
         y: Int64Type;
     }
-    interface advance {
-        reveal: string;
-        commit: Checksum256Type;
+    interface addoracle {
+        oracle_id: NameType;
     }
     interface blend {
-        entity_type: NameType;
         id: UInt64Type;
         inputs: Type.cargo_item[];
     }
+    interface buildplot {
+        builder_id: UInt64Type;
+        plot_id: UInt64Type;
+    }
     interface cancel {
-        entity_type: NameType;
         id: UInt64Type;
+        lane_key: UInt8Type;
         count: UInt64Type;
     }
+    interface claimplot {
+        builder_id: UInt64Type;
+        target_item_id: UInt16Type;
+        coords: Type.coordinates;
+    }
     interface claimstarter {
-        account: NameType;
-        x: Int64Type;
-        y: Int64Type;
+        owner: NameType;
     }
     interface cleanrsvp {
         epoch: UInt64Type;
@@ -964,30 +1291,25 @@ declare namespace ActionParams {
         max_rows?: UInt64Type;
     }
     interface commit {
+        oracle_id: NameType;
+        epoch: UInt64Type;
         commit: Checksum256Type;
     }
     interface configlog {
         config: Type.game_config;
     }
     interface craft {
-        entity_type: NameType;
         id: UInt64Type;
         recipe_id: UInt16Type;
         quantity: UInt32Type;
         inputs: Type.cargo_item[];
     }
-    interface createentity {
-        owner: NameType;
-        entity_type: NameType;
-        entity_name: string;
-        x: Int64Type;
-        y: Int64Type;
+    interface demolish {
+        entity_id: UInt64Type;
     }
     interface deploy {
-        entity_type: NameType;
         id: UInt64Type;
-        packed_item_id: UInt16Type;
-        stats: UInt64Type;
+        ref: Type.cargo_ref;
     }
     interface descentity {
         item_id: UInt16Type;
@@ -998,20 +1320,38 @@ declare namespace ActionParams {
     interface enable {
         enabled: boolean;
     }
+    interface fixcargomass {
+        entity_id: UInt64Type;
+    }
+    interface forcereveal {
+        epoch: UInt64Type;
+    }
     interface gather {
-        source: Type.entity_ref;
-        destination: Type.entity_ref;
+        source_id: UInt64Type;
+        destination_id: UInt64Type;
         stratum: UInt16Type;
         quantity: UInt32Type;
     }
+    interface genesisfleet {
+        entities: Type.entity_row[];
+    }
     interface getconfig {
     }
+    interface getdeposit {
+        owner: NameType;
+        asset_id: UInt64Type;
+    }
+    interface geteligible {
+        coords: Type.coordinates;
+        stratum: UInt16Type;
+    }
+    interface getentcls {
+    }
     interface getentities {
         owner: NameType;
         entity_type?: NameType;
     }
     interface getentity {
-        entity_type: NameType;
         entity_id: UInt64Type;
     }
     interface getitemdata {
@@ -1020,8 +1360,13 @@ declare namespace ActionParams {
     }
     interface getitems {
     }
+    interface getitemtype {
+        item_id: UInt16Type;
+    }
     interface getitemtypes {
     }
+    interface getkindmeta {
+    }
     interface getlocation {
         x: Int64Type;
         y: Int64Type;
@@ -1035,15 +1380,20 @@ declare namespace ActionParams {
     interface getmodules {
     }
     interface getnearby {
-        entity_type: NameType;
         entity_id: UInt64Type;
         recharge: boolean;
     }
+    interface getnftbase {
+    }
     interface getnftinfo {
     }
     interface getplayer {
         account: NameType;
     }
+    interface getprojstate {
+        entity_id: UInt64Type;
+        task_count?: UInt8Type;
+    }
     interface getrecipe {
         output_item_id: UInt16Type;
     }
@@ -1082,123 +1432,180 @@ declare namespace ActionParams {
     interface hash512 {
         value: string;
     }
-    interface init {
-        seed: Checksum256Type;
+    interface importcargo {
+        row: Type.cargo_row;
+    }
+    interface importentity {
+        row: Type.entity_row;
+    }
+    interface importgroup {
+        row: Type.entitygroup_row;
+    }
+    interface importplayer {
+        owner: NameType;
+    }
+    interface importreserve {
+        epoch_scope: UInt32Type;
+        row: Type.reserve_row;
+    }
+    interface importstate {
+        row: Type.state_row;
     }
     interface join {
         account: NameType;
     }
+    interface nftimgurl {
+        item: Type.cargo_item;
+        location?: Type.coordinates;
+    }
     interface notify {
         event: Type.task_event;
     }
+    interface placecargo {
+        owner: NameType;
+        host_id: UInt64Type;
+        asset_id: UInt64Type;
+    }
+    interface placeentity {
+        owner: NameType;
+        asset_id: UInt64Type;
+        target_nexus_id: UInt64Type;
+    }
     interface recharge {
-        entity_type: NameType;
         id: UInt64Type;
     }
+    interface refrshentity {
+        entity_id: UInt64Type;
+    }
+    interface removeoracle {
+        oracle_id: NameType;
+    }
+    interface rename {
+        id: UInt64Type;
+        name: string;
+    }
     interface resolve {
-        entity_type: NameType;
         id: UInt64Type;
         count?: UInt64Type;
     }
+    interface retarget {
+        source_id: UInt64Type;
+        task_index: UInt64Type;
+        new_dest_id: UInt64Type;
+    }
+    interface reveal {
+        oracle_id: NameType;
+        epoch: UInt64Type;
+        reveal: Checksum256Type;
+    }
     interface rmmodule {
-        entity_type: NameType;
         entity_id: UInt64Type;
         module_index: UInt8Type;
-        target_cargo_id: UInt64Type;
+        target_ref?: Type.cargo_ref;
     }
     interface rmnftcfg {
         item_id: UInt16Type;
     }
-    interface salt {
-        salt: UInt64Type;
-    }
     interface setnftcfg {
         item_id: UInt16Type;
         template_id: Int32Type;
         schema_name: NameType;
     }
-    interface spawncargo {
+    interface setthreshold {
+        threshold: UInt8Type;
+    }
+    interface setwrapcost {
+        item_type: UInt8Type;
+        tier: UInt8Type;
+        amount: UInt64Type;
+    }
+    interface setwrapfee {
+        fee_pct: UInt16Type;
+        fee_account: NameType;
+    }
+    interface stowcargo {
+        owner: NameType;
         entity_id: UInt64Type;
-        item_id: UInt64Type;
+        nexus_id: UInt64Type;
+        cargo_id: UInt64Type;
         quantity: UInt64Type;
     }
-    interface spawnpacked {
+    interface stowentity {
+        owner: NameType;
         entity_id: UInt64Type;
-        item_id: UInt16Type;
-        hull_stats: UInt64Type;
-        installed: Type.packed_module[];
+        nexus_id: UInt64Type;
     }
-    interface spawnseeded {
+    interface swapmodule {
         entity_id: UInt64Type;
-        item_id: UInt64Type;
-        quantity: UInt64Type;
-        stats: UInt64Type;
+        module_index: UInt8Type;
+        module_ref: Type.cargo_ref;
     }
     interface transfer {
-        source_type: NameType;
         source_id: UInt64Type;
-        dest_type: NameType;
         dest_id: UInt64Type;
-        item_id: UInt16Type;
-        stats: UInt64Type;
-        quantity: UInt32Type;
+        items: Type.cargo_item[];
     }
     interface travel {
-        entity_type: NameType;
         id: UInt64Type;
         x: Int64Type;
         y: Int64Type;
         recharge: boolean;
     }
+    interface undeploy {
+        host_id: UInt64Type;
+        target_id: UInt64Type;
+    }
     interface warp {
-        entity_type: NameType;
         id: UInt64Type;
         x: Int64Type;
         y: Int64Type;
     }
     interface wipe {
     }
-    interface wipesequence {
-    }
-    interface wrap {
-        owner: NameType;
-        entity_type: NameType;
-        entity_id: UInt64Type;
-        cargo_id: UInt64Type;
-        quantity: UInt64Type;
-    }
 }
 interface ActionNameParams {
     addmodule: ActionParams.addmodule;
     addnexus: ActionParams.addnexus;
-    advance: ActionParams.advance;
+    addoracle: ActionParams.addoracle;
     blend: ActionParams.blend;
+    buildplot: ActionParams.buildplot;
     cancel: ActionParams.cancel;
+    claimplot: ActionParams.claimplot;
     claimstarter: ActionParams.claimstarter;
     cleanrsvp: ActionParams.cleanrsvp;
     cleartable: ActionParams.cleartable;
     commit: ActionParams.commit;
     configlog: ActionParams.configlog;
     craft: ActionParams.craft;
-    createentity: ActionParams.createentity;
+    demolish: ActionParams.demolish;
     deploy: ActionParams.deploy;
     descentity: ActionParams.descentity;
     enable: ActionParams.enable;
+    fixcargomass: ActionParams.fixcargomass;
+    forcereveal: ActionParams.forcereveal;
     gather: ActionParams.gather;
+    genesisfleet: ActionParams.genesisfleet;
     getconfig: ActionParams.getconfig;
+    getdeposit: ActionParams.getdeposit;
+    geteligible: ActionParams.geteligible;
+    getentcls: ActionParams.getentcls;
     getentities: ActionParams.getentities;
     getentity: ActionParams.getentity;
     getitemdata: ActionParams.getitemdata;
     getitemids: ActionParams.getitemids;
     getitems: ActionParams.getitems;
+    getitemtype: ActionParams.getitemtype;
     getitemtypes: ActionParams.getitemtypes;
+    getkindmeta: ActionParams.getkindmeta;
     getlocation: ActionParams.getlocation;
     getlocdata: ActionParams.getlocdata;
     getmodtypes: ActionParams.getmodtypes;
     getmodules: ActionParams.getmodules;
     getnearby: ActionParams.getnearby;
+    getnftbase: ActionParams.getnftbase;
     getnftinfo: ActionParams.getnftinfo;
     getplayer: ActionParams.getplayer;
+    getprojstate: ActionParams.getprojstate;
     getrecipe: ActionParams.getrecipe;
     getrecipes: ActionParams.getrecipes;
     getrescats: ActionParams.getrescats;
@@ -1210,46 +1617,70 @@ interface ActionNameParams {
     grouptravel: ActionParams.grouptravel;
     hash: ActionParams.hash;
     hash512: ActionParams.hash512;
-    init: ActionParams.init;
+    importcargo: ActionParams.importcargo;
+    importentity: ActionParams.importentity;
+    importgroup: ActionParams.importgroup;
+    importplayer: ActionParams.importplayer;
+    importreserve: ActionParams.importreserve;
+    importstate: ActionParams.importstate;
     join: ActionParams.join;
+    nftimgurl: ActionParams.nftimgurl;
     notify: ActionParams.notify;
+    placecargo: ActionParams.placecargo;
+    placeentity: ActionParams.placeentity;
     recharge: ActionParams.recharge;
+    refrshentity: ActionParams.refrshentity;
+    removeoracle: ActionParams.removeoracle;
+    rename: ActionParams.rename;
     resolve: ActionParams.resolve;
+    retarget: ActionParams.retarget;
+    reveal: ActionParams.reveal;
     rmmodule: ActionParams.rmmodule;
     rmnftcfg: ActionParams.rmnftcfg;
-    salt: ActionParams.salt;
     setnftcfg: ActionParams.setnftcfg;
-    spawncargo: ActionParams.spawncargo;
-    spawnpacked: ActionParams.spawnpacked;
-    spawnseeded: ActionParams.spawnseeded;
+    setthreshold: ActionParams.setthreshold;
+    setwrapcost: ActionParams.setwrapcost;
+    setwrapfee: ActionParams.setwrapfee;
+    stowcargo: ActionParams.stowcargo;
+    stowentity: ActionParams.stowentity;
+    swapmodule: ActionParams.swapmodule;
     transfer: ActionParams.transfer;
     travel: ActionParams.travel;
+    undeploy: ActionParams.undeploy;
     warp: ActionParams.warp;
     wipe: ActionParams.wipe;
-    wipesequence: ActionParams.wipesequence;
-    wrap: ActionParams.wrap;
 }
 type ActionNames = keyof ActionNameParams;
 interface ActionReturnValues {
+    buildplot: Types.task_results;
     cancel: Types.cancel_results;
+    claimplot: Types.task_results;
     craft: Types.task_results;
+    demolish: Types.task_results;
     deploy: Types.task_results;
     descentity: string;
     gather: Types.task_results;
     getconfig: Types.game_config;
+    getdeposit: ExtendedAsset;
+    geteligible: UInt16[];
+    getentcls: Types.enum_result;
     getentities: Types.entity_info[];
     getentity: Types.entity_info;
     getitemdata: Types.itemdata_result;
     getitemids: Types.item_ids_result;
     getitems: Types.items_info;
+    getitemtype: UInt8;
     getitemtypes: Types.enum_result;
+    getkindmeta: Types.kind_meta_result;
     getlocation: Types.location_info;
     getlocdata: Types.location_derived;
     getmodtypes: Types.enum_result;
     getmodules: Types.modules_result;
     getnearby: Types.nearby_info;
+    getnftbase: string[];
     getnftinfo: Types.nftinfo_result;
     getplayer: Types.player_info;
+    getprojstate: Types.projected_state;
     getrecipe: Types.recipes_result;
     getrecipes: Types.recipes_result;
     getrescats: Types.enum_result;
@@ -1261,12 +1692,18 @@ interface ActionReturnValues {
     grouptravel: Types.task_results;
     hash: Checksum256;
     hash512: Checksum512;
+    nftimgurl: string;
+    placecargo: Types.task_results;
+    placeentity: Types.task_results;
     recharge: Types.task_results;
     resolve: Types.resolve_results;
+    retarget: Types.task_results;
+    stowcargo: Types.task_results;
+    stowentity: Types.task_results;
     transfer: Types.task_results;
     travel: Types.task_results;
+    undeploy: Types.task_results;
     warp: Types.task_results;
-    wrap: Types.task_results;
 }
 type ActionReturnNames = keyof ActionReturnValues;
 declare class Contract extends Contract$2 {
@@ -1326,16 +1763,15 @@ declare const REQUIRES_POSITIVE_VALUE = "Value must be greater than zero.";
 declare const PLAYER_ALREADY_JOINED = "Player has already joined the game.";
 declare const PLAYER_NOT_JOINED = "Player has not joined the game.";
 declare const PLAYER_NOT_FOUND = "Cannot find player for given account name.";
-declare const STARTER_ALREADY_CLAIMED = "Starter ship already claimed; destroy existing ships to re-claim.";
-declare const SHIP_ALREADY_THERE = "Ship cannot travel to the location its already at.";
+declare const ENTITY_ALREADY_THERE = "Entity cannot travel to the location it is already at.";
 declare const SHIP_ALREADY_TRAVELING = "Ship is already traveling.";
 declare const SHIP_CANNOT_BUY_TRAVELING = "Ship cannot buy goods while traveling.";
 declare const SHIP_CANNOT_UPDATE_TRAVELING = "Ship cannot be updated while traveling.";
-declare const SHIP_INVALID_DESTINATION = "Ship cannot travel, no system at specified destination.";
-declare const SHIP_INVALID_TRAVEL_DURATION = "This trip cannot be made as it would exceed the maximum travel duration.";
+declare const ENTITY_INVALID_DESTINATION = "Cannot travel: no system at specified destination.";
+declare const ENTITY_INVALID_TRAVEL_DURATION = "This trip cannot be made as it would exceed the maximum travel duration.";
 declare const SHIP_NOT_ARRIVED = "Ship has not yet arrived at its destination.";
-declare const SHIP_NOT_ENOUGH_ENERGY = "Ship does not have enough energy to travel to the destination.";
-declare const SHIP_NOT_ENOUGH_ENERGY_CAPACITY = "Ship does not have enough energy capacity to travel.";
+declare const ENTITY_NOT_ENOUGH_ENERGY = "Entity does not have enough energy to travel to the destination.";
+declare const ENTITY_NOT_ENOUGH_ENERGY_CAPACITY = "Entity does not have enough energy capacity to travel.";
 declare const SHIP_NOT_FOUND = "Cannot find ship for given account.";
 declare const SHIP_NOT_OWNED = "Ship is not owned by this account.";
 declare const NO_SCHEDULE = "No scheduled tasks.";
@@ -1344,16 +1780,13 @@ declare const SHIP_NO_COMPLETED_TASKS = "No completed tasks to resolve.";
 declare const RESOLVE_COUNT_EXCEEDS_COMPLETED = "Requested resolve count exceeds completed tasks.";
 declare const SHIP_CANNOT_CANCEL_TASK = "Cannot cancel task that is immutable or in progress.";
 declare const SHIP_NO_TASKS_TO_CANCEL = "No tasks to cancel.";
-declare const SHIP_INVALID_CARGO = "Invalid cargo specified for load/unload.";
-declare const SHIP_CARGO_NOT_OWNED = "Cannot load cargo that is not owned.";
-declare const SHIP_CARGO_NOT_LOADED = "Cannot unload cargo that is not loaded.";
-declare const SHIP_CAPACITY_EXCEEDED = "Ship cargo capacity would be exceeded.";
+declare const ENTITY_INVALID_CARGO = "Invalid cargo specified for load/unload.";
+declare const ENTITY_CARGO_NOT_OWNED = "Cannot load cargo that is not owned.";
+declare const ENTITY_CARGO_NOT_LOADED = "Cannot unload cargo that is not loaded.";
 declare const ENTITY_CAPACITY_EXCEEDED = "Entity cargo capacity would be exceeded.";
 declare const WAREHOUSE_NOT_FOUND = "Cannot find warehouse for given id.";
 declare const WAREHOUSE_ALREADY_AT_LOCATION = "Warehouse already exists at this location.";
-declare const WAREHOUSE_CAPACITY_EXCEEDED = "Warehouse capacity would be exceeded.";
 declare const CONTAINER_NOT_FOUND = "Cannot find container for given id.";
-declare const CONTAINER_CAPACITY_EXCEEDED = "Container capacity would be exceeded.";
 declare const DESTINATION_CAPACITY_EXCEEDED = "Destination entity does not have enough capacity for the gather.";
 declare const CANCEL_PAIRED_HAS_PENDING = "Cannot cancel transfer, paired entity has pending tasks.";
 declare const GROUP_EMPTY = "Group travel requires at least one entity.";
@@ -1400,12 +1833,14 @@ declare const INSUFFICIENT_ITEM_SUPPLY = "Insufficient supply of item at locatio
 
 declare const PRECISION = 10000;
 declare const CRAFT_ENERGY_DIVISOR = 150000;
-declare const WAREHOUSE_Z = 500;
+declare const PLANETARY_STRUCTURE_Z = 0;
 declare const CONTAINER_Z = 300;
 declare const TRAVEL_MAX_DURATION = 86400;
 declare const MIN_ORBITAL_ALTITUDE = 800;
 declare const MAX_ORBITAL_ALTITUDE = 3000;
 declare const BASE_ORBITAL_MASS = 100000;
+declare const MIN_TRANSFER_DISTANCE_PLANETARY_STRUCTURE = 100;
+declare const MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL = 300;
 interface ShipLike {
     coordinates: Types.coordinates;
     hullmass?: UInt32;
@@ -1430,26 +1865,25 @@ declare enum TaskType {
     WARP = 6,
     CRAFT = 7,
     DEPLOY = 8,
-    WRAP = 9,
-    UNWRAP = 10
+    UNWRAP = 10,
+    UNDEPLOY = 11,
+    DEMOLISH = 13,
+    CLAIMPLOT = 14,
+    BUILDPLOT = 15,
+    RESERVED = 16
 }
 declare enum LocationType {
     EMPTY = 0,
     PLANET = 1,
     ASTEROID = 2,
-    NEBULA = 3
+    NEBULA = 3,
+    ICE_FIELD = 4
 }
 declare enum TaskCancelable {
     NEVER = 0,
     BEFORE_START = 1,
     ALWAYS = 2
 }
-declare const EntityType$1: {
-    readonly SHIP: Name;
-    readonly WAREHOUSE: Name;
-    readonly CONTAINER: Name;
-};
-type EntityTypeName = (typeof EntityType$1)[keyof typeof EntityType$1];
 type CoordinatesType = Coordinates | Types.coordinates | {
     x: Int64Type;
     y: Int64Type;
@@ -1467,8 +1901,10 @@ interface Distance {
 }
 type ItemType = 'resource' | 'component' | 'module' | 'entity';
 type ResourceCategory = 'ore' | 'crystal' | 'gas' | 'regolith' | 'biomass';
-type ModuleType = 'any' | 'engine' | 'generator' | 'gatherer' | 'loader' | 'warp' | 'crafter' | 'launcher' | 'storage' | 'hauler';
-declare const TIER_ADJECTIVES: Record<number, string>;
+type ModuleType = 'any' | 'engine' | 'generator' | 'gatherer' | 'loader' | 'warp' | 'crafter' | 'launcher' | 'storage' | 'hauler' | 'battery';
+declare const RESOURCE_TIER_ADJECTIVES: Record<number, string>;
+declare const COMPONENT_TIER_PREFIXES: Record<number, string>;
+declare const MODULE_TIER_PREFIXES: Record<number, string>;
 declare const CATEGORY_LABELS: Record<ResourceCategory, string>;
 interface Item {
     id: number;
@@ -1482,6 +1918,7 @@ interface Item {
     moduleType?: ModuleType;
 }
 declare function formatTier(tier: number): string;
+declare function tierAdjective(tier: number): string;
 
 declare const ITEM_ORE_T1 = 101;
 declare const ITEM_ORE_T2 = 102;
@@ -1533,16 +1970,16 @@ declare const ITEM_BIOMASS_T7 = 507;
 declare const ITEM_BIOMASS_T8 = 508;
 declare const ITEM_BIOMASS_T9 = 509;
 declare const ITEM_BIOMASS_T10 = 510;
-declare const ITEM_HULL_PLATES = 10001;
-declare const ITEM_CARGO_LINING = 10002;
-declare const ITEM_THRUSTER_CORE = 10003;
-declare const ITEM_POWER_CELL = 10004;
-declare const ITEM_MATTER_CONDUIT = 10005;
-declare const ITEM_SURVEY_PROBE = 10006;
-declare const ITEM_CARGO_ARM = 10007;
-declare const ITEM_TOOL_BIT = 10008;
-declare const ITEM_REACTION_CHAMBER = 10009;
-declare const ITEM_FOCUSING_ARRAY = 10010;
+declare const ITEM_PLATE = 10001;
+declare const ITEM_FRAME = 10002;
+declare const ITEM_PLASMA_CELL = 10003;
+declare const ITEM_RESONATOR = 10004;
+declare const ITEM_BEAM = 10005;
+declare const ITEM_SENSOR = 10006;
+declare const ITEM_POLYMER = 10007;
+declare const ITEM_CERAMIC = 10008;
+declare const ITEM_REACTOR = 10009;
+declare const ITEM_RESIN = 10010;
 declare const ITEM_ENGINE_T1 = 10100;
 declare const ITEM_GENERATOR_T1 = 10101;
 declare const ITEM_GATHERER_T1 = 10102;
@@ -1551,23 +1988,20 @@ declare const ITEM_CRAFTER_T1 = 10104;
 declare const ITEM_STORAGE_T1 = 10105;
 declare const ITEM_HAULER_T1 = 10106;
 declare const ITEM_WARP_T1 = 10107;
+declare const ITEM_BATTERY_T1 = 10108;
 declare const ITEM_CONTAINER_T1_PACKED = 10200;
 declare const ITEM_SHIP_T1_PACKED = 10201;
 declare const ITEM_WAREHOUSE_T1_PACKED = 10202;
-declare const ITEM_HULL_PLATES_T2 = 20001;
-declare const ITEM_CARGO_LINING_T2 = 20002;
+declare const ITEM_EXTRACTOR_T1_PACKED = 10203;
+declare const ITEM_FACTORY_T1_PACKED = 10204;
+declare const ITEM_PLATE_T2 = 20001;
+declare const ITEM_FRAME_T2 = 20002;
 declare const ITEM_CONTAINER_T2_PACKED = 20200;
 
-interface RecipeInputItemId {
+interface RecipeInput {
     itemId: number;
     quantity: number;
 }
-interface RecipeInputCategory {
-    category: ResourceCategory;
-    tier: number;
-    quantity: number;
-}
-type RecipeInput = RecipeInputItemId | RecipeInputCategory;
 interface StatSlot {
     sources: {
         inputIndex: number;
@@ -1583,6 +2017,7 @@ interface Recipe {
 }
 interface EntitySlot {
     type: ModuleType;
+    outputPct: number;
 }
 interface EntityLayout {
     entityItemId: number;
@@ -1590,27 +2025,424 @@ interface EntityLayout {
 }
 declare function getRecipe(outputItemId: number): Recipe | undefined;
 declare function getEntityLayout(entityItemId: number): EntityLayout | undefined;
-declare function findItemByCategoryAndTier(category: ResourceCategory, tier: number): Item;
 
-interface EpochInfo {
-    epoch: UInt64;
-    start: Date;
-    end: Date;
+declare const CAP_WRAP = 1;
+declare const CAP_UNDEPLOY = 2;
+declare const CAP_DEMOLISH = 4;
+declare const CAP_MODULES = 16;
+declare enum EntityClass {
+    OrbitalVessel = 0,
+    PlanetaryStructure = 1,
+    Plot = 2
+}
+type EntityTypeName = 'ship' | 'warehouse' | 'extractor' | 'factory' | 'container' | 'nexus' | 'plot';
+interface KindMeta {
+    kind: Name;
+    classification: EntityClass;
+    capabilityFlags: number;
+    zCoord: number;
+    defaultLabel: string;
+}
+interface TemplateMeta {
+    itemId: number;
+    kind: Name;
+    displayLabel: string;
+}
+declare const ALL_ENTITY_TYPES: readonly EntityTypeName[];
+declare function getKindMeta(kind: NameType | EntityTypeName): KindMeta | undefined;
+declare function getTemplateMeta(itemId: number): TemplateMeta | undefined;
+declare function getPackedEntityType(itemId: number): Name | null;
+declare function kindCan(kind: NameType | EntityTypeName, cap: number): boolean;
+declare function getEntityClass(kind: NameType | EntityTypeName): EntityClass;
+declare const ENTITY_SHIP: Name;
+declare const ENTITY_WAREHOUSE: Name;
+declare const ENTITY_EXTRACTOR: Name;
+declare const ENTITY_FACTORY: Name;
+declare const ENTITY_CONTAINER: Name;
+declare const ENTITY_NEXUS: Name;
+declare function isShip(entity: {
+    type?: Name;
+}): boolean;
+declare function isWarehouse(entity: {
+    type?: Name;
+}): boolean;
+declare function isExtractor(entity: {
+    type?: Name;
+}): boolean;
+declare function isFactory(entity: {
+    type?: Name;
+}): boolean;
+declare function isContainer(entity: {
+    type?: Name;
+}): boolean;
+declare function isNexus(entity: {
+    type?: Name;
+}): boolean;
+declare function isPlot(entity: {
+    type?: Name;
+}): boolean;
+
+declare class EntityInventory extends Types.cargo_item {
+    private _item?;
+    get item(): Item;
+    get good(): Item;
+    get name(): string;
+    get unitMass(): UInt32;
+    get totalMass(): UInt64;
+    get hasCargo(): boolean;
+    get isEmpty(): boolean;
 }
-declare function getCurrentEpoch(game: Types$1.game_row): UInt64;
-declare function getEpochInfo(game: Types$1.game_row, epoch: UInt64): EpochInfo;
 
-/**
- * GameState class extends the state_row from the server contract
- * with helper methods for epoch management and system generation
- */
-declare class GameState extends Types.state_row {
-    private _game?;
-    /**
-     * Create a GameState instance from a state_row
-     */
-    static from(state: Types.state_row, game?: Types$1.game_row): GameState;
-    /**
+interface MovementCapability {
+    engines: Types.movement_stats;
+    generator: Types.energy_stats;
+}
+interface EnergyCapability {
+    energy: UInt16;
+}
+interface StorageCapability {
+    capacity: UInt32;
+    cargomass: UInt32;
+    cargo: Types.cargo_item[];
+}
+interface LoaderCapability {
+    loaders: Types.loader_stats;
+}
+interface GathererCapability {
+    gatherer: Types.gatherer_stats;
+}
+interface MassCapability {
+    hullmass: UInt32;
+}
+interface ScheduleCapability {
+    lanes?: Types.lane[];
+    schedule?: Types.schedule;
+}
+interface EntityCapabilities {
+    hullmass?: UInt32;
+    capacity?: UInt32;
+    engines?: Types.movement_stats;
+    generator?: Types.energy_stats;
+    loaders?: Types.loader_stats;
+    gatherer?: Types.gatherer_stats;
+    crafter?: Types.crafter_stats;
+    hauler?: Types.hauler_stats;
+}
+interface EntityState {
+    owner: Name;
+    location: Types.coordinates;
+    energy?: UInt16;
+    cargomass: UInt32;
+    cargo: Types.cargo_item[];
+}
+declare function capsHasMovement(caps: EntityCapabilities): boolean;
+declare function capsHasStorage(caps: EntityCapabilities): boolean;
+declare function capsHasLoaders(caps: EntityCapabilities): boolean;
+declare function capsHasGatherer(caps: EntityCapabilities): boolean;
+declare function capsHasMass(caps: EntityCapabilities): boolean;
+declare function capsHasHauler(caps: EntityCapabilities): boolean;
+
+interface HasCargo {
+    cargo: Types.cargo_item[];
+}
+interface HasCapacity {
+    capacity: UInt32;
+}
+interface HasCargomass {
+    cargomass: UInt32;
+}
+interface MassInput {
+    item_id: UInt16;
+    quantity: UInt32;
+    modules: Types.module_entry[];
+}
+declare function calcCargoItemMass(item: MassInput): UInt64;
+declare function calcCargoMass(entity: HasCargo): UInt64;
+declare function calcStacksMass(stacks: CargoStack[]): UInt64;
+declare function availableCapacity$1(entity: StorageCapability): UInt64;
+declare function availableCapacityFromMass(capacity: UInt64Type, cargoMass: UInt64Type): UInt64;
+declare function hasSpace$1(entity: StorageCapability, goodMass: UInt64, quantity: number): boolean;
+declare function hasSpaceForMass(capacity: UInt64Type, currentMass: UInt64Type, additionalMass: UInt64Type): boolean;
+declare function isFull$1(entity: HasCapacity & HasCargomass): boolean;
+declare function isFullFromMass(capacity: UInt64Type, cargoMass: UInt64Type): boolean;
+interface CargoStack {
+    item_id: UInt16;
+    quantity: UInt32;
+    stats: UInt64;
+    modules: Types.module_entry[];
+}
+declare function cargoItemToStack(item: Types.cargo_item): CargoStack;
+declare function stackToCargoItem(stack: CargoStack): Types.cargo_item;
+declare function stackKey(s: CargoStack): string;
+declare function stacksEqual(a: CargoStack, b: CargoStack): boolean;
+declare function mergeStacks(stacks: CargoStack[], add: CargoStack): CargoStack[];
+declare function removeFromStacks(stacks: CargoStack[], remove: CargoStack): CargoStack[];
+declare function subtractFromStacks(stacks: CargoStack[], remove: CargoStack): CargoStack[];
+
+declare class InventoryAccessor {
+    private readonly entity;
+    private _items?;
+    constructor(entity: HasCargo);
+    get items(): EntityInventory[];
+    get totalMass(): UInt64;
+    forItem(goodId: UInt64Type): EntityInventory | undefined;
+    get sellable(): EntityInventory[];
+    get hasSellable(): boolean;
+    get sellableCount(): number;
+}
+declare function createInventoryAccessor(entity: HasCargo): InventoryAccessor;
+
+declare class Location {
+    readonly coordinates: Coordinates;
+    private _gameSeed?;
+    private _hasSystem?;
+    private _epoch?;
+    constructor(coordinates: CoordinatesType);
+    static from(coordinates: CoordinatesType): Location;
+    hasSystemAt(gameSeed: Checksum256Type): boolean;
+    getLocationTypeAt(gameSeed: Checksum256Type): LocationType;
+    isGatherableAt(gameSeed: Checksum256Type): boolean;
+    findNearby(gameSeed: Checksum256Type, maxDistance?: UInt16Type): Distance[];
+    equals(other: CoordinatesType | Location): boolean;
+    get epoch(): UInt64 | undefined;
+    clearCache(): void;
+}
+declare function toLocation(coords: CoordinatesType | Location): Location;
+
+type Schedule$2 = Types.schedule;
+declare function laneStartsIn(schedule: Schedule$2, now: Date): number;
+declare function currentTaskIndexForLane(schedule: Schedule$2, now: Date): number;
+declare function laneTaskComplete(schedule: Schedule$2, index: number, now: Date): boolean;
+declare function laneTaskInProgress(schedule: Schedule$2, index: number, now: Date): boolean;
+declare function laneCompletesAt(schedule: Schedule$2, index: number): Date;
+declare function currentTaskProgressFloatForLane(schedule: Schedule$2, now: Date): number;
+
+type Schedule$1 = Types.schedule;
+type Task$2 = Types.task;
+type Lane$1 = Types.lane;
+declare const LANE_MOBILITY = 0;
+declare const LANE_BARRIER = 255;
+interface ScheduleData {
+    lanes?: Lane$1[];
+}
+interface LaneView {
+    laneKey: number;
+    schedule: Schedule$1;
+}
+
+declare function getLanes(entity: ScheduleData): LaneView[];
+declare function getLane(entity: ScheduleData, laneKey: number): LaneView | undefined;
+declare function mobilityLane(entity: ScheduleData): LaneView | undefined;
+declare function hasSchedule$1(entity: ScheduleData): boolean;
+declare function isIdle(entity: ScheduleData): boolean;
+declare function isEntityIdle(entity: ScheduleData, now: Date): boolean;
+declare function entityIdleAt(entity: ScheduleData, _now: Date): Date | undefined;
+declare function getTasks(entity: ScheduleData): Task$2[];
+declare function scheduleDuration(entity: ScheduleData): number;
+declare function scheduleElapsed(entity: ScheduleData, now: Date): number;
+declare function scheduleRemaining(entity: ScheduleData, now: Date): number;
+declare function scheduleComplete(entity: ScheduleData, now: Date): boolean;
+declare function hasResolvable(entity: ScheduleData, now: Date): boolean;
+declare function currentTaskForLane(entity: ScheduleData, laneKey: number, now: Date): Task$2 | undefined;
+declare function currentTaskTypeForLane(entity: ScheduleData, laneKey: number, now: Date): TaskType | undefined;
+declare function activeTasks(entity: ScheduleData, now: Date): Task$2[];
+interface ResolvedEvent {
+    laneKey: number;
+    taskIndex: number;
+    task: Task$2;
+    completesAt: Date;
+}
+declare function resolveOrder(entity: ScheduleData, now: Date): ResolvedEvent[];
+interface OrderedTask {
+    laneKey: number;
+    taskIndex: number;
+    task: Task$2;
+    startsAt: Date;
+    completesAt: Date;
+}
+declare function orderedTasks(entity: ScheduleData): OrderedTask[];
+declare function laneRemainingOf(entity: ScheduleData, laneKey: number, now: Date): number;
+declare function laneStartsInOf(entity: ScheduleData, laneKey: number, now: Date): number;
+declare function laneCompleteOf(entity: ScheduleData, laneKey: number, now: Date): boolean;
+declare function laneProgressOf(entity: ScheduleData, laneKey: number, now: Date): number;
+declare function laneTaskElapsedOf(entity: ScheduleData, laneKey: number, index: number, now: Date): number;
+declare function laneTaskRemainingOf(entity: ScheduleData, laneKey: number, index: number, now: Date): number;
+declare function laneTaskCompleteOf(entity: ScheduleData, laneKey: number, index: number, now: Date): boolean;
+declare function laneTaskInProgressOf(entity: ScheduleData, laneKey: number, index: number, now: Date): boolean;
+declare function currentTaskIndexOf(entity: ScheduleData, laneKey: number, now: Date): number;
+declare function isInFlight(entity: ScheduleData, now: Date): boolean;
+declare function isRecharging(entity: ScheduleData, now: Date): boolean;
+declare function isLoading(entity: ScheduleData, now: Date): boolean;
+declare function isUnloading(entity: ScheduleData, now: Date): boolean;
+declare function isGathering(entity: ScheduleData, now: Date): boolean;
+
+declare const schedule_LANE_MOBILITY: typeof LANE_MOBILITY;
+declare const schedule_LANE_BARRIER: typeof LANE_BARRIER;
+type schedule_ScheduleData = ScheduleData;
+type schedule_LaneView = LaneView;
+declare const schedule_getLanes: typeof getLanes;
+declare const schedule_getLane: typeof getLane;
+declare const schedule_mobilityLane: typeof mobilityLane;
+declare const schedule_isIdle: typeof isIdle;
+declare const schedule_isEntityIdle: typeof isEntityIdle;
+declare const schedule_entityIdleAt: typeof entityIdleAt;
+declare const schedule_getTasks: typeof getTasks;
+declare const schedule_scheduleDuration: typeof scheduleDuration;
+declare const schedule_scheduleElapsed: typeof scheduleElapsed;
+declare const schedule_scheduleRemaining: typeof scheduleRemaining;
+declare const schedule_scheduleComplete: typeof scheduleComplete;
+declare const schedule_hasResolvable: typeof hasResolvable;
+declare const schedule_currentTaskForLane: typeof currentTaskForLane;
+declare const schedule_currentTaskTypeForLane: typeof currentTaskTypeForLane;
+declare const schedule_activeTasks: typeof activeTasks;
+type schedule_ResolvedEvent = ResolvedEvent;
+declare const schedule_resolveOrder: typeof resolveOrder;
+type schedule_OrderedTask = OrderedTask;
+declare const schedule_orderedTasks: typeof orderedTasks;
+declare const schedule_laneRemainingOf: typeof laneRemainingOf;
+declare const schedule_laneStartsInOf: typeof laneStartsInOf;
+declare const schedule_laneCompleteOf: typeof laneCompleteOf;
+declare const schedule_laneProgressOf: typeof laneProgressOf;
+declare const schedule_laneTaskElapsedOf: typeof laneTaskElapsedOf;
+declare const schedule_laneTaskRemainingOf: typeof laneTaskRemainingOf;
+declare const schedule_laneTaskCompleteOf: typeof laneTaskCompleteOf;
+declare const schedule_laneTaskInProgressOf: typeof laneTaskInProgressOf;
+declare const schedule_currentTaskIndexOf: typeof currentTaskIndexOf;
+declare const schedule_isInFlight: typeof isInFlight;
+declare const schedule_isRecharging: typeof isRecharging;
+declare const schedule_isLoading: typeof isLoading;
+declare const schedule_isUnloading: typeof isUnloading;
+declare const schedule_isGathering: typeof isGathering;
+declare const schedule_laneStartsIn: typeof laneStartsIn;
+declare const schedule_currentTaskIndexForLane: typeof currentTaskIndexForLane;
+declare const schedule_laneTaskComplete: typeof laneTaskComplete;
+declare const schedule_laneTaskInProgress: typeof laneTaskInProgress;
+declare const schedule_laneCompletesAt: typeof laneCompletesAt;
+declare const schedule_currentTaskProgressFloatForLane: typeof currentTaskProgressFloatForLane;
+declare namespace schedule {
+  export {
+    schedule_LANE_MOBILITY as LANE_MOBILITY,
+    schedule_LANE_BARRIER as LANE_BARRIER,
+    schedule_ScheduleData as ScheduleData,
+    schedule_LaneView as LaneView,
+    schedule_getLanes as getLanes,
+    schedule_getLane as getLane,
+    schedule_mobilityLane as mobilityLane,
+    hasSchedule$1 as hasSchedule,
+    schedule_isIdle as isIdle,
+    schedule_isEntityIdle as isEntityIdle,
+    schedule_entityIdleAt as entityIdleAt,
+    schedule_getTasks as getTasks,
+    schedule_scheduleDuration as scheduleDuration,
+    schedule_scheduleElapsed as scheduleElapsed,
+    schedule_scheduleRemaining as scheduleRemaining,
+    schedule_scheduleComplete as scheduleComplete,
+    schedule_hasResolvable as hasResolvable,
+    schedule_currentTaskForLane as currentTaskForLane,
+    schedule_currentTaskTypeForLane as currentTaskTypeForLane,
+    schedule_activeTasks as activeTasks,
+    schedule_ResolvedEvent as ResolvedEvent,
+    schedule_resolveOrder as resolveOrder,
+    schedule_OrderedTask as OrderedTask,
+    schedule_orderedTasks as orderedTasks,
+    schedule_laneRemainingOf as laneRemainingOf,
+    schedule_laneStartsInOf as laneStartsInOf,
+    schedule_laneCompleteOf as laneCompleteOf,
+    schedule_laneProgressOf as laneProgressOf,
+    schedule_laneTaskElapsedOf as laneTaskElapsedOf,
+    schedule_laneTaskRemainingOf as laneTaskRemainingOf,
+    schedule_laneTaskCompleteOf as laneTaskCompleteOf,
+    schedule_laneTaskInProgressOf as laneTaskInProgressOf,
+    schedule_currentTaskIndexOf as currentTaskIndexOf,
+    schedule_isInFlight as isInFlight,
+    schedule_isRecharging as isRecharging,
+    schedule_isLoading as isLoading,
+    schedule_isUnloading as isUnloading,
+    schedule_isGathering as isGathering,
+    schedule_laneStartsIn as laneStartsIn,
+    schedule_currentTaskIndexForLane as currentTaskIndexForLane,
+    schedule_laneTaskComplete as laneTaskComplete,
+    schedule_laneTaskInProgress as laneTaskInProgress,
+    schedule_laneCompletesAt as laneCompletesAt,
+    schedule_currentTaskProgressFloatForLane as currentTaskProgressFloatForLane,
+  };
+}
+
+type Task$1 = Types.task;
+declare class ScheduleAccessor {
+    private entity;
+    private laneKey;
+    private _laneResolved;
+    private _lane;
+    constructor(entity: ScheduleData, laneKey?: number);
+    private get lane();
+    forLane(laneKey: number): ScheduleAccessor;
+    get lanes(): LaneView[];
+    get hasSchedule(): boolean;
+    get isIdle(): boolean;
+    get tasks(): Task$1[];
+    activeTasks(now: Date): Task$1[];
+    duration(): number;
+    elapsed(now: Date): number;
+    remaining(now: Date): number;
+    startsIn(now: Date): number;
+    complete(now: Date): boolean;
+    currentTaskIndex(now: Date): number;
+    currentTask(now: Date): Task$1 | undefined;
+    currentTaskType(now: Date): TaskType | undefined;
+    taskStartTime(index: number): number;
+    taskElapsed(index: number, now: Date): number;
+    taskRemaining(index: number, now: Date): number;
+    taskComplete(index: number, now: Date): boolean;
+    taskInProgress(index: number, now: Date): boolean;
+    currentTaskProgress(now: Date): number;
+    currentTaskProgressFloat(now: Date): number;
+    progress(now: Date): number;
+}
+declare function createScheduleAccessor(entity: ScheduleData, laneKey?: number): ScheduleAccessor;
+
+declare class Entity$1 extends Types.entity_info {
+    private _sched?;
+    private _inv?;
+    get name(): string;
+    get location(): Location;
+    get isIdle(): boolean;
+    get sched(): ScheduleAccessor;
+    get inv(): InventoryAccessor;
+    get inventory(): EntityInventory[];
+    get totalCargoMass(): UInt64;
+    get maxCapacity(): UInt64;
+    get availableCapacity(): UInt64;
+    get isFull(): boolean;
+    get totalMass(): UInt64;
+    get entityClass(): EntityClass;
+    get canWrap(): boolean;
+    get canUndeploy(): boolean;
+    get canDemolish(): boolean;
+    get canUseModules(): boolean;
+    isLoading(now: Date): boolean;
+    isUnloading(now: Date): boolean;
+}
+
+interface EpochInfo {
+    epoch: UInt64;
+    start: Date;
+    end: Date;
+}
+declare function getCurrentEpoch(game: Types$1.game_row): UInt64;
+declare function getEpochInfo(game: Types$1.game_row, epoch: UInt64): EpochInfo;
+
+/**
+ * GameState class extends the state_row from the server contract
+ * with helper methods for epoch management and system generation
+ */
+declare class GameState extends Types.state_row {
+    private _game?;
+    /**
+     * Create a GameState instance from a state_row
+     */
+    static from(state: Types.state_row, game?: Types$1.game_row): GameState;
+    /**
      * Set the game configuration (needed for epoch calculations)
      */
     setGame(game: Types$1.game_row): void;
@@ -1630,18 +2462,6 @@ declare class GameState extends Types.state_row {
      * Check if the game is currently enabled
      */
     get isEnabled(): boolean;
-    /**
-     * Get the total number of ships in the game
-     */
-    get shipCount(): number;
-    /**
-     * Get the current salt value (used for random number generation)
-     */
-    get currentSalt(): UInt64;
-    /**
-     * Get the commit hash for the next epoch
-     */
-    get nextEpochCommit(): Checksum256;
     /**
      * Calculate the current epoch from game config (if game is set)
      * This might differ from state.epoch if the blockchain hasn't advanced yet
@@ -1670,9 +2490,7 @@ declare class GameState extends Types.state_row {
     get summary(): {
         enabled: boolean;
         epoch: string;
-        ships: number;
         hasSeed: boolean;
-        hasCommit: boolean;
     };
 }
 
@@ -1726,12 +2544,15 @@ declare function deriveStrata(coords: CoordinatesType, gameSeed: Checksum256Type
 declare function deriveLocationSize(loc: Types.location_static): number;
 
 declare const DEPTH_THRESHOLD_T1 = 0;
-declare const DEPTH_THRESHOLD_T2 = 2000;
-declare const DEPTH_THRESHOLD_T3 = 10000;
-declare const DEPTH_THRESHOLD_T4 = 30000;
-declare const DEPTH_THRESHOLD_T5 = 55000;
+declare const DEPTH_THRESHOLD_T2 = 1500;
+declare const DEPTH_THRESHOLD_T3 = 5000;
+declare const DEPTH_THRESHOLD_T4 = 12000;
+declare const DEPTH_THRESHOLD_T5 = 22000;
 declare const LOCATION_MIN_DEPTH = 500;
 declare const LOCATION_MAX_DEPTH = 65535;
+declare const YIELD_FRACTION_SHALLOW = 0.0025;
+declare const YIELD_FRACTION_DEEP = 0.0005;
+declare function yieldThresholdAt(stratum: number): number;
 declare const PLANET_SUBTYPE_GAS_GIANT = 0;
 declare const PLANET_SUBTYPE_ROCKY = 1;
 declare const PLANET_SUBTYPE_TERRESTRIAL = 2;
@@ -1741,6 +2562,11 @@ declare const PLANET_SUBTYPE_INDUSTRIAL = 5;
 declare function getDepthThreshold(tier: number): number;
 declare function getResourceTier(itemId: number): number;
 declare function getResourceWeight(itemId: number, stratum: number): number;
+interface LocationProfileEntry {
+    category: number;
+    maxTier: number;
+}
+declare function getLocationProfile(locationType: number, subtype: number): LocationProfileEntry[];
 declare function getLocationCandidates(locationType: number, subtype: number): number[];
 declare function getEligibleResources(locationType: number, subtype: number, stratum: number): number[];
 
@@ -1752,7 +2578,15 @@ interface TierRange {
 declare const RESERVE_TIERS: Record<ReserveTier, TierRange>;
 declare const TIER_ROLL_MAX = 65536;
 declare function rollTier(tierRoll: number, stratum: number): ReserveTier;
-declare function rollWithinTier(withinRoll: number, range: TierRange): number;
+declare function rollWithinTier(withinRoll: number, range: TierRange, resourceUnitMass: number): number;
+declare function tierOfReserve(reserve: number, itemId: number): ReserveTier | null;
+
+interface EffectiveReserveInput {
+    remaining: UInt32 | number;
+    max_reserve: UInt32 | number;
+    last_block: BlockTimestamp;
+}
+declare function getEffectiveReserve(row: EffectiveReserveInput, now: BlockTimestamp, epochSeconds: number): number;
 
 interface StatDefinition {
     key: string;
@@ -1825,55 +2659,102 @@ declare function computeCraftedOutputStats(outputItemId: number, slotInputs: Rec
  * returns a UInt64 whose bit-packed form matches what the contract writes
  * to cargo_item.stats on gather.
  *
- * Use this whenever off-chain code simulates a gather (testmap, player
+ * Use this whenever off-chain code simulates a gather (webapp, player
  * scanners that project cargo outcomes) and needs a value that matches
  * what on-chain cargo would carry.
  */
 declare function encodeGatheredCargoStats(depositSeed: bigint): UInt64;
 
+declare const STAR_STEP = 250;
+declare const MAX_STARS_PER_STAT = 3;
+declare const MAX_STAR_RATING: number;
+declare function starsForStat(value: number): number;
+declare function starRating(stat1: number, stat2: number, stat3: number): number;
+declare function statMagnitude(stat1: number, stat2: number, stat3: number): number;
+
 interface LocationStratum extends DerivedStratum {
     reserveMax: number;
 }
 declare class LocationsManager extends BaseManager {
     hasSystem(location: CoordinatesType): Promise<boolean>;
     findNearbyPlanets(origin: CoordinatesType, maxDistance?: UInt16Type): Promise<Distance[]>;
-    getStrata(coords: CoordinatesType): Promise<LocationStratum[]>;
-    getLocationEntity(id: UInt64Type): Promise<Types.location_row | undefined>;
-    getLocationEntityAt(coords: CoordinatesType): Promise<Types.location_row | undefined>;
-    getAllLocationEntities(): Promise<Types.location_row[]>;
+    getStrata(coords: CoordinatesType, now?: BlockTimestamp): Promise<LocationStratum[]>;
 }
 
 declare class EpochsManager extends BaseManager {
     getCurrentHeight(): Promise<UInt64>;
+    getFinalizedEpoch(reload?: boolean): Promise<UInt64>;
     getCurrent(): Promise<EpochInfo>;
     getByHeight(height: UInt64Type): Promise<EpochInfo>;
     getTimeRemaining(): Promise<number>;
     getProgress(): Promise<number>;
     fitsInCurrentEpoch(durationMs: number): Promise<boolean>;
+    getEpochRow(epoch: UInt64Type): Promise<Types.epoch_row | undefined>;
+    getActiveEpochInfo(): Promise<Types.epoch_row | undefined>;
+    getOracles(): Promise<Types.oracle_row[]>;
+    getThreshold(): Promise<number>;
+    getCommitsFor(epoch: UInt64Type): Promise<Types.commit_row[]>;
+    getRevealsFor(epoch: UInt64Type): Promise<Types.reveal_row[]>;
 }
 
 type EntityRefInput = {
-    entityType: EntityTypeName;
+    entityType: NameType;
     entityId: UInt64Type;
 };
 declare class ActionsManager extends BaseManager {
     travel(shipId: UInt64Type, destination: CoordinatesType, recharge?: boolean): Action;
     grouptravel(entities: EntityRefInput[], destination: CoordinatesType, recharge?: boolean): Action;
-    resolve(entityId: UInt64Type, entityType?: EntityTypeName, count?: UInt64Type): Action;
-    cancel(entityId: UInt64Type, count: UInt64Type, entityType?: EntityTypeName): Action;
-    recharge(entityId: UInt64Type, entityType?: EntityTypeName): Action;
-    transfer(sourceType: EntityTypeName, sourceId: UInt64Type, destType: EntityTypeName, destId: UInt64Type, itemId: UInt64Type, stats: UInt64Type, quantity: UInt64Type): Action;
+    resolve(entityId: UInt64Type, count?: UInt64Type): Action;
+    cancel(entityId: UInt64Type, laneKey: number, count: UInt64Type): Action;
+    retarget(sourceId: UInt64Type, taskIndex: UInt64Type, newDestId: UInt64Type): Action;
+    recharge(entityId: UInt64Type): Action;
+    rename(entityId: UInt64Type, name: string): Action;
+    refrshentity(entityId: UInt64Type): Action;
+    transfer(sourceId: UInt64Type, destId: UInt64Type, items: ActionParams.Type.cargo_item[]): Action;
     foundCompany(account: NameType, name: string): Action;
     join(account: NameType): Action;
-    gather(source: EntityRefInput, destination: EntityRefInput, stratum: UInt16Type, quantity: UInt32Type): Action;
-    warp(entityId: UInt64Type, destination: CoordinatesType, entityType?: EntityTypeName): Action;
-    craft(entityType: EntityTypeName, entityId: UInt64Type, recipeId: number, quantity: number, inputs: ActionParams.Type.cargo_item[]): Action;
-    blend(entityType: EntityTypeName, entityId: UInt64Type, inputs: ActionParams.Type.cargo_item[]): Action;
-    deploy(entityType: EntityTypeName, entityId: UInt64Type, packedItemId: number, stats: bigint): Action;
-    addmodule(entityType: EntityTypeName, entityId: UInt64Type, moduleIndex: number, moduleCargoId: UInt64Type, targetCargoId?: UInt64Type): Action;
-    rmmodule(entityType: EntityTypeName, entityId: UInt64Type, moduleIndex: number, targetCargoId?: UInt64Type): Action;
-    wrap(owner: NameType, entityType: EntityTypeName, entityId: UInt64Type, cargoId: UInt64Type, quantity: UInt64Type): Action;
+    gather(sourceId: UInt64Type, destinationId: UInt64Type, stratum: UInt16Type, quantity: UInt32Type): Action;
+    warp(entityId: UInt64Type, destination: CoordinatesType): Action;
+    craft(entityId: UInt64Type, recipeId: number, quantity: number, inputs: ActionParams.Type.cargo_item[]): Action;
+    blend(entityId: UInt64Type, inputs: ActionParams.Type.cargo_item[]): Action;
+    deploy(entityId: UInt64Type, ref: ActionParams.Type.cargo_ref): Action;
+    claimplot(entityId: UInt64Type, targetItemId: UInt16Type, coords: ActionParams.Type.coordinates): Action;
+    buildplot(entityId: UInt64Type, plotId: UInt64Type): Action;
+    addmodule(entityId: UInt64Type, moduleIndex: number, moduleRef: ActionParams.Type.cargo_ref, targetRef?: ActionParams.Type.cargo_ref | null): Action;
+    rmmodule(entityId: UInt64Type, moduleIndex: number, targetRef?: ActionParams.Type.cargo_ref | null): Action;
+    swapmodule(entityId: UInt64Type, moduleIndex: number, moduleRef: ActionParams.Type.cargo_ref): Action;
+    wrap(owner: NameType, entityId: UInt64Type, nexusId: UInt64Type, cargoId: UInt64Type, quantity: UInt64Type, opts?: {
+        claimRam?: boolean;
+    }): Promise<Action[]>;
+    undeploy(hostId: UInt64Type, targetId: UInt64Type): Action;
+    claimStarter(owner: NameType): Action;
+    wrapEntity(owner: NameType, entityId: UInt64Type, nexusId: UInt64Type, opts?: {
+        claimRam?: boolean;
+    }): Promise<Action[]>;
+    placecargo(owner: NameType, hostId: UInt64Type, assetId: UInt64Type): Action;
+    placeentity(owner: NameType, assetId: UInt64Type, targetNexusId: UInt64Type): Action;
+    transferForUnwrap(owner: NameType, assetId: UInt64Type): Action;
+    unwrapCargoTx(owner: NameType, assetId: UInt64Type, hostId: UInt64Type): Action[];
+    unwrapEntityTx(owner: NameType, assetId: UInt64Type, targetNexusId: UInt64Type): Action[];
+    setRamPayer(newPayer: NameType, assetId: UInt64Type): Action;
+    setLastPayer(owner: NameType, collectionName: NameType): Action;
+    demolish(entityId: UInt64Type): Action;
     joinGame(account: NameType, companyName: string): Action[];
+    commit(oracleId: NameType, epoch: UInt64Type, commit: Checksum256Type): Action;
+    reveal(oracleId: NameType, epoch: UInt64Type, reveal: Checksum256Type): Action;
+    addoracle(oracleId: NameType): Action;
+    removeoracle(oracleId: NameType): Action;
+    setthreshold(threshold: UInt8Type): Action;
+    cleanrsvp(epoch: UInt64Type, maxRows: UInt64Type): Action;
+}
+
+interface NftConfigForItem {
+    templateId: number;
+    schemaName: string;
+}
+declare class NftManager extends BaseManager {
+    private cache;
+    getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined>;
 }
 
 type EntityInfo = Types.entity_info;
@@ -1907,7 +2788,7 @@ type UnsubscribeMessage = {
 type SubscribeEntityMessage = {
     type: 'subscribe_entity';
     sub_id: string;
-    entity_type: 'ship' | 'warehouse' | 'container';
+    entity_type: 'ship' | 'warehouse' | 'container' | 'nexus';
     entity_id: string;
 };
 type UnsubscribeEntityMessage = {
@@ -1919,510 +2800,71 @@ type SubscribeEventsMessage = {
     sub_id: string;
     event_filter?: Record<string, unknown>;
 };
-type UnsubscribeEventsMessage = {
-    type: 'unsubscribe_events';
-    sub_id: string;
-};
-type PingMessage = {
-    type: 'ping';
-};
-type ClientMessage = SubscribeMessage | UpdateBoundsMessage | UnsubscribeMessage | SubscribeEntityMessage | UnsubscribeEntityMessage | SubscribeEventsMessage | UnsubscribeEventsMessage | PingMessage;
-type AckMessage = {
-    type: 'subscribed' | 'unsubscribed' | 'bounds_updated';
-    sub_id: string;
-};
-type WireEntity = Record<string, unknown> & {
-    type: number;
-    type_name: 'ship' | 'warehouse' | 'container';
-    id: string | number;
-    owner: string;
-    coordinates: WireCoordinates;
-};
-type SnapshotMessage = {
-    type: 'snapshot';
-    sub_id: string;
-    seq: number;
-    entities: WireEntity[];
-    truncated?: boolean;
-};
-type UpdateMessage = {
-    type: 'update';
-    sub_ids: string[];
-    entity_id: number;
-    entity: WireEntity;
-    seq: number;
-};
-type BoundsDeltaMessage = {
-    type: 'bounds_delta';
-    sub_id: string;
-    entered: WireEntity[];
-    exited: number[];
-    seq: number;
-    truncated?: boolean;
-};
-type EventMessage = {
-    type: 'event';
-    sub_id: string;
-    catchup: boolean;
-    events: Array<Record<string, unknown>>;
-    seq?: number;
-};
-type EventCatchupCompleteMessage = {
-    type: 'event_catchup_complete';
-    sub_id: string;
-};
-type PongMessage = {
-    type: 'pong';
-};
-type ErrorMessage = {
-    type: 'error';
-    error: string;
-    sub_id?: string;
-};
-type ServerMessage = AckMessage | SnapshotMessage | UpdateMessage | BoundsDeltaMessage | EventMessage | EventCatchupCompleteMessage | PongMessage | ErrorMessage;
-
-interface MovementCapability {
-    engines: Types.movement_stats;
-    generator: Types.energy_stats;
-}
-interface EnergyCapability {
-    energy: UInt16;
-}
-interface StorageCapability {
-    capacity: UInt32;
-    cargomass: UInt32;
-    cargo: Types.cargo_item[];
-}
-interface LoaderCapability {
-    loaders: Types.loader_stats;
-}
-interface GathererCapability {
-    gatherer: Types.gatherer_stats;
-}
-interface MassCapability {
-    hullmass: UInt32;
-}
-interface ScheduleCapability {
-    schedule?: Types.schedule;
-}
-interface EntityCapabilities {
-    hullmass?: UInt32;
-    capacity?: UInt32;
-    engines?: Types.movement_stats;
-    generator?: Types.energy_stats;
-    loaders?: Types.loader_stats;
-    gatherer?: Types.gatherer_stats;
-    crafter?: Types.crafter_stats;
-    hauler?: Types.hauler_stats;
-}
-interface EntityState {
-    owner: Name;
-    location: Types.coordinates;
-    energy?: UInt16;
-    cargomass: UInt32;
-    cargo: Types.cargo_item[];
-}
-declare function capsHasMovement(caps: EntityCapabilities): boolean;
-declare function capsHasStorage(caps: EntityCapabilities): boolean;
-declare function capsHasLoaders(caps: EntityCapabilities): boolean;
-declare function capsHasGatherer(caps: EntityCapabilities): boolean;
-declare function capsHasMass(caps: EntityCapabilities): boolean;
-declare function capsHasHauler(caps: EntityCapabilities): boolean;
-
-interface HasCargo {
-    cargo: Types.cargo_item[];
-}
-interface HasCapacity {
-    capacity: UInt32;
-}
-interface HasCargomass {
-    cargomass: UInt32;
-}
-interface MassInput {
-    item_id: UInt16;
-    quantity: UInt32;
-    modules: Types.module_entry[];
-}
-declare function calcCargoItemMass(item: MassInput): UInt64;
-declare function calcCargoMass(entity: HasCargo): UInt64;
-declare function calcStacksMass(stacks: CargoStack[]): UInt64;
-declare function availableCapacity$1(entity: StorageCapability): UInt64;
-declare function availableCapacityFromMass(capacity: UInt64Type, cargoMass: UInt64Type): UInt64;
-declare function hasSpace$1(entity: StorageCapability, goodMass: UInt64, quantity: number): boolean;
-declare function hasSpaceForMass(capacity: UInt64Type, currentMass: UInt64Type, additionalMass: UInt64Type): boolean;
-declare function isFull$1(entity: HasCapacity & HasCargomass): boolean;
-declare function isFullFromMass(capacity: UInt64Type, cargoMass: UInt64Type): boolean;
-interface CargoStack {
-    item_id: UInt16;
-    quantity: UInt32;
-    stats: UInt64;
-    modules: Types.module_entry[];
-}
-declare function cargoItemToStack(item: Types.cargo_item): CargoStack;
-declare function stackToCargoItem(stack: CargoStack): Types.cargo_item;
-declare function stackKey(s: CargoStack): string;
-declare function stacksEqual(a: CargoStack, b: CargoStack): boolean;
-declare function mergeStacks(stacks: CargoStack[], add: CargoStack): CargoStack[];
-declare function removeFromStacks(stacks: CargoStack[], remove: CargoStack): CargoStack[];
-
-type Schedule = Types.schedule;
-type Task$1 = Types.task;
-interface ScheduleData {
-    schedule?: Schedule;
-}
-interface Scheduleable extends ScheduleData {
-    hasSchedule: boolean;
-    isIdle: boolean;
-    tasks: Task$1[];
-    scheduleDuration(): number;
-    scheduleElapsed(now: Date): number;
-    scheduleRemaining(now: Date): number;
-    scheduleComplete(now: Date): boolean;
-    currentTaskIndex(now: Date): number;
-    currentTask(now: Date): Task$1 | undefined;
-    currentTaskType(now: Date): TaskType | undefined;
-    getTaskStartTime(index: number): number;
-    getTaskElapsed(index: number, now: Date): number;
-    getTaskRemaining(index: number, now: Date): number;
-    isTaskComplete(index: number, now: Date): boolean;
-    isTaskInProgress(index: number, now: Date): boolean;
-    currentTaskProgress(now: Date): number;
-    scheduleProgress(now: Date): number;
-}
-declare function hasSchedule$1(entity: ScheduleData): boolean;
-declare function isIdle(entity: ScheduleData): boolean;
-declare function getTasks(entity: ScheduleData): Task$1[];
-declare function scheduleDuration(entity: ScheduleData): number;
-declare function scheduleElapsed(entity: ScheduleData, now: Date): number;
-declare function scheduleRemaining(entity: ScheduleData, now: Date): number;
-declare function scheduleComplete(entity: ScheduleData, now: Date): boolean;
-declare function currentTaskIndex(entity: ScheduleData, now: Date): number;
-declare function currentTask(entity: ScheduleData, now: Date): Task$1 | undefined;
-declare function currentTaskType(entity: ScheduleData, now: Date): TaskType | undefined;
-declare function getTaskStartTime(entity: ScheduleData, index: number): number;
-declare function getTaskElapsed(entity: ScheduleData, index: number, now: Date): number;
-declare function getTaskRemaining(entity: ScheduleData, index: number, now: Date): number;
-declare function isTaskComplete(entity: ScheduleData, index: number, now: Date): boolean;
-declare function isTaskInProgress(entity: ScheduleData, index: number, now: Date): boolean;
-declare function currentTaskProgress(entity: ScheduleData, now: Date): number;
-declare function scheduleProgress(entity: ScheduleData, now: Date): number;
-declare function isTaskType(entity: ScheduleData, taskType: TaskType, now: Date): boolean;
-declare function isInFlight(entity: ScheduleData, now: Date): boolean;
-declare function isRecharging(entity: ScheduleData, now: Date): boolean;
-declare function isLoading(entity: ScheduleData, now: Date): boolean;
-declare function isUnloading(entity: ScheduleData, now: Date): boolean;
-declare function isGathering(entity: ScheduleData, now: Date): boolean;
-
-type schedule_ScheduleData = ScheduleData;
-type schedule_Scheduleable = Scheduleable;
-declare const schedule_isIdle: typeof isIdle;
-declare const schedule_getTasks: typeof getTasks;
-declare const schedule_scheduleDuration: typeof scheduleDuration;
-declare const schedule_scheduleElapsed: typeof scheduleElapsed;
-declare const schedule_scheduleRemaining: typeof scheduleRemaining;
-declare const schedule_scheduleComplete: typeof scheduleComplete;
-declare const schedule_currentTaskIndex: typeof currentTaskIndex;
-declare const schedule_currentTask: typeof currentTask;
-declare const schedule_currentTaskType: typeof currentTaskType;
-declare const schedule_getTaskStartTime: typeof getTaskStartTime;
-declare const schedule_getTaskElapsed: typeof getTaskElapsed;
-declare const schedule_getTaskRemaining: typeof getTaskRemaining;
-declare const schedule_isTaskComplete: typeof isTaskComplete;
-declare const schedule_isTaskInProgress: typeof isTaskInProgress;
-declare const schedule_currentTaskProgress: typeof currentTaskProgress;
-declare const schedule_scheduleProgress: typeof scheduleProgress;
-declare const schedule_isTaskType: typeof isTaskType;
-declare const schedule_isInFlight: typeof isInFlight;
-declare const schedule_isRecharging: typeof isRecharging;
-declare const schedule_isLoading: typeof isLoading;
-declare const schedule_isUnloading: typeof isUnloading;
-declare const schedule_isGathering: typeof isGathering;
-declare namespace schedule {
-  export {
-    schedule_ScheduleData as ScheduleData,
-    schedule_Scheduleable as Scheduleable,
-    hasSchedule$1 as hasSchedule,
-    schedule_isIdle as isIdle,
-    schedule_getTasks as getTasks,
-    schedule_scheduleDuration as scheduleDuration,
-    schedule_scheduleElapsed as scheduleElapsed,
-    schedule_scheduleRemaining as scheduleRemaining,
-    schedule_scheduleComplete as scheduleComplete,
-    schedule_currentTaskIndex as currentTaskIndex,
-    schedule_currentTask as currentTask,
-    schedule_currentTaskType as currentTaskType,
-    schedule_getTaskStartTime as getTaskStartTime,
-    schedule_getTaskElapsed as getTaskElapsed,
-    schedule_getTaskRemaining as getTaskRemaining,
-    schedule_isTaskComplete as isTaskComplete,
-    schedule_isTaskInProgress as isTaskInProgress,
-    schedule_currentTaskProgress as currentTaskProgress,
-    schedule_scheduleProgress as scheduleProgress,
-    schedule_isTaskType as isTaskType,
-    schedule_isInFlight as isInFlight,
-    schedule_isRecharging as isRecharging,
-    schedule_isLoading as isLoading,
-    schedule_isUnloading as isUnloading,
-    schedule_isGathering as isGathering,
-  };
-}
-
-interface ProjectedEntity {
-    location: Coordinates;
-    energy: UInt16;
-    cargo: CargoStack[];
-    shipMass: UInt32;
-    capacity?: UInt64;
-    engines?: Types.movement_stats;
-    loaders?: Types.loader_stats;
-    generator?: Types.energy_stats;
-    hauler?: Types.hauler_stats;
-    readonly cargoMass: UInt64;
-    readonly totalMass: UInt64;
-    hasMovement(): boolean;
-    hasStorage(): boolean;
-    hasLoaders(): boolean;
-    capabilities(): EntityCapabilities;
-    state(): EntityState;
-}
-interface Projectable extends ScheduleData {
-    coordinates: Coordinates | Types.coordinates;
-    energy?: UInt16;
-    hullmass?: UInt32;
-    generator?: Types.energy_stats;
-    engines?: Types.movement_stats;
-    loaders?: Types.loader_stats;
-    hauler?: Types.hauler_stats;
-    capacity?: UInt32;
-    cargo: Types.cargo_item[];
-    cargomass: UInt32;
-    owner?: Name;
-}
-declare function createProjectedEntity(entity: Projectable): ProjectedEntity;
-interface ProjectionOptions {
-    upToTaskIndex?: number;
-}
-declare function projectEntity(entity: Projectable, options?: ProjectionOptions): ProjectedEntity;
-interface ProjectableSnapshot extends Projectable {
-    current_task?: Types.task;
-    pending_tasks?: Types.task[];
-}
-declare function projectFromCurrentState(snapshot: ProjectableSnapshot): ProjectedEntity;
-declare function validateSchedule(entity: Projectable): void;
-declare function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity;
-declare function projectFromCurrentStateAt(snapshot: ProjectableSnapshot, now: Date): ProjectedEntity;
-
-declare class Location {
-    readonly coordinates: Coordinates;
-    private _gameSeed?;
-    private _hasSystem?;
-    private _epoch?;
-    constructor(coordinates: CoordinatesType);
-    static from(coordinates: CoordinatesType): Location;
-    hasSystemAt(gameSeed: Checksum256Type): boolean;
-    getLocationTypeAt(gameSeed: Checksum256Type): LocationType;
-    isGatherableAt(gameSeed: Checksum256Type): boolean;
-    findNearby(gameSeed: Checksum256Type, maxDistance?: UInt16Type): Distance[];
-    equals(other: CoordinatesType | Location): boolean;
-    get epoch(): UInt64 | undefined;
-    clearCache(): void;
-}
-declare function toLocation(coords: CoordinatesType | Location): Location;
-
-type Task = Types.task;
-declare class ScheduleAccessor {
-    private entity;
-    constructor(entity: ScheduleData);
-    get hasSchedule(): boolean;
-    get isIdle(): boolean;
-    get tasks(): Task[];
-    duration(): number;
-    elapsed(now: Date): number;
-    remaining(now: Date): number;
-    complete(now: Date): boolean;
-    currentTaskIndex(now: Date): number;
-    currentTask(now: Date): Task | undefined;
-    currentTaskType(now: Date): TaskType | undefined;
-    taskStartTime(index: number): number;
-    taskElapsed(index: number, now: Date): number;
-    taskRemaining(index: number, now: Date): number;
-    taskComplete(index: number, now: Date): boolean;
-    taskInProgress(index: number, now: Date): boolean;
-    currentTaskProgress(now: Date): number;
-    progress(now: Date): number;
-}
-declare function createScheduleAccessor(entity: ScheduleData): ScheduleAccessor;
-
-declare class EntityInventory extends Types.cargo_item {
-    private _item?;
-    get item(): Item;
-    get good(): Item;
-    get name(): string;
-    get unitMass(): UInt32;
-    get totalMass(): UInt64;
-    get hasCargo(): boolean;
-    get isEmpty(): boolean;
-}
-
-declare class InventoryAccessor {
-    private readonly entity;
-    private _items?;
-    constructor(entity: HasCargo);
-    get items(): EntityInventory[];
-    get totalMass(): UInt64;
-    forItem(goodId: UInt64Type): EntityInventory | undefined;
-    get sellable(): EntityInventory[];
-    get hasSellable(): boolean;
-    get sellableCount(): number;
-}
-declare function createInventoryAccessor(entity: HasCargo): InventoryAccessor;
-
-interface PackedModuleInput {
-    itemId: UInt16Type;
-    stats: UInt64Type;
-}
-interface ShipStateInput {
-    id: UInt64Type;
-    owner: string;
-    name: string;
-    coordinates: CoordinatesType | {
-        x: number;
-        y: number;
-        z?: number;
-    };
-    hullmass?: number;
-    capacity?: number;
-    energy?: number;
-    modules?: PackedModuleInput[];
-    schedule?: Types.schedule;
-    cargo?: Types.cargo_item[];
-}
-declare class Ship extends Types.entity_info {
-    private _sched?;
-    private _inv?;
-    get name(): string;
-    get inv(): InventoryAccessor;
-    get inventory(): EntityInventory[];
-    get sched(): ScheduleAccessor;
-    get maxDistance(): UInt32;
-    get isIdle(): boolean;
-    getFlightOrigin(flightTaskIndex: number): Coordinates;
-    destinationLocation(): Coordinates | undefined;
-    positionAt(now: Date): Coordinates;
-    isInFlight(now: Date): boolean;
-    isRecharging(now: Date): boolean;
-    isLoading(now: Date): boolean;
-    isUnloading(now: Date): boolean;
-    isGathering(now: Date): boolean;
-    get hasEngines(): boolean;
-    get hasGenerator(): boolean;
-    get hasGatherer(): boolean;
-    get hasWarp(): boolean;
-    project(): ProjectedEntity;
-    projectAt(now: Date): ProjectedEntity;
-    get location(): Location;
-    get totalCargoMass(): UInt64;
-    get totalMass(): UInt64;
-    get maxCapacity(): UInt64;
-    hasSpace(goodMass: UInt64, quantity: number): boolean;
-    get availableCapacity(): UInt64;
-    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined;
-    get sellableCargo(): EntityInventory[];
-    get hasSellableCargo(): boolean;
-    get sellableGoodsCount(): number;
-    get isFull(): boolean;
-    get energyPercent(): number;
-    get needsRecharge(): boolean;
-    hasEnergyFor(distance: UInt64): boolean;
-}
-
-interface WarehouseStateInput {
-    id: UInt64Type;
-    owner: string;
-    name: string;
-    coordinates: CoordinatesType | {
-        x: number;
-        y: number;
-        z?: number;
-    };
-    hullmass?: number;
-    capacity: number;
-    modules?: PackedModuleInput[];
-    schedule?: Types.schedule;
-    cargo?: Types.cargo_item[];
-}
-declare class Warehouse extends Types.entity_info {
-    private _sched?;
-    private _inv?;
-    get name(): string;
-    get inv(): InventoryAccessor;
-    get inventory(): EntityInventory[];
-    get sched(): ScheduleAccessor;
-    get isIdle(): boolean;
-    isLoading(now: Date): boolean;
-    isUnloading(now: Date): boolean;
-    get location(): Location;
-    get totalCargoMass(): UInt64;
-    get maxCapacity(): UInt64;
-    get availableCapacity(): UInt64;
-    hasSpace(goodMass: UInt64, quantity: number): boolean;
-    get isFull(): boolean;
-    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined;
-    get orbitalAltitude(): number;
-    get totalMass(): UInt64;
-}
-declare function computeWarehouseCapabilities(modules: {
-    itemId: number;
-    stats: bigint;
-}[]): {
-    loaders?: {
-        mass: number;
-        thrust: number;
-        quantity: number;
-    };
-};
-
-interface ContainerStateInput {
-    id: UInt64Type;
+type UnsubscribeEventsMessage = {
+    type: 'unsubscribe_events';
+    sub_id: string;
+};
+type PingMessage = {
+    type: 'ping';
+};
+type ClientMessage = SubscribeMessage | UpdateBoundsMessage | UnsubscribeMessage | SubscribeEntityMessage | UnsubscribeEntityMessage | SubscribeEventsMessage | UnsubscribeEventsMessage | PingMessage;
+type AckMessage = {
+    type: 'subscribed' | 'unsubscribed' | 'bounds_updated';
+    sub_id: string;
+};
+type WireEntity = Record<string, unknown> & {
+    type: number;
+    type_name: 'ship' | 'warehouse' | 'container' | 'nexus';
+    id: string | number;
     owner: string;
-    name: string;
-    coordinates: CoordinatesType | {
-        x: number;
-        y: number;
-        z?: number;
-    };
-    hullmass: number;
-    capacity: number;
-    cargomass?: number;
-    cargo?: Types.cargo_item[];
-    schedule?: Types.schedule;
-}
-declare class Container extends Types.entity_info {
-    private _sched?;
-    get name(): string;
-    get sched(): ScheduleAccessor;
-    get isIdle(): boolean;
-    isLoading(now: Date): boolean;
-    isUnloading(now: Date): boolean;
-    get location(): Location;
-    get totalMass(): UInt64;
-    get maxCapacity(): UInt64;
-    get availableCapacity(): UInt64;
-    hasSpace(additionalMass: UInt64): boolean;
-    get isFull(): boolean;
-    get orbitalAltitude(): number;
-}
-declare function computeContainerCapabilities(stats: Record<string, number>): {
-    hullmass: number;
-    capacity: number;
+    coordinates: WireCoordinates;
+    item_id: number;
 };
-declare function computeContainerT2Capabilities(stats: Record<string, number>): {
-    hullmass: number;
-    capacity: number;
+type SnapshotMessage = {
+    type: 'snapshot';
+    sub_id: string;
+    seq: number;
+    entities: WireEntity[];
+    truncated?: boolean;
+};
+type UpdateMessage = {
+    type: 'update';
+    sub_ids: string[];
+    entity_id: number;
+    entity: WireEntity;
+    seq: number;
+};
+type BoundsDeltaMessage = {
+    type: 'bounds_delta';
+    sub_id: string;
+    entered: WireEntity[];
+    exited: number[];
+    seq: number;
+    truncated?: boolean;
+};
+type EventMessage = {
+    type: 'event';
+    sub_id: string;
+    catchup: boolean;
+    events: Array<Record<string, unknown>>;
+    seq?: number;
+};
+type EventCatchupCompleteMessage = {
+    type: 'event_catchup_complete';
+    sub_id: string;
 };
+type PongMessage = {
+    type: 'pong';
+};
+type ErrorMessage = {
+    type: 'error';
+    error: string;
+    sub_id?: string;
+};
+type ServerMessage = AckMessage | SnapshotMessage | UpdateMessage | BoundsDeltaMessage | EventMessage | EventCatchupCompleteMessage | PongMessage | ErrorMessage;
 
-type SubscriptionEntityType = 'ship' | 'warehouse' | 'container';
-type EntityInstance = Ship | Warehouse | Container;
+type SubscriptionEntityType = 'ship' | 'warehouse' | 'container' | 'nexus';
+type EntityInstance = Entity$1;
 interface SubscriptionsOptions {
     url: string;
     minReconnectDelay?: number;
@@ -2435,6 +2877,11 @@ interface BoundsSubscriptionHandle {
     updateBounds(bounds: BoundingBox): void;
     current: Map<number, EntityInstance>;
 }
+interface OwnerSubscriptionHandle {
+    readonly subId: string;
+    unsubscribe(): void;
+    current: Map<number, EntityInstance>;
+}
 interface EntitySubscriptionHandle {
     readonly subId: string;
     readonly entityType: SubscriptionEntityType;
@@ -2461,6 +2908,10 @@ declare class SubscriptionsManager {
         owner?: string;
         prioritizeOwner?: string;
     }): BoundsSubscriptionHandle;
+    subscribeOwner(owner: string, handlers?: {
+        onSnapshot?: (entities: EntityInstance[]) => void;
+        onUpdate?: (entity: EntityInstance) => void;
+    }): OwnerSubscriptionHandle;
     private unsubscribeBounds;
     private updateBounds;
     private onStateChange;
@@ -2476,21 +2927,24 @@ declare class GameContext {
     readonly client: APIClient;
     readonly server: Contract$2;
     readonly platform: Contract$2;
+    readonly atomicAssetsAccount: string;
     private _entities?;
     private _players?;
     private _locations?;
     private _epochs?;
     private _actions?;
+    private _nft?;
     private _subscriptions?;
     private _subscriptionsUrl?;
     private _gameCache?;
     private _stateCache?;
-    constructor(client: APIClient, server: Contract$2, platform: Contract$2);
+    constructor(client: APIClient, server: Contract$2, platform: Contract$2, atomicAssetsAccount?: string);
     get entities(): EntitiesManager;
     get players(): PlayersManager;
     get locations(): LocationsManager;
     get epochs(): EpochsManager;
     get actions(): ActionsManager;
+    get nft(): NftManager;
     setSubscriptionsUrl(url: string): void;
     get subscriptions(): SubscriptionsManager;
     getGame(reload?: boolean): Promise<Types$1.game_row>;
@@ -2505,25 +2959,16 @@ declare abstract class BaseManager {
     protected get client(): _wharfkit_antelope.APIClient;
     protected get server(): _wharfkit_contract.Contract;
     protected get platform(): _wharfkit_contract.Contract;
+    protected get atomicAssetsAccount(): string;
     protected getGame(): Promise<Types$1.game_row>;
-    protected getState(): Promise<GameState>;
+    protected getState(reload?: boolean): Promise<GameState>;
 }
 
-type EntityType = 'ship' | 'warehouse' | 'container' | 'location';
 declare class EntitiesManager extends BaseManager {
-    getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse | Container>;
-    getEntities(owner: NameType | Types.player_row, type?: EntityType): Promise<(Ship | Warehouse | Container)[]>;
-    getSummaries(owner: NameType | Types.player_row, type?: EntityType): Promise<Types.entity_summary[]>;
-    getShip(id: UInt64Type): Promise<Ship>;
-    getWarehouse(id: UInt64Type): Promise<Warehouse>;
-    getContainer(id: UInt64Type): Promise<Container>;
-    getShips(owner: NameType | Types.player_row): Promise<Ship[]>;
-    getWarehouses(owner: NameType | Types.player_row): Promise<Warehouse[]>;
-    getContainers(owner: NameType | Types.player_row): Promise<Container[]>;
-    getShipSummaries(owner: NameType | Types.player_row): Promise<Types.entity_summary[]>;
-    getWarehouseSummaries(owner: NameType | Types.player_row): Promise<Types.entity_summary[]>;
-    getContainerSummaries(owner: NameType | Types.player_row): Promise<Types.entity_summary[]>;
-    private wrapEntity;
+    getEntity(id: UInt64Type): Promise<Entity$1>;
+    getProjection(id: UInt64Type, taskCount?: number): Promise<unknown>;
+    getEntities(owner: NameType | Types.player_row, kind?: EntityTypeName): Promise<Entity$1[]>;
+    getSummaries(owner: NameType | Types.player_row, kind?: EntityTypeName): Promise<Types.entity_summary[]>;
     private resolveOwner;
 }
 
@@ -2532,6 +2977,7 @@ interface ShiploadOptions {
     serverContractName?: string;
     client?: APIClient;
     subscriptionsUrl?: string;
+    atomicAssetsAccount?: string;
 }
 interface ShiploadConstructorOptions extends ShiploadOptions {
     platformContract?: Contract$2;
@@ -2542,6 +2988,7 @@ declare class Shipload {
     constructor(chain: ChainDefinition, constructorOptions?: ShiploadConstructorOptions);
     static load(chain: ChainDefinition, shiploadOptions?: ShiploadOptions): Promise<Shipload>;
     get client(): APIClient;
+    get atomicAssetsAccount(): string;
     get server(): Contract$2;
     get platform(): Contract$2;
     get entities(): EntitiesManager;
@@ -2549,14 +2996,144 @@ declare class Shipload {
     get locations(): LocationsManager;
     get epochs(): EpochsManager;
     get actions(): ActionsManager;
+    get nft(): NftManager;
     get subscriptions(): SubscriptionsManager;
     getGame(reload?: boolean): Promise<Types$1.game_row>;
     getState(reload?: boolean): Promise<GameState>;
 }
 
-declare function makeShip(state: ShipStateInput): Ship;
-declare function makeWarehouse(state: WarehouseStateInput): Warehouse;
-declare function makeContainer(state: ContainerStateInput): Container;
+interface PackedModuleInput {
+    itemId: number;
+    stats: bigint;
+}
+interface EntityStateInput {
+    id: UInt64Type;
+    owner: NameType;
+    name: string;
+    coordinates: {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    itemId?: number;
+    hullmass?: number;
+    capacity?: number;
+    cargomass?: number;
+    energy?: number;
+    modules?: PackedModuleInput[];
+    schedule?: Types.schedule;
+    lanes?: Types.lane[];
+    cargo?: Types.cargo_item[];
+}
+declare function makeEntity(packedItemId: number, state: EntityStateInput): Entity$1;
+
+interface InstalledModule {
+    slotIndex: number;
+    itemId: number;
+    stats: bigint;
+}
+
+type BuildState = 'initializing' | 'accepting' | 'ready' | 'scheduled' | 'finalizing';
+type FinalizerCapability = 'crafter';
+interface BuildableTarget {
+    entityId: UInt64;
+    ownerName: Name;
+    coordinates: Types.coordinates;
+    targetItemId: number;
+    targetItem: Item;
+    state: BuildState;
+    recipe: Recipe;
+    progress: PlotProgress;
+    finalizeAction: Name;
+    finalizerCapability: FinalizerCapability;
+    activeTask?: Types.task;
+    scheduledBuild?: ScheduledBuild;
+}
+interface SourceEntityRef {
+    entityId: UInt64;
+    name: string;
+    hasLoaders: boolean;
+    loaderCount: number;
+    loaderTotalMass: number;
+    relevantCargo: SourceCargoStack[];
+}
+interface SourceCargoStack {
+    key: string;
+    rowId: UInt64;
+    itemId: number;
+    item: Item;
+    stats: UInt64;
+    modules: Types.module_entry[];
+    available: number;
+    plotNeeds: number;
+    reserved: number;
+}
+interface FinalizerEntityRef {
+    entityId: UInt64;
+    name: string;
+    capability: FinalizerCapability;
+    crafterSpeed: number;
+    estimatedDuration: UInt32;
+}
+interface InboundTransfer {
+    sourceEntityId: UInt64;
+    sourceEntityType: Name;
+    sourceName: string;
+    itemId: number;
+    quantity: number;
+    etaSeconds: number;
+}
+interface ScheduledBuild {
+    shipId: UInt64;
+    shipName: string;
+    hasStarted: boolean;
+    startsAt: number;
+    completesAt: number;
+    cancelable: boolean;
+    blockingTaskCount: number;
+}
+interface Reservation {
+    targetEntityId: UInt64;
+    targetEntityType: Name;
+    itemId: number;
+    quantity: number;
+}
+
+interface PlotProgressInputRow {
+    itemId: number;
+    required: number;
+    provided: number;
+    missing: number;
+}
+interface PlotProgress {
+    targetItemId: number;
+    rows: PlotProgressInputRow[];
+    massProvided: number;
+    massRequired: number;
+    isComplete: boolean;
+}
+
+declare class ConstructionManager extends BaseManager {
+    private readonly plot;
+    getTarget(entity: Types.entity_row, cargo: Types.cargo_row[], activeTask?: Types.task, scheduledBuild?: ScheduledBuild): BuildableTarget | null;
+    eligibleSources(target: BuildableTarget, entities: Types.entity_info[], cargo: Types.cargo_row[]): SourceEntityRef[];
+    unreachableSources(target: BuildableTarget, entities: Types.entity_info[], cargo: Types.cargo_row[]): SourceEntityRef[];
+    partitionSources(target: BuildableTarget, entities: Types.entity_info[], cargo: Types.cargo_row[]): {
+        eligible: SourceEntityRef[];
+        unreachable: SourceEntityRef[];
+    };
+    eligibleFinalizers(target: BuildableTarget, entities: Types.entity_info[]): FinalizerEntityRef[];
+    inboundTransfersTo(plotId: UInt64, entities: Types.entity_info[], now: Date): InboundTransfer[];
+    inboundTransfersByTarget(entities: Types.entity_info[], now: Date): Map<string, InboundTransfer[]>;
+    private plotReservation;
+    private builderCancelability;
+    private buildFromReservation;
+    scheduledBuildFor(plot: Types.entity_info, entities: Types.entity_info[], now: Date): ScheduledBuild | null;
+    scheduledBuildsByTarget(entities: Types.entity_info[], now: Date): Map<string, ScheduledBuild>;
+    reservationsFrom(sourceEntityId: UInt64, entities: Types.entity_info[]): Reservation[];
+    estimateFinalizeDuration(target: BuildableTarget, crafterSpeed: number): UInt32;
+    static isConstructionKind(kind: string): boolean;
+}
 
 declare const itemIds: number[];
 declare function getItem(itemId: UInt16Type): Item;
@@ -2578,7 +3155,6 @@ declare function getEntityItems(opts?: {
 declare function resolveItemCategory(id: number): ResourceCategory | undefined;
 declare function typeLabel(type: ItemType | number): string;
 declare function categoryLabel(cat: ResourceCategory): string;
-declare function tierLabel(tier: number): string;
 declare function categoryFromIndex(i: number): ResourceCategory | undefined;
 declare function categoryLabelFromIndex(i: number): string;
 
@@ -2588,12 +3164,20 @@ declare function getLocationTypeName(type: LocationType): string;
 declare function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string;
 declare function hasSystem(gameSeed: Checksum256Type, coordinates: CoordinatesType): boolean;
 declare function deriveLocationStatic(gameSeed: Checksum256Type, coordinates: CoordinatesType): Types.location_static;
-declare function deriveLocationEpoch(epochSeed: Checksum256Type, coordinates: CoordinatesType): Types.location_epoch;
-declare function deriveLocation(gameSeed: Checksum256Type, epochSeed: Checksum256Type, coordinates: CoordinatesType): Types.location_derived;
+declare function isLocationBuildable(gameSeed: Checksum256Type, coordinates: CoordinatesType): boolean;
+declare function deriveLocation(gameSeed: Checksum256Type, coordinates: CoordinatesType): Types.location_derived;
 
 declare function hash(seed: Checksum256Type, string: string): Checksum256;
 declare function hash512(seed: Checksum256Type, string: string): Checksum512;
 
+interface DisplayNameResult {
+    valid: boolean;
+    reason?: string;
+    name: string;
+}
+declare function normalizeDisplayName(input: string): string;
+declare function validateDisplayName(input: string): DisplayNameResult;
+
 /**
  * Travel calculations for ship movement, energy usage, and flight times.
  *
@@ -2610,6 +3194,22 @@ declare function calc_orbital_altitude(mass: number): number;
 declare function distanceBetweenCoordinates(origin: ActionParams.Type.coordinates, destination: ActionParams.Type.coordinates): UInt64;
 declare function distanceBetweenPoints(x1: Int64Type, y1: Int64Type, x2: Int64Type, y2: Int64Type): UInt64;
 declare function lerp(origin: ActionParams.Type.coordinates, destination: ActionParams.Type.coordinates, time: number): ActionParams.Type.coordinates;
+interface FloatPosition {
+    x: number;
+    y: number;
+}
+declare function easeFlightProgress(t: number): number;
+declare function flightSpeedFactor(t: number): number;
+declare function interpolateFlightPosition(origin: {
+    x: Int64Type | number;
+    y: Int64Type | number;
+}, destination: {
+    x: Int64Type | number;
+    y: Int64Type | number;
+}, taskProgress: number, options?: {
+    easing?: 'physics' | 'linear';
+}): FloatPosition;
+declare function getInterpolatedPosition(entity: HasScheduleAndLocation, taskIndex: number, taskProgress: number): FloatPosition;
 declare function rotation(origin: ActionParams.Type.coordinates, destination: ActionParams.Type.coordinates): number;
 declare function findNearbyPlanets(seed: Checksum256, origin: ActionParams.Type.coordinates, maxDistance?: UInt64Type): Distance[];
 declare function calc_rechargetime(capacity: UInt32Type, energy: UInt32Type, recharge: UInt32Type): UInt32;
@@ -2654,6 +3254,7 @@ interface TransferEntity {
             toNumber(): number;
         } | number;
     };
+    entityClass: EntityClass;
     loaders?: {
         thrust: {
             toNumber(): number;
@@ -2666,15 +3267,23 @@ interface TransferEntity {
         } | number;
     };
 }
-interface HasScheduleAndLocation {
+interface HasScheduleAndLocation extends ScheduleData {
     coordinates: ActionParams.Type.coordinates;
-    schedule?: Types.schedule;
 }
 declare function getFlightOrigin(entity: HasScheduleAndLocation, flightTaskIndex: number): ActionParams.Type.coordinates;
 declare function getDestinationLocation(entity: HasScheduleAndLocation): ActionParams.Type.coordinates | undefined;
+/** Returns chain-tile coordinates (rounded). For visual position use getInterpolatedPosition. */
 declare function getPositionAt(entity: HasScheduleAndLocation, taskIndex: number, taskProgress: number): ActionParams.Type.coordinates;
 declare function calc_transfer_duration(source: TransferEntity, dest: TransferEntity, cargoMass: number): number;
 
+type ModuleEntry$2 = Types.module_entry;
+type Lane = Types.lane;
+type Schedule = Types.schedule;
+declare function laneKeyForModule(slotIndex: number): number;
+declare function workerLaneKey(modules: ModuleEntry$2[], moduleSubtype: ModuleType, lanes: Lane[]): number;
+declare function rawScheduleEnd(schedule: Schedule): Date;
+declare function candidateLaneCompletesAt(entity: ScheduleData, laneKey: number, durationSec: number, now: Date): Date;
+
 interface CargoData {
     cargo: EntityInventory[];
 }
@@ -2710,6 +3319,94 @@ declare namespace cargoUtils {
   };
 }
 
+declare function cargoRef(src: {
+    item_id: number;
+    stats: bigint | number;
+    modules?: Types.module_entry[];
+}): ActionParams.Type.cargo_ref;
+declare function cargoItem(src: {
+    item_id: number;
+    stats: bigint | number;
+    modules?: Types.module_entry[];
+}, quantity: bigint | number): ActionParams.Type.cargo_item;
+
+interface ProjectedEntity {
+    location: Coordinates;
+    energy: UInt16;
+    cargo: CargoStack[];
+    shipMass: UInt32;
+    capacity?: UInt64;
+    engines?: Types.movement_stats;
+    loaders?: Types.loader_stats;
+    generator?: Types.energy_stats;
+    hauler?: Types.hauler_stats;
+    readonly cargoMass: UInt64;
+    readonly totalMass: UInt64;
+    hasMovement(): boolean;
+    hasStorage(): boolean;
+    hasLoaders(): boolean;
+    capabilities(): EntityCapabilities;
+    state(): EntityState;
+}
+interface Projectable extends ScheduleData {
+    coordinates: Coordinates | Types.coordinates;
+    energy?: UInt16;
+    hullmass?: UInt32;
+    generator?: Types.energy_stats;
+    engines?: Types.movement_stats;
+    loaders?: Types.loader_stats;
+    hauler?: Types.hauler_stats;
+    capacity?: UInt32;
+    cargo: Types.cargo_item[];
+    cargomass: UInt32;
+    owner?: Name;
+    stats?: bigint;
+    item_id?: number | UInt16;
+    modules?: Types.module_entry[] | InstalledModule[];
+}
+declare function createProjectedEntity(entity: Projectable): ProjectedEntity;
+interface ProjectionOptions {
+    upToTaskIndex?: number;
+}
+declare function projectEntity(entity: Projectable, options?: ProjectionOptions): ProjectedEntity;
+declare function projectRemainingAt(entity: Projectable, _now: Date): ProjectedEntity;
+declare function validateSchedule(entity: Projectable): void;
+declare function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity;
+
+type TaskCargoDirection = 'in' | 'out';
+interface TaskCargoChange {
+    direction: TaskCargoDirection;
+    item_id: number;
+    stats: bigint;
+    modules: Types.module_entry[];
+    quantity: number;
+}
+declare function taskCargoChanges(task: Types.task): TaskCargoChange[];
+
+type Task = Types.task;
+type CargoItem$1 = Types.cargo_item;
+interface CargoEffect {
+    added: CargoItem$1[];
+    removed: CargoItem$1[];
+}
+interface AvailabilityInput extends ScheduleData {
+    cargo: CargoItem$1[];
+}
+declare function taskCargoEffect(task: Task): CargoEffect;
+declare function projectedCargoAvailableAt(entity: AvailabilityInput, at: Date): Map<string, bigint>;
+declare function cargoReadyAt(entity: AvailabilityInput, inputItemIds: readonly number[]): Date;
+declare function availableForItem(avail: Map<string, bigint>, itemId: number): bigint;
+
+type CargoItem = Types.cargo_item;
+type ModuleEntry$1 = Types.module_entry;
+interface CraftableEntity extends ScheduleData {
+    cargo: CargoItem[];
+    modules: ModuleEntry$1[];
+}
+declare function maxCraftable(entity: CraftableEntity, recipe: Recipe, crafterSpeed: number, now: Date): number;
+
+declare function energyAtTime(entity: Projectable, now: Date): number;
+
 interface Entity {
     id: UInt64;
     type: Name;
@@ -2737,9 +3434,12 @@ declare function calcEnergyUsage(entity: MovementCapability, distance: UInt64):
 declare function energyPercent(entity: MovementCapability & EnergyCapability): number;
 declare function needsRecharge(entity: MovementCapability & EnergyCapability): boolean;
 
-declare function calcLoadDuration(entity: LoaderCapability, cargoMass: UInt64): UInt32;
-
 declare function calc_gather_duration(gatherer: Types.gatherer_stats, itemMass: number, quantity: number, stratum: number, richness: number): UInt32;
+declare function calc_gather_rate(gatherer: Types.gatherer_stats, itemMass: number, stratum: number, richness: number): {
+    unitsPerSec: number;
+    unitsPerMin: number;
+    secPerUnit: number;
+};
 declare function calc_gather_energy(gatherer: Types.gatherer_stats, duration: number): UInt16;
 
 interface CrafterCapability {
@@ -2747,7 +3447,7 @@ interface CrafterCapability {
 }
 declare function capsHasCrafter(caps: EntityCapabilities): boolean;
 declare function calc_craft_duration(speed: number, totalInputMass: number): UInt32;
-declare function calc_craft_energy(drain: number, totalInputMass: number): UInt16;
+declare function calc_craft_energy(drain: number, totalInputMass: number): UInt32;
 
 declare const MODULE_ANY = 0;
 declare const MODULE_ENGINE = 1;
@@ -2759,6 +3459,7 @@ declare const MODULE_CRAFTER = 6;
 declare const MODULE_LAUNCHER = 7;
 declare const MODULE_STORAGE = 8;
 declare const MODULE_HAULER = 9;
+declare const MODULE_BATTERY = 10;
 interface PackedModule {
     itemId: number;
     stats: bigint;
@@ -2773,14 +3474,10 @@ declare function isModuleItem(itemId: number): boolean;
 declare function moduleSlotTypeToCode(slotType: string): number;
 
 declare function computeHaulPenalty(totalThrust: number, haulCount: number, avgEfficiency: number): number;
-declare function computeHaulerDrain(distance: number, drain: number, haulCount: number): number;
+declare function computeHaulerDrain$1(distance: number, drain: number, haulCount: number): number;
 
 declare const categoryColors: Record<ResourceCategory, string>;
 declare const tierColors: Record<number, string>;
-declare const tierLabels: Record<number, string>;
-declare const categoryIcons: Record<ResourceCategory, string>;
-type CategoryIconShape = 'hex' | 'diamond' | 'star' | 'circle' | 'square';
-declare const categoryIconShapes: Record<ResourceCategory, CategoryIconShape>;
 declare const componentIcon = "\u25A3";
 declare const moduleIcon = "\u2B22";
 declare const itemAbbreviations: Record<number, string>;
@@ -2825,17 +3522,34 @@ interface StatMapping {
     stat: string;
     capability: string;
     attribute: string;
-    rationale: string;
 }
 declare const capabilityNames: string[];
 declare const capabilityAttributes: CapabilityAttribute[];
-declare const statMappings: StatMapping[];
 declare function isInvertedAttribute(attribute: string): boolean;
 declare function getCapabilityAttributes(capability?: string): CapabilityAttribute[];
+
+interface SlotConsumer {
+    capability: string;
+    attribute: string;
+}
+type SlotConsumerKind = 'engine' | 'generator' | 'gatherer' | 'loader' | 'crafter' | 'storage' | 'hauler' | 'warp' | 'battery' | 'ship-t1' | 'container-t1' | 'warehouse-t1' | 'extractor-t1' | 'container-t2';
+declare const SLOT_FORMULAS: Record<SlotConsumerKind, Record<number, SlotConsumer>>;
+
+declare function deriveStatMappings(): StatMapping[];
 declare function getStatMappings(): StatMapping[];
 declare function getStatMappingsForStat(stat: string): StatMapping[];
 declare function getStatMappingsForCapability(capability: string): StatMapping[];
 
+type BuildMethod = 'craft+deploy' | 'plot';
+declare function availableBuildMethods(itemId: number): BuildMethod[];
+declare function isBuildable(itemId: number): boolean;
+declare function isPlotBuildable(itemId: number): boolean;
+declare function filterByBuildMethod<T extends {
+    itemId: number;
+}>(items: T[], method: BuildMethod): T[];
+declare function allBuildableItems(): Item[];
+declare function allPlotBuildableItems(): Item[];
+
 declare function computeShipHullCapabilities(stats: Record<string, number>): {
     hullmass: number;
     capacity: number;
@@ -2848,11 +3562,17 @@ declare function computeGeneratorCapabilities(stats: Record<string, number>): {
     capacity: number;
     recharge: number;
 };
-declare function computeGathererCapabilities(stats: Record<string, number>): {
+interface GathererDepthParams {
+    readonly floor: number;
+    readonly slope: number;
+}
+declare const GATHERER_DEPTH_TABLE: readonly GathererDepthParams[];
+declare const GATHERER_DEPTH_MAX_TIER = 10;
+declare function gathererDepthForTier(tol: number, tier: number): number;
+declare function computeGathererCapabilities(stats: Record<string, number>, tier: number): {
     yield: number;
     drain: number;
     depth: number;
-    speed: number;
 };
 declare function computeLoaderCapabilities(stats: Record<string, number>): {
     mass: number;
@@ -2871,11 +3591,18 @@ declare function computeHaulerCapabilities(stats: Record<string, number>): {
 declare function computeStorageCapabilities(stats: Record<string, number>, baseCapacity: number): {
     capacityBonus: number;
 };
+
+declare function computeBaseCapacity(itemId: number, stats: Record<string, number>): number;
+declare function computeWarpCapabilities(stats: Record<string, number>): {
+    range: number;
+};
 declare function computeWarehouseHullCapabilities(stats: Record<string, number>): {
     hullmass: number;
     capacity: number;
 };
-interface ShipCapabilities {
+interface ComputedCapabilities {
+    hullmass: number;
+    capacity: number;
     engines?: {
         thrust: number;
         drain: number;
@@ -2888,12 +3615,6 @@ interface ShipCapabilities {
         yield: number;
         drain: number;
         depth: number;
-        speed: number;
-    };
-    hauler?: {
-        capacity: number;
-        efficiency: number;
-        drain: number;
     };
     loaders?: {
         mass: number;
@@ -2904,11 +3625,24 @@ interface ShipCapabilities {
         speed: number;
         drain: number;
     };
+    hauler?: {
+        capacity: number;
+        efficiency: number;
+        drain: number;
+    };
+    warp?: {
+        range: number;
+    };
 }
-declare function computeShipCapabilities(modules: {
-    itemId: number;
-    stats: bigint;
-}[]): ShipCapabilities;
+declare function computeEntityCapabilities(stats: Record<string, number>, itemId: number, modules: InstalledModule[], layout: EntitySlot[]): ComputedCapabilities;
+declare function computeContainerCapabilities(stats: Record<string, number>): {
+    hullmass: number;
+    capacity: number;
+};
+declare function computeContainerT2Capabilities(stats: Record<string, number>): {
+    hullmass: number;
+    capacity: number;
+};
 
 interface ResolvedItemStat {
     key: string;
@@ -3009,22 +3743,104 @@ declare function computeBaseCapacityShip(stats: bigint): number;
 declare function computeBaseCapacityWarehouse(stats: bigint): number;
 declare const computeEngineThrust: (vol: number) => number;
 declare const computeEngineDrain: (thm: number) => number;
-declare const computeGeneratorCap: (res: number) => number;
-declare const computeGeneratorRech: (ref: number) => number;
+declare const computeGeneratorCap: (com: number) => number;
+declare const computeGeneratorRech: (fin: number) => number;
 declare const computeGathererYield: (str: number) => number;
 declare const computeGathererDrain: (con: number) => number;
-declare const computeGathererDepth: (tol: number) => number;
-declare const computeGathererSpeed: (ref: number) => number;
-declare const computeLoaderMass: (fin: number) => number;
+declare const computeGathererDepth: (tol: number, tier: number) => number;
+declare const computeLoaderMass: (ins: number) => number;
 declare const computeLoaderThrust: (pla: number) => number;
 declare const computeCrafterSpeed: (rea: number) => number;
-declare const computeCrafterDrain: (com: number) => number;
+declare const computeCrafterDrain: (fin: number) => number;
+declare const computeHaulerCapacity: (fin: number) => number;
+declare const computeHaulerEfficiency: (con: number) => number;
+declare const computeHaulerDrain: (com: number) => number;
 declare const computeWarpRange: (stat: number) => number;
 declare function entityDisplayName(itemId: number): string;
 declare function moduleDisplayName(itemId: number): string;
 declare function formatModuleLine(slot: number, itemId: number, stats: bigint): string;
 declare function buildEntityDescription(itemId: number, hullStats: bigint, moduleItems: number[], moduleStats: bigint[]): string;
 
+interface SchemaField {
+    name: string;
+    type: string;
+}
+type RawData = Uint8Array | string | number[] | {
+    immutable_serialized_data: Uint8Array | string | number[];
+};
+declare function deserializeAtomicData(data: RawData, schema: SchemaField[]): Record<string, unknown>;
+
+type AtomicAttributeType = 'string' | 'uint8' | 'uint16' | 'uint32' | 'uint64' | 'int32' | 'image' | 'ipfs' | 'UINT16_VEC' | 'UINT64_VEC';
+interface ImmutableEntry {
+    first: string;
+    second: [AtomicAttributeType, unknown];
+}
+interface ImmutableModuleSlot {
+    type?: number | string | bigint;
+    installed?: {
+        item_id: number | string | bigint;
+        stats: number | string | bigint;
+    };
+}
+declare function moduleSlotsForImmutable(modules: Types.module_entry[]): ImmutableModuleSlot[];
+declare function computeNftImageUrl(item: {
+    item_id: number;
+    stats: bigint;
+    modules: ImmutableModuleSlot[];
+    quantity: number;
+}, originX: number, originY: number): string;
+declare function buildResourceImmutable(itemId: number, quantity: number, stats: bigint, originX: number, originY: number): ImmutableEntry[];
+declare function buildComponentImmutable(itemId: number, quantity: number, stats: bigint, originX: number, originY: number): ImmutableEntry[];
+declare function buildModuleImmutable(itemId: number, quantity: number, stats: bigint, originX: number, originY: number): ImmutableEntry[];
+declare function buildEntityImmutable(itemId: number, quantity: number, stats: bigint, originX: number, originY: number, modules: ImmutableModuleSlot[]): ImmutableEntry[];
+declare function buildImmutableData(itemId: number, quantity: number, stats: bigint, originX: number, originY: number, modules?: ImmutableModuleSlot[]): ImmutableEntry[];
+
+declare const ATOMICASSETS_ACCOUNT = "atomicassets";
+declare const SHIPLOAD_COLLECTION = "shipload";
+declare const ATOMICASSETS_ABI: ABI;
+interface MintAssetParams {
+    authorizedMinter: NameType;
+    collectionName: NameType;
+    schemaName: NameType;
+    templateId: number;
+    newAssetOwner: NameType;
+    immutableData: ImmutableEntry[];
+}
+declare function buildMintAssetAction(params: MintAssetParams): Action;
+interface AtomicAssetRow {
+    asset_id: string;
+    collection_name: string;
+    schema_name: string;
+    template_id: number;
+    ram_payer?: string;
+    backed_tokens?: string[];
+    immutable_serialized_data: string | number[];
+    mutable_serialized_data?: string | number[];
+}
+interface AtomicSchemaRow {
+    schema_name: string;
+    format: SchemaField[];
+}
+interface FetchAssetsOptions {
+    collection?: NameType;
+    pageSize?: number;
+    account?: NameType;
+}
+declare function fetchAtomicAssetsForOwner(client: APIClient, owner: NameType, opts?: FetchAssetsOptions): Promise<AtomicAssetRow[]>;
+declare function fetchAtomicSchemas(client: APIClient, collection: NameType, account?: NameType): Promise<AtomicSchemaRow[]>;
+interface DecodedAtomicAsset {
+    asset_id: bigint;
+    schema_name: string;
+    template_id: number;
+    item_id: number;
+    quantity: number;
+    stats: string;
+    origin_x: bigint;
+    origin_y: bigint;
+    modules?: NFTModuleSlot[];
+}
+declare function decodeAtomicAsset(asset: AtomicAssetRow, schemaFormat: SchemaField[], itemId: number): DecodedAtomicAsset;
+
 type index_NFTInstalledModule = NFTInstalledModule;
 type index_NFTModuleSlot = NFTModuleSlot;
 type index_NFTCargoItem = NFTCargoItem;
@@ -3046,16 +3862,43 @@ declare const index_computeGeneratorRech: typeof computeGeneratorRech;
 declare const index_computeGathererYield: typeof computeGathererYield;
 declare const index_computeGathererDrain: typeof computeGathererDrain;
 declare const index_computeGathererDepth: typeof computeGathererDepth;
-declare const index_computeGathererSpeed: typeof computeGathererSpeed;
 declare const index_computeLoaderMass: typeof computeLoaderMass;
 declare const index_computeLoaderThrust: typeof computeLoaderThrust;
 declare const index_computeCrafterSpeed: typeof computeCrafterSpeed;
 declare const index_computeCrafterDrain: typeof computeCrafterDrain;
+declare const index_computeHaulerCapacity: typeof computeHaulerCapacity;
+declare const index_computeHaulerEfficiency: typeof computeHaulerEfficiency;
+declare const index_computeHaulerDrain: typeof computeHaulerDrain;
 declare const index_computeWarpRange: typeof computeWarpRange;
 declare const index_entityDisplayName: typeof entityDisplayName;
 declare const index_moduleDisplayName: typeof moduleDisplayName;
 declare const index_formatModuleLine: typeof formatModuleLine;
 declare const index_buildEntityDescription: typeof buildEntityDescription;
+type index_SchemaField = SchemaField;
+type index_RawData = RawData;
+declare const index_deserializeAtomicData: typeof deserializeAtomicData;
+declare const index_ATOMICASSETS_ACCOUNT: typeof ATOMICASSETS_ACCOUNT;
+declare const index_SHIPLOAD_COLLECTION: typeof SHIPLOAD_COLLECTION;
+declare const index_ATOMICASSETS_ABI: typeof ATOMICASSETS_ABI;
+type index_MintAssetParams = MintAssetParams;
+declare const index_buildMintAssetAction: typeof buildMintAssetAction;
+type index_AtomicAssetRow = AtomicAssetRow;
+type index_AtomicSchemaRow = AtomicSchemaRow;
+type index_FetchAssetsOptions = FetchAssetsOptions;
+declare const index_fetchAtomicAssetsForOwner: typeof fetchAtomicAssetsForOwner;
+declare const index_fetchAtomicSchemas: typeof fetchAtomicSchemas;
+type index_DecodedAtomicAsset = DecodedAtomicAsset;
+declare const index_decodeAtomicAsset: typeof decodeAtomicAsset;
+type index_AtomicAttributeType = AtomicAttributeType;
+type index_ImmutableEntry = ImmutableEntry;
+type index_ImmutableModuleSlot = ImmutableModuleSlot;
+declare const index_moduleSlotsForImmutable: typeof moduleSlotsForImmutable;
+declare const index_computeNftImageUrl: typeof computeNftImageUrl;
+declare const index_buildResourceImmutable: typeof buildResourceImmutable;
+declare const index_buildComponentImmutable: typeof buildComponentImmutable;
+declare const index_buildModuleImmutable: typeof buildModuleImmutable;
+declare const index_buildEntityImmutable: typeof buildEntityImmutable;
+declare const index_buildImmutableData: typeof buildImmutableData;
 declare namespace index {
   export {
     index_NFTInstalledModule as NFTInstalledModule,
@@ -3079,29 +3922,66 @@ declare namespace index {
     index_computeGathererYield as computeGathererYield,
     index_computeGathererDrain as computeGathererDrain,
     index_computeGathererDepth as computeGathererDepth,
-    index_computeGathererSpeed as computeGathererSpeed,
     index_computeLoaderMass as computeLoaderMass,
     index_computeLoaderThrust as computeLoaderThrust,
     index_computeCrafterSpeed as computeCrafterSpeed,
     index_computeCrafterDrain as computeCrafterDrain,
+    index_computeHaulerCapacity as computeHaulerCapacity,
+    index_computeHaulerEfficiency as computeHaulerEfficiency,
+    index_computeHaulerDrain as computeHaulerDrain,
     index_computeWarpRange as computeWarpRange,
     index_entityDisplayName as entityDisplayName,
     index_moduleDisplayName as moduleDisplayName,
     index_formatModuleLine as formatModuleLine,
     index_buildEntityDescription as buildEntityDescription,
+    index_SchemaField as SchemaField,
+    index_RawData as RawData,
+    index_deserializeAtomicData as deserializeAtomicData,
+    index_ATOMICASSETS_ACCOUNT as ATOMICASSETS_ACCOUNT,
+    index_SHIPLOAD_COLLECTION as SHIPLOAD_COLLECTION,
+    index_ATOMICASSETS_ABI as ATOMICASSETS_ABI,
+    index_MintAssetParams as MintAssetParams,
+    index_buildMintAssetAction as buildMintAssetAction,
+    index_AtomicAssetRow as AtomicAssetRow,
+    index_AtomicSchemaRow as AtomicSchemaRow,
+    index_FetchAssetsOptions as FetchAssetsOptions,
+    index_fetchAtomicAssetsForOwner as fetchAtomicAssetsForOwner,
+    index_fetchAtomicSchemas as fetchAtomicSchemas,
+    index_DecodedAtomicAsset as DecodedAtomicAsset,
+    index_decodeAtomicAsset as decodeAtomicAsset,
+    index_AtomicAttributeType as AtomicAttributeType,
+    index_ImmutableEntry as ImmutableEntry,
+    index_ImmutableModuleSlot as ImmutableModuleSlot,
+    index_moduleSlotsForImmutable as moduleSlotsForImmutable,
+    index_computeNftImageUrl as computeNftImageUrl,
+    index_buildResourceImmutable as buildResourceImmutable,
+    index_buildComponentImmutable as buildComponentImmutable,
+    index_buildModuleImmutable as buildModuleImmutable,
+    index_buildEntityImmutable as buildEntityImmutable,
+    index_buildImmutableData as buildImmutableData,
   };
 }
 
 declare function formatMass(kg: number): string;
 declare function formatMassDelta(kg: number): string;
+declare function formatLocation(loc: {
+    x: number;
+    y: number;
+}): string;
+declare function formatMassScaled(kg: number): string;
 
-interface DisplayNameInput {
-    itemType: 'resource' | 'component' | 'module' | 'entity' | string;
+interface DisplayNameInputCommon {
     tier: number;
     category?: ResourceCategory;
     name: string;
 }
-declare function displayName(resolved: DisplayNameInput): string;
+type DisplayNameInput = (DisplayNameInputCommon & {
+    itemType: 'resource' | 'component' | 'module' | 'entity' | string;
+}) | (DisplayNameInputCommon & {
+    type: string;
+});
+declare function baseName(item: DisplayNameInput): string;
+declare function displayName(item: DisplayNameInput): string;
 interface DescribeOptions {
     translate?: (key: string) => string;
     formatNumber?: (n: number) => string;
@@ -3152,23 +4032,28 @@ declare class WebSocketConnection {
     get isConnected(): boolean;
 }
 
-declare function mapEntity(ei: Types.entity_info): Ship | Warehouse | Container;
+declare function mapEntity(ei: Types.entity_info): Entity$1;
 declare function parseWireEntity(raw: WireEntity): Types.entity_info;
 
 declare function setSubscriptionsDebug(on: boolean): void;
 declare function isSubscriptionsDebugEnabled(): boolean;
 
+type Ship = Entity$1;
+type Warehouse = Entity$1;
+type Container = Entity$1;
+type Extractor = Entity$1;
+type Factory = Entity$1;
+type Nexus = Entity$1;
+
 type movement_stats = Types.movement_stats;
 type energy_stats = Types.energy_stats;
 type loader_stats = Types.loader_stats;
+type lane = Types.lane;
 type task = Types.task;
 type cargo_item = Types.cargo_item;
-type warehouse_row = Types.warehouse_row;
-type container_row = Types.container_row;
+type entity_row = Types.entity_row;
 type gatherer_stats = Types.gatherer_stats;
 type location_static = Types.location_static;
-type location_epoch = Types.location_epoch;
 type location_derived = Types.location_derived;
-type location_row = Types.location_row;
 
-export { AckMessage, ActionsManager, AnyEntity, BASE_ORBITAL_MASS, BLEND_INPUTS_MUST_MATCH, BLEND_REQUIRES_MULTIPLE, BLEND_STAT_LESS_NOT_SUPPORTED, BoundingBox, BoundsDeltaMessage, BoundsSubscriptionHandle, CANCEL_CONTAINS_GROUPED_TASK, CANCEL_PAIRED_HAS_PENDING, CATEGORY_LABELS, COMMIT_ALREADY_SET, COMMIT_CANNOT_MATCH, COMMIT_NOT_SET, COMPANY_NOT_FOUND, CONTAINER_CAPACITY_EXCEEDED, CONTAINER_NOT_FOUND, CONTAINER_Z, CRAFT_ENERGY_DIVISOR, CRAFT_EXCEEDS_ENERGY_CAPACITY, CRAFT_NOT_ENOUGH_ENERGY, CapabilityAttribute, CapabilityInput, CargoData, CargoMassInfo, CargoStack, CategoryIconShape, CategoryInfo, CategoryStacks, ClientMessage, ConnectionState, Container, ContainerEntity, ContainerStateInput, Coordinates, CoordinatesType, CraftedItemCategory, CrafterCapability, DEPLOY_ENTITY_HAS_SCHEDULE, DEPTH_THRESHOLD_T1, DEPTH_THRESHOLD_T2, DEPTH_THRESHOLD_T3, DEPTH_THRESHOLD_T4, DEPTH_THRESHOLD_T5, DESTINATION_CAPACITY_EXCEEDED, DerivedStratum, DescribeOptions, Distance, ENTITY_CAPACITY_EXCEEDED, ENTITY_NO_CRAFTER, EPOCH_NON_ZERO, EPOCH_NOT_READY, ERROR_SYSTEM_ALREADY_INITIALIZED, ERROR_SYSTEM_DISABLED, ERROR_SYSTEM_NOT_INITIALIZED, EnergyCapability, EntitiesManager, Entity, EntityCapabilities, EntityInfo, EntityInstance, EntityInventory, EntityLayout, EntityRefInput, EntitySlot, EntityState, EntitySubscriptionHandle, EntityType, EntityTypeName, EpochInfo, EpochsManager, ErrorMessage, EstimateTravelTimeOptions, EstimatedTravelTime, EventCatchupCompleteMessage, EventMessage, GAME_NOT_FOUND, GAME_SEED_NOT_SET, GATHER_EXCEEDS_ENERGY_CAPACITY, GATHER_NOT_ENOUGH_ENERGY, GROUP_DUPLICATE_ENTITY, GROUP_EMPTY, GROUP_ENTITY_NOT_MOVABLE, GROUP_HAUL_CAPACITY_EXCEEDED, GROUP_NOT_FOUND, GROUP_NOT_SAME_LOCATION, GROUP_NOT_SAME_OWNER, GROUP_NO_THRUST, GameState, GathererCapability, HasCapacity, HasCargo, HasCargomass, HasScheduleAndLocation, INSUFFICIENT_BALANCE, INSUFFICIENT_ITEM_QUANTITY, INSUFFICIENT_ITEM_SUPPLY, INVALID_AMOUNT, ITEM_BIOMASS_T1, ITEM_BIOMASS_T10, ITEM_BIOMASS_T2, ITEM_BIOMASS_T3, ITEM_BIOMASS_T4, ITEM_BIOMASS_T5, ITEM_BIOMASS_T6, ITEM_BIOMASS_T7, ITEM_BIOMASS_T8, ITEM_BIOMASS_T9, ITEM_CARGO_ARM, ITEM_CARGO_LINING, ITEM_CARGO_LINING_T2, ITEM_CONTAINER_T1_PACKED, ITEM_CONTAINER_T2_PACKED, ITEM_CRAFTER_T1, ITEM_CRYSTAL_T1, ITEM_CRYSTAL_T10, ITEM_CRYSTAL_T2, ITEM_CRYSTAL_T3, ITEM_CRYSTAL_T4, ITEM_CRYSTAL_T5, ITEM_CRYSTAL_T6, ITEM_CRYSTAL_T7, ITEM_CRYSTAL_T8, ITEM_CRYSTAL_T9, ITEM_DOES_NOT_EXIST, ITEM_ENGINE_T1, ITEM_FOCUSING_ARRAY, ITEM_GAS_T1, ITEM_GAS_T10, ITEM_GAS_T2, ITEM_GAS_T3, ITEM_GAS_T4, ITEM_GAS_T5, ITEM_GAS_T6, ITEM_GAS_T7, ITEM_GAS_T8, ITEM_GAS_T9, ITEM_GATHERER_T1, ITEM_GENERATOR_T1, ITEM_HAULER_T1, ITEM_HULL_PLATES, ITEM_HULL_PLATES_T2, ITEM_LOADER_T1, ITEM_MATTER_CONDUIT, ITEM_NOT_AVAILABLE_AT_LOCATION, ITEM_NOT_DEPLOYABLE, ITEM_NOT_PACKED_ENTITY, ITEM_ORE_T1, ITEM_ORE_T10, ITEM_ORE_T2, ITEM_ORE_T3, ITEM_ORE_T4, ITEM_ORE_T5, ITEM_ORE_T6, ITEM_ORE_T7, ITEM_ORE_T8, ITEM_ORE_T9, ITEM_POWER_CELL, ITEM_REACTION_CHAMBER, ITEM_REGOLITH_T1, ITEM_REGOLITH_T10, ITEM_REGOLITH_T2, ITEM_REGOLITH_T3, ITEM_REGOLITH_T4, ITEM_REGOLITH_T5, ITEM_REGOLITH_T6, ITEM_REGOLITH_T7, ITEM_REGOLITH_T8, ITEM_REGOLITH_T9, ITEM_SHIP_T1_PACKED, ITEM_STORAGE_T1, ITEM_SURVEY_PROBE, ITEM_THRUSTER_CORE, ITEM_TOOL_BIT, ITEM_TYPE_COMPONENT, ITEM_TYPE_ENTITY, ITEM_TYPE_MODULE, ITEM_TYPE_RESOURCE, ITEM_WAREHOUSE_T1_PACKED, ITEM_WARP_T1, InventoryAccessor, Item, ItemType, LOCATION_MAX_DEPTH, LOCATION_MIN_DEPTH, LoadTimeBreakdown, LoaderCapability, Location, LocationStratum, LocationType, LocationsManager, MAX_ORBITAL_ALTITUDE, MIN_ORBITAL_ALTITUDE, MODULE_ANY, MODULE_CARGO_NOT_FOUND, MODULE_CRAFTER, MODULE_ENGINE, MODULE_ENTITY_BUSY, MODULE_GATHERER, MODULE_GENERATOR, MODULE_HAULER, MODULE_LAUNCHER, MODULE_LOADER, MODULE_NOT_MODULE, MODULE_SLOT_EMPTY, MODULE_SLOT_INVALID, MODULE_SLOT_OCCUPIED, MODULE_STORAGE, MODULE_TYPE_MISMATCH, MODULE_WARP, MassCapability, ModuleDescription, ModuleEntry, ModuleType, MovementCapability, index as NFT, NFTCargoItem, NFTCommonBase, NFTInstalledModule, NFTModuleSlot, NO_SCHEDULE, NamedStats, PLANET_SUBTYPE_GAS_GIANT, PLANET_SUBTYPE_ICY, PLANET_SUBTYPE_INDUSTRIAL, PLANET_SUBTYPE_OCEAN, PLANET_SUBTYPE_ROCKY, PLANET_SUBTYPE_TERRESTRIAL, PLAYER_ALREADY_JOINED, PLAYER_NOT_FOUND, PLAYER_NOT_JOINED, PRECISION, PackedModule, PackedModuleInput, PingMessage, PlanetSubtypeInfo, platform as PlatformContract, Types$1 as PlatformTypes, Player, PlayerStateInput, PlayersManager, PongMessage, Projectable, ProjectableSnapshot, ProjectedEntity, ProjectionOptions, RECIPE_INPUTS_EXCESS, RECIPE_INPUTS_INSUFFICIENT, RECIPE_INPUTS_INVALID, RECIPE_INPUTS_MIXED, RECIPE_NOT_FOUND, REQUIRES_MORE_THAN_ONE, REQUIRES_POSITIVE_VALUE, RESERVE_TIERS, RESOLVE_COUNT_EXCEEDS_COMPLETED, Recipe, RecipeInput, RecipeInputCategory, RecipeInputItemId, RecipeSlotInput, RenderDescriptionOptions, ReserveTier, ResolvedAttributeGroup, ResolvedItem, ResolvedItemStat, ResolvedItemType, ResolvedModuleSlot, ResourceCategory, ResourceStats, SHIP_ALREADY_THERE, SHIP_ALREADY_TRAVELING, SHIP_CANNOT_BUY_TRAVELING, SHIP_CANNOT_CANCEL_TASK, SHIP_CANNOT_UPDATE_TRAVELING, SHIP_CAPACITY_EXCEEDED, SHIP_CARGO_NOT_LOADED, SHIP_CARGO_NOT_OWNED, SHIP_INVALID_CARGO, SHIP_INVALID_DESTINATION, SHIP_INVALID_TRAVEL_DURATION, SHIP_NOT_ARRIVED, SHIP_NOT_ENOUGH_ENERGY, SHIP_NOT_ENOUGH_ENERGY_CAPACITY, SHIP_NOT_FOUND, SHIP_NOT_IDLE, SHIP_NOT_OWNED, SHIP_NO_COMPLETED_TASKS, SHIP_NO_TASKS_TO_CANCEL, STARTER_ALREADY_CLAIMED, ScheduleAccessor, ScheduleCapability, ScheduleData, Scheduleable, server as ServerContract, ServerMessage, Types as ServerTypes, Ship, ShipCapabilities, ShipEntity, ShipLike, ShipStateInput, Shipload, SnapshotMessage, StackInput, StatDefinition, StatMapping, StatSlot, StorageCapability, StratumInfo, SubscribeEntityMessage, SubscribeEventsMessage, SubscribeMessage, SubscriptionEntityType, SubscriptionsManager, SubscriptionsOptions, TIER_ADJECTIVES, TIER_ROLL_MAX, TRAVEL_MAX_DURATION, TaskCancelable, TaskType, TextSpan, TierRange, TransferEntity, UnsubscribeEntityMessage, UnsubscribeEventsMessage, UnsubscribeMessage, UpdateBoundsMessage, UpdateMessage, WAREHOUSE_ALREADY_AT_LOCATION, WAREHOUSE_CAPACITY_EXCEEDED, WAREHOUSE_NOT_FOUND, WAREHOUSE_Z, WARP_HAS_CARGO, WARP_HAS_SCHEDULE, WARP_NOT_FULL_ENERGY, WARP_NO_CAPABILITY, WARP_OUT_OF_RANGE, Warehouse, WarehouseEntity, WarehouseStateInput, WebSocketConnection, WebSocketConnectionOptions, WireCoordinates, WireEntity, availableCapacity$1 as availableCapacity, availableCapacityFromMass, blendCargoStacks, blendComponentStacks, blendCrossGroup, blendStacks, buildEntityDescription, calcCargoItemMass, calcCargoMass, calcEnergyUsage, calcLoadDuration, calcStacksMass, calc_acceleration, calc_craft_duration, calc_craft_energy, calc_energyusage, calc_flighttime, calc_gather_duration, calc_gather_energy, calc_loader_acceleration, calc_loader_flighttime, calc_orbital_altitude, calc_rechargetime, calc_ship_acceleration, calc_ship_flighttime, calc_ship_mass, calc_ship_rechargetime, calc_transfer_duration, calculateFlightTime, calculateLoadTimeBreakdown, calculateRefuelingTime, calculateTransferTime, canMove, capabilityAttributes, capabilityNames, capsHasCrafter, capsHasGatherer, capsHasHauler, capsHasLoaders, capsHasMass, capsHasMovement, capsHasStorage, cargoItemToStack, cargoUtils, cargo_item, categoryColors, categoryFromIndex, categoryIconShapes, categoryIcons, categoryLabel, categoryLabelFromIndex, componentIcon, computeBaseCapacityShip, computeBaseCapacityWarehouse, computeBaseHullmass, computeComponentStats, computeContainerCapabilities, computeContainerT2Capabilities, computeCraftedOutputStats, computeCrafterCapabilities, computeCrafterDrain, computeCrafterSpeed, computeEngineCapabilities, computeEngineDrain, computeEngineThrust, computeEntityStats, computeGathererCapabilities, computeGathererDepth, computeGathererDrain, computeGathererSpeed, computeGathererYield, computeGeneratorCap, computeGeneratorCapabilities, computeGeneratorRech, computeHaulPenalty, computeHaulerCapabilities, computeHaulerDrain, computeInputMass, computeLoaderCapabilities, computeLoaderMass, computeLoaderThrust, computeShipCapabilities, computeShipHullCapabilities, computeStorageCapabilities, computeWarehouseCapabilities, computeWarehouseHullCapabilities, container_row, coordsToLocationId, createInventoryAccessor, createProjectedEntity, createScheduleAccessor, decodeCraftedItemStats, decodeStat, decodeStats, Shipload as default, deriveLocation, deriveLocationEpoch, deriveLocationSize, deriveLocationStatic, deriveResourceStats, deriveStrata, deriveStratum, describeItem, describeModule, describeModuleForItem, describeModuleForSlot, deserializeAsset, deserializeComponent, deserializeEntity, deserializeModule, deserializeResource, displayName, distanceBetweenCoordinates, distanceBetweenPoints, encodeGatheredCargoStats, encodeStats, energyPercent, energy_stats, entityDisplayName, estimateDealTravelTime, estimateTravelTime, findItemByCategoryAndTier, findNearbyPlanets, formatMass, formatMassDelta, formatModuleLine, formatTier, gatherer_stats, getCapabilityAttributes, getCategoryInfo, getComponents, getCurrentEpoch, getDepthThreshold, getDestinationLocation, getEligibleResources, getEntityItems, getEntityLayout, getEpochInfo, getFlightOrigin, getItem, getItems, getLocationCandidates, getLocationType, getLocationTypeName, getModuleCapabilityType, getModules, getPlanetSubtype, getPlanetSubtypes, getPositionAt, getRecipe, getResourceTier, getResourceWeight, getResources, getStatDefinitions, getStatMappings, getStatMappingsForCapability, getStatMappingsForStat, getStatName, getSystemName, hasEnergy, hasEnergyForDistance, hasGatherer, hasLoaders, hasMass, hasSchedule, hasSpace$1 as hasSpace, hasSpaceForMass, hasStorage, hasSystem, hash, hash512, isCraftedItem, isFull$1 as isFull, isFullFromMass, isGatherableLocation, isInvertedAttribute, isModuleItem, isRelatedItem, isSubscriptionsDebugEnabled, itemAbbreviations, itemCategory, itemIds, itemOffset, itemTier, itemTypeCode, lerp, loader_stats, location_derived, location_epoch, location_row, location_static, makeContainer, makeShip, makeWarehouse, mapEntity, maxTravelDistance, mergeStacks, moduleAccepts, moduleDisplayName, moduleIcon, moduleSlotTypeToCode, movement_stats, needsRecharge, parseWireEntity, projectEntity, projectEntityAt, projectFromCurrentState, projectFromCurrentStateAt, readCommonBase, removeFromStacks, renderDescription, resolveItem, resolveItemCategory, resolveStats, rollTier, rollWithinTier, rotation, schedule, setSubscriptionsDebug, stackKey, stackToCargoItem, stacksEqual, statMappings, task, tierColors, tierLabel, tierLabels, toLocation, typeLabel, validateSchedule, warehouse_row };
+export { ALL_ENTITY_TYPES, ATOMICASSETS_ACCOUNT, AckMessage, ActionsManager, AnyEntity, AtomicAssetRow, AtomicAttributeType, AtomicSchemaRow, BASE_ORBITAL_MASS, BLEND_INPUTS_MUST_MATCH, BLEND_REQUIRES_MULTIPLE, BLEND_STAT_LESS_NOT_SUPPORTED, BoundingBox, BoundsDeltaMessage, BoundsSubscriptionHandle, BuildMethod, BuildState, BuildableTarget, CANCEL_CONTAINS_GROUPED_TASK, CANCEL_PAIRED_HAS_PENDING, CAP_DEMOLISH, CAP_MODULES, CAP_UNDEPLOY, CAP_WRAP, CATEGORY_LABELS, COMMIT_ALREADY_SET, COMMIT_CANNOT_MATCH, COMMIT_NOT_SET, COMPANY_NOT_FOUND, COMPONENT_TIER_PREFIXES, CONTAINER_NOT_FOUND, CONTAINER_Z, CRAFT_ENERGY_DIVISOR, CRAFT_EXCEEDS_ENERGY_CAPACITY, CRAFT_NOT_ENOUGH_ENERGY, CapabilityAttribute, CapabilityInput, CargoData, CargoMassInfo, CargoStack, CategoryInfo, CategoryStacks, ClientMessage, ComputedCapabilities, ConnectionState, ConstructionManager, Container, ContainerEntity, Coordinates, CoordinatesType, CraftedItemCategory, CrafterCapability, DEPLOY_ENTITY_HAS_SCHEDULE, DEPTH_THRESHOLD_T1, DEPTH_THRESHOLD_T2, DEPTH_THRESHOLD_T3, DEPTH_THRESHOLD_T4, DEPTH_THRESHOLD_T5, DESTINATION_CAPACITY_EXCEEDED, DecodedAtomicAsset, DerivedStratum, DescribeOptions, DisplayNameResult, Distance, ENTITY_ALREADY_THERE, ENTITY_CAPACITY_EXCEEDED, ENTITY_CARGO_NOT_LOADED, ENTITY_CARGO_NOT_OWNED, ENTITY_CONTAINER, ENTITY_EXTRACTOR, ENTITY_FACTORY, ENTITY_INVALID_CARGO, ENTITY_INVALID_DESTINATION, ENTITY_INVALID_TRAVEL_DURATION, ENTITY_NEXUS, ENTITY_NOT_ENOUGH_ENERGY, ENTITY_NOT_ENOUGH_ENERGY_CAPACITY, ENTITY_NO_CRAFTER, ENTITY_SHIP, ENTITY_WAREHOUSE, EPOCH_NON_ZERO, EPOCH_NOT_READY, ERROR_SYSTEM_ALREADY_INITIALIZED, ERROR_SYSTEM_DISABLED, ERROR_SYSTEM_NOT_INITIALIZED, EffectiveReserveInput, EnergyCapability, EntitiesManager, Entity$1 as Entity, EntityCapabilities, EntityClass, EntityInfo, EntityInstance, EntityInventory, EntityLayout, EntityRefInput, EntitySlot, EntityState, EntityStateInput, EntitySubscriptionHandle, EntityTypeName, EpochInfo, EpochsManager, ErrorMessage, EstimateTravelTimeOptions, EstimatedTravelTime, EventCatchupCompleteMessage, EventMessage, Extractor, Factory, FetchAssetsOptions, FinalizerCapability, FinalizerEntityRef, FloatPosition, GAME_NOT_FOUND, GAME_SEED_NOT_SET, GATHERER_DEPTH_MAX_TIER, GATHERER_DEPTH_TABLE, GATHER_EXCEEDS_ENERGY_CAPACITY, GATHER_NOT_ENOUGH_ENERGY, GROUP_DUPLICATE_ENTITY, GROUP_EMPTY, GROUP_ENTITY_NOT_MOVABLE, GROUP_HAUL_CAPACITY_EXCEEDED, GROUP_NOT_FOUND, GROUP_NOT_SAME_LOCATION, GROUP_NOT_SAME_OWNER, GROUP_NO_THRUST, GameState, GathererCapability, GathererDepthParams, HasCapacity, HasCargo, HasCargomass, HasScheduleAndLocation, INSUFFICIENT_BALANCE, INSUFFICIENT_ITEM_QUANTITY, INSUFFICIENT_ITEM_SUPPLY, INVALID_AMOUNT, ITEM_BATTERY_T1, ITEM_BEAM, ITEM_BIOMASS_T1, ITEM_BIOMASS_T10, ITEM_BIOMASS_T2, ITEM_BIOMASS_T3, ITEM_BIOMASS_T4, ITEM_BIOMASS_T5, ITEM_BIOMASS_T6, ITEM_BIOMASS_T7, ITEM_BIOMASS_T8, ITEM_BIOMASS_T9, ITEM_CERAMIC, ITEM_CONTAINER_T1_PACKED, ITEM_CONTAINER_T2_PACKED, ITEM_CRAFTER_T1, ITEM_CRYSTAL_T1, ITEM_CRYSTAL_T10, ITEM_CRYSTAL_T2, ITEM_CRYSTAL_T3, ITEM_CRYSTAL_T4, ITEM_CRYSTAL_T5, ITEM_CRYSTAL_T6, ITEM_CRYSTAL_T7, ITEM_CRYSTAL_T8, ITEM_CRYSTAL_T9, ITEM_DOES_NOT_EXIST, ITEM_ENGINE_T1, ITEM_EXTRACTOR_T1_PACKED, ITEM_FACTORY_T1_PACKED, ITEM_FRAME, ITEM_FRAME_T2, ITEM_GAS_T1, ITEM_GAS_T10, ITEM_GAS_T2, ITEM_GAS_T3, ITEM_GAS_T4, ITEM_GAS_T5, ITEM_GAS_T6, ITEM_GAS_T7, ITEM_GAS_T8, ITEM_GAS_T9, ITEM_GATHERER_T1, ITEM_GENERATOR_T1, ITEM_HAULER_T1, ITEM_LOADER_T1, ITEM_NOT_AVAILABLE_AT_LOCATION, ITEM_NOT_DEPLOYABLE, ITEM_NOT_PACKED_ENTITY, ITEM_ORE_T1, ITEM_ORE_T10, ITEM_ORE_T2, ITEM_ORE_T3, ITEM_ORE_T4, ITEM_ORE_T5, ITEM_ORE_T6, ITEM_ORE_T7, ITEM_ORE_T8, ITEM_ORE_T9, ITEM_PLASMA_CELL, ITEM_PLATE, ITEM_PLATE_T2, ITEM_POLYMER, ITEM_REACTOR, ITEM_REGOLITH_T1, ITEM_REGOLITH_T10, ITEM_REGOLITH_T2, ITEM_REGOLITH_T3, ITEM_REGOLITH_T4, ITEM_REGOLITH_T5, ITEM_REGOLITH_T6, ITEM_REGOLITH_T7, ITEM_REGOLITH_T8, ITEM_REGOLITH_T9, ITEM_RESIN, ITEM_RESONATOR, ITEM_SENSOR, ITEM_SHIP_T1_PACKED, ITEM_STORAGE_T1, ITEM_TYPE_COMPONENT, ITEM_TYPE_ENTITY, ITEM_TYPE_MODULE, ITEM_TYPE_RESOURCE, ITEM_WAREHOUSE_T1_PACKED, ITEM_WARP_T1, ImmutableEntry, ImmutableModuleSlot, InboundTransfer, InstalledModule, InventoryAccessor, Item, ItemType, KindMeta, LANE_BARRIER, LANE_MOBILITY, LOCATION_MAX_DEPTH, LOCATION_MIN_DEPTH, LaneView, LoadTimeBreakdown, LoaderCapability, Location, LocationStratum, LocationType, LocationsManager, MAX_ORBITAL_ALTITUDE, MAX_STARS_PER_STAT, MAX_STAR_RATING, MIN_ORBITAL_ALTITUDE, MIN_TRANSFER_DISTANCE_ORBITAL_VESSEL, MIN_TRANSFER_DISTANCE_PLANETARY_STRUCTURE, MODULE_ANY, MODULE_BATTERY, MODULE_CARGO_NOT_FOUND, MODULE_CRAFTER, MODULE_ENGINE, MODULE_ENTITY_BUSY, MODULE_GATHERER, MODULE_GENERATOR, MODULE_HAULER, MODULE_LAUNCHER, MODULE_LOADER, MODULE_NOT_MODULE, MODULE_SLOT_EMPTY, MODULE_SLOT_INVALID, MODULE_SLOT_OCCUPIED, MODULE_STORAGE, MODULE_TIER_PREFIXES, MODULE_TYPE_MISMATCH, MODULE_WARP, MassCapability, MintAssetParams, ModuleDescription, ModuleEntry, ModuleType, MovementCapability, index as NFT, NFTCargoItem, NFTCommonBase, NFTInstalledModule, NFTModuleSlot, NO_SCHEDULE, NamedStats, Nexus, NftConfigForItem, NftManager, OrderedTask, OwnerSubscriptionHandle, PLANETARY_STRUCTURE_Z, PLANET_SUBTYPE_GAS_GIANT, PLANET_SUBTYPE_ICY, PLANET_SUBTYPE_INDUSTRIAL, PLANET_SUBTYPE_OCEAN, PLANET_SUBTYPE_ROCKY, PLANET_SUBTYPE_TERRESTRIAL, PLAYER_ALREADY_JOINED, PLAYER_NOT_FOUND, PLAYER_NOT_JOINED, PRECISION, PackedModule, PackedModuleInput, PingMessage, PlanetSubtypeInfo, platform as PlatformContract, Types$1 as PlatformTypes, Player, PlayerStateInput, PlayersManager, PongMessage, Projectable, ProjectedEntity, ProjectionOptions, RECIPE_INPUTS_EXCESS, RECIPE_INPUTS_INSUFFICIENT, RECIPE_INPUTS_INVALID, RECIPE_INPUTS_MIXED, RECIPE_NOT_FOUND, REQUIRES_MORE_THAN_ONE, REQUIRES_POSITIVE_VALUE, RESERVE_TIERS, RESOLVE_COUNT_EXCEEDS_COMPLETED, RESOURCE_TIER_ADJECTIVES, RawData, Recipe, RecipeInput, RecipeSlotInput, RenderDescriptionOptions, Reservation, ReserveTier, ResolvedAttributeGroup, ResolvedEvent, ResolvedItem, ResolvedItemStat, ResolvedItemType, ResolvedModuleSlot, ResourceCategory, ResourceStats, SHIPLOAD_COLLECTION, SHIP_ALREADY_TRAVELING, SHIP_CANNOT_BUY_TRAVELING, SHIP_CANNOT_CANCEL_TASK, SHIP_CANNOT_UPDATE_TRAVELING, SHIP_NOT_ARRIVED, SHIP_NOT_FOUND, SHIP_NOT_IDLE, SHIP_NOT_OWNED, SHIP_NO_COMPLETED_TASKS, SHIP_NO_TASKS_TO_CANCEL, SLOT_FORMULAS, STAR_STEP, ScheduleAccessor, ScheduleCapability, ScheduleData, ScheduledBuild, SchemaField, server as ServerContract, ServerMessage, Types as ServerTypes, Ship, ShipEntity, ShipLike, Shipload, SlotConsumer, SlotConsumerKind, SnapshotMessage, SourceCargoStack, SourceEntityRef, StackInput, StatDefinition, StatMapping, StatSlot, StorageCapability, StratumInfo, SubscribeEntityMessage, SubscribeEventsMessage, SubscribeMessage, SubscriptionEntityType, SubscriptionsManager, SubscriptionsOptions, TIER_ROLL_MAX, TRAVEL_MAX_DURATION, TaskCancelable, TaskCargoChange, TaskCargoDirection, TaskType, TemplateMeta, TextSpan, TierRange, TransferEntity, UnsubscribeEntityMessage, UnsubscribeEventsMessage, UnsubscribeMessage, UpdateBoundsMessage, UpdateMessage, WAREHOUSE_ALREADY_AT_LOCATION, WAREHOUSE_NOT_FOUND, WARP_HAS_CARGO, WARP_HAS_SCHEDULE, WARP_NOT_FULL_ENERGY, WARP_NO_CAPABILITY, WARP_OUT_OF_RANGE, Warehouse, WarehouseEntity, WebSocketConnection, WebSocketConnectionOptions, WireCoordinates, WireEntity, YIELD_FRACTION_DEEP, YIELD_FRACTION_SHALLOW, allBuildableItems, allPlotBuildableItems, availableBuildMethods, availableCapacity$1 as availableCapacity, availableCapacityFromMass, availableForItem, baseName, blendCargoStacks, blendComponentStacks, blendCrossGroup, blendStacks, buildComponentImmutable, buildEntityDescription, buildEntityImmutable, buildImmutableData, buildMintAssetAction, buildModuleImmutable, buildResourceImmutable, calcCargoItemMass, calcCargoMass, calcEnergyUsage, calcStacksMass, calc_acceleration, calc_craft_duration, calc_craft_energy, calc_energyusage, calc_flighttime, calc_gather_duration, calc_gather_energy, calc_gather_rate, calc_loader_acceleration, calc_loader_flighttime, calc_orbital_altitude, calc_rechargetime, calc_ship_acceleration, calc_ship_flighttime, calc_ship_mass, calc_ship_rechargetime, calc_transfer_duration, calculateFlightTime, calculateLoadTimeBreakdown, calculateRefuelingTime, calculateTransferTime, canMove, candidateLaneCompletesAt, capabilityAttributes, capabilityNames, capsHasCrafter, capsHasGatherer, capsHasHauler, capsHasLoaders, capsHasMass, capsHasMovement, capsHasStorage, cargoItem, cargoItemToStack, cargoReadyAt, cargoRef, cargoUtils, cargo_item, categoryColors, categoryFromIndex, categoryLabel, categoryLabelFromIndex, componentIcon, computeBaseCapacity, computeBaseCapacityShip, computeBaseCapacityWarehouse, computeBaseHullmass, computeComponentStats, computeContainerCapabilities, computeContainerT2Capabilities, computeCraftedOutputStats, computeCrafterCapabilities, computeCrafterDrain, computeCrafterSpeed, computeEngineCapabilities, computeEngineDrain, computeEngineThrust, computeEntityCapabilities, computeEntityStats, computeGathererCapabilities, computeGathererDepth, computeGathererDrain, computeGathererYield, computeGeneratorCap, computeGeneratorCapabilities, computeGeneratorRech, computeHaulPenalty, computeHaulerCapabilities, computeHaulerCapacity, computeHaulerDrain$1 as computeHaulerDrain, computeHaulerEfficiency, computeInputMass, computeLoaderCapabilities, computeLoaderMass, computeLoaderThrust, computeNftImageUrl, computeShipHullCapabilities, computeStorageCapabilities, computeWarehouseHullCapabilities, computeWarpCapabilities, computeWarpRange, coordsToLocationId, createInventoryAccessor, createProjectedEntity, createScheduleAccessor, decodeAtomicAsset, decodeCraftedItemStats, decodeStat, decodeStats, Shipload as default, deriveLocation, deriveLocationSize, deriveLocationStatic, deriveResourceStats, deriveStatMappings, deriveStrata, deriveStratum, describeItem, describeModule, describeModuleForItem, describeModuleForSlot, deserializeAsset, deserializeAtomicData, deserializeComponent, deserializeEntity, deserializeModule, deserializeResource, displayName, distanceBetweenCoordinates, distanceBetweenPoints, easeFlightProgress, encodeGatheredCargoStats, encodeStats, energyAtTime, energyPercent, energy_stats, entityDisplayName, entity_row, estimateDealTravelTime, estimateTravelTime, fetchAtomicAssetsForOwner, fetchAtomicSchemas, filterByBuildMethod, findNearbyPlanets, flightSpeedFactor, formatLocation, formatMass, formatMassDelta, formatMassScaled, formatModuleLine, formatTier, gathererDepthForTier, gatherer_stats, getCapabilityAttributes, getCategoryInfo, getComponents, getCurrentEpoch, getDepthThreshold, getDestinationLocation, getEffectiveReserve, getEligibleResources, getEntityClass, getEntityItems, getEntityLayout, getEpochInfo, getFlightOrigin, getInterpolatedPosition, getItem, getItems, getKindMeta, getLocationCandidates, getLocationProfile, getLocationType, getLocationTypeName, getModuleCapabilityType, getModules, getPackedEntityType, getPlanetSubtype, getPlanetSubtypes, getPositionAt, getRecipe, getResourceTier, getResourceWeight, getResources, getStatDefinitions, getStatMappings, getStatMappingsForCapability, getStatMappingsForStat, getStatName, getSystemName, getTemplateMeta, hasEnergy, hasEnergyForDistance, hasGatherer, hasLoaders, hasMass, hasSchedule, hasSpace$1 as hasSpace, hasSpaceForMass, hasStorage, hasSystem, hash, hash512, interpolateFlightPosition, isBuildable, isContainer, isCraftedItem, isExtractor, isFactory, isFull$1 as isFull, isFullFromMass, isGatherableLocation, isInvertedAttribute, isLocationBuildable, isModuleItem, isNexus, isPlot, isPlotBuildable, isRelatedItem, isShip, isSubscriptionsDebugEnabled, isWarehouse, itemAbbreviations, itemCategory, itemIds, itemOffset, itemTier, itemTypeCode, kindCan, lane, laneKeyForModule, lerp, loader_stats, location_derived, location_static, makeEntity, mapEntity, maxCraftable, maxTravelDistance, mergeStacks, moduleAccepts, moduleDisplayName, moduleIcon, moduleSlotTypeToCode, movement_stats, needsRecharge, normalizeDisplayName, parseWireEntity, projectEntity, projectEntityAt, projectRemainingAt, projectedCargoAvailableAt, rawScheduleEnd, readCommonBase, removeFromStacks, renderDescription, resolveItem, resolveItemCategory, resolveStats, rollTier, rollWithinTier, rotation, schedule, setSubscriptionsDebug, stackKey, stackToCargoItem, stacksEqual, starRating, starsForStat, statMagnitude, subtractFromStacks, task, taskCargoChanges, taskCargoEffect, tierAdjective, tierColors, tierOfReserve, toLocation, typeLabel, validateDisplayName, validateSchedule, workerLaneKey, yieldThresholdAt };