@shipload/sdk 0.7.0 → 2.0.0-rc1

package/lib/shipload.d.ts

@@ -1,4 +1,6 @@
-import { Blob, ABI, Struct, Name, UInt64, Checksum256, UInt32, TimePointSec, Checksum256Type, UInt32Type, NameType, UInt64Type, Action, Int64, UInt16, TimePoint, UInt8, Float64, Int64Type, UInt16Type, Checksum512, APIClient } from '@wharfkit/antelope';
+import * as _wharfkit_antelope from '@wharfkit/antelope';
+import { Blob, ABI, Struct, Name, UInt64, Checksum256, UInt32, TimePointSec, Checksum256Type, UInt32Type, NameType, UInt64Type, Action, UInt16, Int64, UInt8, TimePoint, UInt8Type, TimePointType, Int64Type, UInt16Type, Checksum512, APIClient } from '@wharfkit/antelope';
+import * as _wharfkit_contract from '@wharfkit/contract';
 import { Contract as Contract$2, PartialBy, ContractArgs, ActionOptions, Table } from '@wharfkit/contract';
 import { ChainDefinition } from '@wharfkit/session';
 
@@ -160,25 +162,64 @@ declare namespace Types {
         reveal: string;
         commit: Checksum256;
     }
-    class arrive extends Struct {
-        id: UInt64;
-    }
     class buygoods extends Struct {
         ship_id: UInt64;
-        good_id: UInt64;
-        quantity: UInt64;
+        good_id: UInt16;
+        quantity: UInt32;
     }
     class buyship extends Struct {
         account: Name;
         name: string;
     }
