@shipload/sdk 2.0.0-rc1 → 2.0.0-rc2

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, UInt16, Int64, UInt8, TimePoint, UInt8Type, TimePointType, Int64Type, UInt16Type, Checksum512, APIClient } from '@wharfkit/antelope';
+import { Blob, ABI, Struct, Name, UInt64, Checksum256, UInt32, TimePointSec, Checksum256Type, UInt32Type, NameType, UInt64Type, Action, UInt16, UInt8, TimePoint, Int64, UInt8Type, TimePointType, UInt16Type, Int64Type, 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';
@@ -162,8 +162,14 @@ declare namespace Types {
         reveal: string;
         commit: Checksum256;
     }
-    class buygoods extends Struct {
+    class buycontainer extends Struct {
+        account: Name;
         ship_id: UInt64;
+        name: string;
+    }
+    class buygoods extends Struct {
+        entity_type: Name;
+        id: UInt64;
         good_id: UInt16;
         quantity: UInt32;
     }
@@ -181,38 +187,30 @@ declare namespace Types {
         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;
+    class entity_ref extends Struct {
         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;
+        entitygroup?: UInt64;
+        group_members?: entity_ref[];
+    }
+    class mixture_component extends Struct {
+        good_id: UInt16;
+        purity: UInt16;
+    }
+    class mixture_info extends Struct {
+        components: mixture_component[];
+    }
+    class cargo_item extends Struct {
+        good_id: UInt16;
+        quantity: UInt32;
+        unit_cost: UInt64;
+        mixture?: mixture_info;
     }
     class cargo_row extends Struct {
         id: UInt64;
@@ -229,6 +227,36 @@ declare namespace Types {
     class commit extends Struct {
         commit: Checksum256;
     }
+    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;
+        credits?: Int64;
+        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 enable extends Struct {
         enabled: boolean;
     }
@@ -236,6 +264,10 @@ declare namespace Types {
         capacity: UInt16;
         recharge: UInt16;
     }
+    class entity_current_state extends Struct {
+        coordinates: coordinates;
+        energy: UInt16;
+    }
     class loader_stats extends Struct {
         mass: UInt32;
         thrust: UInt16;
@@ -245,24 +277,26 @@ declare namespace Types {
         thrust: UInt32;
         drain: UInt16;
     }
-    class schedule extends Struct {
-        started: TimePoint;
-        tasks: task[];
+    class extractor_stats extends Struct {
+        rate: UInt16;
+        drain: UInt16;
+        efficiency: UInt16;
     }
     class entity_info extends Struct {
         type: Name;
         id: UInt64;
         owner: Name;
         entity_name: string;
-        location: coordinates;
+        coordinates: coordinates;
         cargomass: UInt32;
         cargo: cargo_item[];
         loaders?: loader_stats;
         energy?: UInt16;
-        mass?: UInt32;
+        hullmass?: UInt32;
         engines?: movement_stats;
         generator?: energy_stats;
         capacity?: UInt32;
+        extractor?: extractor_stats;
         is_idle: boolean;
         current_task?: task;
         current_task_elapsed: UInt32;
@@ -271,16 +305,12 @@ declare namespace Types {
         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;
+        coordinates: coordinates;
         is_idle: boolean;
         resolved_count: UInt32;
         pending_count: UInt32;
@@ -291,6 +321,13 @@ declare namespace Types {
         task_count: UInt8;
         schedule_started: TimePoint;
     }
+    class entitygroup_row extends Struct {
+        id: UInt64;
+        participants: entity_ref[];
+    }
+    class extract extends Struct {
+        ship_id: UInt64;
+    }
     class getentities extends Struct {
         owner: Name;
         entity_type?: Name;
@@ -305,6 +342,10 @@ declare namespace Types {
         x: Int64;
         y: Int64;
     }
+    class getlocdata extends Struct {
+        x: Int64;
+        y: Int64;
+    }
     class getnearby extends Struct {
         entity_type: Name;
         entity_id: UInt64;
@@ -313,6 +354,8 @@ declare namespace Types {
     class getplayer extends Struct {
         account: Name;
     }
+    class getstarter extends Struct {
+    }
     class getsummaries extends Struct {
         owner: Name;
         entity_type?: Name;
@@ -325,6 +368,12 @@ declare namespace Types {
     class goods_info extends Struct {
         goods: good[];
     }
+    class grouptravel extends Struct {
+        entities: entity_ref[];
+        x: Int64;
+        y: Int64;
+        recharge: boolean;
+    }
     class hash extends Struct {
         value: string;
     }
@@ -337,6 +386,22 @@ declare namespace Types {
     class join extends Struct {
         account: Name;
     }
+    class location_static extends Struct {
+        coords: coordinates;
+        type: UInt8;
+        subtype: UInt8;
+        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;
+    }
     class location_good extends Struct {
         id: UInt16;
         price: UInt32;
@@ -351,44 +416,43 @@ declare namespace Types {
     }
     class location_row extends Struct {
         id: UInt64;
+        owner: Name;
         coordinates: coordinates;
-        epoch: UInt64;
-        good_id: UInt16;
-        supply: UInt16;
+        cargomass: UInt32;
+        cargo: cargo_item[];
+        schedule?: schedule;
     }
-    class logcancel extends Struct {
-        log: cancel_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_current_state;
+        projected: entity_current_state;
+        max_energy: UInt16;
+        systems: nearby_system[];
     }
-    class resolve_log extends Struct {
+    class task_event extends Struct {
+        event_type: UInt8;
         owner: Name;
         entity_type: Name;
         entity_id: UInt64;
         task_index: UInt8;
         task: task;
-        started_at: TimePoint;
-        completed_at: TimePoint;
+        starts_at: TimePoint;
+        completes_at: TimePoint;
         new_energy?: UInt16;
-        new_location?: coordinates;
+        new_coordinates?: 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 notify extends Struct {
+        event: task_event;
     }
     class payloan extends Struct {
         account: Name;
@@ -404,8 +468,10 @@ declare namespace Types {
         available_loan: UInt64;
         next_ship_price: UInt64;
         next_warehouse_price: UInt64;
+        next_container_price: UInt64;
         ship_count: UInt64;
         warehouse_count: UInt64;
+        container_count: UInt64;
     }
     class player_row extends Struct {
         owner: Name;
@@ -423,18 +489,22 @@ declare namespace Types {
     class resolve extends Struct {
         entity_type: Name;
         id: UInt64;
+        count?: UInt64;
     }
     class resolve_results extends Struct {
         entity_id: UInt64;
         entity_type: Name;
         resolved_count: UInt8;
         new_schedule_started?: TimePoint;
+        entitygroup?: UInt64;
+        group_members?: entity_ref[];
     }
     class salt extends Struct {
         salt: UInt64;
     }
     class sellgoods extends Struct {
-        ship_id: UInt64;
+        entity_type: Name;
+        id: UInt64;
         good_id: UInt16;
         quantity: UInt32;
     }
@@ -442,19 +512,30 @@ declare namespace Types {
         key: Name;
         value: UInt64;
     }
+    class trade_stats extends Struct {
+        margin: UInt16;
+    }
     class ship_row extends Struct {
         id: UInt64;
         owner: Name;
         name: string;
-        location: coordinates;
-        mass: UInt32;
+        coordinates: coordinates;
+        hullmass: UInt32;
         capacity: UInt32;
         energy: UInt16;
+        cargomass: UInt32;
         engines: movement_stats;
         generator: energy_stats;
         loaders: loader_stats;
+        trade?: trade_stats;
+        extractor?: extractor_stats;
         schedule?: schedule;
     }
+    class starter_info extends Struct {
+        balance: UInt64;
+        debt: UInt64;
+        ship: entity_info;
+    }
     class state_row extends Struct {
         enabled: boolean;
         epoch: UInt32;
@@ -463,6 +544,13 @@ declare namespace Types {
         seed: Checksum256;
         commit: Checksum256;
     }
+    class supply_row extends Struct {
+        id: UInt64;
+        coordinates: coordinates;
+        epoch: UInt64;
+        good_id: UInt16;
+        supply: UInt16;
+    }
     class takeloan extends Struct {
         account: Name;
         amount: UInt64;
@@ -488,6 +576,7 @@ declare namespace Types {
     class types_row extends Struct {
         id: UInt64;
         entity_summary_type: entity_summary;
+        starter_info_type: starter_info;
     }
     class updatecredit extends Struct {
         account: Name;
@@ -501,8 +590,9 @@ declare namespace Types {
         id: UInt64;
         owner: Name;
         name: string;
-        location: coordinates;
+        coordinates: coordinates;
         capacity: UInt32;
+        cargomass: UInt32;
         loaders: loader_stats;
         schedule?: schedule;
     }
@@ -513,21 +603,27 @@ declare namespace Types {
 }
 declare const TableMap: {
     cargo: typeof Types.cargo_row;
+    container: typeof Types.container_row;
+    entitygroup: typeof Types.entitygroup_row;
     location: typeof Types.location_row;
     player: typeof Types.player_row;
     sequence: typeof Types.sequence_row;
     ship: typeof Types.ship_row;
     state: typeof Types.state_row;
+    supply: typeof Types.supply_row;
     types: typeof Types.types_row;
     warehouse: typeof Types.warehouse_row;
 };
 interface TableTypes {
     cargo: Types.cargo_row;
+    container: Types.container_row;
+    entitygroup: Types.entitygroup_row;
     location: Types.location_row;
     player: Types.player_row;
     sequence: Types.sequence_row;
     ship: Types.ship_row;
     state: Types.state_row;
+    supply: Types.supply_row;
     types: Types.types_row;
     warehouse: Types.warehouse_row;
 }
@@ -535,22 +631,36 @@ type RowType<T> = T extends keyof TableTypes ? TableTypes[T] : any;
 type TableNames = keyof TableTypes;
 declare namespace ActionParams {
     namespace Type {
-        interface cancel_log {
+        interface entity_ref {
+            entity_type: NameType;
+            entity_id: UInt64Type;
+        }
+        interface task_event {
+            event_type: UInt8Type;
             owner: NameType;
             entity_type: NameType;
             entity_id: UInt64Type;
             task_index: UInt8Type;
             task: Type.task;
-            started_at: TimePointType;
+            starts_at: TimePointType;
+            completes_at: TimePointType;
+            new_energy?: UInt16Type;
+            new_coordinates?: Type.coordinates;
+            cargomass_delta: Int64Type;
+            cargo_added: Type.cargo_item[];
+            cargo_removed: Type.cargo_item[];
+            credits?: Int64Type;
         }
         interface task {
             type: UInt8Type;
             duration: UInt32Type;
             cancelable: UInt8Type;
-            location?: Type.coordinates;
+            coordinates?: Type.coordinates;
             cargo: Type.cargo_item[];
-            entity?: UInt64Type;
+            entitytarget?: Type.entity_ref;
+            entitygroup?: UInt64Type;
             credits?: Int64Type;
+            energy_cost?: UInt16Type;
         }
         interface coordinates {
             x: Int64Type;
@@ -561,29 +671,28 @@ declare namespace ActionParams {
             good_id: UInt16Type;
             quantity: UInt32Type;
             unit_cost: UInt64Type;
+            mixture?: Type.mixture_info;
         }
-        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 mixture_info {
+            components: Type.mixture_component[];
+        }
+        interface mixture_component {
+            good_id: UInt16Type;
+            purity: UInt16Type;
         }
     }
     interface advance {
         reveal: string;
         commit: Checksum256Type;
     }
-    interface buygoods {
+    interface buycontainer {
+        account: NameType;
         ship_id: UInt64Type;
+        name: string;
+    }
+    interface buygoods {
+        entity_type: NameType;
+        id: UInt64Type;
         good_id: UInt16Type;
         quantity: UInt32Type;
     }
@@ -612,6 +721,9 @@ declare namespace ActionParams {
     interface enable {
         enabled: boolean;
     }
+    interface extract {
+        ship_id: UInt64Type;
+    }
     interface getentities {
         owner: NameType;
         entity_type?: NameType;
@@ -626,6 +738,10 @@ declare namespace ActionParams {
         x: Int64Type;
         y: Int64Type;
     }
+    interface getlocdata {
+        x: Int64Type;
+        y: Int64Type;
+    }
     interface getnearby {
         entity_type: NameType;
         entity_id: UInt64Type;
@@ -634,10 +750,18 @@ declare namespace ActionParams {
     interface getplayer {
         account: NameType;
     }
+    interface getstarter {
+    }
     interface getsummaries {
         owner: NameType;
         entity_type?: NameType;
     }
+    interface grouptravel {
+        entities: Type.entity_ref[];
+        x: Int64Type;
+        y: Int64Type;
+        recharge: boolean;
+    }
     interface hash {
         value: string;
     }
@@ -650,11 +774,8 @@ declare namespace ActionParams {
     interface join {
         account: NameType;
     }
-    interface logcancel {
-        log: Type.cancel_log;
-    }
-    interface logresolve {
-        log: Type.resolve_log;
+    interface notify {
+        event: Type.task_event;
     }
     interface payloan {
         account: NameType;
@@ -670,12 +791,14 @@ declare namespace ActionParams {
     interface resolve {
         entity_type: NameType;
         id: UInt64Type;
+        count?: UInt64Type;
     }
     interface salt {
         salt: UInt64Type;
     }
     interface sellgoods {
-        ship_id: UInt64Type;
+        entity_type: NameType;
+        id: UInt64Type;
         good_id: UInt16Type;
         quantity: UInt32Type;
     }
@@ -713,6 +836,7 @@ declare namespace ActionParams {
 }
 interface ActionNameParams {
     advance: ActionParams.advance;
+    buycontainer: ActionParams.buycontainer;
     buygoods: ActionParams.buygoods;
     buyship: ActionParams.buyship;
     buywarehouse: ActionParams.buywarehouse;
@@ -720,19 +844,22 @@ interface ActionNameParams {
     cleartable: ActionParams.cleartable;
     commit: ActionParams.commit;
     enable: ActionParams.enable;
+    extract: ActionParams.extract;
     getentities: ActionParams.getentities;
     getentity: ActionParams.getentity;
     getgoods: ActionParams.getgoods;
     getlocation: ActionParams.getlocation;
+    getlocdata: ActionParams.getlocdata;
     getnearby: ActionParams.getnearby;
     getplayer: ActionParams.getplayer;
+    getstarter: ActionParams.getstarter;
     getsummaries: ActionParams.getsummaries;
+    grouptravel: ActionParams.grouptravel;
     hash: ActionParams.hash;
     hash512: ActionParams.hash512;
     init: ActionParams.init;
     join: ActionParams.join;
-    logcancel: ActionParams.logcancel;
-    logresolve: ActionParams.logresolve;
+    notify: ActionParams.notify;
     payloan: ActionParams.payloan;
     purgesupply: ActionParams.purgesupply;
     recharge: ActionParams.recharge;
@@ -751,13 +878,17 @@ type ActionNames = keyof ActionNameParams;
 interface ActionReturnValues {
     buygoods: Types.task_results;
     cancel: Types.cancel_results;
+    extract: Types.task_results;
     getentities: Types.entity_info[];
     getentity: Types.entity_info;
     getgoods: Types.goods_info;
     getlocation: Types.location_info;
+    getlocdata: Types.location_derived;
     getnearby: Types.nearby_info;
     getplayer: Types.player_info;
+    getstarter: Types.starter_info;
     getsummaries: Types.entity_summary[];
+    grouptravel: Types.task_results;
     hash: Checksum256;
     hash512: Checksum512;
     recharge: Types.task_results;
@@ -851,12 +982,32 @@ declare const WAREHOUSE_ALREADY_AT_LOCATION = "Warehouse already exists at this
 declare const WAREHOUSE_CAPACITY_EXCEEDED = "Warehouse capacity would be exceeded.";
 
 declare const PRECISION = 10000;
-declare const INITIAL_SHIP_MASS = 500000;
+declare const INITIAL_SHIP_GENERATOR_CAPACITY = 350;
+declare const INITIAL_SHIP_DRAIN = 25;
+declare const INITIAL_SHIP_ENERGY = 350;
+declare const INITIAL_SHIP_HULLMASS = 100000;
+declare const INITIAL_SHIP_CAPACITY = 500000;
+declare const INITIAL_SHIP_Z = 800;
+declare const INITIAL_SHIP_RECHARGE = 10;
+declare const INITIAL_SHIP_THRUST = 250;
+declare const INITIAL_LOADER_MASS = 1000;
+declare const INITIAL_LOADER_QUANTITY = 1;
+declare const INITIAL_LOADER_THRUST = 1;
+declare const WAREHOUSE_Z = 500;
+declare const INITIAL_WAREHOUSE_CAPACITY = 10000000;
+declare const CONTAINER_Z = 300;
+declare const INITIAL_CONTAINER_HULLMASS = 50000;
+declare const INITIAL_CONTAINER_CAPACITY = 2000000;
+declare const TRAVEL_MAX_DURATION = 86400;
 declare const MIN_ORBITAL_ALTITUDE = 800;
 declare const MAX_ORBITAL_ALTITUDE = 3000;
+declare const INITIAL_SHIP_MASS = 500000;
+declare const INITIAL_EXTRACTOR_RATE = 700;
+declare const INITIAL_EXTRACTOR_DRAIN = 2500;
+declare const INITIAL_EXTRACTOR_EFFICIENCY = 5000;
 interface ShipLike {
-    location: Types.coordinates;
-    mass: UInt32;
+    coordinates: Types.coordinates;
+    hullmass: UInt32;
     energy: UInt16;
     engines: Types.movement_stats;
     generator: Types.energy_stats;
@@ -868,10 +1019,18 @@ interface CargoMassInfo {
     quantity: UInt32Type;
 }
 declare enum TaskType {
-    RECHARGE = 0,
-    LOAD = 1,
-    UNLOAD = 2,
-    FLIGHT = 3
+    IDLE = 0,
+    TRAVEL = 1,
+    RECHARGE = 2,
+    LOAD = 3,
+    UNLOAD = 4,
+    EXTRACT = 5
+}
+declare enum LocationType {
+    EMPTY = 0,
+    PLANET = 1,
+    ASTEROID = 2,
+    NEBULA = 3
 }
 declare enum TaskCancelable {
     NEVER = 0,
@@ -881,6 +1040,7 @@ declare enum TaskCancelable {
 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 | {
@@ -890,7 +1050,9 @@ type CoordinatesType = Coordinates | Types.coordinates | {
 declare class Coordinates extends Types.coordinates {
     static from(value: CoordinatesType): Coordinates;
     equals(other: CoordinatesType): boolean;
+    toLocationId(): UInt64;
 }
+declare function coordsToLocationId(coords: CoordinatesType): UInt64;
 interface Distance {
     origin: ActionParams.Type.coordinates;
     destination: ActionParams.Type.coordinates;
@@ -1147,9 +1309,17 @@ declare class Location {
      */
     static from(coordinates: CoordinatesType): Location;
     /**
-     * Check if this location has a system (planet)
+     * Check if this location has a system (planet, asteroid, or nebula)
      */
     hasSystemAt(gameSeed: Checksum256Type): boolean;
+    /**
+     * Get the location type (EMPTY, PLANET, ASTEROID, or NEBULA)
+     */
+    getLocationTypeAt(gameSeed: Checksum256Type): LocationType;
+    /**
+     * Check if this location is extractable (asteroid or nebula)
+     */
+    isExtractableAt(gameSeed: Checksum256Type): boolean;
     /**
      * Set cached market prices for this location
      */
@@ -1173,11 +1343,11 @@ declare class Location {
     /**
      * Set location rows (supply data) for this location
      */
-    setLocationRows(rows: Types.location_row[], epoch: UInt64): void;
+    setLocationRows(rows: Types.supply_row[], epoch: UInt64): void;
     /**
      * Get cached location rows (supply data)
      */
-    get locationRows(): Types.location_row[] | undefined;
+    get locationRows(): Types.supply_row[] | undefined;
     /**
      * Get supply for a specific good at this location
      * Returns undefined if location rows not cached or good not found
@@ -1187,7 +1357,7 @@ declare class Location {
      * Get all available goods at this location (goods with supply > 0)
      * Returns undefined if location rows not cached
      */
-    get availableGoods(): Types.location_row[] | undefined;
+    get availableGoods(): Types.supply_row[] | undefined;
     /**
      * Check if a specific good is available (has supply)
      * Returns false if location rows not cached
@@ -1238,27 +1408,80 @@ declare class LocationsManager extends BaseManager {
     getMarketPricesWithSupply(location: CoordinatesType): Promise<GoodPrice[]>;
     hasSystem(location: CoordinatesType): Promise<boolean>;
     findNearbyPlanets(origin: CoordinatesType, maxDistance?: UInt16Type): Promise<Distance[]>;
-    getLocation(location: CoordinatesType): Promise<any[]>;
+    getSupplyRows(location: CoordinatesType): Promise<any[]>;
     getLocationWithPrices(coords: CoordinatesType): Promise<Location>;
     getLocationWithSupply(coords: CoordinatesType): Promise<Location>;
     getLocationComplete(coords: CoordinatesType): Promise<Location>;
+    getLocationEntity(id: UInt64Type): Promise<Types.location_row | undefined>;
+    getLocationEntityAt(coords: CoordinatesType): Promise<Types.location_row | undefined>;
+    getAllLocationEntities(): Promise<Types.location_row[]>;
 }
 
+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 TradeCapability {
+    trade: Types.trade_stats;
+}
+interface ExtractorCapability {
+    extractor: Types.extractor_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;
+    trade?: Types.trade_stats;
+    extractor?: Types.extractor_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 capsHasTrade(caps: EntityCapabilities): boolean;
+declare function capsHasExtractor(caps: EntityCapabilities): boolean;
+declare function capsHasMass(caps: EntityCapabilities): boolean;
+
 type Schedule = Types.schedule;
-type Task = Types.task;
+type Task$1 = Types.task;
 interface ScheduleData {
     schedule?: Schedule;
 }
 interface Scheduleable extends ScheduleData {
     hasSchedule: boolean;
     isIdle: boolean;
-    tasks: Task[];
+    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 | undefined;
+    currentTask(now: Date): Task$1 | undefined;
     currentTaskType(now: Date): TaskType | undefined;
     getTaskStartTime(index: number): number;
     getTaskElapsed(index: number, now: Date): number;
@@ -1268,15 +1491,15 @@ interface Scheduleable extends ScheduleData {
     currentTaskProgress(now: Date): number;
     scheduleProgress(now: Date): number;
 }
-declare function hasSchedule(entity: ScheduleData): boolean;
+declare function hasSchedule$1(entity: ScheduleData): boolean;
 declare function isIdle(entity: ScheduleData): boolean;
-declare function getTasks(entity: ScheduleData): Task[];
+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 | undefined;
+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;
@@ -1285,10 +1508,15 @@ declare function isTaskComplete(entity: ScheduleData, index: number, now: Date):
 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 isExtracting(entity: ScheduleData, now: Date): boolean;
 
 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;
@@ -1305,11 +1533,17 @@ 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_isExtracting: typeof isExtracting;
 declare namespace schedule {
   export {
     schedule_ScheduleData as ScheduleData,
     schedule_Scheduleable as Scheduleable,
-    schedule_hasSchedule as hasSchedule,
+    hasSchedule$1 as hasSchedule,
     schedule_isIdle as isIdle,
     schedule_getTasks as getTasks,
     schedule_scheduleDuration as scheduleDuration,
@@ -1326,24 +1560,15 @@ declare namespace schedule {
     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_isExtracting as isExtracting,
   };
 }
 
-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;
@@ -1353,46 +1578,160 @@ interface ProjectedEntity {
     engines?: Types.movement_stats;
     loaders?: Types.loader_stats;
     generator?: Types.energy_stats;
+    trade?: Types.trade_stats;
     readonly totalMass: UInt64;
+    hasMovement(): boolean;
+    hasStorage(): boolean;
+    hasLoaders(): boolean;
+    hasTrade(): boolean;
+    capabilities(): EntityCapabilities;
+    state(): EntityState;
 }
-/**
- * Interface for entities that can be projected.
- * Ships and Warehouses both implement this.
- */
 interface Projectable extends ScheduleData {
-    location: Coordinates;
-    energy: UInt16;
-    mass: UInt32;
+    coordinates: Coordinates | Types.coordinates;
+    energy?: UInt16;
+    hullmass?: UInt32;
     generator?: Types.energy_stats;
     engines?: Types.movement_stats;
     loaders?: Types.loader_stats;
-    capacity?: UInt64;
-    calcCargoMass(): UInt64;
+    trade?: Types.trade_stats;
+    capacity?: UInt32;
+    cargo: Types.cargo_item[];
+    cargomass: UInt32;
+    owner?: Name;
 }
-/**
- * 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;
 
+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 _good?;
+    get good(): Good;
+    get name(): string;
+    get unitMass(): UInt32;
+    get totalMass(): UInt64;
+    get totalCost(): UInt64;
+    get hasCargo(): boolean;
+    get isEmpty(): boolean;
+}
+
+interface HasCargo {
+    cargo: Types.cargo_item[];
+}
+interface HasCapacity {
+    capacity: UInt32;
+}
+interface HasCargomass {
+    cargomass: UInt32;
+}
+declare function calcCargoMass(entity: HasCargo): UInt64;
+declare function calcCargoValue(entity: HasCargo): 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;
+
+declare class InventoryAccessor {
+    private readonly entity;
+    private _items?;
+    constructor(entity: HasCargo);
+    get items(): EntityInventory[];
+    get totalMass(): UInt64;
+    get totalValue(): UInt64;
+    forGood(goodId: UInt64Type): EntityInventory | undefined;
+    get sellable(): EntityInventory[];
+    get hasSellable(): boolean;
+    get sellableCount(): number;
+}
+declare function createInventoryAccessor(entity: HasCargo): InventoryAccessor;
+
+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;
+interface SaleValue {
+    revenue: UInt64;
+    profit: UInt64;
+    cost: UInt64;
+}
+declare function calculateSaleValue(cargo: Types.cargo_item[], prices: Map<number, UInt64>): SaleValue;
+declare function calculateSaleValueFromArray(cargo: Types.cargo_item[], prices: UInt64[]): SaleValue;
+declare function afterSellGoods(cargo: Types.cargo_item[], goodsToSell: Array<{
+    goodId: number;
+    quantity: number;
+}>): EntityInventory[];
+declare function afterSellAllGoods(cargo: Types.cargo_item[]): EntityInventory[];
+
+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;
+type cargoUtils_SaleValue = SaleValue;
+declare const cargoUtils_calculateSaleValue: typeof calculateSaleValue;
+declare const cargoUtils_calculateSaleValueFromArray: typeof calculateSaleValueFromArray;
+declare const cargoUtils_afterSellGoods: typeof afterSellGoods;
+declare const cargoUtils_afterSellAllGoods: typeof afterSellAllGoods;
+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,
+    cargoUtils_SaleValue as SaleValue,
+    cargoUtils_calculateSaleValue as calculateSaleValue,
+    cargoUtils_calculateSaleValueFromArray as calculateSaleValueFromArray,
+    cargoUtils_afterSellGoods as afterSellGoods,
+    cargoUtils_afterSellAllGoods as afterSellAllGoods,
+  };
+}
+
 interface ShipStateInput {
     id: UInt64Type;
-    owner: NameType;
+    owner: string;
     name: string;
-    location: CoordinatesType | {
+    coordinates: CoordinatesType | {
         x: number;
         y: number;
         z?: number;
     };
-    mass: number;
+    hullmass: number;
     capacity: number;
     energy: number;
     engines: Types.movement_stats;
@@ -1401,30 +1740,15 @@ interface ShipStateInput {
     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?;
+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 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;
@@ -1432,19 +1756,17 @@ declare class Ship extends Types.entity_info implements Scheduleable {
     isRecharging(now: Date): boolean;
     isLoading(now: Date): boolean;
     isUnloading(now: Date): boolean;
-    calcCargoMass(): UInt64;
-    private createProjectedEntity;
+    isExtracting(now: Date): boolean;
+    get hasExtractor(): boolean;
     project(): ProjectedEntity;
     projectAt(now: Date): ProjectedEntity;
-    get currentLocation(): Coordinates;
+    get location(): Location;
     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;
@@ -1453,16 +1775,8 @@ declare class Ship extends Types.entity_info implements Scheduleable {
     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;
-    };
+    calculateSaleValue(prices: Map<number, UInt64>): SaleValue;
+    calculateSaleValueFromArray(prices: UInt64[]): SaleValue;
     afterSellGoods(goodsToSell: Array<{
         goodId: number;
         quantity: number;
@@ -1542,6 +1856,13 @@ interface TransferEntity {
         } | number;
     };
 }
+interface HasScheduleAndLocation {
+    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;
+declare function getPositionAt(entity: HasScheduleAndLocation, taskIndex: number, taskProgress: number): ActionParams.Type.coordinates;
 declare function calc_transfer_duration(source: TransferEntity, dest: TransferEntity, cargoMass: number): number;
 
 /**
@@ -1829,25 +2150,27 @@ interface SellableCargo {
     } | number;
     hasCargo: boolean;
 }
-type CargoItemInput = {
-    goodId: UInt64Type;
-    quantity: UInt64Type;
-    unitCost?: UInt64Type;
+type EntityRefInput = {
+    entityType: EntityTypeName;
+    entityId: UInt64Type;
 };
 declare class ActionsManager extends BaseManager {
     travel(shipId: UInt64Type, destination: CoordinatesType, recharge?: boolean): Action;
+    grouptravel(entities: EntityRefInput[], destination: CoordinatesType, recharge?: boolean): Action;
     resolve(entityId: UInt64Type, entityType?: EntityTypeName): 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;
+    transfer(sourceType: EntityTypeName, sourceId: UInt64Type, destType: EntityTypeName, destId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type): Action;
+    buyGoods(entityId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type, entityType?: EntityTypeName): Action;
+    sellGoods(entityId: UInt64Type, goodId: UInt64Type, quantity: UInt64Type, entityType?: EntityTypeName): Action;
     buyShip(account: NameType, name: string): Action;
     buyWarehouse(account: NameType, shipId: UInt64Type, name: string): Action;
+    buyContainer(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;
+    extract(shipId: UInt64Type): Action;
     joinGame(account: NameType, companyName: string): Action[];
     sellAllCargo(ship: Ship | UInt64Type, cargo?: SellableCargo[]): Action[];
 }
@@ -1889,9 +2212,9 @@ declare abstract class BaseManager {
 
 interface WarehouseStateInput {
     id: UInt64Type;
-    owner: NameType;
+    owner: string;
     name: string;
-    location: CoordinatesType | {
+    coordinates: CoordinatesType | {
         x: number;
         y: number;
         z?: number;
@@ -1901,56 +2224,71 @@ interface WarehouseStateInput {
     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?;
+declare class Warehouse extends Types.entity_info {
+    private _sched?;
+    private _inv?;
     get name(): string;
+    get inv(): InventoryAccessor;
     get inventory(): EntityInventory[];
-    get hasSchedule(): boolean;
+    get sched(): ScheduleAccessor;
     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 location(): Location;
     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';
+interface ContainerStateInput {
+    id: UInt64Type;
+    owner: string;
+    name: string;
+    coordinates: CoordinatesType | {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    hullmass: number;
+    capacity: number;
+    cargomass?: number;
+    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;
+}
+
+type EntityType = 'ship' | 'warehouse' | 'container' | 'location';
 declare class EntitiesManager extends BaseManager {
-    getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse>;
-    getEntities(owner: NameType | Types.player_row, type?: EntityType): Promise<(Ship | Warehouse)[]>;
+    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;
 }
@@ -1981,6 +2319,10 @@ declare class Shipload {
     getState(reload?: boolean): Promise<GameState>;
 }
 
+declare function makeShip(state: ShipStateInput): Ship;
+declare function makeWarehouse(state: WarehouseStateInput): Warehouse;
+declare function makeContainer(state: ContainerStateInput): Container;
+
 declare const goodIds: number[];
 declare function getGood(goodId: UInt16Type): Good;
 declare function getGoods(): Good[];
@@ -2002,10 +2344,16 @@ declare function getRarity(gameSeed: Checksum256Type, epochSeed: Checksum256Type
 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 getLocationType(gameSeed: Checksum256Type, coordinates: CoordinatesType): LocationType;
+declare function isExtractableLocation(locationType: LocationType): boolean;
 declare function getSystemName(gameSeed: Checksum256Type, location: CoordinatesType): string;
 declare function hasSystem(gameSeed: Checksum256Type, coordinates: CoordinatesType): boolean;
+declare function deriveLocationStatic(gameSeed: Checksum256Type, coordinates: CoordinatesType): Types.location_static;
+declare function deriveLocationEpoch(epochSeed: Checksum256Type, coordinates: CoordinatesType): Types.location_epoch;
+declare function deriveLocation(gameSeed: Checksum256Type, epochSeed: Checksum256Type, coordinates: CoordinatesType): Types.location_derived;
+declare function deriveLocationMixture(location: Types.location_derived, epochSeed: Checksum256Type): Types.mixture_info;
 
-declare function hash(seed: Checksum256Type, string: string): Checksum512;
+declare function hash(seed: Checksum256Type, string: string): Checksum256;
 declare function hash512(seed: Checksum256Type, string: string): Checksum512;
 
 /**
@@ -2088,34 +2436,39 @@ declare function isProfitable(buyPrice: UInt32Type, sellPrice: UInt32Type): bool
  */
 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;
+interface Entity {
+    id: UInt64;
+    type: Name;
+    owner: Name;
+    entity_name: string;
+    location: Coordinates | Types.coordinates;
+}
+type ShipEntity = Entity & MovementCapability & EnergyCapability & StorageCapability & LoaderCapability & MassCapability & ScheduleCapability & {
+    trade?: Types.trade_stats;
+    extractor?: Types.extractor_stats;
+};
+type WarehouseEntity = Entity & StorageCapability & LoaderCapability & ScheduleCapability;
+type ContainerEntity = Entity & StorageCapability & MassCapability & ScheduleCapability;
+type AnyEntity = ShipEntity | WarehouseEntity | ContainerEntity;
 
-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,
-  };
-}
+declare function canMove(e: Entity): e is Entity & MovementCapability & EnergyCapability;
+declare function hasEnergy(e: Entity): e is Entity & EnergyCapability;
+declare function hasStorage(e: Entity): e is Entity & StorageCapability;
+declare function hasLoaders(e: Entity): e is Entity & LoaderCapability;
+declare function hasTrade(e: Entity): e is Entity & TradeCapability;
+declare function hasMass(e: Entity): e is Entity & MassCapability;
+declare function hasSchedule(e: Entity): e is Entity & ScheduleCapability;
+declare function hasExtractor(e: Entity): e is Entity & ExtractorCapability;
+
+declare function maxTravelDistance(entity: MovementCapability): UInt32;
+declare function calcEnergyUsage(entity: MovementCapability, distance: UInt64): 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_extraction_duration(extractor: Types.extractor_stats, loaders: Types.loader_stats, shipZ: number, batchMass: number): UInt32;
+declare function calc_extraction_energy(extractor: Types.extractor_stats, duration: number): UInt16;
 
 type movement_stats = Types.movement_stats;
 type energy_stats = Types.energy_stats;
@@ -2123,5 +2476,13 @@ type loader_stats = Types.loader_stats;
 type task = Types.task;
 type cargo_item = Types.cargo_item;
 type warehouse_row = Types.warehouse_row;
+type container_row = Types.container_row;
+type extractor_stats = Types.extractor_stats;
+type mixture_info = Types.mixture_info;
+type mixture_component = Types.mixture_component;
+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 { 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 };
+export { ActionsManager, AnyEntity, BetterSaleLocation, COMMIT_ALREADY_SET, COMMIT_CANNOT_MATCH, COMMIT_NOT_SET, COMPANY_NOT_FOUND, CONTAINER_Z, CargoData, CargoMassInfo, CargoSaleItem, CollectActionType, CollectAnalysis, CollectAnalysisCallbacks, CollectAnalysisOptions, CollectOption, Container, ContainerEntity, ContainerStateInput, Coordinates, CoordinatesType, Deal, DiscountedGoodInfo, Distance, EPOCH_NON_ZERO, EPOCH_NOT_READY, ERROR_SYSTEM_ALREADY_INITIALIZED, ERROR_SYSTEM_DISABLED, ERROR_SYSTEM_NOT_INITIALIZED, EnergyCapability, EntitiesManager, Entity, EntityCapabilities, EntityInventory, EntityRefInput, EntityState, EntityType, EntityTypeName, EpochInfo, EpochsManager, EstimateTravelTimeOptions, EstimatedTravelTime, ExtractorCapability, FindDealsOptions, GAME_NOT_FOUND, GAME_SEED_NOT_SET, GOOD_DOES_NOT_EXIST, GOOD_NOT_AVAILABLE_AT_LOCATION, GameState, Good, GoodPrice, HasCapacity, HasCargo, HasCargomass, HasScheduleAndLocation, INITIAL_CONTAINER_CAPACITY, INITIAL_CONTAINER_HULLMASS, INITIAL_EXTRACTOR_DRAIN, INITIAL_EXTRACTOR_EFFICIENCY, INITIAL_EXTRACTOR_RATE, INITIAL_LOADER_MASS, INITIAL_LOADER_QUANTITY, INITIAL_LOADER_THRUST, INITIAL_SHIP_CAPACITY, INITIAL_SHIP_DRAIN, INITIAL_SHIP_ENERGY, INITIAL_SHIP_GENERATOR_CAPACITY, INITIAL_SHIP_HULLMASS, INITIAL_SHIP_MASS, INITIAL_SHIP_RECHARGE, INITIAL_SHIP_THRUST, INITIAL_SHIP_Z, INITIAL_WAREHOUSE_CAPACITY, INSUFFICIENT_BALANCE, INSUFFICIENT_GOOD_QUANTITY, INSUFFICIENT_GOOD_SUPPLY, INVALID_AMOUNT, InventoryAccessor, LoadTimeBreakdown, LoaderCapability, Location, LocationType, LocationsManager, MAX_ORBITAL_ALTITUDE, MIN_ORBITAL_ALTITUDE, MassCapability, MovementCapability, 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, ScheduleAccessor, ScheduleCapability, ScheduleData, Scheduleable, server as ServerContract, Ship, ShipEntity, ShipLike, ShipStateInput, Shipload, StorageCapability, TRAVEL_MAX_DURATION, TaskCancelable, TaskType, TradeCalculation, TradeCapability, TradeProfitResult, TradesManager, TransferEntity, WAREHOUSE_ALREADY_AT_LOCATION, WAREHOUSE_CAPACITY_EXCEEDED, WAREHOUSE_NOT_FOUND, WAREHOUSE_Z, Warehouse, WarehouseEntity, WarehouseStateInput, analyzeCargoSale, analyzeCollectOptions, availableCapacity$1 as availableCapacity, availableCapacityFromMass, calcCargoMass, calcCargoValue, calcEnergyUsage, calcLoadDuration, calc_acceleration, calc_energyusage, calc_extraction_duration, calc_extraction_energy, 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, canMove, capsHasExtractor, capsHasLoaders, capsHasMass, capsHasMovement, capsHasStorage, capsHasTrade, cargoUtils, cargo_item, container_row, coordsToLocationId, createExploreOption, createInventoryAccessor, createProjectedEntity, createScheduleAccessor, createSellAndRepositionOption, createSellAndStayOption, createSellAndTradeOption, createTravelToSellOption, Shipload as default, deriveLocation, deriveLocationEpoch, deriveLocationMixture, deriveLocationStatic, distanceBetweenCoordinates, distanceBetweenPoints, energyPercent, energy_stats, estimateDealTravelTime, estimateTravelTime, extractor_stats, findBestDeal, findBestGoodToTrade, findDealsForShip, findNearbyPlanets, getCurrentEpoch, getDestinationLocation, getEpochInfo, getFlightOrigin, getGood, getGoods, getLocationType, getPositionAt, getRarity, getSystemName, goodIds, hasEnergy, hasEnergyForDistance, hasExtractor, hasLoaders, hasMass, hasSchedule, hasSpace$1 as hasSpace, hasSpaceForMass, hasStorage, hasSystem, hasTrade, hash, hash512, isExtractableLocation, isFull$1 as isFull, isFullFromMass, isProfitable, lerp, loader_stats, location_derived, location_epoch, location_row, location_static, makeContainer, makeShip, makeWarehouse, marketPrice, marketPrices, maxTravelDistance, mixture_component, mixture_info, movement_stats, needsRecharge, projectEntity, projectEntityAt, rotation, schedule, task, toLocation, warehouse_row };