@shipload/sdk 1.0.0-next.4 → 1.0.0-next.40

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, Transaction, 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,58 +447,26 @@ 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;
         inputs: cargo_item[];
+        target?: UInt64;
+        slot?: UInt8;
     }
-    class crafter_stats extends Struct {
+    class crafter_lane extends Struct {
+        slot_index: UInt8;
         speed: UInt16;
-        drain: UInt16;
+        drain: UInt32;
+        output_pct: UInt16;
     }
-    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 +478,68 @@ 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 gatherer_stats extends Struct {
-        yield: UInt16;
-        drain: UInt16;
-        depth: UInt16;
-        speed: UInt16;
+    class warp_stats extends Struct {
+        range: UInt32;
     }
     class hauler_stats extends Struct {
         capacity: UInt8;
         efficiency: UInt16;
+        drain: UInt32;
+    }
+    class gatherer_lane extends Struct {
+        slot_index: UInt8;
+        yield: UInt16;
+        drain: UInt32;
+        depth: UInt16;
+        output_pct: UInt16;
+    }
+    class loader_lane extends Struct {
+        slot_index: UInt8;
+        mass: UInt32;
+        thrust: UInt16;
+        output_pct: UInt16;
+    }
+    class launcher_stats extends Struct {
+        charge_rate: UInt16;
+        velocity: UInt16;
         drain: UInt16;
     }
-    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;
+        hold?: UInt64;
+    }
+    class schedule extends Struct {
+        started: TimePoint;
+        tasks: task[];
+    }
+    class lane extends Struct {
+        lane_key: UInt8;
+        schedule: schedule;
+    }
+    class hold extends Struct {
+        id: UInt64;
+        kind: UInt8;
+        counterpart: entity_ref;
+        until: TimePoint;
+        incoming_mass: UInt32;
     }
     class entity_info extends Struct {
         type: Name;
@@ -360,29 +547,27 @@ 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;
         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;
+        gatherer_lanes: gatherer_lane[];
+        crafter_lanes: crafter_lane[];
+        loader_lanes: loader_lane[];
+        launcher?: launcher_stats;
+        lanes: lane[];
+        holds: hold[];
     }
     class slot_def extends Struct {
         type: UInt8;
+        output_pct: UInt16;
     }
     class entity_layout extends Struct {
         entity_item_id: UInt16;
@@ -391,6 +576,23 @@ 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[];
+        holds: hold[];
+    }
+    class entity_seq_row extends Struct {
+        next_id: UInt64;
+    }
     class entity_summary extends Struct {
         type: Name;
         id: UInt64;
@@ -418,20 +620,51 @@ 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;
+        slot?: UInt8;
+    }
+    class genesisfleet extends Struct {
+        entities: entity_row[];
     }
     class getconfig extends Struct {
     }
+    class getdeposit extends Struct {
+        owner: Name;
+        asset_id: UInt64;
+    }
+    class getdistance extends Struct {
+        ax: Int64;
+        ay: Int64;
+        bx: Int64;
+        by: Int64;
+    }
+    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 +673,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 +693,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;
     }
@@ -490,6 +733,17 @@ declare namespace Types {
         owner: Name;
         entity_type?: Name;
     }