+    class buywarehouse extends Struct {
+        account: Name;
+        ship_id: UInt64;
+        name: string;
+    }
+    class cancel extends Struct {
+        entity_type: Name;
+        id: UInt64;
+        count: UInt64;
+    }
+    class coordinates extends Struct {
+        x: Int64;
+        y: Int64;
+        z?: UInt16;
+    }
+    class cargo_item extends Struct {
+        good_id: UInt16;
+        quantity: UInt32;
+        unit_cost: UInt64;
+    }
+    class task extends Struct {
+        type: UInt8;
+        duration: UInt32;
+        cancelable: UInt8;
+        location?: coordinates;
+        cargo: cargo_item[];
+        entity?: UInt64;
+        credits?: Int64;
+    }
+    class cancel_log extends Struct {
+        owner: Name;
+        entity_type: Name;
+        entity_id: UInt64;
+        task_index: UInt8;
+        task: task;
+        started_at: TimePoint;
+    }
+    class cancel_results extends Struct {
+        entity_id: UInt64;
+        entity_type: Name;
+        cancelled_count: UInt8;
+        schedule_started?: TimePoint;
+    }
     class cargo_row extends Struct {
         id: UInt64;
-        ship_id: UInt64;
+        entity_id: UInt64;
         good_id: UInt64;
-        paid: UInt64;
-        owned: UInt32;
-        loaded: UInt32;
+        quantity: UInt64;
+        unit_cost: UInt64;
     }
     class cleartable extends Struct {
         table_name: Name;
@@ -188,17 +229,101 @@ declare namespace Types {
     class commit extends Struct {
         commit: Checksum256;
     }
-    class coordinates extends Struct {
+    class enable extends Struct {
+        enabled: boolean;
+    }
+    class energy_stats extends Struct {
+        capacity: UInt16;
+        recharge: UInt16;
+    }
+    class loader_stats extends Struct {
+        mass: UInt32;
+        thrust: UInt16;
+        quantity: UInt8;
+    }
+    class movement_stats extends Struct {
+        thrust: UInt32;
+        drain: UInt16;
+    }
+    class schedule extends Struct {
+        started: TimePoint;
+        tasks: task[];
+    }
+    class entity_info extends Struct {
+        type: Name;
+        id: UInt64;
+        owner: Name;
+        entity_name: string;
+        location: coordinates;
+        cargomass: UInt32;
+        cargo: cargo_item[];
+        loaders?: loader_stats;
+        energy?: UInt16;
+        mass?: UInt32;
+        engines?: movement_stats;
+        generator?: energy_stats;
+        capacity?: UInt32;
+        is_idle: boolean;
+        current_task?: task;
+        current_task_elapsed: UInt32;
+        current_task_remaining: UInt32;
+        pending_tasks: task[];
+        idle_at?: TimePoint;
+        schedule?: schedule;
+    }
+    class entity_state extends Struct {
+        location: coordinates;
+        energy: UInt16;
+    }
+    class entity_summary extends Struct {
+        type: Name;
+        id: UInt64;
+        owner: Name;
+        entity_name: string;
+        location: coordinates;
+        is_idle: boolean;
+        resolved_count: UInt32;
+        pending_count: UInt32;
+    }
+    class entity_task_info extends Struct {
+        entity_id: UInt64;
+        entity_type: Name;
+        task_count: UInt8;
+        schedule_started: TimePoint;
+    }
+    class getentities extends Struct {
+        owner: Name;
+        entity_type?: Name;
+    }
+    class getentity extends Struct {
+        entity_type: Name;
+        entity_id: UInt64;
+    }
+    class getgoods extends Struct {
+    }
+    class getlocation extends Struct {
         x: Int64;
         y: Int64;
     }
-    class enable extends Struct {
-        enabled: boolean;
+    class getnearby extends Struct {
+        entity_type: Name;
+        entity_id: UInt64;
+        recharge: boolean;
     }
-    class good_price extends Struct {
+    class getplayer extends Struct {
+        account: Name;
+    }
+    class getsummaries extends Struct {
+        owner: Name;
+        entity_type?: Name;
+    }
+    class good extends Struct {
         id: UInt16;
-        price: UInt64;
-        supply: UInt64;
+        base_price: UInt32;
+        mass: UInt32;
+    }
+    class goods_info extends Struct {
+        goods: good[];
     }
     class hash extends Struct {
         value: string;
@@ -209,18 +334,20 @@ declare namespace Types {
     class init extends Struct {
         seed: Checksum256;
     }
-    class jettison extends Struct {
-        ship_id: UInt64;
-        good_id: UInt16;
-        quantity: UInt64;
-    }
     class join extends Struct {
         account: Name;
     }
-    class loader_stats extends Struct {
-        mass: UInt32;
-        quantity: UInt16;
-        thrust: UInt32;
+    class location_good extends Struct {
+        id: UInt16;
+        price: UInt32;
+        supply: UInt16;
+        rarity_multiplier: UInt32;
+        location_multiplier: UInt32;
+    }
+    class location_info extends Struct {
+        coords: coordinates;
+        is_system: boolean;
+        goods: location_good[];
     }
     class location_row extends Struct {
         id: UInt64;
@@ -229,73 +356,108 @@ declare namespace Types {
         good_id: UInt16;
         supply: UInt16;
     }
-    class marketprice extends Struct {
-        location: coordinates;
-        good_id: UInt16;
+    class logcancel extends Struct {
+        log: cancel_log;
     }
-    class marketprices extends Struct {
-        location: coordinates;
+    class resolve_log extends Struct {
+        owner: Name;
+        entity_type: Name;
+        entity_id: UInt64;
+        task_index: UInt8;
+        task: task;
+        started_at: TimePoint;
+        completed_at: TimePoint;
+        new_energy?: UInt16;
+        new_location?: coordinates;
+        cargomass_delta: Int64;
+        cargo_added: cargo_item[];
+        cargo_removed: cargo_item[];
+        credits?: Int64;
+    }
+    class logresolve extends Struct {
+        log: resolve_log;
+    }
+    class nearby_system extends Struct {
+        distance: UInt64;
+        energy_cost: UInt64;
+        flight_time: UInt32;
+        location: location_info;
+    }
+    class nearby_info extends Struct {
+        can_travel: boolean;
+        current: entity_state;
+        projected: entity_state;
+        max_energy: UInt16;
+        systems: nearby_system[];
     }
     class payloan extends Struct {
         account: Name;
         amount: UInt64;
     }
+    class player_info extends Struct {
+        owner: Name;
+        is_player: boolean;
+        company_name: string;
+        balance: UInt64;
+        debt: UInt32;
+        networth: Int64;
+        available_loan: UInt64;
+        next_ship_price: UInt64;
+        next_warehouse_price: UInt64;
+        ship_count: UInt64;
+        warehouse_count: UInt64;
+    }
     class player_row extends Struct {
         owner: Name;
         balance: UInt64;
-        debt: UInt64;
+        debt: UInt32;
         networth: Int64;
     }
+    class purgesupply extends Struct {
+        max_rows?: UInt64;
+    }
+    class recharge extends Struct {
+        entity_type: Name;
+        id: UInt64;
+    }
+    class resolve extends Struct {
+        entity_type: Name;
+        id: UInt64;
+    }
+    class resolve_results extends Struct {
+        entity_id: UInt64;
+        entity_type: Name;
+        resolved_count: UInt8;
+        new_schedule_started?: TimePoint;
+    }
     class salt extends Struct {
         salt: UInt64;
     }
     class sellgoods extends Struct {
         ship_id: UInt64;
-        good_id: UInt64;
-        quantity: UInt64;
+        good_id: UInt16;
+        quantity: UInt32;
     }
     class sequence_row extends Struct {
         key: Name;
         value: UInt64;
     }
-    class ship_state extends Struct {
-        energy: UInt32;
-    }
-    class ship_stats extends Struct {
-        capacity: UInt32;
-        drain: UInt32;
-        mass: UInt64;
-        maxmass: UInt64;
-        orbit: UInt16;
-        recharge: UInt32;
-        thrust: UInt64;
-    }
-    class travel_plan extends Struct {
-        departure: TimePoint;
-        destination: coordinates;
-        distance: UInt64;
-        flighttime: UInt32;
-        loadtime: UInt32;
-        rechargetime: UInt32;
-        masspenalty: UInt32;
-        mass: UInt64;
-        energyusage: UInt32;
-    }
     class ship_row extends Struct {
         id: UInt64;
         owner: Name;
         name: string;
         location: coordinates;
-        skin: UInt8;
-        tier: UInt8;
-        state: ship_state;
-        stats: ship_stats;
+        mass: UInt32;
+        capacity: UInt32;
+        energy: UInt16;
+        engines: movement_stats;
+        generator: energy_stats;
         loaders: loader_stats;
-        travelplan?: travel_plan;
+        schedule?: schedule;
     }
     class state_row extends Struct {
         enabled: boolean;
-        epoch: UInt64;
+        epoch: UInt32;
         salt: UInt64;
         ships: UInt32;
         seed: Checksum256;
@@ -305,35 +467,27 @@ declare namespace Types {
         account: Name;
         amount: UInt64;
     }
-    class travel extends Struct {
-        id: UInt64;
-        destination: coordinates;
-        recharge: boolean;
+    class task_results extends Struct {
+        entities: entity_task_info[];
     }
-    class travel_summary extends Struct {
-        stats: ship_stats;
-        loaders: loader_stats;
-        origin: coordinates;
-        destination: coordinates;
-        distance: UInt64;
-        totalmass: UInt64;
-        acceleration: Float64;
-        flighttime: UInt32;
-        energyusage: UInt32;
-        rechargetime: UInt32;
-        masspenalty: UInt32;
-        loadtime: UInt64;
-        time: UInt64;
-    }
-    class travelplan extends Struct {
+    class transfer extends Struct {
+        source_type: Name;
+        source_id: UInt64;
+        dest_type: Name;
+        dest_id: UInt64;
+        good_id: UInt16;
+        quantity: UInt32;
+    }
+    class travel extends Struct {
+        entity_type: Name;
         id: UInt64;
-        origin: coordinates;
-        destination: coordinates;
+        x: Int64;
+        y: Int64;
         recharge: boolean;
     }
-    class traveltime extends Struct {
+    class types_row extends Struct {
         id: UInt64;
-        destination: coordinates;
+        entity_summary_type: entity_summary;
     }
     class updatecredit extends Struct {
         account: Name;
@@ -343,9 +497,14 @@ declare namespace Types {
         account: Name;
         amount: Int64;
     }
-    class upgradeship extends Struct {
-        account: Name;
+    class warehouse_row extends Struct {
         id: UInt64;
+        owner: Name;
+        name: string;
+        location: coordinates;
+        capacity: UInt32;
+        loaders: loader_stats;
+        schedule?: schedule;
     }
     class wipe extends Struct {
     }
@@ -359,6 +518,8 @@ declare const TableMap: {
     sequence: typeof Types.sequence_row;
     ship: typeof Types.ship_row;
     state: typeof Types.state_row;
+    types: typeof Types.types_row;
+    warehouse: typeof Types.warehouse_row;
 };
 interface TableTypes {
     cargo: Types.cargo_row;
@@ -367,32 +528,79 @@ interface TableTypes {
     sequence: Types.sequence_row;
     ship: Types.ship_row;
     state: Types.state_row;
+    types: Types.types_row;
+    warehouse: Types.warehouse_row;
 }
 type RowType<T> = T extends keyof TableTypes ? TableTypes[T] : any;
 type TableNames = keyof TableTypes;
 declare namespace ActionParams {
     namespace Type {
+        interface cancel_log {
+            owner: NameType;
+            entity_type: NameType;
+            entity_id: UInt64Type;
+            task_index: UInt8Type;
+            task: Type.task;
+            started_at: TimePointType;
+        }
+        interface task {
+            type: UInt8Type;
+            duration: UInt32Type;
+            cancelable: UInt8Type;
+            location?: Type.coordinates;
+            cargo: Type.cargo_item[];
+            entity?: UInt64Type;
+            credits?: Int64Type;
+        }
         interface coordinates {
             x: Int64Type;
             y: Int64Type;
+            z?: UInt16Type;
+        }
+        interface cargo_item {
+            good_id: UInt16Type;
+            quantity: UInt32Type;
+            unit_cost: UInt64Type;
+        }
+        interface resolve_log {
+            owner: NameType;
+            entity_type: NameType;
+            entity_id: UInt64Type;
+            task_index: UInt8Type;
+            task: Type.task;
+            started_at: TimePointType;
+            completed_at: TimePointType;
+            new_energy?: UInt16Type;
+            new_location?: Type.coordinates;
+            cargomass_delta: Int64Type;
+            cargo_added: Type.cargo_item[];
+            cargo_removed: Type.cargo_item[];
+            credits?: Int64Type;
         }
     }
     interface advance {
         reveal: string;
         commit: Checksum256Type;
     }
-    interface arrive {
-        id: UInt64Type;
-    }
     interface buygoods {
         ship_id: UInt64Type;
-        good_id: UInt64Type;
-        quantity: UInt64Type;
+        good_id: UInt16Type;
+        quantity: UInt32Type;
     }
     interface buyship {
         account: NameType;
         name: string;
     }
+    interface buywarehouse {
+        account: NameType;
+        ship_id: UInt64Type;
+        name: string;
+    }
+    interface cancel {
+        entity_type: NameType;
+        id: UInt64Type;
+        count: UInt64Type;
+    }
     interface cleartable {
         table_name: NameType;
         scope?: NameType;
@@ -404,6 +612,32 @@ declare namespace ActionParams {
     interface enable {
         enabled: boolean;
     }
+    interface getentities {
+        owner: NameType;
+        entity_type?: NameType;
+    }
+    interface getentity {
+        entity_type: NameType;
+        entity_id: UInt64Type;
+    }
+    interface getgoods {
+    }
+    interface getlocation {
+        x: Int64Type;
+        y: Int64Type;
+    }
+    interface getnearby {
+        entity_type: NameType;
+        entity_id: UInt64Type;
+        recharge: boolean;
+    }
+    interface getplayer {
+        account: NameType;
+    }
+    interface getsummaries {
+        owner: NameType;
+        entity_type?: NameType;
+    }
     interface hash {
         value: string;
     }
@@ -413,52 +647,57 @@ declare namespace ActionParams {
     interface init {
         seed: Checksum256Type;
     }
-    interface jettison {
-        ship_id: UInt64Type;
-        good_id: UInt16Type;
-        quantity: UInt64Type;
-    }
     interface join {
         account: NameType;
     }
-    interface marketprice {
-        location: Type.coordinates;
-        good_id: UInt16Type;
+    interface logcancel {
+        log: Type.cancel_log;
     }
-    interface marketprices {
-        location: Type.coordinates;
+    interface logresolve {
+        log: Type.resolve_log;
     }
     interface payloan {
         account: NameType;
         amount: UInt64Type;
     }
+    interface purgesupply {
+        max_rows?: UInt64Type;
+    }
+    interface recharge {
+        entity_type: NameType;
+        id: UInt64Type;
+    }
+    interface resolve {
+        entity_type: NameType;
+        id: UInt64Type;
+    }
     interface salt {
         salt: UInt64Type;
     }
     interface sellgoods {
         ship_id: UInt64Type;
-        good_id: UInt64Type;
-        quantity: UInt64Type;
+        good_id: UInt16Type;
+        quantity: UInt32Type;
     }
     interface takeloan {
         account: NameType;
         amount: UInt64Type;
     }
-    interface travel {
-        id: UInt64Type;
-        destination: Type.coordinates;
-        recharge: boolean;
+    interface transfer {
+        source_type: NameType;
+        source_id: UInt64Type;
+        dest_type: NameType;
+        dest_id: UInt64Type;
+        good_id: UInt16Type;
+        quantity: UInt32Type;
     }
-    interface travelplan {
+    interface travel {
+        entity_type: NameType;
         id: UInt64Type;
-        origin: Type.coordinates;
-        destination: Type.coordinates;
+        x: Int64Type;
+        y: Int64Type;
         recharge: boolean;
     }
-    interface traveltime {
-        id: UInt64Type;
-        destination: Type.coordinates;
-    }
     interface updatecredit {
         account: NameType;
         amount: Int64Type;
@@ -467,10 +706,6 @@ declare namespace ActionParams {
         account: NameType;
         amount: Int64Type;
     }
-    interface upgradeship {
-        account: NameType;
-        id: UInt64Type;
-    }
     interface wipe {
     }
     interface wipesequence {
@@ -478,40 +713,58 @@ declare namespace ActionParams {
 }
 interface ActionNameParams {
     advance: ActionParams.advance;
-    arrive: ActionParams.arrive;
     buygoods: ActionParams.buygoods;
     buyship: ActionParams.buyship;
+    buywarehouse: ActionParams.buywarehouse;
+    cancel: ActionParams.cancel;
     cleartable: ActionParams.cleartable;
     commit: ActionParams.commit;
     enable: ActionParams.enable;
+    getentities: ActionParams.getentities;
+    getentity: ActionParams.getentity;
+    getgoods: ActionParams.getgoods;
+    getlocation: ActionParams.getlocation;
+    getnearby: ActionParams.getnearby;
+    getplayer: ActionParams.getplayer;
+    getsummaries: ActionParams.getsummaries;
     hash: ActionParams.hash;
     hash512: ActionParams.hash512;
     init: ActionParams.init;
-    jettison: ActionParams.jettison;
     join: ActionParams.join;
-    marketprice: ActionParams.marketprice;
-    marketprices: ActionParams.marketprices;
+    logcancel: ActionParams.logcancel;
+    logresolve: ActionParams.logresolve;
     payloan: ActionParams.payloan;
+    purgesupply: ActionParams.purgesupply;
+    recharge: ActionParams.recharge;
+    resolve: ActionParams.resolve;
     salt: ActionParams.salt;
     sellgoods: ActionParams.sellgoods;
     takeloan: ActionParams.takeloan;
+    transfer: ActionParams.transfer;
     travel: ActionParams.travel;
-    travelplan: ActionParams.travelplan;
-    traveltime: ActionParams.traveltime;
     updatecredit: ActionParams.updatecredit;
     updatedebt: ActionParams.updatedebt;
-    upgradeship: ActionParams.upgradeship;
     wipe: ActionParams.wipe;
     wipesequence: ActionParams.wipesequence;
 }
 type ActionNames = keyof ActionNameParams;
 interface ActionReturnValues {
+    buygoods: Types.task_results;
+    cancel: Types.cancel_results;
+    getentities: Types.entity_info[];
+    getentity: Types.entity_info;
+    getgoods: Types.goods_info;
+    getlocation: Types.location_info;
+    getnearby: Types.nearby_info;
+    getplayer: Types.player_info;
+    getsummaries: Types.entity_summary[];
     hash: Checksum256;
     hash512: Checksum512;
-    marketprice: Types.good_price;
-    marketprices: Types.good_price[];
-    travelplan: Types.travel_plan;
-    traveltime: Types.travel_summary;
+    recharge: Types.task_results;
+    resolve: Types.resolve_results;
+    sellgoods: Types.task_results;
+    transfer: Types.task_results;
+    travel: Types.task_results;
 }
 type ActionReturnNames = keyof ActionReturnValues;
 declare class Contract extends Contract$2 {
@@ -553,32 +806,90 @@ declare namespace server {
   };
 }
 
-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;
-
-declare const ERROR_SYSTEM_NOT_INITIALIZED = "System not initialized";
-declare const GOOD_DOES_NOT_EXIST = "Good does not exist";
-declare const GOOD_NOT_AVAILABLE_AT_LOCATION = "Good not available at location";
-declare const PLAYER_NOT_FOUND = "Player not found";
-declare const SHIP_NOT_FOUND = "Ship not found";
-declare const SHIP_CANNOT_BUY_TRAVELING = "Ship cannot buy while traveling";
-declare const INSUFFICIENT_BALANCE = "Insufficient balance";
-declare const INSUFFICIENT_GOOD_QUANTITY = "Insufficient good quantity";
-declare const REQUIRES_MORE_THAN_ONE = "Requires more than one";
+declare const COMPANY_NOT_FOUND = "Cannot find company for given account.";
+declare const COMMIT_ALREADY_SET = "Commit has already been set.";
+declare const COMMIT_CANNOT_MATCH = "Next commit cannot match current commit.";
+declare const COMMIT_NOT_SET = "Commit has not been set.";
+declare const EPOCH_NON_ZERO = "Epoch must be greater than zero.";
+declare const EPOCH_NOT_READY = "Current epoch is not ready to advance";
+declare const ERROR_SYSTEM_ALREADY_INITIALIZED = "This game has already been initialized.";
+declare const ERROR_SYSTEM_DISABLED = "This game is currently disabled.";
+declare const ERROR_SYSTEM_NOT_INITIALIZED = "This game has not been initialized.";
+declare const GAME_NOT_FOUND = "Cannot find game for given account name.";
+declare const GAME_SEED_NOT_SET = "This game has not initialized an epoch seed value.";
+declare const GOOD_DOES_NOT_EXIST = "Good does not exist.";
+declare const GOOD_NOT_AVAILABLE_AT_LOCATION = "Good is not tradeable at ship location.";
+declare const INSUFFICIENT_BALANCE = "Insufficient balance.";
+declare const INSUFFICIENT_GOOD_QUANTITY = "Insufficient quantity in cargo.";
+declare const INSUFFICIENT_GOOD_SUPPLY = "Insufficient supply of good at location.";
+declare const INVALID_AMOUNT = "Invalid amount.";
+declare const REQUIRES_MORE_THAN_ONE = "A value greater than one is required.";
+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_FOUND = "Cannot find player for given account name.";
+declare const SHIP_ALREADY_THERE = "Ship cannot travel to the location its 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 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 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.";
+declare const SHIP_NOT_IDLE = "Ship must be idle (no active schedule) for this action.";
+declare const SHIP_NO_COMPLETED_TASKS = "No completed tasks to resolve.";
+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 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 PRECISION = 10000;
-declare const TRAVEL_MAXMASS_PENALTY = 5;
-interface CameraPosition extends ActionParams.Type.coordinates {
-    z: number;
+declare const INITIAL_SHIP_MASS = 500000;
+declare const MIN_ORBITAL_ALTITUDE = 800;
+declare const MAX_ORBITAL_ALTITUDE = 3000;
+interface ShipLike {
+    location: Types.coordinates;
+    mass: UInt32;
+    energy: UInt16;
+    engines: Types.movement_stats;
+    generator: Types.energy_stats;
+    loaders: Types.loader_stats;
+    capacity: UInt32;
 }
-interface Dimensions {
-    width: number;
-    height: number;
+interface CargoMassInfo {
+    good_id: UInt16Type;
+    quantity: UInt32Type;
+}
+declare enum TaskType {
+    RECHARGE = 0,
+    LOAD = 1,
+    UNLOAD = 2,
+    FLIGHT = 3
+}
+declare enum TaskCancelable {
+    NEVER = 0,
+    BEFORE_START = 1,
+    ALWAYS = 2
+}
+declare const EntityType$1: {
+    readonly SHIP: Name;
+    readonly WAREHOUSE: Name;
+};
+type EntityTypeName = (typeof EntityType$1)[keyof typeof EntityType$1];
+type CoordinatesType = Coordinates | Types.coordinates | {
+    x: Int64Type;
+    y: Int64Type;
+};
+declare class Coordinates extends Types.coordinates {
+    static from(value: CoordinatesType): Coordinates;
+    equals(other: CoordinatesType): boolean;
 }
 interface Distance {
     origin: ActionParams.Type.coordinates;
@@ -589,83 +900,1060 @@ declare class Good extends Struct {
     id: UInt16;
     name: string;
     description: string;
-    base_price: UInt64;
-    mass: UInt64;
-}
-interface GoodType {
-    id: UInt16Type;
-    name: string;
-    description: string;
-    base_price: UInt64Type;
-    mass: UInt64Type;
+    base_price: UInt32;
+    mass: UInt32;
 }
 declare class GoodPrice extends Struct {
     id: UInt16;
     good: Good;
-    price: UInt64;
-    supply: UInt64;
+    price: UInt32;
+    supply: UInt16;
 }
-interface Coordinates extends ActionParams.Type.coordinates {
+
+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;
 
-declare const goodIds: any[];
-declare function getGood(good_id: UInt16Type): Good;
-declare function getGoods(): Good[];
+/**
+ * GameState class extends the state_row from the server contract
+ * with helper methods for epoch management and system generation
+ */
+declare class GameState extends Types.state_row {
+    private _game?;
+    /**
+     * Create a GameState instance from a state_row
+     */
+    static from(state: Types.state_row, game?: Types$1.game_row): GameState;
+    /**
+     * Set the game configuration (needed for epoch calculations)
+     */
+    setGame(game: Types$1.game_row): void;
+    /**
+     * Get the current epoch number from the state
+     */
+    get currentEpoch(): UInt64;
+    /**
+     * Get the epoch seed (used for market pricing and system generation)
+     */
+    get epochSeed(): Checksum256;
+    /**
+     * Get the game seed (from game config, if available)
+     */
+    get gameSeed(): Checksum256 | undefined;
+    /**
+     * 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
+     */
+    get calculatedCurrentEpoch(): UInt64 | undefined;
+    /**
+     * Get epoch info (start/end times) for the current epoch
+     */
+    get currentEpochInfo(): EpochInfo | undefined;
+    /**
+     * Get epoch info for a specific epoch number
+     */
+    getEpochInfo(epoch: UInt64): EpochInfo | undefined;
+    /**
+     * Check if a system exists at given coordinates
+     * Requires game seed from game config
+     */
+    hasSystemAt(x: number, y: number): boolean;
+    /**
+     * Check if a system exists at coordinates object
+     */
+    hasSystemAtCoords(coords: Types.coordinates): boolean;
+    /**
+     * Get a summary of the game state
+     */
+    get summary(): {
+        enabled: boolean;
+        epoch: string;
+        ships: number;
+        hasSeed: boolean;
+        hasCommit: boolean;
+    };
+}
 
-declare function hash(seed: Checksum256Type, string: string): Checksum512;
-declare function hash512(seed: Checksum256Type, string: string): Checksum512;
+interface PlayerStateInput {
+    owner: NameType;
+    balance: UInt64Type;
+    debt: UInt32Type;
+    networth: Int64Type;
+}
+/**
+ * Player helper class extending player_row with computed financial properties.
+ * Provides easy access to balance, debt, networth, and loan calculations.
+ */
+declare class Player extends Types.player_row {
+    /**
+     * Construct a Player instance from individual state pieces.
+     * Used by UI's ReactivePlayer to reconstruct Player from reactive state.
+     */
+    static fromState(state: PlayerStateInput): Player;
+    private static readonly MAX_LOAN;
+    private static readonly BASE_SHIP_COST;
+    private static readonly SHIP_COST_MULTIPLIER;
+    private _shipCount?;
+    /**
+     * Set the current ship count (needed for nextShipCost calculation)
+     */
+    setShipCount(count: number): void;
+    /**
+     * Get the current ship count (if set)
+     */
+    get shipCount(): number | undefined;
+    /**
+     * Calculate the cost of the next ship based on current ship count
+     * Matches contract: pow(5, sequence) * 100
+     * @param shipCount - Optional ship count (uses cached value if not provided)
+     */
+    getNextShipCost(shipCount?: number): UInt64;
+    /**
+     * Get the cost of the next ship based on cached ship count
+     */
+    get nextShipCost(): UInt64;
+    /**
+     * Check if player can afford to buy a ship
+     * @param shipCount - Optional ship count (uses cached value if not provided)
+     */
+    canBuyShip(shipCount?: number): boolean;
+    /**
+     * Calculate available loan amount (max loan - current debt)
+     */
+    get availableLoan(): UInt64;
+    /**
+     * Check if player can take out a loan
+     */
+    get canTakeLoan(): boolean;
+    /**
+     * Check if player can pay back loan
+     */
+    get canPayLoan(): boolean;
+    /**
+     * Calculate maximum payback amount (min of debt and balance)
+     */
+    get maxPayback(): UInt64;
+    /**
+     * Get the maximum loan amount (constant)
+     */
+    static get MAX_LOAN_LIMIT(): number;
+    /**
+     * Check if player is in debt
+     */
+    get hasDebt(): boolean;
+    /**
+     * Check if player is solvent (positive networth)
+     */
+    get isSolvent(): boolean;
+    /**
+     * Create an optimistic update for balance changes
+     * Uses integer math to match contract
+     * @param delta - Amount to change (can be negative)
+     */
+    withBalanceChange(delta: UInt64 | number): Player;
+    /**
+     * Create an optimistic update for debt changes
+     * Uses integer math to match contract
+     * @param delta - Amount to change (can be negative)
+     */
+    withDebtChange(delta: UInt64 | number): Player;
+    /**
+     * Create an optimistic update for taking a loan
+     */
+    withLoan(amount: UInt64): Player;
+    /**
+     * Create an optimistic update for paying back a loan
+     */
+    withLoanPayment(amount: UInt64): Player;
+    /**
+     * Simulate networth update from selling goods.
+     * Matches contract: networth += (sellPrice - paid * quantity)
+     * Contract reference: market.cpp:75
+     *
+     * @param sellPrice - Total revenue from sale (price * quantity)
+     * @param paidPerUnit - Average cost per unit paid (from cargo.paid)
+     * @param quantity - Quantity being sold
+     * @returns New player with updated networth
+     *
+     * @example
+     * // Sold 10 units at 150 each (revenue=1500), paid 100 per unit
+     * const newPlayer = player.withSaleNetworth(
+     *     UInt64.from(1500),
+     *     UInt64.from(100),
+     *     UInt32.from(10)
+     * )
+     * // Networth increases by: 1500 - (100*10) = 500
+     */
+    withSaleNetworth(sellPrice: UInt64, paidPerUnit: UInt64, quantity: UInt64): Player;
+    /**
+     * Simulate complete sell goods transaction.
+     * Updates both balance (adds revenue) and networth (adds profit).
+     * Matches contract actions: update_balance + update_networth
+     *
+     * @param sellPrice - Total revenue from sale (price * quantity)
+     * @param paidPerUnit - Average cost per unit paid (from cargo.paid)
+     * @param quantity - Quantity being sold
+     * @returns New player with updated balance and networth
+     */
+    withSellGoods(sellPrice: UInt64, paidPerUnit: UInt64, quantity: UInt64): Player;
+    /**
+     * Simulate complete buy goods transaction.
+     * Updates balance (subtracts cost).
+     *
+     * @param purchaseCost - Total cost of purchase (price * quantity)
+     * @returns New player with updated balance
+     */
+    withBuyGoods(purchaseCost: UInt64): Player;
+}
 
-declare function getSystemName(gameSeed: Checksum256, location: Coordinates): string;
-declare function hasSystem(gameSeed: Checksum256, coordinates: ActionParams.Type.coordinates): boolean;
+declare class PlayersManager extends BaseManager {
+    getPlayer(account: NameType): Promise<Player | undefined>;
+}
 
-declare enum Rarities {
-    legendary = "LEGENDARY",
-    epic = "EPIC",
-    rare = "RARE",
-    uncommon = "UNCOMMON",
-    common = "COMMON",
-    trash = "TRASH"
+/**
+ * Location helper class for working with game coordinates.
+ * Provides system detection, market price caching, nearby planet finding, and supply tracking.
+ */
+declare class Location {
+    readonly coordinates: Coordinates;
+    private _marketPrices?;
+    private _gameSeed?;
+    private _hasSystem?;
+    private _locationRows?;
+    private _epoch?;
+    constructor(coordinates: CoordinatesType);
+    /**
+     * Create a Location from coordinates
+     */
+    static from(coordinates: CoordinatesType): Location;
+    /**
+     * Check if this location has a system (planet)
+     */
+    hasSystemAt(gameSeed: Checksum256Type): boolean;
+    /**
+     * Set cached market prices for this location
+     */
+    setMarketPrices(prices: GoodPrice[]): void;
+    /**
+     * Get cached market prices (returns undefined if not cached)
+     */
+    get marketPrices(): GoodPrice[] | undefined;
+    /**
+     * Get price for a specific good (from cache)
+     */
+    getPrice(goodId: UInt16Type): GoodPrice | undefined;
+    /**
+     * Find nearby planets from this location
+     */
+    findNearby(gameSeed: Checksum256Type, maxDistance?: UInt16Type): Distance[];
+    /**
+     * Check if this location equals another location
+     */
+    equals(other: CoordinatesType | Location): boolean;
+    /**
+     * Set location rows (supply data) for this location
+     */
+    setLocationRows(rows: Types.location_row[], epoch: UInt64): void;
+    /**
+     * Get cached location rows (supply data)
+     */
+    get locationRows(): Types.location_row[] | undefined;
+    /**
+     * Get supply for a specific good at this location
+     * Returns undefined if location rows not cached or good not found
+     */
+    getSupply(goodId: UInt16Type): UInt16 | undefined;
+    /**
+     * Get all available goods at this location (goods with supply > 0)
+     * Returns undefined if location rows not cached
+     */
+    get availableGoods(): Types.location_row[] | undefined;
+    /**
+     * Check if a specific good is available (has supply)
+     * Returns false if location rows not cached
+     */
+    hasGood(goodId: UInt16Type): boolean;
+    /**
+     * Get the epoch for cached location data
+     */
+    get epoch(): UInt64 | undefined;
+    /**
+     * Check if cached data exists
+     */
+    get hasCachedData(): boolean;
+    /**
+     * Check if supply data is cached
+     */
+    get hasSupplyData(): boolean;
+    /**
+     * Clear all cached data
+     */
+    clearCache(): void;
+    /**
+     * Create optimistic Location with updated supply after purchase/sale.
+     * Matches contract: update_location_supply (delta can be positive or negative)
+     * Contract reference: market.cpp:53, 123-151
+     *
+     * @param goodId - Good ID to update supply for
+     * @param quantityDelta - Change in supply (negative for purchase, positive for sale)
+     * @returns New Location with updated supply in cached data
+     *
+     * @example
+     * // After buying 10 units (supply decreases)
+     * const newLocation = location.withUpdatedSupply(1, -10)
+     *
+     * // After selling 5 units (supply increases)
+     * const newLocation = location.withUpdatedSupply(1, 5)
+     */
+    withUpdatedSupply(goodId: UInt16Type, quantityDelta: number): Location;
 }
-interface Rarity {
-    rarity: Rarities;
-    minMultiplier: number;
-    maxMultiplier: number;
+/**
+ * Helper function to convert various coordinate types to Location
+ */
+declare function toLocation(coords: CoordinatesType | Location): Location;
+
+declare class LocationsManager extends BaseManager {
+    getMarketPrice(location: CoordinatesType, goodId: number): Promise<GoodPrice>;
+    getMarketPrices(location: CoordinatesType): Promise<GoodPrice[]>;
+    getMarketPricesWithSupply(location: CoordinatesType): Promise<GoodPrice[]>;
+    hasSystem(location: CoordinatesType): Promise<boolean>;
+    findNearbyPlanets(origin: CoordinatesType, maxDistance?: UInt16Type): Promise<Distance[]>;
+    getLocation(location: CoordinatesType): Promise<any[]>;
+    getLocationWithPrices(coords: CoordinatesType): Promise<Location>;
+    getLocationWithSupply(coords: CoordinatesType): Promise<Location>;
+    getLocationComplete(coords: CoordinatesType): Promise<Location>;
 }
-declare function generateLocationSeed(epochSeed: Checksum256Type, location: Coordinates, entitySalt: string): string;
-declare function getRarity(gameSeed: Checksum256Type, epochSeed: Checksum256Type, location: Coordinates, good_id: UInt16Type): Rarity;
-declare function getRarityMultiplier(gameSeed: Checksum256Type, epochSeed: Checksum256Type, location: Coordinates, good_id: UInt16Type): number;
-declare function getLocationMultiplier(gameSeed: Checksum256Type, location: Coordinates, good_id: UInt16Type): number;
-declare function getSupply(gameSeed: Checksum256Type, state: Types.state_row, location: Coordinates, good_id: UInt16Type): number;
-declare function marketprice(location: ActionParams.Type.coordinates, good_id: UInt16Type, gameSeed: Checksum256Type, state: Types.state_row): GoodPrice;
-declare function marketprices(location: ActionParams.Type.coordinates, gameSeed: Checksum256Type, state: Types.state_row): GoodPrice[];
 
-declare class Ship extends Types.ship_row {
+type Schedule = Types.schedule;
+type Task = Types.task;
+interface ScheduleData {
+    schedule?: Schedule;
+}
+interface Scheduleable extends ScheduleData {
+    hasSchedule: boolean;
+    isIdle: boolean;
+    tasks: Task[];
+    scheduleDuration(): number;
+    scheduleElapsed(now: Date): number;
+    scheduleRemaining(now: Date): number;
+    scheduleComplete(now: Date): boolean;
+    currentTaskIndex(now: Date): number;
+    currentTask(now: Date): Task | 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(entity: ScheduleData): boolean;
+declare function isIdle(entity: ScheduleData): boolean;
+declare function getTasks(entity: ScheduleData): Task[];
+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 | 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;
+
+type schedule_ScheduleData = ScheduleData;
+type schedule_Scheduleable = Scheduleable;
+declare const schedule_hasSchedule: typeof hasSchedule;
+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 namespace schedule {
+  export {
+    schedule_ScheduleData as ScheduleData,
+    schedule_Scheduleable as Scheduleable,
+    schedule_hasSchedule 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,
+  };
+}
+
+declare class EntityInventory extends Types.cargo_item {
+    private _good?;
+    get good(): Good;
+    get name(): string;
+    get unitMass(): UInt32;
+    get totalMass(): UInt64;
+    get totalCost(): UInt64;
+    get hasCargo(): boolean;
+    get isEmpty(): boolean;
+}
+
+/**
+ * Projected state of an entity after scheduled tasks complete.
+ * Mirrors contract's projected_entity struct.
+ */
+interface ProjectedEntity {
+    location: Coordinates;
+    energy: UInt16;
+    cargoMass: UInt64;
+    shipMass: UInt32;
+    capacity?: UInt64;
+    engines?: Types.movement_stats;
+    loaders?: Types.loader_stats;
+    generator?: Types.energy_stats;
+    readonly totalMass: UInt64;
+}
+/**
+ * Interface for entities that can be projected.
+ * Ships and Warehouses both implement this.
+ */
+interface Projectable extends ScheduleData {
+    location: Coordinates;
+    energy: UInt16;
+    mass: UInt32;
+    generator?: Types.energy_stats;
+    engines?: Types.movement_stats;
+    loaders?: Types.loader_stats;
+    capacity?: UInt64;
+    calcCargoMass(): UInt64;
+}
+/**
+ * Create initial projected entity state from a projectable entity.
+ */
+declare function createProjectedEntity(entity: Projectable): ProjectedEntity;
+/**
+ * Project entity state after all scheduled tasks complete.
+ * Mirrors contract's project_ship/project_warehouse methods.
+ */
+declare function projectEntity(entity: Projectable): ProjectedEntity;
+/**
+ * Project entity state at a specific time (partial task execution).
+ */
+declare function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity;
+
+interface ShipStateInput {
+    id: UInt64Type;
+    owner: NameType;
+    name: string;
+    location: CoordinatesType | {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    mass: number;
+    capacity: number;
+    energy: number;
+    engines: Types.movement_stats;
+    generator: Types.energy_stats;
+    loaders: Types.loader_stats;
+    schedule?: Types.schedule;
+    cargo?: Types.cargo_item[];
+}
+declare class Ship extends Types.entity_info implements Scheduleable {
+    static fromState(state: ShipStateInput): Ship;
+    private _location?;
+    private _inventory?;
+    get name(): string;
+    get inventory(): EntityInventory[];
     get maxDistance(): UInt32;
-    get traveling(): boolean;
-    get arrived(): boolean;
-    get eta(): number;
+    get hasSchedule(): boolean;
+    get isIdle(): boolean;
+    get tasks(): Types.task[];
+    scheduleDuration(): number;
+    scheduleElapsed(now: Date): number;
+    scheduleRemaining(now: Date): number;
+    scheduleComplete(now: Date): boolean;
+    currentTaskIndex(now: Date): number;
+    currentTask(now: Date): Types.task | 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;
+    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;
+    calcCargoMass(): UInt64;
+    private createProjectedEntity;
+    project(): ProjectedEntity;
+    projectAt(now: Date): ProjectedEntity;
+    get currentLocation(): Coordinates;
+    get totalCargoMass(): UInt64;
+    get cargoValue(): UInt64;
+    get totalMass(): UInt64;
+    get maxCapacity(): UInt64;
+    hasSpace(goodMass: UInt64, quantity: number): boolean;
+    get availableCapacity(): UInt64;
+    get locationObject(): Location;
+    setLocation(location: Location): void;
+    getCargoForGood(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;
+    calculateSaleValue(prices: Map<number, UInt64>): {
+        revenue: UInt64;
+        profit: UInt64;
+        cost: UInt64;
+    };
+    calculateSaleValueFromArray(prices: UInt64[]): {
+        revenue: UInt64;
+        profit: UInt64;
+        cost: UInt64;
+    };
+    afterSellGoods(goodsToSell: Array<{
+        goodId: number;
+        quantity: number;
+    }>): EntityInventory[];
+    afterSellAllGoods(): EntityInventory[];
 }
 
-declare function travelplanDuration(travelplan: Types.travel_plan): UInt64;
-declare function distanceTraveled(ship: Types.ship_row, current?: Date): number;
+/**
+ * Travel calculations for ship movement, energy usage, and flight times.
+ *
+ * Functions prefixed with `calc_` are contract-parity functions that mirror
+ * the C++ implementation in the server contract (schedule.cpp, ship.cpp).
+ * These use snake_case intentionally to match the contract naming convention
+ * and signal that they must produce identical results to the on-chain code.
+ *
+ * Functions prefixed with `calculate` are higher-level SDK helpers that may
+ * combine multiple contract calculations for convenience.
+ */
+
+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;
 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 travelplan(game: Types$1.game_row, ship: Types.ship_row, cargos: Types.cargo_row[], origin: ActionParams.Type.coordinates, destination: ActionParams.Type.coordinates, recharge: boolean, alwaysValid?: boolean): Types.travel_plan;
-declare function calc_mass_penalty(ship: Types.ship_row, mass: UInt64Type): UInt32;
 declare function calc_rechargetime(capacity: UInt32Type, energy: UInt32Type, recharge: UInt32Type): UInt32;
-declare function calc_ship_rechargetime(ship: Types.ship_row): UInt32;
-declare function calc_ship_loadtime(ship: Types.ship_row, cargos: Types.cargo_row[]): UInt32;
+declare function calc_ship_rechargetime(ship: ShipLike): UInt32;
 declare function calc_flighttime(distance: UInt64Type, acceleration: number): UInt32;
-declare function calc_loader_flighttime(ship: Types.ship_row, mass: UInt64): UInt32;
-declare function calc_loader_acceleration(ship: Types.ship_row, mass: UInt64): number;
-declare function calc_ship_flighttime(ship: Types.ship_row, mass: UInt64, distance: UInt64): UInt32;
-declare function calc_ship_acceleration(ship: Types.ship_row, mass: UInt64): number;
+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;
+declare function calc_ship_acceleration(ship: ShipLike, mass: UInt64): number;
 declare function calc_acceleration(thrust: number, mass: number): number;
-declare function calc_ship_mass(ship: Types.ship_row, cargos: Types.cargo_row[]): UInt64;
+declare function calc_ship_mass(ship: ShipLike, cargos: CargoMassInfo[]): UInt64;
 declare function calc_energyusage(distance: UInt64Type, drain: UInt32Type): UInt32;
+declare function calculateTransferTime(ship: ShipLike, cargos: CargoMassInfo[], quantities?: Map<number, number>): UInt32;
+declare function calculateRefuelingTime(ship: ShipLike): UInt32;
+declare function calculateFlightTime(ship: ShipLike, cargos: CargoMassInfo[], distance: UInt64Type): UInt32;
+interface LoadTimeBreakdown {
+    unloadTime: number;
+    loadTime: number;
+    totalTime: number;
+    unloadMass: number;
+    loadMass: number;
+}
+declare function calculateLoadTimeBreakdown(ship: ShipLike, cargos: CargoMassInfo[], loadQuantities?: Map<number, number>, unloadQuantities?: Map<number, number>): LoadTimeBreakdown;
+interface EstimatedTravelTime {
+    flightTime: UInt32;
+    rechargeTime: UInt32;
+    loadTime: UInt32;
+    unloadTime: UInt32;
+    total: UInt32;
+}
+interface EstimateTravelTimeOptions {
+    needsRecharge?: boolean;
+    loadMass?: UInt32Type;
+    unloadMass?: UInt32Type;
+}
+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 TransferEntity {
+    location: {
+        z?: {
+            toNumber(): number;
+        } | number;
+    };
+    loaders?: {
+        thrust: {
+            toNumber(): number;
+        } | number;
+        mass: {
+            toNumber(): number;
+        } | number;
+        quantity: {
+            toNumber(): number;
+        } | number;
+    };
+}
+declare function calc_transfer_duration(source: TransferEntity, dest: TransferEntity, cargoMass: number): number;
+
+/**
+ * Trading deal interface representing a profitable trade opportunity
+ */
+interface Deal {
+    /** Origin location */
+    origin: Location;
+    /** Destination location */
+    destination: Location;
+    /** Good to trade */
+    good: GoodPrice;
+    /** Distance between origin and destination */
+    distance: UInt64;
+    /** Available supply at origin */
+    supply: UInt16;
+    /** Buy price at origin */
+    buyPrice: UInt32;
+    /** Sell price at destination */
+    sellPrice: UInt32;
+    /** Profit per unit */
+    profitPerUnit: UInt32;
+    /** Maximum quantity that can be traded */
+    maxQuantity: UInt32;
+    /** Total profit for max quantity */
+    totalProfit: Int64;
+    /** Estimated travel time in seconds */
+    travelTime: UInt32;
+    /** Detailed breakdown of travel time components */
+    travelTimeBreakdown: EstimatedTravelTime;
+    /** Profit per second (floating point for UI display) */
+    profitPerSecond: number;
+    /** Profit margin percentage (floating point for UI display) */
+    marginPercent: number;
+}
+/**
+ * Options for finding deals
+ */
+interface FindDealsOptions {
+    /** Maximum number of deals to return */
+    maxDeals?: number;
+    /** Maximum search distance */
+    maxDistance?: number;
+    /** Player's current balance (for affordability filtering) */
+    playerBalance?: UInt64Type;
+    /** Minimum profit per second threshold */
+    minProfitPerSecond?: number;
+    /** Minimum profit margin percentage */
+    minMarginPercent?: number;
+    /** Override available cargo space (in mass units). If provided, uses this instead of calculating from ship's current cargo. */
+    availableSpace?: number;
+}
+/**
+ * Calculate deals for a ship from a specific origin location
+ */
+declare function findDealsForShip(ship: Ship, originLocation: Coordinates, getNearbyLocations: (origin: Coordinates, maxDistance: number) => Promise<Location[]>, getMarketPrices: (location: Coordinates) => Promise<GoodPrice[]>, options?: FindDealsOptions): Promise<Deal[]>;
+/**
+ * Find the single best deal for a ship from a specific origin location
+ */
+declare function findBestDeal(ship: Ship, originLocation: Coordinates, getNearbyLocations: (origin: Coordinates, maxDistance: number) => Promise<Location[]>, getMarketPrices: (location: Coordinates) => Promise<GoodPrice[]>, options?: FindDealsOptions): Promise<Deal | undefined>;
+
+/**
+ * Types of collect actions available to the player
+ */
+type CollectActionType = 'sell-and-trade' | 'sell-and-reposition' | 'travel-to-sell' | 'sell-and-stay' | 'explore' | 'orbit';
+/**
+ * Represents a single collect option presented to the player
+ */
+interface CollectOption {
+    /** Unique identifier for this option */
+    id: string;
+    /** Type of action sequence */
+    type: CollectActionType;
+    /** Human-readable title */
+    title: string;
+    /** Detailed description of what will happen */
+    description: string;
+    /** Brief explanation of why this option is worth considering */
+    reason: string;
+    /** Whether this is the recommended option (best profitPerSecond with quality threshold) */
+    recommended: boolean;
+    /** Whether this option has the highest absolute profit (may differ from recommended) */
+    highestProfit: boolean;
+    /** Estimated profit/loss from this action */
+    estimatedProfit: UInt64;
+    /** Revenue from selling cargo (if applicable) */
+    saleRevenue?: UInt64;
+    /** Cost of purchasing new cargo (if applicable) */
+    purchaseCost?: UInt64;
+    /** Expected profit from the next trade (if applicable) */
+    nextTradeProfit?: UInt64;
+    /** Profit per second for this option (floating point for display) */
+    profitPerSecond?: number;
+    /** Margin percentage for the deal (floating point for display) */
+    marginPercent?: number;
+    /** Destination location (if traveling) */
+    destination?: Location;
+    /** Deal to execute (if buying goods) */
+    deal?: Deal;
+    /** Sale location if different from current */
+    saleLocation?: Location;
+    /** Price per unit at sale location */
+    salePrice?: UInt32;
+    /** Price per unit at current location (for comparison) */
+    currentPrice?: UInt32;
+    /** Estimated travel time in seconds (undefined = instant/no travel) */
+    travelTime?: UInt32;
+    /** Detailed breakdown of travel time components */
+    travelTimeBreakdown?: EstimatedTravelTime;
+    /** Info about a discounted good at the destination (for explore options) */
+    discountedGood?: DiscountedGoodInfo;
+    /** Top potential deals available at destination (for explore options) */
+    potentialDeals?: PotentialDeal[];
+    /** Details of cargo being sold (if selling cargo) */
+    cargoSale?: CargoSaleItem[];
+    /** Total profit/loss from selling cargo */
+    cargoProfitLoss?: Int64;
+}
+/**
+ * Analysis result for collect options
+ */
+interface CollectAnalysis {
+    /** Current location where ship arrived */
+    arrivedAt: Coordinates;
+    /** Ship being analyzed */
+    ship: Ship;
+    /** Current cargo on ship */
+    cargo: EntityInventory[];
+    /** Value of cargo if sold at current location */
+    cargoValueHere: UInt64;
+    /** All available options, sorted by estimated profit */
+    options: CollectOption[];
+    /** Whether any profitable options exist */
+    hasProfitableOptions: boolean;
+}
+/**
+ * Options for analyzing collect choices
+ */
+interface CollectAnalysisOptions {
+    /** Player's current balance (defaults to Infinity) */
+    playerBalance?: number;
+    /** Maximum distance to search (defaults to ship's max range) */
+    maxDistance?: number;
+    /** Minimum profit improvement to suggest traveling elsewhere to sell */
+    minSaleImprovement?: number;
+}
+/**
+ * Find locations where current cargo could be sold for more
+ */
+interface BetterSaleLocation {
+    location: Location;
+    /** Price per unit at this location */
+    price: UInt32;
+    /** Total revenue if sold here */
+    revenue: UInt64;
+    /** Difference vs selling at current location */
+    improvement: Int64;
+    /** Best deal available at this location after selling */
+    bestDealAfterSale?: Deal;
+    /** Distance to this location */
+    distance: UInt64;
+    /** Estimated travel time */
+    travelTime: UInt32;
+    /** Detailed breakdown of travel time components */
+    travelTimeBreakdown?: EstimatedTravelTime;
+}
+/**
+ * Find locations with good deals when current location has none
+ */
+interface RepositionLocation {
+    location: Location;
+    /** Best deal available at this location */
+    bestDeal: Deal;
+    /** Distance to this location */
+    distance: UInt64;
+    /** Estimated travel time */
+    travelTime: UInt32;
+    /** Detailed breakdown of travel time components */
+    travelTimeBreakdown?: EstimatedTravelTime;
+}
+/**
+ * Analyze cargo sale value at a specific location
+ */
+declare function analyzeCargoSale(cargo: EntityInventory[], prices: Map<number, UInt64>): {
+    revenue: UInt64;
+    cost: UInt64;
+    profit: Int64;
+};
+/**
+ * Create a "Sell & Trade" option (full loop)
+ */
+declare function createSellAndTradeOption(saleRevenue: UInt64, saleCost: UInt64, deal: Deal, cargoSale?: CargoSaleItem[], unloadTime?: UInt32): CollectOption;
+/**
+ * Create a "Travel to Sell" option (better market elsewhere)
+ */
+declare function createTravelToSellOption(currentRevenue: UInt64, cargoCost: UInt64, betterSale: BetterSaleLocation, cargo: EntityInventory[], destPrices?: Map<number, UInt64>): CollectOption;
+/**
+ * Create a "Sell & Reposition" option (sell here, travel empty to deals)
+ */
+declare function createSellAndRepositionOption(saleRevenue: UInt64, saleCost: UInt64, reposition: RepositionLocation, cargoSale?: CargoSaleItem[]): CollectOption;
+/**
+ * Create a "Sell & Stay" option (just sell, stay idle)
+ */
+declare function createSellAndStayOption(saleRevenue: UInt64, saleCost: UInt64, cargoSale?: CargoSaleItem[], unloadTime?: UInt32): CollectOption;
+/**
+ * Details about a cargo item being sold
+ */
+interface CargoSaleItem {
+    goodId: UInt16;
+    goodName: string;
+    quantity: UInt32;
+    /** Price per unit at sale location */
+    pricePerUnit: UInt32;
+    /** Total revenue from this item */
+    revenue: UInt64;
+    /** Original cost (paid) per unit */
+    costPerUnit: UInt64;
+    /** Profit/loss on this item */
+    profit: Int64;
+}
+/**
+ * Info about a discounted good for explore options
+ */
+interface DiscountedGoodInfo {
+    goodId: number;
+    name: string;
+    rarity: string;
+    discountPercent: number;
+}
+/**
+ * A potential deal available at a destination (for explore options)
+ */
+interface PotentialDeal {
+    goodId: number;
+    goodName: string;
+    destinationCoords: Coordinates;
+    marginPercent: number;
+    profitPerSecond: number;
+}
+/**
+ * Create an "Explore" option (travel to find opportunities)
+ */
+declare function createExploreOption(destination: Location, travelTime?: UInt32, discountedGood?: DiscountedGoodInfo, travelTimeBreakdown?: EstimatedTravelTime, potentialDeals?: PotentialDeal[]): CollectOption;
+/**
+ * Callbacks for collect analysis (provided by manager)
+ */
+interface CollectAnalysisCallbacks {
+    getNearbyLocations: (origin: Coordinates, maxDistance: number) => Promise<Location[]>;
+    getMarketPrices: (location: Coordinates) => Promise<GoodPrice[]>;
+    getGameSeed?: () => Checksum256Type;
+    getState?: () => Types.state_row;
+}
+/**
+ * Analyze all collect options for a ship that has arrived at its destination.
+ * Returns all available options sorted by estimated profit.
+ */
+declare function analyzeCollectOptions(ship: Ship, arrivedAt: Coordinates, callbacks: CollectAnalysisCallbacks, options?: CollectAnalysisOptions): Promise<CollectAnalysis>;
+
+declare class TradesManager extends BaseManager {
+    private priceCache;
+    private priceCacheEpoch;
+    private makePriceCacheKey;
+    private createCallbacks;
+    clearPriceCache(): void;
+    findDeals(ship: Ship, originLocation?: Coordinates, options?: FindDealsOptions): Promise<Deal[]>;
+    findBestDeal(ship: Ship, originLocation?: Coordinates, options?: FindDealsOptions): Promise<Deal | undefined>;
+    getCollectOptions(ship: Ship, arrivedAt?: Coordinates, options?: CollectAnalysisOptions): Promise<CollectAnalysis>;
+}
+
+declare class EpochsManager extends BaseManager {
+    getCurrentHeight(): Promise<UInt64>;
+    getCurrent(): Promise<EpochInfo>;
+    getByHeight(height: UInt64Type): Promise<EpochInfo>;
+    getTimeRemaining(): Promise<number>;
+    getProgress(): Promise<number>;
+    fitsInCurrentEpoch(durationMs: number): Promise<boolean>;
+}
+
+interface SellableCargo {
+    good_id: {
+        toNumber(): number;
+    } | number;
+    quantity: {
+        toNumber(): number;
+    } | number;
+    hasCargo: boolean;
+}
+type CargoItemInput = {
+    goodId: UInt64Type;
+    quantity: UInt64Type;
+    unitCost?: UInt64Type;
+};
+declare class ActionsManager extends BaseManager {
+    travel(shipId: UInt64Type, destination: CoordinatesType, recharge?: boolean): Action;
+    resolve(entityId: UInt64Type, entityType?: EntityTypeName): Action;
+    cancel(entityId: UInt64Type, count: UInt64Type, entityType?: EntityTypeName): Action;
+    recharge(shipId: UInt64Type): Action;
+    transfer(sourceType: EntityTypeName, sourceId: UInt64Type, destType: EntityTypeName, destId: UInt64Type, cargo: CargoItemInput[]): Action;
+    buyGoods(shipId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type): Action;
+    sellGoods(shipId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type): Action;
+    buyShip(account: NameType, name: string): Action;
+    buyWarehouse(account: NameType, shipId: UInt64Type, name: string): Action;
+    takeLoan(account: NameType, amount: UInt64Type): Action;
+    payLoan(account: NameType, amount: UInt64Type): Action;
+    foundCompany(account: NameType, name: string): Action;
+    join(account: NameType): Action;
+    joinGame(account: NameType, companyName: string): Action[];
+    sellAllCargo(ship: Ship | UInt64Type, cargo?: SellableCargo[]): Action[];
+}
+
+declare class GameContext {
+    readonly client: APIClient;
+    readonly server: Contract$2;
+    readonly platform: Contract$2;
+    private _entities?;
+    private _players?;
+    private _locations?;
+    private _trades?;
+    private _epochs?;
+    private _actions?;
+    private _gameCache?;
+    private _stateCache?;
+    constructor(client: APIClient, server: Contract$2, platform: Contract$2);
+    get entities(): EntitiesManager;
+    get players(): PlayersManager;
+    get locations(): LocationsManager;
+    get trades(): TradesManager;
+    get epochs(): EpochsManager;
+    get actions(): ActionsManager;
+    getGame(reload?: boolean): Promise<Types$1.game_row>;
+    getState(reload?: boolean): Promise<GameState>;
+    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>;
+}
+
+interface WarehouseStateInput {
+    id: UInt64Type;
+    owner: NameType;
+    name: string;
+    location: CoordinatesType | {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    capacity: number;
+    loaders: Types.loader_stats;
+    schedule?: Types.schedule;
+    cargo?: Types.cargo_item[];
+}
+declare class Warehouse extends Types.entity_info implements Scheduleable {
+    static fromState(state: WarehouseStateInput): Warehouse;
+    private _location?;
+    private _inventory?;
+    get name(): string;
+    get inventory(): EntityInventory[];
+    get hasSchedule(): boolean;
+    get isIdle(): boolean;
+    get tasks(): Types.task[];
+    scheduleDuration(): number;
+    scheduleElapsed(now: Date): number;
+    scheduleRemaining(now: Date): number;
+    scheduleComplete(now: Date): boolean;
+    currentTaskIndex(now: Date): number;
+    currentTask(now: Date): Types.task | 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;
+    isLoading(now: Date): boolean;
+    isUnloading(now: Date): boolean;
+    calcCargoMass(): UInt64;
+    get currentLocation(): Coordinates;
+    get totalCargoMass(): UInt64;
+    get cargoValue(): UInt64;
+    get maxCapacity(): UInt64;
+    get availableCapacity(): UInt64;
+    hasSpace(goodMass: UInt64, quantity: number): boolean;
+    get isFull(): boolean;
+    get locationObject(): Location;
+    setLocation(location: Location): void;
+    getCargoForGood(goodId: UInt64Type): EntityInventory | undefined;
+    get orbitalAltitude(): number;
+}
+
+type EntityType = 'ship' | 'warehouse';
+declare class EntitiesManager extends BaseManager {
+    getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse>;
+    getEntities(owner: NameType | Types.player_row, type?: EntityType): Promise<(Ship | Warehouse)[]>;
+    getSummaries(owner: NameType | Types.player_row, type?: EntityType): Promise<Types.entity_summary[]>;
+    getShip(id: UInt64Type): Promise<Ship>;
+    getWarehouse(id: UInt64Type): Promise<Warehouse>;
+    getShips(owner: NameType | Types.player_row): Promise<Ship[]>;
+    getWarehouses(owner: NameType | Types.player_row): Promise<Warehouse[]>;
+    getShipSummaries(owner: NameType | Types.player_row): Promise<Types.entity_summary[]>;
+    getWarehouseSummaries(owner: NameType | Types.player_row): Promise<Types.entity_summary[]>;
+    private wrapEntity;
+    private resolveOwner;
+}
 
 interface ShiploadOptions {
     platformContractName?: string;
@@ -677,26 +1965,163 @@ interface ShiploadConstructorOptions extends ShiploadOptions {
     serverContract?: Contract$2;
 }
 declare class Shipload {
-    client: APIClient;
-    server: Contract$2;
-    platform: Contract$2;
-    game: Types$1.game_row | undefined;
+    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 trades(): TradesManager;
+    get epochs(): EpochsManager;
+    get actions(): ActionsManager;
     getGame(reload?: boolean): Promise<Types$1.game_row>;
-    getState(): Promise<Types.state_row>;
-    getShip(ship_id: UInt64Type): Promise<Ship>;
-    getShips(player: NameType | Types.player_row): Promise<Ship[]>;
-    marketprice(location: ActionParams.Type.coordinates, good_id: number): Promise<GoodPrice>;
-    marketprices(location: ActionParams.Type.coordinates): Promise<GoodPrice[]>;
-    hasSystem(location: ActionParams.Type.coordinates): Promise<boolean>;
-    findNearbyPlanets(origin: ActionParams.Type.coordinates, maxDistance?: UInt16Type): Promise<Distance[]>;
-    travelplan(ship: Types.ship_row, origin: ActionParams.Type.coordinates, destination: ActionParams.Type.coordinates, recharge?: boolean): Promise<Types.travel_plan>;
-    getCargo(ship: UInt64Type | Types.ship_row): Promise<Types.cargo_row[]>;
-    getCurrentEpochHeight(): Promise<UInt64>;
-    getCurrentEpoch(): Promise<EpochInfo>;
-    getEpoch(height: UInt64Type): Promise<EpochInfo>;
-    getLocation(location: Coordinates): Promise<any[]>;
-}
-
-export { CameraPosition, Coordinates, Dimensions, Distance, ERROR_SYSTEM_NOT_INITIALIZED, EpochInfo, GOOD_DOES_NOT_EXIST, GOOD_NOT_AVAILABLE_AT_LOCATION, Good, GoodPrice, GoodType, INSUFFICIENT_BALANCE, INSUFFICIENT_GOOD_QUANTITY, PLAYER_NOT_FOUND, PRECISION, platform as PlatformContract, REQUIRES_MORE_THAN_ONE, Rarities, Rarity, SHIP_CANNOT_BUY_TRAVELING, SHIP_NOT_FOUND, server as ServerContract, Ship, TRAVEL_MAXMASS_PENALTY, calc_acceleration, calc_energyusage, calc_flighttime, calc_loader_acceleration, calc_loader_flighttime, calc_mass_penalty, calc_rechargetime, calc_ship_acceleration, calc_ship_flighttime, calc_ship_loadtime, calc_ship_mass, calc_ship_rechargetime, Shipload as default, distanceBetweenCoordinates, distanceBetweenPoints, distanceTraveled, findNearbyPlanets, generateLocationSeed, getCurrentEpoch, getEpochInfo, getGood, getGoods, getLocationMultiplier, getRarity, getRarityMultiplier, getSupply, getSystemName, goodIds, hasSystem, hash, hash512, lerp, marketprice, marketprices, rotation, travelplan, travelplanDuration };
+    getState(reload?: boolean): Promise<GameState>;
+}
+
+declare const goodIds: number[];
+declare function getGood(goodId: UInt16Type): Good;
+declare function getGoods(): Good[];
+
+declare enum Rarities {
+    legendary = "LEGENDARY",
+    epic = "EPIC",
+    rare = "RARE",
+    uncommon = "UNCOMMON",
+    common = "COMMON",
+    trash = "TRASH"
+}
+interface Rarity {
+    rarity: Rarities;
+    minMultiplier: number;
+    maxMultiplier: number;
+}
+declare function getRarity(gameSeed: Checksum256Type, epochSeed: Checksum256Type, location: CoordinatesType, goodId: UInt16Type): Rarity;
+declare function marketPrice(location: ActionParams.Type.coordinates, goodId: UInt16Type, gameSeed: Checksum256Type, state: Types.state_row): GoodPrice;
+declare function marketPrices(location: ActionParams.Type.coordinates, gameSeed: Checksum256Type, state: Types.state_row): GoodPrice[];
+
+declare function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string;
+declare function hasSystem(gameSeed: Checksum256Type, coordinates: CoordinatesType): boolean;
+
+declare function hash(seed: Checksum256Type, string: string): Checksum512;
+declare function hash512(seed: Checksum256Type, string: string): Checksum512;
+
+/**
+ * Trade calculation result
+ */
+interface TradeCalculation {
+    maxQuantity: number;
+    totalCost: number;
+    totalMass: UInt64;
+    affordableQuantity: number;
+    spaceForQuantity: number;
+}
+/**
+ * Calculate updated weighted average cargo cost after purchase.
+ * Matches contract logic: (paid * owned + cost) / (owned + quantity)
+ *
+ * @param currentPaid - Current average cost per unit (from cargo.paid)
+ * @param currentOwned - Current owned quantity
+ * @param purchaseCost - Total cost of new purchase (price * quantity)
+ * @param purchaseQuantity - Quantity being purchased
+ * @returns New weighted average cost per unit
+ *
+ * @example
+ * // Owned 10 units at 100 each, buying 5 more at 120 each
+ * const newPaid = calculateUpdatedCargoCost(
+ *     UInt64.from(100),
+ *     UInt32.from(10),
+ *     UInt64.from(600),
+ *     UInt32.from(5)
+ * )
+ * // Result: (100*10 + 600) / (10+5) = 106.67 per unit
+ */
+declare function calculateUpdatedCargoCost(currentPaid: UInt64, currentOwned: UInt32, purchaseCost: UInt64, purchaseQuantity: UInt32): UInt64;
+/**
+ * Calculate the maximum quantity of a good a ship can buy
+ * considering both space and player balance
+ */
+declare function calculateMaxTradeQuantity(ship: Ship, player: Player, goodPrice: GoodPrice): TradeCalculation;
+/**
+ * Trade profit calculation result
+ */
+interface TradeProfitResult {
+    revenue: UInt64;
+    cost: UInt64;
+    profit: Int64;
+    margin: number;
+}
+/**
+ * Calculate profit for a trade route
+ */
+declare function calculateTradeProfit(quantity: UInt32Type, buyPrice: UInt32Type, sellPrice: UInt32Type): TradeProfitResult;
+/**
+ * Calculate profit per unit of mass
+ */
+declare function calculateProfitPerMass(quantity: number, buyPrice: number, sellPrice: number, massPerUnit: number): number;
+/**
+ * Calculate profit per second for a trade route
+ */
+declare function calculateProfitPerSecond(profit: Int64Type, travelTimeSeconds: UInt32Type): number;
+/**
+ * Find the best good to trade between two locations
+ */
+declare function findBestGoodToTrade(ship: Ship, player: Player, originPrices: GoodPrice[], destPrices: GoodPrice[], travelTimeSeconds: UInt32Type): {
+    good: GoodPrice;
+    quantity: number;
+    profit: number;
+    profitPerSecond: number;
+    margin: number;
+} | null;
+/**
+ * Calculate break-even price for selling cargo
+ */
+declare function calculateBreakEvenPrice(costPaid: number, quantity: number): number;
+/**
+ * Check if a trade is profitable
+ */
+declare function isProfitable(buyPrice: UInt32Type, sellPrice: UInt32Type): boolean;
+/**
+ * Calculate return on investment percentage
+ */
+declare function calculateROI(cost: number, profit: number): number;
+
+interface CargoData {
+    cargo: EntityInventory[];
+}
+declare function totalCargoMass(cargo: EntityInventory[]): UInt64;
+declare function cargoValue(cargo: EntityInventory[]): UInt64;
+declare function getCargoForGood(cargo: EntityInventory[], goodId: UInt64Type): EntityInventory | undefined;
+declare function hasSpace(currentMass: UInt64, maxCapacity: UInt64, goodMass: UInt64, quantity: number): boolean;
+declare function availableCapacity(currentMass: UInt64, maxCapacity: UInt64): UInt64;
+declare function isFull(currentMass: UInt64, maxCapacity: UInt64): boolean;
+
+type cargoUtils_CargoData = CargoData;
+declare const cargoUtils_totalCargoMass: typeof totalCargoMass;
+declare const cargoUtils_cargoValue: typeof cargoValue;
+declare const cargoUtils_getCargoForGood: typeof getCargoForGood;
+declare const cargoUtils_hasSpace: typeof hasSpace;
+declare const cargoUtils_availableCapacity: typeof availableCapacity;
+declare const cargoUtils_isFull: typeof isFull;
+declare namespace cargoUtils {
+  export {
+    cargoUtils_CargoData as CargoData,
+    cargoUtils_totalCargoMass as totalCargoMass,
+    cargoUtils_cargoValue as cargoValue,
+    cargoUtils_getCargoForGood as getCargoForGood,
+    cargoUtils_hasSpace as hasSpace,
+    cargoUtils_availableCapacity as availableCapacity,
+    cargoUtils_isFull as isFull,
+  };
+}
+
+type movement_stats = Types.movement_stats;
+type energy_stats = Types.energy_stats;
+type loader_stats = Types.loader_stats;
+type task = Types.task;
+type cargo_item = Types.cargo_item;
+type warehouse_row = Types.warehouse_row;
+
+export { ActionsManager, BetterSaleLocation, COMMIT_ALREADY_SET, COMMIT_CANNOT_MATCH, COMMIT_NOT_SET, COMPANY_NOT_FOUND, CargoData, CargoMassInfo, CargoSaleItem, CollectActionType, CollectAnalysis, CollectAnalysisCallbacks, CollectAnalysisOptions, CollectOption, Coordinates, CoordinatesType, Deal, DiscountedGoodInfo, Distance, EPOCH_NON_ZERO, EPOCH_NOT_READY, ERROR_SYSTEM_ALREADY_INITIALIZED, ERROR_SYSTEM_DISABLED, ERROR_SYSTEM_NOT_INITIALIZED, EntitiesManager, EntityInventory, EntityType, EntityTypeName, EpochInfo, EpochsManager, EstimateTravelTimeOptions, EstimatedTravelTime, FindDealsOptions, GAME_NOT_FOUND, GAME_SEED_NOT_SET, GOOD_DOES_NOT_EXIST, GOOD_NOT_AVAILABLE_AT_LOCATION, GameState, Good, GoodPrice, INITIAL_SHIP_MASS, INSUFFICIENT_BALANCE, INSUFFICIENT_GOOD_QUANTITY, INSUFFICIENT_GOOD_SUPPLY, INVALID_AMOUNT, LoadTimeBreakdown, Location, LocationsManager, MAX_ORBITAL_ALTITUDE, MIN_ORBITAL_ALTITUDE, NO_SCHEDULE, PLAYER_ALREADY_JOINED, PLAYER_NOT_FOUND, PRECISION, platform as PlatformContract, Player, PlayerStateInput, PlayersManager, PotentialDeal, Projectable, ProjectedEntity, REQUIRES_MORE_THAN_ONE, REQUIRES_POSITIVE_VALUE, Rarities, Rarity, RepositionLocation, SHIP_ALREADY_THERE, SHIP_ALREADY_TRAVELING, SHIP_CANNOT_BUY_TRAVELING, SHIP_CANNOT_CANCEL_TASK, SHIP_CANNOT_UPDATE_TRAVELING, 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, ScheduleData, Scheduleable, server as ServerContract, Ship, ShipLike, ShipStateInput, Shipload, TaskCancelable, TaskType, TradeCalculation, TradeProfitResult, TradesManager, TransferEntity, WAREHOUSE_ALREADY_AT_LOCATION, WAREHOUSE_CAPACITY_EXCEEDED, WAREHOUSE_NOT_FOUND, Warehouse, analyzeCargoSale, analyzeCollectOptions, calc_acceleration, calc_energyusage, calc_flighttime, 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, calculateBreakEvenPrice, calculateFlightTime, calculateLoadTimeBreakdown, calculateMaxTradeQuantity, calculateProfitPerMass, calculateProfitPerSecond, calculateROI, calculateRefuelingTime, calculateTradeProfit, calculateTransferTime, calculateUpdatedCargoCost, cargoUtils, cargo_item, createExploreOption, createProjectedEntity, createSellAndRepositionOption, createSellAndStayOption, createSellAndTradeOption, createTravelToSellOption, Shipload as default, distanceBetweenCoordinates, distanceBetweenPoints, energy_stats, estimateDealTravelTime, estimateTravelTime, findBestDeal, findBestGoodToTrade, findDealsForShip, findNearbyPlanets, getCurrentEpoch, getEpochInfo, getGood, getGoods, getRarity, getSystemName, goodIds, hasEnergyForDistance, hasSystem, hash, hash512, isProfitable, lerp, loader_stats, marketPrice, marketPrices, movement_stats, projectEntity, projectEntityAt, rotation, schedule, task, toLocation, warehouse_row };