+    class getwormhole extends Struct {
+        x: Int64;
+        y: Int64;
+    }
+    class grouptransit extends Struct {
+        entities: entity_ref[];
+        ax: Int64;
+        ay: Int64;
+        bx: Int64;
+        by: Int64;
+    }
     class grouptravel extends Struct {
         entities: entity_ref[];
         x: Int64;
@@ -502,9 +756,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 +796,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 +831,32 @@ 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 launch extends Struct {
+        launcher_id: UInt64;
+        catcher_id: UInt64;
+        items: cargo_item[];
+    }
+    class load extends Struct {
+        id: UInt64;
+        from_id: UInt64;
+        items: cargo_item[];
+    }
     class location_static extends Struct {
         coords: coordinates;
         type: UInt8;
@@ -558,27 +864,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;
+        is_wormhole: boolean;
     }
     class module_info extends Struct {
         id: UInt16;
@@ -599,14 +892,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 +916,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 +940,67 @@ 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 oracle_config_row extends Struct {
+        threshold: UInt8;
+    }
+    class oracle_row extends Struct {
+        id: Name;
+    }
+    class placecargo extends Struct {
+        owner: Name;
+        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;
-        ship_count: UInt64;
-        warehouse_count: UInt64;
-        container_count: UInt64;
     }
     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;
+        hauler?: hauler_stats;
+        gatherer_lanes: gatherer_lane[];
+        crafter_lanes: crafter_lane[];
+        loader_lanes: loader_lane[];
+        launcher?: launcher_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;
     }
@@ -677,6 +1012,13 @@ declare namespace Types {
         entitygroup?: UInt64;
         group_members?: entity_ref[];
     }
+    class resolveall extends Struct {
+        owner: Name;
+    }
+    class resolveall_results extends Struct {
+        scanned: UInt32;
+        resolved: UInt32;
+    }
     class resource_info extends Struct {
         id: UInt16;
         mass: UInt32;
@@ -691,71 +1033,58 @@ declare namespace Types {
     class resources_result extends Struct {
         resources: resource_info[];
     }
+    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 setcoords extends Struct {
+        entity_id: UInt64;
+        x: Int64;
+        y: Int64;
     }
     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 +1100,24 @@ 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;
+    class transit extends Struct {
+        id: UInt64;
+        ax: Int64;
+        ay: Int64;
+        bx: Int64;
+        by: Int64;
     }
     class travel extends Struct {
-        entity_type: Name;
         id: UInt64;
         x: Int64;
         y: Int64;
@@ -796,77 +1128,86 @@ 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 {
+    class undeploy extends Struct {
+        host_id: UInt64;
+        target_id: UInt64;
+    }
+    class unload 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;
+        to_id: UInt64;
+        items: cargo_item[];
     }
     class warp extends Struct {
-        entity_type: Name;
         id: UInt64;
         x: Int64;
         y: Int64;
     }
     class wipe extends Struct {
     }
-    class wipesequence extends Struct {
+    class wormhole_info extends Struct {
+        coords: coordinates;
+        is_wormhole: boolean;
+        destination: coordinates;
     }
-    class wrap extends Struct {
-        owner: Name;
-        entity_type: Name;
-        entity_id: UInt64;
-        cargo_id: UInt64;
-        quantity: UInt64;
+    class wrapconfig_row extends Struct {
+        fee_pct: UInt16;
+        fee_account: Name;
+    }
+    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 +1217,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 +1245,75 @@ 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[];
+            holds: Type.hold[];
+        }
+        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;
+            hold?: UInt64Type;
+        }
         interface entity_ref {
             entity_type: NameType;
             entity_id: UInt64Type;
         }
+        interface hold {
+            id: UInt64Type;
+            kind: UInt8Type;
+            counterpart: Type.entity_ref;
+            until: TimePointType;
+            incoming_mass: UInt32Type;
+        }
+        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 +1323,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 +1372,27 @@ 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[];
+        target?: UInt64Type;
+        slot?: UInt8Type;
     }
-    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 +1403,45 @@ 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;
+        slot?: UInt8Type;
+    }
+    interface genesisfleet {
+        entities: Type.entity_row[];
     }
     interface getconfig {
     }
+    interface getdeposit {
+        owner: NameType;
+        asset_id: UInt64Type;
+    }
+    interface getdistance {
+        ax: Int64Type;
+        ay: Int64Type;
+        bx: Int64Type;
+        by: Int64Type;
+    }
+    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 +1450,13 @@ declare namespace ActionParams {
     }
     interface getitems {
     }
+    interface getitemtype {
+        item_id: UInt16Type;
+    }
     interface getitemtypes {
     }
+    interface getkindmeta {
+    }
     interface getlocation {
         x: Int64Type;
         y: Int64Type;
@@ -1035,15 +1470,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;
     }
@@ -1070,6 +1510,17 @@ declare namespace ActionParams {
         owner: NameType;
         entity_type?: NameType;
     }
+    interface getwormhole {
+        x: Int64Type;
+        y: Int64Type;
+    }
+    interface grouptransit {
+        entities: Type.entity_ref[];
+        ax: Int64Type;
+        ay: Int64Type;
+        bx: Int64Type;
+        by: Int64Type;
+    }
     interface grouptravel {
         entities: Type.entity_ref[];
         x: Int64Type;
@@ -1082,123 +1533,201 @@ 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 launch {
+        launcher_id: UInt64Type;
+        catcher_id: UInt64Type;
+        items: Type.cargo_item[];
+    }
+    interface load {
+        id: UInt64Type;
+        from_id: UInt64Type;
+        items: Type.cargo_item[];
+    }
+    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 resolveall {
+        owner: NameType;
+    }
+    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 setcoords {
+        entity_id: UInt64Type;
+        x: Int64Type;
+        y: Int64Type;
     }
     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;
+    interface transit {
+        id: UInt64Type;
+        ax: Int64Type;
+        ay: Int64Type;
+        bx: Int64Type;
+        by: Int64Type;
     }
     interface travel {
-        entity_type: NameType;
         id: UInt64Type;
         x: Int64Type;
         y: Int64Type;
         recharge: boolean;
     }
+    interface undeploy {
+        host_id: UInt64Type;
+        target_id: UInt64Type;
+    }
+    interface unload {
+        id: UInt64Type;
+        to_id: UInt64Type;
+        items: Type.cargo_item[];
+    }
     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;
+    getdistance: ActionParams.getdistance;
+    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;
@@ -1207,49 +1736,80 @@ interface ActionNameParams {
     getslots: ActionParams.getslots;
     getstratum: ActionParams.getstratum;
     getsummaries: ActionParams.getsummaries;
+    getwormhole: ActionParams.getwormhole;
+    grouptransit: ActionParams.grouptransit;
     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;
+    launch: ActionParams.launch;
+    load: ActionParams.load;
+    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;
+    resolveall: ActionParams.resolveall;
+    reveal: ActionParams.reveal;
     rmmodule: ActionParams.rmmodule;
     rmnftcfg: ActionParams.rmnftcfg;
-    salt: ActionParams.salt;
+    setcoords: ActionParams.setcoords;
     setnftcfg: ActionParams.setnftcfg;
-    spawncargo: ActionParams.spawncargo;
-    spawnpacked: ActionParams.spawnpacked;
-    spawnseeded: ActionParams.spawnseeded;
-    transfer: ActionParams.transfer;
+    setthreshold: ActionParams.setthreshold;
+    setwrapcost: ActionParams.setwrapcost;
+    setwrapfee: ActionParams.setwrapfee;
+    stowcargo: ActionParams.stowcargo;
+    stowentity: ActionParams.stowentity;
+    swapmodule: ActionParams.swapmodule;
+    transit: ActionParams.transit;
     travel: ActionParams.travel;
+    undeploy: ActionParams.undeploy;
+    unload: ActionParams.unload;
     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;
+    getdistance: UInt64;
+    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;
@@ -1258,15 +1818,26 @@ interface ActionReturnValues {
     getslots: Types.entity_layouts_result;
     getstratum: Types.stratum_data;
     getsummaries: Types.entity_summary[];
+    getwormhole: Types.wormhole_info;
+    grouptransit: Types.task_results;
     grouptravel: Types.task_results;
     hash: Checksum256;
     hash512: Checksum512;
+    launch: Types.task_results;
+    load: Types.task_results;
+    nftimgurl: string;
+    placecargo: Types.task_results;
+    placeentity: Types.task_results;
     recharge: Types.task_results;
     resolve: Types.resolve_results;
-    transfer: Types.task_results;
+    resolveall: Types.resolveall_results;
+    stowcargo: Types.task_results;
+    stowentity: Types.task_results;
+    transit: Types.task_results;
     travel: Types.task_results;
+    undeploy: Types.task_results;
+    unload: Types.task_results;
     warp: Types.task_results;
-    wrap: Types.task_results;
 }
 type ActionReturnNames = keyof ActionReturnValues;
 declare class Contract extends Contract$2 {
@@ -1326,16 +1897,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,18 +1914,14 @@ 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.";
 declare const GROUP_NO_THRUST = "Group travel requires at least one entity with engines.";
 declare const GROUP_NOT_SAME_LOCATION = "All entities must be at the same location for group travel.";
@@ -1365,6 +1931,8 @@ declare const GROUP_NOT_FOUND = "Entity group not found.";
 declare const GROUP_DUPLICATE_ENTITY = "Duplicate entity in group.";
 declare const GROUP_HAUL_CAPACITY_EXCEEDED = "Group travel requires sufficient hauler capacity for all non-self-propelled entities.";
 declare const CANCEL_CONTAINS_GROUPED_TASK = "Cannot cancel range containing grouped task - cancel non-grouped tasks first.";
+declare const WOULD_STRAND = "Cancelling this would leave a later task without the cargo it needs.";
+declare const WOULD_OVERFILL = "Cancelling this would overfill the other entity with returned cargo.";
 declare const WARP_NO_CAPABILITY = "Entity does not have warp capability.";
 declare const WARP_HAS_SCHEDULE = "Entity must be idle to warp.";
 declare const WARP_HAS_CARGO = "Entity must have no cargo to warp.";
@@ -1400,19 +1968,21 @@ 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 = 200;
 interface ShipLike {
     coordinates: Types.coordinates;
     hullmass?: UInt32;
     energy?: UInt16;
     engines?: Types.movement_stats;
     generator?: Types.energy_stats;
-    loaders?: Types.loader_stats;
+    loader_lanes?: Types.loader_lane[];
     hauler?: Types.hauler_stats;
     capacity?: UInt32;
 }
@@ -1430,26 +2000,31 @@ declare enum TaskType {
     WARP = 6,
     CRAFT = 7,
     DEPLOY = 8,
-    WRAP = 9,
-    UNWRAP = 10
+    TRANSIT = 9,
+    UNWRAP = 10,
+    UNDEPLOY = 11,
+    DEMOLISH = 13,
+    CLAIMPLOT = 14,
+    BUILDPLOT = 15
+}
+declare enum HoldKind {
+    PULL = 1,
+    PUSH = 2,
+    GATHER = 3,
+    BUILD = 4
 }
 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 +2042,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' | 'catcher';
+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 +2059,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 +2111,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 +2129,23 @@ 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_LAUNCHER_T1 = 10109;
 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_MASS_DRIVER_T1_PACKED = 10205;
+declare const ITEM_MASS_CATCHER_T1_PACKED = 10206;
+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 +2161,7 @@ interface Recipe {
 }
 interface EntitySlot {
     type: ModuleType;
+    outputPct: number;
 }
 interface EntityLayout {
     entityItemId: number;
@@ -1590,12 +2169,451 @@ 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' | 'mdriver' | 'mcatcher';
+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;
+}
+
+interface LoaderStats {
+    mass: {
+        toNumber(): number;
+        multiplying(v: unknown): {
+            toNumber(): number;
+        };
+    };
+    thrust: {
+        toNumber(): number;
+    };
+    quantity: {
+        toNumber(): number;
+        gt(v: unknown): boolean;
+    };
+}
+interface GathererStats {
+    yield: {
+        toNumber(): number;
+    };
+    drain: {
+        toNumber(): number;
+    };
+    depth: {
+        toNumber(): number;
+        toString(): string;
+    };
+}
+interface CrafterStats {
+    speed: {
+        toNumber(): number;
+    };
+    drain: {
+        toNumber(): number;
+    };
+}
+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: LoaderStats;
+}
+interface GathererCapability {
+    gatherer: GathererStats;
+}
+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?: LoaderStats;
+    gatherer?: GathererStats;
+    crafter?: CrafterStats;
+    hauler?: Types.hauler_stats;
+    launcher?: Types.launcher_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;
+declare function capsHasLauncher(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;
+type Hold = Types.hold;
+declare const LANE_MOBILITY = 0;
+declare const LANE_BARRIER = 255;
+interface ScheduleData {
+    lanes?: Lane$1[];
+    holds?: Hold[];
+}
+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 hasHolds(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_hasHolds: typeof hasHolds;
+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_hasHolds as hasHolds,
+    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;
@@ -1630,18 +2648,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 +2676,7 @@ declare class GameState extends Types.state_row {
     get summary(): {
         enabled: boolean;
         epoch: string;
-        ships: number;
         hasSeed: boolean;
-        hasCommit: boolean;
     };
 }
 
@@ -1726,12 +2730,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.005;
+declare const YIELD_FRACTION_DEEP = 0.001;
+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 +2748,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 +2764,17 @@ 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 const RESOURCE_TIER_MULT_TENTHS: readonly [200, 154, 118, 91, 70, 54, 41, 32, 24, 19];
+declare function applyResourceTierMultiplier(units: number, resourceTier: 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,58 +2847,209 @@ 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[]>;
+}
+
+interface CoordinateAddress {
+    sector: string;
+    region: string;
+    localX: number;
+    localY: number;
+}
+declare function encodeAddress(seed: Checksum256Type, x: number, y: number): CoordinateAddress;
+declare function decodeAddress(seed: Checksum256Type, addr: CoordinateAddress): {
+    x: number;
+    y: number;
+};
+declare function addressFromCoordinates(seed: Checksum256Type, coords: {
+    x: number | {
+        toNumber(): number;
+    };
+    y: number | {
+        toNumber(): number;
+    };
+}): CoordinateAddress;
+
+declare function encodeSector(seed: Checksum256Type, sx: number, sy: number): string;
+declare function decodeSector(seed: Checksum256Type, name: string): {
+    sx: number;
+    sy: number;
+};
+
+declare function encodeRegion(seed: Checksum256Type, rx: number, ry: number): string;
+declare function decodeRegion(seed: Checksum256Type, token: string): {
+    rx: number;
+    ry: number;
+};
+
+declare function encodeAddressMemo(seed: Checksum256Type, x: number, y: number): CoordinateAddress;
+
+declare const COORD_MIN = -2147483648;
+declare const COORD_MAX = 2147483647;
+declare const COORD_OFFSET = 2147485000;
+declare const SECTOR_DIV = 100000000;
+declare const REGION_DIV = 10000;
+declare const SECTORS_PER_AXIS = 43;
+declare const REGION_PER_AXIS = 10000;
+declare const LOCAL_HALF = 5000;
+
+declare class CoordinatesManager extends BaseManager {
+    encode(x: number, y: number): Promise<CoordinateAddress>;
+    decode(addr: CoordinateAddress): Promise<{
+        x: number;
+        y: number;
+    }>;
 }
 
 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;
+type LaunchNumericInput = number | bigint | string | {
+    toNumber(): number;
+} | {
+    toString(): string;
+};
+interface LaunchStatsInput {
+    charge_rate?: LaunchNumericInput;
+    chargeRate?: LaunchNumericInput;
+    velocity: LaunchNumericInput;
+    drain: LaunchNumericInput;
+}
+interface LaunchQuoteLauncher {
+    coordinates: CoordinatesType;
+    launcher: LaunchStatsInput;
+    generator?: {
+        capacity: LaunchNumericInput;
+    };
+}
+interface LaunchQuoteCatcher {
+    coordinates: CoordinatesType;
+}
+interface LaunchQuote {
+    chargeTime: number;
+    flightTime: number;
+    arrival: Date;
+    energyCost: number;
+    maxReach: bigint;
+}
+type EntityRefInput = {
+    entityType: NameType;
     entityId: UInt64Type;
 };
 declare class ActionsManager extends BaseManager {
     travel(shipId: UInt64Type, destination: CoordinatesType, recharge?: boolean): Action;
+    private entityRefs;
     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;
+    transit(shipId: UInt64Type, entrance: CoordinatesType, exit: CoordinatesType): Action;
+    grouptransit(entities: EntityRefInput[], entrance: CoordinatesType, exit: CoordinatesType): Action;
+    getwormhole(x: Int64Type, y: Int64Type): Action;
+    getdistance(origin: CoordinatesType, destination: CoordinatesType): Action;
+    resolve(entityId: UInt64Type, count?: UInt64Type): Action;
+    resolveall(owner: NameType): Action;
+    cancel(entityId: UInt64Type, laneKey: number, count: UInt64Type): Action;
+    recharge(entityId: UInt64Type): Action;
+    rename(entityId: UInt64Type, name: string): Action;
+    refrshentity(entityId: UInt64Type): Action;
+    load(id: UInt64Type, fromId: UInt64Type, items: ActionParams.Type.cargo_item[]): Action;
+    unload(id: UInt64Type, toId: UInt64Type, items: ActionParams.Type.cargo_item[]): Action;
+    launch(launcherId: UInt64Type, catcherId: UInt64Type, items: ActionParams.Type.cargo_item[]): Action;
+    getLaunchQuote(launcher: LaunchQuoteLauncher, catcher: LaunchQuoteCatcher, items: ActionParams.Type.cargo_item[], start?: Date): LaunchQuote;
     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, slot?: UInt8Type): Action;
+    bundleGather(gathers: {
+        sourceId: UInt64Type;
+        destinationId: UInt64Type;
+        stratum: UInt16Type;
+        quantity: UInt32Type;
+        slot?: UInt8Type;
+    }[]): Transaction;
+    warp(entityId: UInt64Type, destination: CoordinatesType): Action;
+    craft(entityId: UInt64Type, recipeId: number, quantity: number, inputs: ActionParams.Type.cargo_item[], target?: UInt64Type, slot?: UInt8Type): 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;
+}
+interface WrapDeposit {
+    cost: bigint;
+    refund: bigint;
+    feePct: number;
+    symbol: string;
+    precision: number;
+    tokenContract: string;
+}
+declare function resolveLockedAmount(cost: bigint, feePctBasisPoints: number): bigint;
+declare class NftManager extends BaseManager {
+    private cache;
+    getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined>;
+    getWrapDeposit(itemType: number, tier: number): Promise<WrapDeposit | null>;
 }
 
-type EntityInfo = Types.entity_info;
+type EntityInfo$2 = Types.entity_info;
 interface BoundingBox {
     min_x: number;
     min_y: number;
@@ -1907,7 +3080,6 @@ type UnsubscribeMessage = {
 type SubscribeEntityMessage = {
     type: 'subscribe_entity';
     sub_id: string;
-    entity_type: 'ship' | 'warehouse' | 'container';
     entity_id: string;
 };
 type UnsubscribeEntityMessage = {
@@ -1932,11 +3104,12 @@ type AckMessage = {
     sub_id: string;
 };
 type WireEntity = Record<string, unknown> & {
-    type: number;
-    type_name: 'ship' | 'warehouse' | 'container';
+    type: number | string;
+    type_name?: string;
     id: string | number;
     owner: string;
     coordinates: WireCoordinates;
+    item_id: number;
 };
 type SnapshotMessage = {
     type: 'snapshot';
@@ -1960,6 +3133,12 @@ type BoundsDeltaMessage = {
     seq: number;
     truncated?: boolean;
 };
+type EntityDeletedMessage = {
+    type: 'entity_deleted';
+    sub_id: string;
+    entity_id: number;
+    seq: number;
+};
 type EventMessage = {
     type: 'event';
     sub_id: string;
@@ -1979,489 +3158,86 @@ type ErrorMessage = {
     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;
-    };
-};
+type ServerMessage = AckMessage | SnapshotMessage | UpdateMessage | BoundsDeltaMessage | EntityDeletedMessage | EventMessage | EventCatchupCompleteMessage | PongMessage | ErrorMessage;
 
-interface ContainerStateInput {
-    id: UInt64Type;
-    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;
-};
-declare function computeContainerT2Capabilities(stats: Record<string, number>): {
-    hullmass: number;
-    capacity: number;
-};
-
-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;
     pingIntervalMs?: number;
     pongTimeoutMs?: number;
 }
-interface BoundsSubscriptionHandle {
-    readonly subId: string;
-    unsubscribe(): void;
-    updateBounds(bounds: BoundingBox): void;
-    current: Map<number, EntityInstance>;
+type ExactEntitySubscriptionFilter = {
+    id: string | number;
+    owner?: never;
+    bounds?: never;
+    prioritizeOwner?: never;
+};
+type BroadEntitySubscriptionFilter = {
+    id?: undefined;
+    owner?: string;
+    bounds?: BoundingBox;
+    prioritizeOwner?: string;
+};
+type EntitySubscriptionFilter = ExactEntitySubscriptionFilter | BroadEntitySubscriptionFilter;
+interface EntitySubscriptionMeta {
+    seq?: number;
+    truncated?: boolean;
+}
+interface EntitySubscriptionHandlers {
+    onSnapshot?: (entities: EntityInstance[], meta: EntitySubscriptionMeta) => void;
+    onUpdate?: (entity: EntityInstance, meta: EntitySubscriptionMeta) => void;
+    onBoundsDelta?: (entered: EntityInstance[], exited: number[], meta: EntitySubscriptionMeta) => void;
+    onDeleted?: (id: string, meta: EntitySubscriptionMeta) => void;
+    onError?: (error: Error) => void;
 }
-interface EntitySubscriptionHandle {
+interface EntitiesSubscriptionHandle {
     readonly subId: string;
-    readonly entityType: SubscriptionEntityType;
-    readonly entityId: string;
+    readonly filter: EntitySubscriptionFilter;
     unsubscribe(): void;
-    current: EntityInstance | null;
+    current: Map<number, EntityInstance>;
 }
+type BoundsSubscriptionHandle = EntitiesSubscriptionHandle & {
+    readonly filter: BroadEntitySubscriptionFilter & {
+        bounds: BoundingBox;
+    };
+    updateBounds(bounds: BoundingBox): void;
+};
+type OwnerSubscriptionHandle = EntitiesSubscriptionHandle & {
+    readonly filter: BroadEntitySubscriptionFilter;
+};
+type EntitySubscriptionHandle = EntitiesSubscriptionHandle & {
+    readonly filter: ExactEntitySubscriptionFilter;
+};
 declare class SubscriptionsManager {
     private readonly conn;
     private readonly entitySubs;
-    private readonly boundsSubs;
     private subCounter;
     private hasConnected;
     constructor(opts: SubscriptionsOptions);
     close(): void;
     private generateSubID;
     private sendMessage;
-    subscribeEntity(type: SubscriptionEntityType, id: string, onUpdate: (e: EntityInstance) => void): EntitySubscriptionHandle;
-    private unsubscribeEntity;
-    subscribeBounds(bounds: BoundingBox, handlers: {
-        onSnapshot?: (entities: EntityInstance[]) => void;
-        onUpdate?: (entity: EntityInstance) => void;
-        onBoundsDelta?: (entered: EntityInstance[], exited: number[]) => void;
+    subscribeEntities(filter: BroadEntitySubscriptionFilter & {
+        bounds: BoundingBox;
+    }, handlers?: EntitySubscriptionHandlers): BoundsSubscriptionHandle;
+    subscribeEntities(filter: ExactEntitySubscriptionFilter, handlers?: EntitySubscriptionHandlers): EntitySubscriptionHandle;
+    subscribeEntities(filter: BroadEntitySubscriptionFilter, handlers?: EntitySubscriptionHandlers): EntitiesSubscriptionHandle;
+    subscribeEntities(filter: EntitySubscriptionFilter, handlers?: EntitySubscriptionHandlers): EntitiesSubscriptionHandle;
+    subscribeEntity(id: string | number, handlers: EntitySubscriptionHandlers): EntitySubscriptionHandle;
+    subscribeOwner(owner: string, handlers?: EntitySubscriptionHandlers): OwnerSubscriptionHandle;
+    subscribeBounds(bounds: BoundingBox, handlers?: EntitySubscriptionHandlers & {
         owner?: string;
         prioritizeOwner?: string;
     }): BoundsSubscriptionHandle;
-    private unsubscribeBounds;
+    subscribeAllEntities(handlers?: EntitySubscriptionHandlers): EntitiesSubscriptionHandle;
+    private normalizeFilter;
+    private static publicFilter;
+    private cloneBounds;
+    private subscriptionPrefix;
+    private subscribeMessage;
+    private unsubscribeEntities;
     private updateBounds;
     private onStateChange;
     private onMessage;
@@ -2470,27 +3246,33 @@ declare class SubscriptionsManager {
     private handleUpdate;
     private handleBoundsDelta;
     private handleError;
+    private handleEntityDeleted;
 }
 
 declare class GameContext {
     readonly client: APIClient;
     readonly server: Contract$2;
     readonly platform: Contract$2;
+    readonly atomicAssetsAccount: string;
     private _entities?;
     private _players?;
     private _locations?;
+    private _coordinates?;
     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 coordinates(): CoordinatesManager;
     get epochs(): EpochsManager;
     get actions(): ActionsManager;
+    get nft(): NftManager;
     setSubscriptionsUrl(url: string): void;
     get subscriptions(): SubscriptionsManager;
     getGame(reload?: boolean): Promise<Types$1.game_row>;
@@ -2498,65 +3280,191 @@ declare class GameContext {
     get cachedGame(): Types$1.game_row | undefined;
     get cachedState(): GameState | undefined;
 }
-
-declare abstract class BaseManager {
-    protected readonly context: GameContext;
-    constructor(context: GameContext);
-    protected get client(): _wharfkit_antelope.APIClient;
-    protected get server(): _wharfkit_contract.Contract;
-    protected get platform(): _wharfkit_contract.Contract;
-    protected getGame(): Promise<Types$1.game_row>;
-    protected getState(): Promise<GameState>;
+
+declare abstract class BaseManager {
+    protected readonly context: GameContext;
+    constructor(context: GameContext);
+    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(reload?: boolean): Promise<GameState>;
+}
+
+declare class EntitiesManager extends BaseManager {
+    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;
+}
+
+interface ShiploadOptions {
+    platformContractName?: string;
+    serverContractName?: string;
+    client?: APIClient;
+    subscriptionsUrl?: string;
+    atomicAssetsAccount?: string;
+}
+interface ShiploadConstructorOptions extends ShiploadOptions {
+    platformContract?: Contract$2;
+    serverContract?: Contract$2;
+}
+declare class Shipload {
+    private readonly _context;
+    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;
+    get players(): PlayersManager;
+    get locations(): LocationsManager;
+    get coordinates(): CoordinatesManager;
+    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>;
+}
+
+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;
+    entityType: Name;
+    name: string;
+    capability: FinalizerCapability;
+    crafterSpeed: number;
+    estimatedDuration: UInt32;
+}
+interface InboundTransfer {
+    sourceEntityId: UInt64;
+    sourceEntityType: Name;
+    sourceName: string;
+    itemId: number;
+    quantity: number;
+    etaSeconds: number;
 }
-
-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;
-    private resolveOwner;
+interface ScheduledBuild {
+    shipId: UInt64;
+    shipName: string;
+    hasStarted: boolean;
+    startsAt: number;
+    completesAt: number;
+    cancelable: boolean;
+    blockingTaskCount: number;
 }
-
-interface ShiploadOptions {
-    platformContractName?: string;
-    serverContractName?: string;
-    client?: APIClient;
-    subscriptionsUrl?: string;
+interface Reservation {
+    targetEntityId: UInt64;
+    targetEntityType: Name;
+    itemId: number;
+    quantity: number;
 }
-interface ShiploadConstructorOptions extends ShiploadOptions {
-    platformContract?: Contract$2;
-    serverContract?: Contract$2;
+
+interface PlotProgressInputRow {
+    itemId: number;
+    required: number;
+    provided: number;
+    missing: number;
 }
-declare class Shipload {
-    private readonly _context;
-    constructor(chain: ChainDefinition, constructorOptions?: ShiploadConstructorOptions);
-    static load(chain: ChainDefinition, shiploadOptions?: ShiploadOptions): Promise<Shipload>;
-    get client(): APIClient;
-    get server(): Contract$2;
-    get platform(): Contract$2;
-    get entities(): EntitiesManager;
-    get players(): PlayersManager;
-    get locations(): LocationsManager;
-    get epochs(): EpochsManager;
-    get actions(): ActionsManager;
-    get subscriptions(): SubscriptionsManager;
-    getGame(reload?: boolean): Promise<Types$1.game_row>;
-    getState(reload?: boolean): Promise<GameState>;
+interface PlotProgress {
+    targetItemId: number;
+    rows: PlotProgressInputRow[];
+    massProvided: number;
+    massRequired: number;
+    isComplete: boolean;
 }
 
-declare function makeShip(state: ShipStateInput): Ship;
-declare function makeWarehouse(state: WarehouseStateInput): Warehouse;
-declare function makeContainer(state: ContainerStateInput): Container;
+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 builderBuildStart;
+    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 +3486,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;
 
@@ -2587,13 +3494,25 @@ declare function isGatherableLocation(locationType: LocationType): boolean;
 declare function getLocationTypeName(type: LocationType): string;
 declare function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string;
 declare function hasSystem(gameSeed: Checksum256Type, coordinates: CoordinatesType): boolean;
+declare function getLocationKind(gameSeed: Checksum256Type, x: number, y: number): 'wormhole' | 'system' | 'empty';
 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;
+interface ValidateDisplayNameOptions {
+    allowEmpty?: boolean;
+}
+declare function validateDisplayName(input: string, opts?: ValidateDisplayNameOptions): DisplayNameResult;
+
 /**
  * Travel calculations for ship movement, energy usage, and flight times.
  *
@@ -2610,11 +3529,28 @@ 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;
 declare function calc_ship_rechargetime(ship: ShipLike): UInt32;
 declare function calc_flighttime(distance: UInt64Type, acceleration: number): UInt32;
+declare function calc_transit_duration(ax: number, ay: number, bx: number, by: number): UInt32;
 declare function calc_loader_flighttime(ship: ShipLike, mass: UInt64, altitude?: number): UInt32;
 declare function calc_loader_acceleration(ship: ShipLike, mass: UInt64): number;
 declare function calc_ship_flighttime(ship: ShipLike, mass: UInt64, distance: UInt64): UInt32;
@@ -2648,33 +3584,122 @@ interface EstimateTravelTimeOptions {
 declare function estimateTravelTime(ship: ShipLike, travelMass: UInt64Type, distance: UInt64Type, options?: EstimateTravelTimeOptions): EstimatedTravelTime;
 declare function estimateDealTravelTime(ship: ShipLike, shipMass: UInt64Type, distance: UInt64Type, loadMass: UInt32Type): UInt32;
 declare function hasEnergyForDistance(ship: ShipLike, distance: UInt64Type): boolean;
+interface TransferLoaderLane {
+    slot_index?: {
+        toNumber(): number;
+    } | number;
+    thrust: {
+        toNumber(): number;
+    } | number;
+    mass: {
+        toNumber(): number;
+    } | number;
+}
 interface TransferEntity {
     location: {
         z?: {
             toNumber(): number;
         } | number;
     };
-    loaders?: {
-        thrust: {
-            toNumber(): number;
-        } | number;
-        mass: {
-            toNumber(): number;
-        } | number;
-        quantity: {
-            toNumber(): number;
-        } | number;
-    };
+    entityClass: EntityClass;
+    loaderLanes?: TransferLoaderLane[];
 }
-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_onesided_duration(loaderThrust: number, loaderMass: number, activeZ: number, counterpartZ: number, activeEntityClass: EntityClass, counterpartEntityClass: EntityClass, cargoMass: number): number;
 declare function calc_transfer_duration(source: TransferEntity, dest: TransferEntity, cargoMass: number): number;
 
+interface Coord {
+    x: number;
+    y: number;
+}
+interface Neighbor {
+    coord: Coord;
+    dist: number;
+}
+interface SystemGraph {
+    hasSystem(c: Coord): boolean;
+    nearby(c: Coord, reachTiles: number): Neighbor[];
+}
+interface RoutePlan {
+    ok: true;
+    waypoints: Coord[];
+    legs: number;
+    totalDistance: number;
+}
+type RouteFailureReason = 'empty-destination' | 'no-path' | 'max-legs';
+interface RouteFailure {
+    ok: false;
+    reason: RouteFailureReason;
+    furthest?: Coord;
+    legsNeeded?: number;
+    partialWaypoints?: Coord[];
+}
+type RouteResult = RoutePlan | RouteFailure;
+interface PlanRouteParams {
+    origin: Coord;
+    dest: Coord;
+    perLegReach: number;
+    graph: SystemGraph;
+    corridorSlack?: number;
+    nodeBudget?: number;
+    maxLegs?: number;
+}
+declare const MAX_LEGS = 12;
+declare function planRoute(params: PlanRouteParams): RouteResult;
+declare function sdkSystemGraph(seed: Checksum256Type): SystemGraph;
+
+interface ReachStats {
+    generator?: {
+        capacity: bigint;
+    };
+    engines?: {
+        drain: bigint;
+    };
+    hauler?: {
+        drain: bigint;
+    };
+}
+declare function computePerLegReach(s: ReachStats, haulCount?: number): number;
+declare function computeGroupPerLegReach(participants: ReachStats[], haulCount: number): number;
+
+type ModuleEntry$2 = Types.module_entry;
+type Lane = Types.lane;
+type Schedule = Types.schedule;
+interface ResolvedGathererLane {
+    slotIndex: number;
+    yield: number;
+    drain: number;
+    depth: number;
+    outputPct: number;
+}
+interface ResolvedCrafterLane {
+    slotIndex: number;
+    speed: number;
+    drain: number;
+    outputPct: number;
+}
+interface ResolvedLoaderLane {
+    slotIndex: number;
+    thrust: number;
+    mass: number;
+    outputPct: number;
+    valid: boolean;
+}
+declare function laneKeyForModule(slotIndex: number): number;
+declare function resolveLaneGatherer(modules: ModuleEntry$2[], entityItemId: number, laneKey: number): ResolvedGathererLane;
+declare function selectGatherLane(modules: ModuleEntry$2[], entityItemId: number, lanes: Lane[], stratum: number, explicitSlot?: number): number;
+declare function resolveLaneCrafter(modules: ModuleEntry$2[], entityItemId: number, laneKey: number): ResolvedCrafterLane;
+declare function resolveLaneLoader(modules: ModuleEntry$2[], entityItemId: number, laneKey: number): ResolvedLoaderLane;
+declare function workerLaneKey(modules: ModuleEntry$2[], moduleSubtype: ModuleType, lanes: Lane[], stratum?: number): 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 +3735,152 @@ 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;
+    loaderLanes: Types.loader_lane[];
+    generator?: Types.energy_stats;
+    hauler?: Types.hauler_stats;
+    launcher?: Types.launcher_stats;
+    readonly cargoMass: UInt64;
+    readonly totalMass: UInt64;
+    readonly gathererLanes: Types.gatherer_lane[];
+    readonly crafterLanes: Types.crafter_lane[];
+    hasMovement(): boolean;
+    hasStorage(): boolean;
+    hasLoaders(): boolean;
+    hasLauncher(): 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;
+    loader_lanes?: Types.loader_lane[];
+    gatherer_lanes?: Types.gatherer_lane[];
+    crafter_lanes?: Types.crafter_lane[];
+    hauler?: Types.hauler_stats;
+    launcher?: Types.launcher_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 EntityInfo$1 = Types.entity_info;
+type CounterpartLookup = (entityId: UInt64) => EntityInfo$1 | undefined;
+type IdleResolveTarget = ScheduleData & {
+    id: UInt64;
+};
+declare function composeIdleResolve(blocker: IdleResolveTarget, action: Action, actions: ActionsManager, now: Date, lookupCounterpart?: CounterpartLookup): Action[];
+
+declare enum CancelBlockReason {
+    TASK_NEVER = "TASK_NEVER",
+    BEFORE_START_RUNNING = "BEFORE_START_RUNNING",
+    DONE = "DONE",
+    CONTAINS_LINKED_TASK = "CONTAINS_LINKED_TASK",
+    WOULD_STRAND = "WOULD_STRAND",
+    WOULD_OVERFILL = "WOULD_OVERFILL",
+    NOT_OWNER = "NOT_OWNER"
+}
+type EntityInfo = InstanceType<typeof Types.entity_info>;
+type EntityRef = InstanceType<typeof Types.entity_ref>;
+type CargoItem$2 = InstanceType<typeof Types.cargo_item>;
+interface CancelRefund {
+    giver: EntityRef;
+    cargo: CargoItem$2[];
+}
+interface CancelReleasedHold {
+    counterpart: EntityRef;
+    kind: number;
+}
+interface CancelEffects {
+    refunds: CancelRefund[];
+    releasedHolds: CancelReleasedHold[];
+    abandonsRunning: boolean;
+    keepsPlotDeposits?: {
+        plot: EntityRef;
+    };
+    energyForfeited?: number;
+}
+interface CancelPlan {
+    ok: boolean;
+    blockedReason?: CancelBlockReason;
+    range: {
+        count: number;
+        taskIndices: number[];
+    };
+    effects: CancelEffects;
+}
+interface CancelEligibilityInput {
+    now: Date;
+    counterparts?: Map<string, EntityInfo>;
+}
+declare function cancelEligibility(entity: EntityInfo, laneKey: number, fromTaskIndex: number, input: CancelEligibilityInput): CancelPlan;
+
+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;
@@ -2717,9 +3888,7 @@ interface Entity {
     entity_name: string;
     location: Coordinates | Types.coordinates;
 }
-type ShipEntity = Entity & Partial<MovementCapability> & Partial<EnergyCapability> & StorageCapability & Partial<LoaderCapability> & MassCapability & ScheduleCapability & {
-    gatherer?: Types.gatherer_stats;
-};
+type ShipEntity = Entity & Partial<MovementCapability> & Partial<EnergyCapability> & StorageCapability & Partial<LoaderCapability> & MassCapability & ScheduleCapability & Partial<GathererCapability>;
 type WarehouseEntity = Entity & StorageCapability & Partial<LoaderCapability> & MassCapability & ScheduleCapability;
 type ContainerEntity = Entity & StorageCapability & MassCapability & ScheduleCapability;
 type AnyEntity = ShipEntity | WarehouseEntity | ContainerEntity;
@@ -2737,17 +3906,21 @@ 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_energy(gatherer: Types.gatherer_stats, duration: number): UInt16;
+declare const GATHER_MASS_DIVISOR = 228;
+declare function calc_gather_duration(gatherer: GathererStats, itemMass: number, quantity: number, stratum: number, richness: number): UInt32;
+declare function calc_gather_rate(gatherer: GathererStats, itemMass: number, stratum: number, richness: number): {
+    unitsPerSec: number;
+    unitsPerMin: number;
+    secPerUnit: number;
+};
+declare function calc_gather_energy(gatherer: GathererStats, duration: number): UInt32;
 
 interface CrafterCapability {
-    crafter: Types.crafter_stats;
+    crafter: CrafterStats;
 }
 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 +3932,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 +3947,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>;
@@ -2835,7 +4005,7 @@ interface SlotConsumer {
     capability: string;
     attribute: string;
 }
-type SlotConsumerKind = 'engine' | 'generator' | 'gatherer' | 'loader' | 'crafter' | 'storage' | 'hauler' | 'warp' | 'ship-t1' | 'container-t1' | 'warehouse-t1' | 'container-t2';
+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[];
@@ -2843,6 +4013,43 @@ declare function getStatMappings(): StatMapping[];
 declare function getStatMappingsForStat(stat: string): StatMapping[];
 declare function getStatMappingsForCapability(capability: string): StatMapping[];
 
+declare function getAllRecipes(): Recipe[];
+type ResourceDemand = Partial<Record<ResourceCategory, number>>;
+declare function getResourceDemand(itemId: number, quantity?: number): ResourceDemand;
+interface StatFlow {
+    slotIndex: number;
+    capability?: string;
+    attribute?: string;
+    sourceStatIndex: number;
+    sourceStatLabel?: string;
+}
+interface RecipeConsumer {
+    outputItemId: number;
+    quantity: number;
+    statFlows: StatFlow[];
+}
+/** Every recipe that consumes `componentItemId`, with how its stats flow through. */
+declare function getRecipeConsumers(componentItemId: number): RecipeConsumer[];
+interface DemandRow {
+    itemId: number;
+    consumerCount: number;
+    statSourceCount: number;
+    sinkOnlyCount: number;
+    consumers: number[];
+}
+/** Demand tally for every item consumed as a recipe input, ascending by usage. */
+declare function getComponentDemand(): DemandRow[];
+
+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;
@@ -2855,11 +4062,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;
@@ -2875,14 +4088,52 @@ declare function computeHaulerCapabilities(stats: Record<string, number>): {
     efficiency: number;
     drain: number;
 };
-declare function computeStorageCapabilities(stats: Record<string, number>, baseCapacity: number): {
-    capacityBonus: number;
+declare function computeLauncherCapabilities(stats: {
+    charge_rate: number;
+    velocity: number;
+    drain: number;
+}, amp?: number): {
+    chargeRate: number;
+    velocity: number;
+    drain: number;
+};
+declare function computeStorageCapabilities(stats: Record<string, number>): {
+    capacity: number;
+};
+declare function computeBatteryCapabilities(stats: Record<string, number>): {
+    capacity: 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 GathererLaneEntry {
+    slotIndex: number;
+    yield: number;
+    drain: number;
+    depth: number;
+    outputPct: number;
+}
+interface CrafterLaneEntry {
+    slotIndex: number;
+    speed: number;
+    drain: number;
+    outputPct: number;
+}
+interface LoaderLaneEntry {
+    slotIndex: number;
+    mass: number;
+    thrust: number;
+    outputPct: number;
+}
+interface ComputedCapabilities {
+    hullmass: number;
+    capacity: number;
     engines?: {
         thrust: number;
         drain: number;
@@ -2895,27 +4146,88 @@ interface ShipCapabilities {
         yield: number;
         drain: number;
         depth: number;
-        speed: number;
-    };
-    hauler?: {
-        capacity: number;
-        efficiency: number;
-        drain: number;
     };
+    gathererLanes?: GathererLaneEntry[];
     loaders?: {
         mass: number;
         thrust: number;
         quantity: number;
     };
+    loaderLanes?: LoaderLaneEntry[];
     crafter?: {
         speed: number;
         drain: number;
     };
+    crafterLanes?: CrafterLaneEntry[];
+    hauler?: {
+        capacity: number;
+        efficiency: number;
+        drain: number;
+    };
+    warp?: {
+        range: number;
+    };
+    launcher?: {
+        chargeRate: number;
+        velocity: number;
+        drain: 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;
+};
+
+declare const WH: {
+    readonly RSIZE: 75;
+    readonly ZONE: 16384;
+    readonly THRESHOLD: 8192;
+    readonly MIN_REACH: 50000;
+    readonly TRANSIT_SPEED: 500;
+};
+declare function feistel(seed: Checksum256Type, idx: number, key: string): number;
+declare function feistelInv(seed: Checksum256Type, idx: number, key: string): number;
+type Region = {
+    rx: number;
+    ry: number;
+};
+declare function regionOf(x: number, y: number): Region;
+declare function partnerRegion(seed: Checksum256Type, R: Region): Region;
+declare function wormholeAtRegionEndpoint(seed: Checksum256Type, rx: number, ry: number): {
+    from: {
+        x: number;
+        y: number;
+    };
+    to: {
+        x: number;
+        y: number;
+    };
+} | null;
+declare function wormholeAt(seed: Checksum256Type, x: number, y: number): {
+    x: number;
+    y: number;
+} | null;
+declare function isValidWormholePair(seed: Checksum256Type, ax: number, ay: number, bx: number, by: number): boolean;
+
+declare function rollupGatherer(lanes: Types.gatherer_lane[]): {
+    yield: UInt16;
+    drain: UInt32;
+    depth: UInt16;
+} | undefined;
+declare function rollupCrafter(lanes: Types.crafter_lane[]): {
+    speed: UInt16;
+    drain: UInt32;
+} | undefined;
+declare function rollupLoaders(lanes: Types.loader_lane[]): {
+    mass: UInt32;
+    thrust: UInt16;
+    quantity: UInt8;
+} | undefined;
 
 interface ResolvedItemStat {
     key: string;
@@ -2936,6 +4248,7 @@ interface ResolvedAttributeGroup {
 type ResolvedItemType = 'resource' | 'component' | 'module' | 'entity';
 interface ResolvedModuleSlot {
     name?: string;
+    capability?: string;
     installed: boolean;
     attributes?: {
         label: string;
@@ -3013,25 +4326,115 @@ declare function deserializeAsset(data: Record<string, any>, itemId: number): NF
 
 declare function computeBaseHullmass(stats: bigint): number;
 declare function computeBaseCapacityShip(stats: bigint): number;
+declare function computeBaseCapacityContainer(stats: bigint): number;
+declare function computeBaseCapacityContainerT2(stats: bigint): number;
 declare function computeBaseCapacityWarehouse(stats: bigint): number;
 declare const computeEngineThrust: (vol: number) => number;
 declare const computeEngineDrain: (thm: number) => number;
+declare const ENGINE_DRAIN_BASE = 118;
+declare const ENGINE_DRAIN_REF_THRUST = 775;
+declare const ENGINE_DRAIN_REF_THM = 500;
+declare const computeTravelDrain: (totalThrust: number, avgThm: 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 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: (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 const computeCargoBayCapacity: (strength: number, density: number, hardness: number, cohesion: number) => number;
+declare const computeBatteryBankCapacity: (volatility: number, thermal: number, plasticity: number, insulation: 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;
@@ -3045,24 +4448,59 @@ declare const index_deserializeEntity: typeof deserializeEntity;
 declare const index_deserializeAsset: typeof deserializeAsset;
 declare const index_computeBaseHullmass: typeof computeBaseHullmass;
 declare const index_computeBaseCapacityShip: typeof computeBaseCapacityShip;
+declare const index_computeBaseCapacityContainer: typeof computeBaseCapacityContainer;
+declare const index_computeBaseCapacityContainerT2: typeof computeBaseCapacityContainerT2;
 declare const index_computeBaseCapacityWarehouse: typeof computeBaseCapacityWarehouse;
 declare const index_computeEngineThrust: typeof computeEngineThrust;
 declare const index_computeEngineDrain: typeof computeEngineDrain;
+declare const index_ENGINE_DRAIN_BASE: typeof ENGINE_DRAIN_BASE;
+declare const index_ENGINE_DRAIN_REF_THRUST: typeof ENGINE_DRAIN_REF_THRUST;
+declare const index_ENGINE_DRAIN_REF_THM: typeof ENGINE_DRAIN_REF_THM;
+declare const index_computeTravelDrain: typeof computeTravelDrain;
 declare const index_computeGeneratorCap: typeof computeGeneratorCap;
 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_computeCargoBayCapacity: typeof computeCargoBayCapacity;
+declare const index_computeBatteryBankCapacity: typeof computeBatteryBankCapacity;
 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,
@@ -3078,37 +4516,82 @@ declare namespace index {
     index_deserializeAsset as deserializeAsset,
     index_computeBaseHullmass as computeBaseHullmass,
     index_computeBaseCapacityShip as computeBaseCapacityShip,
+    index_computeBaseCapacityContainer as computeBaseCapacityContainer,
+    index_computeBaseCapacityContainerT2 as computeBaseCapacityContainerT2,
     index_computeBaseCapacityWarehouse as computeBaseCapacityWarehouse,
     index_computeEngineThrust as computeEngineThrust,
     index_computeEngineDrain as computeEngineDrain,
+    index_ENGINE_DRAIN_BASE as ENGINE_DRAIN_BASE,
+    index_ENGINE_DRAIN_REF_THRUST as ENGINE_DRAIN_REF_THRUST,
+    index_ENGINE_DRAIN_REF_THM as ENGINE_DRAIN_REF_THM,
+    index_computeTravelDrain as computeTravelDrain,
     index_computeGeneratorCap as computeGeneratorCap,
     index_computeGeneratorRech as computeGeneratorRech,
     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_computeCargoBayCapacity as computeCargoBayCapacity,
+    index_computeBatteryBankCapacity as computeBatteryBankCapacity,
     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;
@@ -3159,23 +4642,40 @@ 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;
 
+interface LanePlanEntry {
+    slot: number;
+    quantity: number;
+}
+type PlanTarget = {
+    quantity: number;
+} | 'max';
+interface GatherPlanEntity extends Projectable {
+    gatherer_lanes: Types.gatherer_lane[];
+    loader_lanes: Types.loader_lane[];
+}
+declare function planParallelGather(entity: GatherPlanEntity, target: PlanTarget, stratum: number, now: Date): LanePlanEntry[];
+declare function planParallelTransfer(entity: GatherPlanEntity, target: PlanTarget): LanePlanEntry[];
+
+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 gatherer_stats = Types.gatherer_stats;
+type entity_row = Types.entity_row;
 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, SLOT_FORMULAS, STARTER_ALREADY_CLAIMED, ScheduleAccessor, ScheduleCapability, ScheduleData, Scheduleable, server as ServerContract, ServerMessage, Types as ServerTypes, Ship, ShipCapabilities, ShipEntity, ShipLike, ShipStateInput, Shipload, SlotConsumer, SlotConsumerKind, 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, computeWarpRange, container_row, coordsToLocationId, createInventoryAccessor, createProjectedEntity, createScheduleAccessor, decodeCraftedItemStats, decodeStat, decodeStats, Shipload as default, deriveLocation, deriveLocationEpoch, deriveLocationSize, deriveLocationStatic, deriveResourceStats, deriveStatMappings, 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, 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, BroadEntitySubscriptionFilter, BuildMethod, BuildState, BuildableTarget, CANCEL_CONTAINS_GROUPED_TASK, 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, COORD_MAX, COORD_MIN, COORD_OFFSET, CRAFT_ENERGY_DIVISOR, CRAFT_EXCEEDS_ENERGY_CAPACITY, CRAFT_NOT_ENOUGH_ENERGY, CancelBlockReason, CancelEffects, CancelEligibilityInput, CancelPlan, CancelRefund, CancelReleasedHold, CapabilityAttribute, CapabilityInput, CargoData, CargoMassInfo, CargoStack, CategoryInfo, CategoryStacks, ClientMessage, ComputedCapabilities, ConnectionState, ConstructionManager, Container, ContainerEntity, Coord, CoordinateAddress, Coordinates, CoordinatesType, CounterpartLookup, CraftedItemCategory, CrafterCapability, CrafterStats, DEPLOY_ENTITY_HAS_SCHEDULE, DEPTH_THRESHOLD_T1, DEPTH_THRESHOLD_T2, DEPTH_THRESHOLD_T3, DEPTH_THRESHOLD_T4, DEPTH_THRESHOLD_T5, DESTINATION_CAPACITY_EXCEEDED, DecodedAtomicAsset, DemandRow, DerivedStratum, DescribeOptions, DisplayNameResult, Distance, ENGINE_DRAIN_BASE, ENGINE_DRAIN_REF_THM, ENGINE_DRAIN_REF_THRUST, 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, EntitiesSubscriptionHandle, Entity$1 as Entity, EntityCapabilities, EntityClass, EntityDeletedMessage, EntityInfo$2 as EntityInfo, EntityInstance, EntityInventory, EntityLayout, EntityRefInput, EntitySlot, EntityState, EntityStateInput, EntitySubscriptionFilter, EntitySubscriptionHandle, EntitySubscriptionHandlers, EntitySubscriptionMeta, EntityTypeName, EpochInfo, EpochsManager, ErrorMessage, EstimateTravelTimeOptions, EstimatedTravelTime, EventCatchupCompleteMessage, EventMessage, ExactEntitySubscriptionFilter, 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_MASS_DIVISOR, 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, GatherPlanEntity, GathererCapability, GathererDepthParams, GathererStats, HasCapacity, HasCargo, HasCargomass, HasScheduleAndLocation, HoldKind, 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_LAUNCHER_T1, ITEM_LOADER_T1, ITEM_MASS_CATCHER_T1_PACKED, ITEM_MASS_DRIVER_T1_PACKED, 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, IdleResolveTarget, ImmutableEntry, ImmutableModuleSlot, InboundTransfer, InstalledModule, InventoryAccessor, Item, ItemType, KindMeta, LANE_BARRIER, LANE_MOBILITY, LOCAL_HALF, LOCATION_MAX_DEPTH, LOCATION_MIN_DEPTH, LanePlanEntry, LaneView, LaunchNumericInput, LaunchQuote, LaunchQuoteCatcher, LaunchQuoteLauncher, LaunchStatsInput, LoadTimeBreakdown, LoaderCapability, LoaderStats, Location, LocationStratum, LocationType, LocationsManager, MAX_LEGS, 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, Neighbor, 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, PlanRouteParams, PlanTarget, 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, REGION_DIV, REGION_PER_AXIS, REQUIRES_MORE_THAN_ONE, REQUIRES_POSITIVE_VALUE, RESERVE_TIERS, RESOLVE_COUNT_EXCEEDS_COMPLETED, RESOURCE_TIER_ADJECTIVES, RESOURCE_TIER_MULT_TENTHS, RawData, ReachStats, Recipe, RecipeConsumer, RecipeInput, RecipeSlotInput, RenderDescriptionOptions, Reservation, ReserveTier, ResolvedAttributeGroup, ResolvedCrafterLane, ResolvedEvent, ResolvedGathererLane, ResolvedItem, ResolvedItemStat, ResolvedItemType, ResolvedLoaderLane, ResolvedModuleSlot, ResourceCategory, ResourceDemand, ResourceStats, RouteFailure, RouteFailureReason, RoutePlan, RouteResult, SECTORS_PER_AXIS, SECTOR_DIV, 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, StatFlow, StatMapping, StatSlot, StorageCapability, StratumInfo, SubscribeEntityMessage, SubscribeEventsMessage, SubscribeMessage, SubscriptionEntityType, SubscriptionsManager, SubscriptionsOptions, SystemGraph, TIER_ROLL_MAX, TRAVEL_MAX_DURATION, TaskCancelable, TaskCargoChange, TaskCargoDirection, TaskType, TemplateMeta, TextSpan, TierRange, TransferEntity, UnsubscribeEntityMessage, UnsubscribeEventsMessage, UnsubscribeMessage, UpdateBoundsMessage, UpdateMessage, ValidateDisplayNameOptions, WAREHOUSE_ALREADY_AT_LOCATION, WAREHOUSE_NOT_FOUND, WARP_HAS_CARGO, WARP_HAS_SCHEDULE, WARP_NOT_FULL_ENERGY, WARP_NO_CAPABILITY, WARP_OUT_OF_RANGE, WH, WOULD_OVERFILL, WOULD_STRAND, Warehouse, WarehouseEntity, WebSocketConnection, WebSocketConnectionOptions, WireCoordinates, WireEntity, WrapDeposit, YIELD_FRACTION_DEEP, YIELD_FRACTION_SHALLOW, addressFromCoordinates, allBuildableItems, allPlotBuildableItems, applyResourceTierMultiplier, 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_onesided_duration, calc_orbital_altitude, calc_rechargetime, calc_ship_acceleration, calc_ship_flighttime, calc_ship_mass, calc_ship_rechargetime, calc_transfer_duration, calc_transit_duration, calculateFlightTime, calculateLoadTimeBreakdown, calculateRefuelingTime, calculateTransferTime, canMove, cancelEligibility, candidateLaneCompletesAt, capabilityAttributes, capabilityNames, capsHasCrafter, capsHasGatherer, capsHasHauler, capsHasLauncher, capsHasLoaders, capsHasMass, capsHasMovement, capsHasStorage, cargoItem, cargoItemToStack, cargoReadyAt, cargoRef, cargoUtils, cargo_item, categoryColors, categoryFromIndex, categoryLabel, categoryLabelFromIndex, componentIcon, composeIdleResolve, computeBaseCapacity, computeBaseCapacityShip, computeBaseCapacityWarehouse, computeBaseHullmass, computeBatteryCapabilities, computeComponentStats, computeContainerCapabilities, computeContainerT2Capabilities, computeCraftedOutputStats, computeCrafterCapabilities, computeCrafterDrain, computeCrafterSpeed, computeEngineCapabilities, computeEngineDrain, computeEngineThrust, computeEntityCapabilities, computeEntityStats, computeGathererCapabilities, computeGathererDepth, computeGathererDrain, computeGathererYield, computeGeneratorCap, computeGeneratorCapabilities, computeGeneratorRech, computeGroupPerLegReach, computeHaulPenalty, computeHaulerCapabilities, computeHaulerCapacity, computeHaulerDrain$1 as computeHaulerDrain, computeHaulerEfficiency, computeInputMass, computeLauncherCapabilities, computeLoaderCapabilities, computeLoaderMass, computeLoaderThrust, computeNftImageUrl, computePerLegReach, computeShipHullCapabilities, computeStorageCapabilities, computeTravelDrain, computeWarehouseHullCapabilities, computeWarpCapabilities, computeWarpRange, coordsToLocationId, createInventoryAccessor, createProjectedEntity, createScheduleAccessor, decodeAddress, decodeAtomicAsset, decodeCraftedItemStats, decodeRegion, decodeSector, 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, encodeAddress, encodeAddressMemo, encodeGatheredCargoStats, encodeRegion, encodeSector, encodeStats, energyAtTime, energyPercent, energy_stats, entityDisplayName, entity_row, estimateDealTravelTime, estimateTravelTime, feistel, feistelInv, fetchAtomicAssetsForOwner, fetchAtomicSchemas, filterByBuildMethod, findNearbyPlanets, flightSpeedFactor, formatLocation, formatMass, formatMassDelta, formatMassScaled, formatModuleLine, formatTier, gathererDepthForTier, getAllRecipes, getCapabilityAttributes, getCategoryInfo, getComponentDemand, getComponents, getCurrentEpoch, getDepthThreshold, getDestinationLocation, getEffectiveReserve, getEligibleResources, getEntityClass, getEntityItems, getEntityLayout, getEpochInfo, getFlightOrigin, getInterpolatedPosition, getItem, getItems, getKindMeta, getLocationCandidates, getLocationKind, getLocationProfile, getLocationType, getLocationTypeName, getModuleCapabilityType, getModules, getPackedEntityType, getPlanetSubtype, getPlanetSubtypes, getPositionAt, getRecipe, getRecipeConsumers, getResourceDemand, 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, isValidWormholePair, isWarehouse, itemAbbreviations, itemCategory, itemIds, itemOffset, itemTier, itemTypeCode, kindCan, lane, laneKeyForModule, lerp, location_derived, location_static, makeEntity, mapEntity, maxCraftable, maxTravelDistance, mergeStacks, moduleAccepts, moduleDisplayName, moduleIcon, moduleSlotTypeToCode, movement_stats, needsRecharge, normalizeDisplayName, parseWireEntity, partnerRegion, planParallelGather, planParallelTransfer, planRoute, projectEntity, projectEntityAt, projectRemainingAt, projectedCargoAvailableAt, rawScheduleEnd, readCommonBase, regionOf, removeFromStacks, renderDescription, resolveItem, resolveItemCategory, resolveLaneCrafter, resolveLaneGatherer, resolveLaneLoader, resolveLockedAmount, resolveStats, rollTier, rollWithinTier, rollupCrafter, rollupGatherer, rollupLoaders, rotation, schedule, sdkSystemGraph, selectGatherLane, setSubscriptionsDebug, stackKey, stackToCargoItem, stacksEqual, starRating, starsForStat, statMagnitude, subtractFromStacks, task, taskCargoChanges, taskCargoEffect, tierAdjective, tierColors, tierOfReserve, toLocation, typeLabel, validateDisplayName, validateSchedule, workerLaneKey, wormholeAt, wormholeAtRegionEndpoint, yieldThresholdAt };