@shipload/sdk 0.7.1 → 2.0.0-rc10

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, UInt8, Int64, UInt16, TimePoint, Bytes, Int32, UInt16Type, UInt8Type, TimePointType, Int64Type, Int32Type, Checksum512, APIClient } from '@wharfkit/antelope';
+import * as _wharfkit_contract from '@wharfkit/contract';
 import { Contract as Contract$2, PartialBy, ContractArgs, ActionOptions, Table } from '@wharfkit/contract';
 import { ChainDefinition } from '@wharfkit/session';
 
@@ -156,29 +158,69 @@ declare namespace platform {
 declare const abiBlob: Blob;
 declare const abi: ABI;
 declare namespace Types {
+    class addmodule extends Struct {
+        entity_type: Name;
+        entity_id: UInt64;
+        module_index: UInt8;
+        module_cargo_id: UInt64;
+        target_cargo_id: UInt64;
+    }
+    class addnexus extends Struct {
+        nexus_name: string;
+        x: Int64;
+        y: Int64;
+    }
     class advance extends Struct {
         reveal: string;
         commit: Checksum256;
     }
-    class arrive extends Struct {
+    class cargo_seed extends Struct {
+        item_id: UInt16;
+        seed: UInt64;
+    }
+    class module_entry extends Struct {
+        type: UInt8;
+        installed?: cargo_seed;
+    }
+    class cargo_item extends Struct {
+        item_id: UInt16;
+        quantity: UInt32;
+        seed?: UInt64;
+        modules: module_entry[];
+    }
+    class blend extends Struct {
+        entity_type: Name;
         id: UInt64;
+        inputs: cargo_item[];
     }
-    class buygoods extends Struct {
-        ship_id: UInt64;
-        good_id: UInt64;
-        quantity: UInt64;
+    class cancel extends Struct {
+        entity_type: Name;
+        id: UInt64;
+        count: UInt64;
     }
-    class buyship extends Struct {
-        account: Name;
-        name: string;
+    class entity_ref extends Struct {
+        entity_type: Name;
+        entity_id: UInt64;
+    }
+    class cancel_results extends Struct {
+        entity_id: UInt64;
+        entity_type: Name;
+        cancelled_count: UInt8;
+        schedule_started?: TimePoint;
+        entitygroup?: UInt64;
+        group_members?: entity_ref[];
     }
     class cargo_row extends Struct {
         id: UInt64;
-        ship_id: UInt64;
-        good_id: UInt64;
-        paid: UInt64;
-        owned: UInt32;
-        loaded: UInt32;
+        entity_id: UInt64;
+        item_id: UInt64;
+        quantity: UInt64;
+        seed: UInt64;
+        modules: module_entry[];
+    }
+    class cleanrsvp extends Struct {
+        epoch: UInt64;
+        max_rows: UInt64;
     }
     class cleartable extends Struct {
         table_name: Name;
@@ -188,17 +230,225 @@ declare namespace Types {
     class commit extends Struct {
         commit: Checksum256;
     }
+    class entity_defaults extends Struct {
+        warehouse_capacity: UInt32;
+        warehouse_z: UInt16;
+        container_hullmass: UInt32;
+        container_capacity: UInt32;
+        container_z: UInt16;
+    }
+    class item_def extends Struct {
+        id: UInt16;
+        mass: UInt32;
+        type: UInt8;
+        subtype: UInt8;
+        tier: UInt8;
+    }
+    class game_config extends Struct {
+        version: UInt32;
+        defaults: entity_defaults;
+        items: item_def[];
+    }
+    class configlog extends Struct {
+        config: game_config;
+    }
     class coordinates extends Struct {
         x: Int64;
         y: Int64;
+        z?: UInt16;
+    }
+    class task extends Struct {
+        type: UInt8;
+        duration: UInt32;
+        cancelable: UInt8;
+        coordinates?: coordinates;
+        cargo: cargo_item[];
+        entitytarget?: entity_ref;
+        entitygroup?: UInt64;
+        energy_cost?: UInt16;
+    }
+    class schedule extends Struct {
+        started: TimePoint;
+        tasks: task[];
+    }
+    class container_row extends Struct {
+        id: UInt64;
+        owner: Name;
+        name: string;
+        coordinates: coordinates;
+        hullmass: UInt32;
+        capacity: UInt32;
+        cargomass: UInt32;
+        schedule?: schedule;
+    }
+    class craft extends Struct {
+        entity_type: Name;
+        id: UInt64;
+        recipe_id: UInt16;
+        quantity: UInt32;
+        inputs: cargo_item[];
+    }
+    class crafter_stats extends Struct {
+        speed: UInt16;
+        drain: UInt16;
+    }
+    class createentity extends Struct {
+        owner: Name;
+        entity_type: Name;
+        entity_name: string;
+        x: Int64;
+        y: Int64;
+    }
+    class deploy extends Struct {
+        entity_type: Name;
+        id: UInt64;
+        packed_item_id: UInt16;
+        seed: UInt64;
+        entity_name: string;
     }
     class enable extends Struct {
         enabled: boolean;
     }
-    class good_price extends Struct {
-        id: UInt16;
-        price: UInt64;
-        supply: UInt64;
+    class energy_stats extends Struct {
+        capacity: UInt16;
+        recharge: UInt16;
+    }
+    class entity_current_state extends Struct {
+        coordinates: coordinates;
+        energy: UInt16;
+    }
+    class loader_stats extends Struct {
+        mass: UInt32;
+        thrust: UInt16;
+        quantity: UInt8;
+    }
+    class movement_stats extends Struct {
+        thrust: UInt32;
+        drain: UInt16;
+    }
+    class extractor_stats extends Struct {
+        rate: UInt16;
+        drain: UInt16;
+        depth: UInt16;
+        drill: UInt16;
+    }
+    class hauler_stats extends Struct {
+        capacity: UInt8;
+        efficiency: UInt16;
+        drain: UInt16;
+    }
+    class warp_stats extends Struct {
+        range: UInt32;
+    }
+    class entity_info extends Struct {
+        type: Name;
+        id: UInt64;
+        owner: Name;
+        entity_name: string;
+        coordinates: coordinates;
+        cargomass: UInt32;
+        cargo: cargo_item[];
+        loaders?: loader_stats;
+        energy?: UInt16;
+        hullmass?: UInt32;
+        engines?: movement_stats;
+        generator?: energy_stats;
+        capacity?: UInt32;
+        extractor?: extractor_stats;
+        hauler?: hauler_stats;
+        warp?: warp_stats;
+        crafter?: crafter_stats;
+        is_idle: boolean;
+        current_task?: task;
+        current_task_elapsed: UInt32;
+        current_task_remaining: UInt32;
+        pending_tasks: task[];
+        idle_at?: TimePoint;
+        schedule?: schedule;
+    }
+    class entity_summary extends Struct {
+        type: Name;
+        id: UInt64;
+        owner: Name;
+        entity_name: string;
+        coordinates: 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 entitygroup_row extends Struct {
+        id: UInt64;
+        participants: entity_ref[];
+    }
+    class extract extends Struct {
+        entity_type: Name;
+        id: UInt64;
+        stratum: UInt16;
+        quantity: UInt32;
+    }
+    class getconfig extends Struct {
+    }
+    class getentities extends Struct {
+        owner: Name;
+        entity_type?: Name;
+    }
+    class getentity extends Struct {
+        entity_type: Name;
+        entity_id: UInt64;
+    }
+    class getitemdata extends Struct {
+    }
+    class getitems extends Struct {
+    }
+    class getlocation extends Struct {
+        x: Int64;
+        y: Int64;
+    }
+    class getlocdata extends Struct {
+        x: Int64;
+        y: Int64;
+    }
+    class getmodules extends Struct {
+    }
+    class getnearby extends Struct {
+        entity_type: Name;
+        entity_id: UInt64;
+        recharge: boolean;
+    }
+    class getnftinfo extends Struct {
+    }
+    class getplayer extends Struct {
+        account: Name;
+    }
+    class getrecipe extends Struct {
+        output_item_id: UInt16;
+    }
+    class getrecipes extends Struct {
+        lower_bound: UInt16;
+        limit: UInt8;
+    }
+    class getresources extends Struct {
+    }
+    class getstratum extends Struct {
+        x: Int64;
+        y: Int64;
+        stratum: UInt16;
+    }
+    class getsummaries extends Struct {
+        owner: Name;
+        entity_type?: Name;
+    }
+    class grouptravel extends Struct {
+        entities: entity_ref[];
+        x: Int64;
+        y: Int64;
+        recharge: boolean;
     }
     class hash extends Struct {
         value: string;
@@ -209,189 +459,433 @@ declare namespace Types {
     class init extends Struct {
         seed: Checksum256;
     }
-    class jettison extends Struct {
-        ship_id: UInt64;
-        good_id: UInt16;
-        quantity: UInt64;
+    class recipe_input extends Struct {
+        item_id: UInt16;
+        category: UInt8;
+        quantity: UInt32;
+    }
+    class stat_source extends Struct {
+        input_index: UInt8;
+        input_stat_index: UInt8;
+    }
+    class stat_slot_response extends Struct {
+        sources: stat_source[];
+    }
+    class recipe_item_info extends Struct {
+        id: UInt16;
+        mass: UInt32;
+    }
+    class recipe_response extends Struct {
+        output_item_id: UInt16;
+        output_mass: UInt32;
+        inputs: recipe_input[];
+        stat_slots: stat_slot_response[];
+        blend_weights: Bytes;
+        output_item: recipe_item_info;
+        input_items: recipe_item_info[];
+    }
+    class recipes_result extends Struct {
+        recipes: recipe_response[];
+    }
+    class itemdata_result extends Struct {
+        items: item_def[];
+        recipes: recipes_result;
+    }
+    class items_info extends Struct {
+        items: item_def[];
     }
     class join extends Struct {
         account: Name;
     }
-    class loader_stats extends Struct {
-        mass: UInt32;
-        quantity: UInt16;
-        thrust: UInt32;
+    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;
+        size: UInt16;
+    }
+    class location_info extends Struct {
+        coords: coordinates;
+        is_system: boolean;
     }
     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 marketprice extends Struct {
-        location: coordinates;
-        good_id: UInt16;
+    class module_info extends Struct {
+        id: UInt16;
+        mass: UInt32;
+        module_type: UInt8;
+        tier: UInt8;
     }
-    class marketprices extends Struct {
-        location: coordinates;
+    class modules_result extends Struct {
+        modules: module_info[];
     }
-    class payloan extends Struct {
-        account: Name;
-        amount: UInt64;
+    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 nexus_row extends Struct {
+        id: UInt64;
+        owner: Name;
+        name: string;
+        coordinates: coordinates;
+    }
+    class schema_field extends Struct {
+        name: string;
+        field_type: string;
+    }
+    class nft_schema_def extends Struct {
+        schema_name: Name;
+        fields: schema_field[];
+    }
+    class nft_template_def extends Struct {
+        item_id: UInt16;
+        schema_name: Name;
+    }
+    class nftconfig_row extends Struct {
+        item_id: UInt16;
+        template_id: Int32;
+        schema_name: Name;
+    }
+    class nftinfo_result extends Struct {
+        schemas: nft_schema_def[];
+        templates: nft_template_def[];
+    }
+    class task_event extends Struct {
+        event_type: UInt8;
+        owner: Name;
+        entity_type: Name;
+        entity_id: UInt64;
+        task_index: UInt8;
+        task: task;
+        starts_at: TimePoint;
+        completes_at: TimePoint;
+        new_energy?: UInt16;
+    }
+    class notify extends Struct {
+        event: task_event;
+    }
+    class player_info extends Struct {
+        owner: Name;
+        is_player: boolean;
+        company_name: string;
+        ship_count: UInt64;
+        warehouse_count: UInt64;
+        container_count: UInt64;
     }
     class player_row extends Struct {
         owner: Name;
-        balance: UInt64;
-        debt: UInt64;
-        networth: Int64;
+    }
+    class recharge extends Struct {
+        entity_type: Name;
+        id: UInt64;
+    }
+    class reserve_row extends Struct {
+        id: UInt64;
+        remaining: UInt32;
+    }
+    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 resource_info extends Struct {
+        id: UInt16;
+        mass: UInt32;
+        category: UInt8;
+        tier: UInt8;
+    }
+    class resource_stats extends Struct {
+        stat1: UInt16;
+        stat2: UInt16;
+        stat3: UInt16;
+    }
+    class resources_result extends Struct {
+        resources: resource_info[];
+    }
+    class rmmodule extends Struct {
+        entity_type: Name;
+        entity_id: UInt64;
+        module_index: UInt8;
+        target_cargo_id: UInt64;
+    }
+    class rmnftcfg extends Struct {
+        item_id: UInt16;
     }
     class salt extends Struct {
         salt: UInt64;
     }
-    class sellgoods extends Struct {
-        ship_id: UInt64;
-        good_id: UInt64;
-        quantity: UInt64;
-    }
     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 setnftcfg extends Struct {
+        item_id: UInt16;
+        template_id: Int32;
+        schema_name: Name;
     }
     class ship_row extends Struct {
         id: UInt64;
         owner: Name;
         name: string;
-        location: coordinates;
-        skin: UInt8;
-        tier: UInt8;
-        state: ship_state;
-        stats: ship_stats;
-        loaders: loader_stats;
-        travelplan?: travel_plan;
+        seed: UInt64;
+        coordinates: coordinates;
+        hullmass?: UInt32;
+        capacity?: UInt32;
+        energy?: UInt16;
+        cargomass: UInt32;
+        engines?: movement_stats;
+        generator?: energy_stats;
+        loaders?: loader_stats;
+        extractor?: extractor_stats;
+        hauler?: hauler_stats;
+        warp?: warp_stats;
+        crafter?: crafter_stats;
+        modules: module_entry[];
+        schedule?: schedule;
+    }
+    class spawncargo extends Struct {
+        entity_id: UInt64;
+        item_id: UInt64;
+        quantity: UInt64;
+    }
+    class spawnseeded extends Struct {
+        entity_id: UInt64;
+        item_id: UInt64;
+        quantity: UInt64;
+        seed: UInt64;
     }
     class state_row extends Struct {
         enabled: boolean;
-        epoch: UInt64;
+        epoch: UInt32;
         salt: UInt64;
         ships: UInt32;
         seed: Checksum256;
         commit: Checksum256;
     }
-    class takeloan extends Struct {
-        account: Name;
-        amount: UInt64;
+    class stratum_info extends Struct {
+        item_id: UInt16;
+        seed: UInt64;
+        richness: UInt16;
+        reserve: UInt32;
+    }
+    class stratum_data extends Struct {
+        stratum: stratum_info;
+        stats: resource_stats;
+    }
+    class task_results extends Struct {
+        entities: entity_task_info[];
+    }
+    class transfer extends Struct {
+        source_type: Name;
+        source_id: UInt64;
+        dest_type: Name;
+        dest_id: UInt64;
+        item_id: UInt16;
+        quantity: UInt32;
     }
     class travel extends Struct {
+        entity_type: Name;
         id: UInt64;
-        destination: coordinates;
+        x: Int64;
+        y: Int64;
         recharge: boolean;
     }
-    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 types_row extends Struct {
         id: UInt64;
-        origin: coordinates;
-        destination: coordinates;
-        recharge: boolean;
+        entity_summary_type: entity_summary;
+        game_config_type: game_config;
     }
-    class traveltime extends Struct {
+    class warehouse_row extends Struct {
         id: UInt64;
-        destination: coordinates;
-    }
-    class updatecredit extends Struct {
-        account: Name;
-        amount: Int64;
-    }
-    class updatedebt extends Struct {
-        account: Name;
-        amount: Int64;
-    }
-    class upgradeship extends Struct {
-        account: Name;
+        owner: Name;
+        name: string;
+        seed: UInt64;
+        coordinates: coordinates;
+        hullmass?: UInt32;
+        capacity?: UInt32;
+        cargomass: UInt32;
+        loaders?: loader_stats;
+        modules: module_entry[];
+        schedule?: schedule;
+    }
+    class warp extends Struct {
+        entity_type: Name;
         id: UInt64;
+        x: Int64;
+        y: Int64;
     }
     class wipe extends Struct {
     }
     class wipesequence extends Struct {
     }
+    class wrap extends Struct {
+        owner: Name;
+        entity_type: Name;
+        entity_id: UInt64;
+        cargo_id: UInt64;
+        quantity: UInt64;
+    }
 }
 declare const TableMap: {
     cargo: typeof Types.cargo_row;
+    container: typeof Types.container_row;
+    entitygroup: typeof Types.entitygroup_row;
     location: typeof Types.location_row;
+    nexus: typeof Types.nexus_row;
+    nftconfig: typeof Types.nftconfig_row;
     player: typeof Types.player_row;
+    reserve: typeof Types.reserve_row;
     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;
+    container: Types.container_row;
+    entitygroup: Types.entitygroup_row;
     location: Types.location_row;
+    nexus: Types.nexus_row;
+    nftconfig: Types.nftconfig_row;
     player: Types.player_row;
+    reserve: Types.reserve_row;
     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 cargo_item {
+            item_id: UInt16Type;
+            quantity: UInt32Type;
+            seed?: UInt64Type;
+            modules: Type.module_entry[];
+        }
+        interface module_entry {
+            type: UInt8Type;
+            installed?: Type.cargo_seed;
+        }
+        interface cargo_seed {
+            item_id: UInt16Type;
+            seed: UInt64Type;
+        }
+        interface game_config {
+            version: UInt32Type;
+            defaults: Type.entity_defaults;
+            items: Type.item_def[];
+        }
+        interface entity_defaults {
+            warehouse_capacity: UInt32Type;
+            warehouse_z: UInt16Type;
+            container_hullmass: UInt32Type;
+            container_capacity: UInt32Type;
+            container_z: UInt16Type;
+        }
+        interface item_def {
+            id: UInt16Type;
+            mass: UInt32Type;
+            type: UInt8Type;
+            subtype: UInt8Type;
+            tier: UInt8Type;
+        }
+        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;
+            starts_at: TimePointType;
+            completes_at: TimePointType;
+            new_energy?: UInt16Type;
+        }
+        interface task {
+            type: UInt8Type;
+            duration: UInt32Type;
+            cancelable: UInt8Type;
+            coordinates?: Type.coordinates;
+            cargo: Type.cargo_item[];
+            entitytarget?: Type.entity_ref;
+            entitygroup?: UInt64Type;
+            energy_cost?: UInt16Type;
+        }
         interface coordinates {
             x: Int64Type;
             y: Int64Type;
+            z?: UInt16Type;
         }
     }
+    interface addmodule {
+        entity_type: NameType;
+        entity_id: UInt64Type;
+        module_index: UInt8Type;
+        module_cargo_id: UInt64Type;
+        target_cargo_id: UInt64Type;
+    }
+    interface addnexus {
+        nexus_name: string;
+        x: Int64Type;
+        y: Int64Type;
+    }
     interface advance {
         reveal: string;
         commit: Checksum256Type;
     }
-    interface arrive {
+    interface blend {
+        entity_type: NameType;
         id: UInt64Type;
+        inputs: Type.cargo_item[];
     }
-    interface buygoods {
-        ship_id: UInt64Type;
-        good_id: UInt64Type;
-        quantity: UInt64Type;
+    interface cancel {
+        entity_type: NameType;
+        id: UInt64Type;
+        count: UInt64Type;
     }
-    interface buyship {
-        account: NameType;
-        name: string;
+    interface cleanrsvp {
+        epoch: UInt64Type;
+        max_rows: UInt64Type;
     }
     interface cleartable {
         table_name: NameType;
@@ -401,9 +895,97 @@ declare namespace ActionParams {
     interface commit {
         commit: Checksum256Type;
     }
+    interface configlog {
+        config: Type.game_config;
+    }
+    interface craft {
+        entity_type: NameType;
+        id: UInt64Type;
+        recipe_id: UInt16Type;
+        quantity: UInt32Type;
+        inputs: Type.cargo_item[];
+    }
+    interface createentity {
+        owner: NameType;
+        entity_type: NameType;
+        entity_name: string;
+        x: Int64Type;
+        y: Int64Type;
+    }
+    interface deploy {
+        entity_type: NameType;
+        id: UInt64Type;
+        packed_item_id: UInt16Type;
+        seed: UInt64Type;
+        entity_name: string;
+    }
     interface enable {
         enabled: boolean;
     }
+    interface extract {
+        entity_type: NameType;
+        id: UInt64Type;
+        stratum: UInt16Type;
+        quantity: UInt32Type;
+    }
+    interface getconfig {
+    }
+    interface getentities {
+        owner: NameType;
+        entity_type?: NameType;
+    }
+    interface getentity {
+        entity_type: NameType;
+        entity_id: UInt64Type;
+    }
+    interface getitemdata {
+    }
+    interface getitems {
+    }
+    interface getlocation {
+        x: Int64Type;
+        y: Int64Type;
+    }
+    interface getlocdata {
+        x: Int64Type;
+        y: Int64Type;
+    }
+    interface getmodules {
+    }
+    interface getnearby {
+        entity_type: NameType;
+        entity_id: UInt64Type;
+        recharge: boolean;
+    }
+    interface getnftinfo {
+    }
+    interface getplayer {
+        account: NameType;
+    }
+    interface getrecipe {
+        output_item_id: UInt16Type;
+    }
+    interface getrecipes {
+        lower_bound: UInt16Type;
+        limit: UInt8Type;
+    }
+    interface getresources {
+    }
+    interface getstratum {
+        x: Int64Type;
+        y: Int64Type;
+        stratum: UInt16Type;
+    }
+    interface getsummaries {
+        owner: NameType;
+        entity_type?: NameType;
+    }
+    interface grouptravel {
+        entities: Type.entity_ref[];
+        x: Int64Type;
+        y: Int64Type;
+        recharge: boolean;
+    }
     interface hash {
         value: string;
     }
@@ -413,105 +995,165 @@ 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 notify {
+        event: Type.task_event;
+    }
+    interface recharge {
+        entity_type: NameType;
+        id: UInt64Type;
     }
-    interface marketprices {
-        location: Type.coordinates;
+    interface resolve {
+        entity_type: NameType;
+        id: UInt64Type;
+        count?: UInt64Type;
     }
-    interface payloan {
-        account: NameType;
-        amount: UInt64Type;
+    interface rmmodule {
+        entity_type: NameType;
+        entity_id: UInt64Type;
+        module_index: UInt8Type;
+        target_cargo_id: UInt64Type;
+    }
+    interface rmnftcfg {
+        item_id: UInt16Type;
     }
     interface salt {
         salt: UInt64Type;
     }
-    interface sellgoods {
-        ship_id: UInt64Type;
-        good_id: UInt64Type;
+    interface setnftcfg {
+        item_id: UInt16Type;
+        template_id: Int32Type;
+        schema_name: NameType;
+    }
+    interface spawncargo {
+        entity_id: UInt64Type;
+        item_id: UInt64Type;
         quantity: UInt64Type;
     }
-    interface takeloan {
-        account: NameType;
-        amount: UInt64Type;
+    interface spawnseeded {
+        entity_id: UInt64Type;
+        item_id: UInt64Type;
+        quantity: UInt64Type;
+        seed: UInt64Type;
     }
-    interface travel {
-        id: UInt64Type;
-        destination: Type.coordinates;
-        recharge: boolean;
+    interface transfer {
+        source_type: NameType;
+        source_id: UInt64Type;
+        dest_type: NameType;
+        dest_id: UInt64Type;
+        item_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;
-    }
-    interface updatedebt {
-        account: NameType;
-        amount: Int64Type;
-    }
-    interface upgradeship {
-        account: NameType;
+    interface warp {
+        entity_type: NameType;
         id: UInt64Type;
+        x: Int64Type;
+        y: Int64Type;
     }
     interface wipe {
     }
     interface wipesequence {
     }
+    interface wrap {
+        owner: NameType;
+        entity_type: NameType;
+        entity_id: UInt64Type;
+        cargo_id: UInt64Type;
+        quantity: UInt64Type;
+    }
 }
 interface ActionNameParams {
+    addmodule: ActionParams.addmodule;
+    addnexus: ActionParams.addnexus;
     advance: ActionParams.advance;
-    arrive: ActionParams.arrive;
-    buygoods: ActionParams.buygoods;
-    buyship: ActionParams.buyship;
+    blend: ActionParams.blend;
+    cancel: ActionParams.cancel;
+    cleanrsvp: ActionParams.cleanrsvp;
     cleartable: ActionParams.cleartable;
     commit: ActionParams.commit;
+    configlog: ActionParams.configlog;
+    craft: ActionParams.craft;
+    createentity: ActionParams.createentity;
+    deploy: ActionParams.deploy;
     enable: ActionParams.enable;
+    extract: ActionParams.extract;
+    getconfig: ActionParams.getconfig;
+    getentities: ActionParams.getentities;
+    getentity: ActionParams.getentity;
+    getitemdata: ActionParams.getitemdata;
+    getitems: ActionParams.getitems;
+    getlocation: ActionParams.getlocation;
+    getlocdata: ActionParams.getlocdata;
+    getmodules: ActionParams.getmodules;
+    getnearby: ActionParams.getnearby;
+    getnftinfo: ActionParams.getnftinfo;
+    getplayer: ActionParams.getplayer;
+    getrecipe: ActionParams.getrecipe;
+    getrecipes: ActionParams.getrecipes;
+    getresources: ActionParams.getresources;
+    getstratum: ActionParams.getstratum;
+    getsummaries: ActionParams.getsummaries;
+    grouptravel: ActionParams.grouptravel;
     hash: ActionParams.hash;
     hash512: ActionParams.hash512;
     init: ActionParams.init;
-    jettison: ActionParams.jettison;
     join: ActionParams.join;
-    marketprice: ActionParams.marketprice;
-    marketprices: ActionParams.marketprices;
-    payloan: ActionParams.payloan;
+    notify: ActionParams.notify;
+    recharge: ActionParams.recharge;
+    resolve: ActionParams.resolve;
+    rmmodule: ActionParams.rmmodule;
+    rmnftcfg: ActionParams.rmnftcfg;
     salt: ActionParams.salt;
-    sellgoods: ActionParams.sellgoods;
-    takeloan: ActionParams.takeloan;
+    setnftcfg: ActionParams.setnftcfg;
+    spawncargo: ActionParams.spawncargo;
+    spawnseeded: ActionParams.spawnseeded;
+    transfer: ActionParams.transfer;
     travel: ActionParams.travel;
-    travelplan: ActionParams.travelplan;
-    traveltime: ActionParams.traveltime;
-    updatecredit: ActionParams.updatecredit;
-    updatedebt: ActionParams.updatedebt;
-    upgradeship: ActionParams.upgradeship;
+    warp: ActionParams.warp;
     wipe: ActionParams.wipe;
     wipesequence: ActionParams.wipesequence;
+    wrap: ActionParams.wrap;
 }
 type ActionNames = keyof ActionNameParams;
 interface ActionReturnValues {
+    cancel: Types.cancel_results;
+    craft: Types.task_results;
+    deploy: Types.task_results;
+    extract: Types.task_results;
+    getconfig: Types.game_config;
+    getentities: Types.entity_info[];
+    getentity: Types.entity_info;
+    getitemdata: Types.itemdata_result;
+    getitems: Types.items_info;
+    getlocation: Types.location_info;
+    getlocdata: Types.location_derived;
+    getmodules: Types.modules_result;
+    getnearby: Types.nearby_info;
+    getnftinfo: Types.nftinfo_result;
+    getplayer: Types.player_info;
+    getrecipe: Types.recipes_result;
+    getrecipes: Types.recipes_result;
+    getresources: Types.resources_result;
+    getstratum: Types.stratum_data;
+    getsummaries: Types.entity_summary[];
+    grouptravel: Types.task_results;
     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;
+    transfer: Types.task_results;
+    travel: Types.task_results;
+    warp: Types.task_results;
+    wrap: Types.task_results;
 }
 type ActionReturnNames = keyof ActionReturnValues;
 declare class Contract extends Contract$2 {
@@ -553,119 +1195,712 @@ 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 ITEM_DOES_NOT_EXIST = "Item does not exist.";
+declare const ITEM_NOT_AVAILABLE_AT_LOCATION = "Item is not tradeable at ship location.";
+declare const INSUFFICIENT_BALANCE = "Insufficient balance.";
+declare const INSUFFICIENT_ITEM_QUANTITY = "Insufficient quantity in cargo.";
+declare const INSUFFICIENT_ITEM_SUPPLY = "Insufficient supply of item 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 CRAFT_ENERGY_DIVISOR = 150000;
+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 BASE_ORBITAL_MASS = 100000;
+interface ShipLike {
+    coordinates: Types.coordinates;
+    hullmass?: UInt32;
+    energy?: UInt16;
+    engines?: Types.movement_stats;
+    generator?: Types.energy_stats;
+    loaders?: Types.loader_stats;
+    hauler?: Types.hauler_stats;
+    capacity?: UInt32;
+}
+interface CargoMassInfo {
+    item_id: UInt16Type;
+    quantity: UInt32Type;
+}
+declare enum TaskType {
+    IDLE = 0,
+    TRAVEL = 1,
+    RECHARGE = 2,
+    LOAD = 3,
+    UNLOAD = 4,
+    EXTRACT = 5,
+    WARP = 6,
+    CRAFT = 7,
+    DEPLOY = 8,
+    DEPLOY_SHIP = 9
+}
+declare enum LocationType {
+    EMPTY = 0,
+    PLANET = 1,
+    ASTEROID = 2,
+    NEBULA = 3
 }
-interface Dimensions {
-    width: number;
-    height: number;
+declare enum TaskCancelable {
+    NEVER = 0,
+    BEFORE_START = 1,
+    ALWAYS = 2
 }
+declare const EntityType$1: {
+    readonly SHIP: Name;
+    readonly WAREHOUSE: Name;
+    readonly CONTAINER: Name;
+};
+type EntityTypeName = (typeof EntityType$1)[keyof typeof EntityType$1];
+type CoordinatesType = Coordinates | Types.coordinates | {
+    x: Int64Type;
+    y: Int64Type;
+};
+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;
     distance: UInt16;
 }
-declare class Good extends Struct {
+type ResourceCategory = 'metal' | 'precious' | 'gas' | 'mineral' | 'organic';
+type ResourceTier = 't1' | 't2' | 't3' | 't4' | 't5';
+declare class Item extends Struct {
     id: UInt16;
     name: string;
     description: string;
-    base_price: UInt64;
-    mass: UInt64;
+    mass: UInt32;
+    category: ResourceCategory;
+    tier: ResourceTier;
+    color: string;
 }
-interface GoodType {
-    id: UInt16Type;
-    name: string;
-    description: string;
-    base_price: UInt64Type;
-    mass: UInt64Type;
+
+interface EpochInfo {
+    epoch: UInt64;
+    start: Date;
+    end: Date;
 }
-declare class GoodPrice extends Struct {
-    id: UInt16;
-    good: Good;
-    price: UInt64;
-    supply: UInt64;
+declare function getCurrentEpoch(game: Types$1.game_row): UInt64;
+declare function getEpochInfo(game: Types$1.game_row, epoch: UInt64): EpochInfo;
+
+/**
+ * GameState class extends the state_row from the server contract
+ * with helper methods for epoch management and system generation
+ */
+declare class GameState extends Types.state_row {
+    private _game?;
+    /**
+     * Create a GameState instance from a state_row
+     */
+    static from(state: Types.state_row, game?: Types$1.game_row): GameState;
+    /**
+     * Set the game configuration (needed for epoch calculations)
+     */
+    setGame(game: Types$1.game_row): void;
+    /**
+     * 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;
+    };
+}
+
+interface PlayerStateInput {
+    owner: NameType;
 }
-interface Coordinates extends ActionParams.Type.coordinates {
+declare class Player extends Types.player_row {
+    static fromState(state: PlayerStateInput): Player;
 }
 
-declare const goodIds: any[];
-declare function getGood(good_id: UInt16Type): Good;
-declare function getGoods(): Good[];
+declare class PlayersManager extends BaseManager {
+    getPlayer(account: NameType): Promise<Player | undefined>;
+}
 
-declare function hash(seed: Checksum256Type, string: string): Checksum512;
-declare function hash512(seed: Checksum256Type, string: string): Checksum512;
+declare class LocationsManager extends BaseManager {
+    hasSystem(location: CoordinatesType): Promise<boolean>;
+    findNearbyPlanets(origin: CoordinatesType, maxDistance?: UInt16Type): Promise<Distance[]>;
+    getLocationEntity(id: UInt64Type): Promise<Types.location_row | undefined>;
+    getLocationEntityAt(coords: CoordinatesType): Promise<Types.location_row | undefined>;
+    getAllLocationEntities(): Promise<Types.location_row[]>;
+}
+
+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>;
+}
+
+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, goodId: UInt64Type, quantity: UInt64Type): Action;
+    foundCompany(account: NameType, name: string): Action;
+    join(account: NameType): Action;
+    extract(shipId: UInt64Type): Action;
+    warp(shipId: UInt64Type, destination: CoordinatesType): Action;
+    craft(entityType: EntityTypeName, entityId: UInt64Type, recipeId: number, quantity: number, inputs: ActionParams.Type.cargo_item[]): Action;
+    blend(entityType: EntityTypeName, entityId: UInt64Type, inputs: ActionParams.Type.cargo_item[]): Action;
+    deploy(entityType: EntityTypeName, entityId: UInt64Type, packedItemId: number, seed: bigint, entityName: string): Action;
+    addmodule(entityType: EntityTypeName, entityId: UInt64Type, moduleIndex: number, moduleCargoId: UInt64Type, targetCargoId?: UInt64Type): Action;
+    rmmodule(entityType: EntityTypeName, entityId: UInt64Type, moduleIndex: number, targetCargoId?: UInt64Type): Action;
+    joinGame(account: NameType, companyName: string): Action[];
+}
+
+declare class GameContext {
+    readonly client: APIClient;
+    readonly server: Contract$2;
+    readonly platform: Contract$2;
+    private _entities?;
+    private _players?;
+    private _locations?;
+    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 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 function getSystemName(gameSeed: Checksum256, location: Coordinates): string;
-declare function hasSystem(gameSeed: Checksum256, coordinates: ActionParams.Type.coordinates): boolean;
-
-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 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 {
+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 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 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;
+    extractor?: Types.extractor_stats;
+    crafter?: Types.crafter_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 capsHasExtractor(caps: EntityCapabilities): boolean;
+declare function capsHasMass(caps: EntityCapabilities): boolean;
+
+type Schedule = Types.schedule;
+type Task$1 = Types.task;
+interface ScheduleData {
+    schedule?: Schedule;
+}
+interface Scheduleable extends ScheduleData {
+    hasSchedule: boolean;
+    isIdle: boolean;
+    tasks: Task$1[];
+    scheduleDuration(): number;
+    scheduleElapsed(now: Date): number;
+    scheduleRemaining(now: Date): number;
+    scheduleComplete(now: Date): boolean;
+    currentTaskIndex(now: Date): number;
+    currentTask(now: Date): Task$1 | undefined;
+    currentTaskType(now: Date): TaskType | undefined;
+    getTaskStartTime(index: number): number;
+    getTaskElapsed(index: number, now: Date): number;
+    getTaskRemaining(index: number, now: Date): number;
+    isTaskComplete(index: number, now: Date): boolean;
+    isTaskInProgress(index: number, now: Date): boolean;
+    currentTaskProgress(now: Date): number;
+    scheduleProgress(now: Date): number;
+}
+declare function hasSchedule$1(entity: ScheduleData): boolean;
+declare function isIdle(entity: ScheduleData): boolean;
+declare function getTasks(entity: ScheduleData): Task$1[];
+declare function scheduleDuration(entity: ScheduleData): number;
+declare function scheduleElapsed(entity: ScheduleData, now: Date): number;
+declare function scheduleRemaining(entity: ScheduleData, now: Date): number;
+declare function scheduleComplete(entity: ScheduleData, now: Date): boolean;
+declare function currentTaskIndex(entity: ScheduleData, now: Date): number;
+declare function currentTask(entity: ScheduleData, now: Date): Task$1 | undefined;
+declare function currentTaskType(entity: ScheduleData, now: Date): TaskType | undefined;
+declare function getTaskStartTime(entity: ScheduleData, index: number): number;
+declare function getTaskElapsed(entity: ScheduleData, index: number, now: Date): number;
+declare function getTaskRemaining(entity: ScheduleData, index: number, now: Date): number;
+declare function isTaskComplete(entity: ScheduleData, index: number, now: Date): boolean;
+declare function isTaskInProgress(entity: ScheduleData, index: number, now: Date): boolean;
+declare function currentTaskProgress(entity: ScheduleData, now: Date): number;
+declare function scheduleProgress(entity: ScheduleData, now: Date): number;
+declare function isTaskType(entity: ScheduleData, taskType: TaskType, now: Date): boolean;
+declare function isInFlight(entity: ScheduleData, now: Date): boolean;
+declare function isRecharging(entity: ScheduleData, now: Date): boolean;
+declare function isLoading(entity: ScheduleData, now: Date): boolean;
+declare function isUnloading(entity: ScheduleData, now: Date): boolean;
+declare function isExtracting(entity: ScheduleData, now: Date): boolean;
+
+type schedule_ScheduleData = ScheduleData;
+type schedule_Scheduleable = Scheduleable;
+declare const schedule_isIdle: typeof isIdle;
+declare const schedule_getTasks: typeof getTasks;
+declare const schedule_scheduleDuration: typeof scheduleDuration;
+declare const schedule_scheduleElapsed: typeof scheduleElapsed;
+declare const schedule_scheduleRemaining: typeof scheduleRemaining;
+declare const schedule_scheduleComplete: typeof scheduleComplete;
+declare const schedule_currentTaskIndex: typeof currentTaskIndex;
+declare const schedule_currentTask: typeof currentTask;
+declare const schedule_currentTaskType: typeof currentTaskType;
+declare const schedule_getTaskStartTime: typeof getTaskStartTime;
+declare const schedule_getTaskElapsed: typeof getTaskElapsed;
+declare const schedule_getTaskRemaining: typeof getTaskRemaining;
+declare const schedule_isTaskComplete: typeof isTaskComplete;
+declare const schedule_isTaskInProgress: typeof isTaskInProgress;
+declare const schedule_currentTaskProgress: typeof currentTaskProgress;
+declare const schedule_scheduleProgress: typeof scheduleProgress;
+declare const schedule_isTaskType: typeof isTaskType;
+declare const schedule_isInFlight: typeof isInFlight;
+declare const schedule_isRecharging: typeof isRecharging;
+declare const schedule_isLoading: typeof isLoading;
+declare const schedule_isUnloading: typeof isUnloading;
+declare const schedule_isExtracting: typeof isExtracting;
+declare namespace schedule {
+  export {
+    schedule_ScheduleData as ScheduleData,
+    schedule_Scheduleable as Scheduleable,
+    hasSchedule$1 as hasSchedule,
+    schedule_isIdle as isIdle,
+    schedule_getTasks as getTasks,
+    schedule_scheduleDuration as scheduleDuration,
+    schedule_scheduleElapsed as scheduleElapsed,
+    schedule_scheduleRemaining as scheduleRemaining,
+    schedule_scheduleComplete as scheduleComplete,
+    schedule_currentTaskIndex as currentTaskIndex,
+    schedule_currentTask as currentTask,
+    schedule_currentTaskType as currentTaskType,
+    schedule_getTaskStartTime as getTaskStartTime,
+    schedule_getTaskElapsed as getTaskElapsed,
+    schedule_getTaskRemaining as getTaskRemaining,
+    schedule_isTaskComplete as isTaskComplete,
+    schedule_isTaskInProgress as isTaskInProgress,
+    schedule_currentTaskProgress as currentTaskProgress,
+    schedule_scheduleProgress as scheduleProgress,
+    schedule_isTaskType as isTaskType,
+    schedule_isInFlight as isInFlight,
+    schedule_isRecharging as isRecharging,
+    schedule_isLoading as isLoading,
+    schedule_isUnloading as isUnloading,
+    schedule_isExtracting as isExtracting,
+  };
+}
+
+interface ProjectedEntity {
+    location: Coordinates;
+    energy: UInt16;
+    cargoMass: UInt64;
+    shipMass: UInt32;
+    capacity?: UInt64;
+    engines?: Types.movement_stats;
+    loaders?: Types.loader_stats;
+    generator?: Types.energy_stats;
+    hauler?: Types.hauler_stats;
+    readonly totalMass: UInt64;
+    hasMovement(): boolean;
+    hasStorage(): boolean;
+    hasLoaders(): boolean;
+    capabilities(): EntityCapabilities;
+    state(): EntityState;
+}
+interface Projectable extends ScheduleData {
+    coordinates: Coordinates | Types.coordinates;
+    energy?: UInt16;
+    hullmass?: UInt32;
+    generator?: Types.energy_stats;
+    engines?: Types.movement_stats;
+    loaders?: Types.loader_stats;
+    hauler?: Types.hauler_stats;
+    capacity?: UInt32;
+    cargo: Types.cargo_item[];
+    cargomass: UInt32;
+    owner?: Name;
+}
+declare function createProjectedEntity(entity: Projectable): ProjectedEntity;
+declare function projectEntity(entity: Projectable): ProjectedEntity;
+declare function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity;
+
+declare class Location {
+    readonly coordinates: Coordinates;
+    private _gameSeed?;
+    private _hasSystem?;
+    private _epoch?;
+    constructor(coordinates: CoordinatesType);
+    static from(coordinates: CoordinatesType): Location;
+    hasSystemAt(gameSeed: Checksum256Type): boolean;
+    getLocationTypeAt(gameSeed: Checksum256Type): LocationType;
+    isExtractableAt(gameSeed: Checksum256Type): boolean;
+    findNearby(gameSeed: Checksum256Type, maxDistance?: UInt16Type): Distance[];
+    equals(other: CoordinatesType | Location): boolean;
+    get epoch(): UInt64 | undefined;
+    clearCache(): void;
+}
+declare function toLocation(coords: CoordinatesType | Location): Location;
+
+type Task = Types.task;
+declare class ScheduleAccessor {
+    private entity;
+    constructor(entity: ScheduleData);
+    get hasSchedule(): boolean;
+    get isIdle(): boolean;
+    get tasks(): Task[];
+    duration(): number;
+    elapsed(now: Date): number;
+    remaining(now: Date): number;
+    complete(now: Date): boolean;
+    currentTaskIndex(now: Date): number;
+    currentTask(now: Date): Task | undefined;
+    currentTaskType(now: Date): TaskType | undefined;
+    taskStartTime(index: number): number;
+    taskElapsed(index: number, now: Date): number;
+    taskRemaining(index: number, now: Date): number;
+    taskComplete(index: number, now: Date): boolean;
+    taskInProgress(index: number, now: Date): boolean;
+    currentTaskProgress(now: Date): number;
+    progress(now: Date): number;
+}
+declare function createScheduleAccessor(entity: ScheduleData): ScheduleAccessor;
+
+declare class EntityInventory extends Types.cargo_item {
+    private _item?;
+    get item(): Item;
+    get good(): Item;
+    get name(): string;
+    get unitMass(): UInt32;
+    get totalMass(): UInt64;
+    get hasCargo(): boolean;
+    get isEmpty(): boolean;
+}
+
+interface HasCargo {
+    cargo: Types.cargo_item[];
+}
+interface HasCapacity {
+    capacity: UInt32;
+}
+interface HasCargomass {
+    cargomass: UInt32;
+}
+declare function calcCargoItemMass(item: Types.cargo_item): UInt64;
+declare function calcCargoMass(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;
+    forItem(goodId: UInt64Type): EntityInventory | undefined;
+    get sellable(): EntityInventory[];
+    get hasSellable(): boolean;
+    get sellableCount(): number;
+}
+declare function createInventoryAccessor(entity: HasCargo): InventoryAccessor;
+
+interface ShipStateInput {
+    id: UInt64Type;
+    owner: string;
+    name: string;
+    coordinates: CoordinatesType | {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    hullmass?: 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 {
+    private _sched?;
+    private _inv?;
+    get name(): string;
+    get inv(): InventoryAccessor;
+    get inventory(): EntityInventory[];
+    get sched(): ScheduleAccessor;
     get maxDistance(): UInt32;
-    get traveling(): boolean;
-    get arrived(): boolean;
-    get eta(): number;
+    get isIdle(): boolean;
+    getFlightOrigin(flightTaskIndex: number): Coordinates;
+    destinationLocation(): Coordinates | undefined;
+    positionAt(now: Date): Coordinates;
+    isInFlight(now: Date): boolean;
+    isRecharging(now: Date): boolean;
+    isLoading(now: Date): boolean;
+    isUnloading(now: Date): boolean;
+    isExtracting(now: Date): boolean;
+    get hasEngines(): boolean;
+    get hasGenerator(): boolean;
+    get hasExtractor(): boolean;
+    get hasWarp(): boolean;
+    project(): ProjectedEntity;
+    projectAt(now: Date): ProjectedEntity;
+    get location(): Location;
+    get totalCargoMass(): UInt64;
+    get totalMass(): UInt64;
+    get maxCapacity(): UInt64;
+    hasSpace(goodMass: UInt64, quantity: number): boolean;
+    get availableCapacity(): UInt64;
+    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined;
+    get sellableCargo(): EntityInventory[];
+    get hasSellableCargo(): boolean;
+    get sellableGoodsCount(): number;
+    get isFull(): boolean;
+    get energyPercent(): number;
+    get needsRecharge(): boolean;
+    hasEnergyFor(distance: UInt64): boolean;
 }
 
-declare function travelplanDuration(travelplan: Types.travel_plan): UInt64;
-declare function distanceTraveled(ship: Types.ship_row, current?: Date): 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_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_acceleration(thrust: number, mass: number): number;
-declare function calc_ship_mass(ship: Types.ship_row, cargos: Types.cargo_row[]): UInt64;
-declare function calc_energyusage(distance: UInt64Type, drain: UInt32Type): UInt32;
+interface WarehouseStateInput {
+    id: UInt64Type;
+    owner: string;
+    name: string;
+    coordinates: CoordinatesType | {
+        x: number;
+        y: number;
+        z?: number;
+    };
+    hullmass?: number;
+    capacity: number;
+    loaders?: Types.loader_stats;
+    schedule?: Types.schedule;
+    cargo?: Types.cargo_item[];
+}
+declare class Warehouse extends Types.entity_info {
+    private _sched?;
+    private _inv?;
+    get name(): string;
+    get inv(): InventoryAccessor;
+    get inventory(): EntityInventory[];
+    get sched(): ScheduleAccessor;
+    get isIdle(): boolean;
+    isLoading(now: Date): boolean;
+    isUnloading(now: Date): boolean;
+    get location(): Location;
+    get totalCargoMass(): UInt64;
+    get maxCapacity(): UInt64;
+    get availableCapacity(): UInt64;
+    hasSpace(goodMass: UInt64, quantity: number): boolean;
+    get isFull(): boolean;
+    getCargoForItem(goodId: UInt64Type): EntityInventory | undefined;
+    get orbitalAltitude(): number;
+    get totalMass(): UInt64;
+}
+
+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;
+}
+declare function computeContainerCapabilities(stats: Record<string, number>): {
+    hullmass: number;
+    capacity: number;
+};
+declare function computeContainerT2Capabilities(stats: Record<string, number>): {
+    hullmass: number;
+    capacity: number;
+};
+
+type EntityType = 'ship' | 'warehouse' | 'container' | 'location';
+declare class EntitiesManager extends BaseManager {
+    getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse | Container>;
+    getEntities(owner: NameType | Types.player_row, type?: EntityType): Promise<(Ship | Warehouse | Container)[]>;
+    getSummaries(owner: NameType | Types.player_row, type?: EntityType): Promise<Types.entity_summary[]>;
+    getShip(id: UInt64Type): Promise<Ship>;
+    getWarehouse(id: UInt64Type): Promise<Warehouse>;
+    getContainer(id: UInt64Type): Promise<Container>;
+    getShips(owner: NameType | Types.player_row): Promise<Ship[]>;
+    getWarehouses(owner: NameType | Types.player_row): Promise<Warehouse[]>;
+    getContainers(owner: NameType | Types.player_row): Promise<Container[]>;
+    getShipSummaries(owner: NameType | Types.player_row): Promise<Types.entity_summary[]>;
+    getWarehouseSummaries(owner: NameType | Types.player_row): Promise<Types.entity_summary[]>;
+    getContainerSummaries(owner: NameType | Types.player_row): Promise<Types.entity_summary[]>;
+    private wrapEntity;
+    private resolveOwner;
+}
 
 interface ShiploadOptions {
     platformContractName?: string;
@@ -677,26 +1912,706 @@ 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 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 function makeShip(state: ShipStateInput): Ship;
+declare function makeWarehouse(state: WarehouseStateInput): Warehouse;
+declare function makeContainer(state: ContainerStateInput): Container;
+
+declare const itemIds: UInt16[];
+declare function getItem(itemId: UInt16Type): Item;
+declare function getItems(): Item[];
+
+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;
+
+interface StratumInfo {
+    itemId: number;
+    seed: bigint;
+    richness: number;
+    reserve: number;
+}
+interface ResourceStats {
+    stat1: number;
+    stat2: number;
+    stat3: number;
+}
+declare function deriveStratum(epochSeed: Checksum256Type, coords: CoordinatesType, stratum: number, locationType: number, subtype: number, _maxDepth: number): StratumInfo;
+declare function deriveResourceStats(seed: bigint): ResourceStats;
+
+declare function deriveLocationSize(loc: Types.location_static): number;
+
+declare const DEPTH_THRESHOLD_T1 = 0;
+declare const DEPTH_THRESHOLD_T2 = 2000;
+declare const DEPTH_THRESHOLD_T3 = 10000;
+declare const DEPTH_THRESHOLD_T4 = 30000;
+declare const DEPTH_THRESHOLD_T5 = 55000;
+declare const LOCATION_MIN_DEPTH = 500;
+declare const LOCATION_MAX_DEPTH = 65535;
+declare const PLANET_SUBTYPE_GAS_GIANT = 0;
+declare const PLANET_SUBTYPE_ROCKY = 1;
+declare const PLANET_SUBTYPE_TERRESTRIAL = 2;
+declare const PLANET_SUBTYPE_ICY = 3;
+declare const PLANET_SUBTYPE_OCEAN = 4;
+declare const PLANET_SUBTYPE_INDUSTRIAL = 5;
+declare function getDepthThreshold(tier: ResourceTier): number;
+declare function getResourceTier(itemId: number): ResourceTier;
+declare function getResourceWeight(itemId: number, stratum: number): number;
+declare function getLocationCandidates(locationType: number, subtype: number): number[];
+declare function getEligibleResources(locationType: number, subtype: number, stratum: number): number[];
+declare function depthScaleFactor(stratum: number): number;
+
+interface StatDefinition {
+    key: string;
+    label: string;
+    abbreviation: string;
+    purpose: string;
+    inverted?: boolean;
+}
+declare function getStatDefinitions(category: ResourceCategory): StatDefinition[];
+declare function getStatName(category: ResourceCategory, index: 0 | 1 | 2): StatDefinition;
+interface NamedStats {
+    definitions: StatDefinition[];
+    values: [number, number, number];
+}
+declare function resolveStats(category: ResourceCategory, stats: {
+    stat1: number;
+    stat2: number;
+    stat3: number;
+}): NamedStats;
+
+interface StackInput {
+    quantity: number;
+    stats: Record<string, number>;
+}
+interface CategoryStacks {
+    category: ResourceCategory;
+    stacks: StackInput[];
+}
+declare function encodeStats(values: number[]): bigint;
+declare function decodeStat(seed: bigint, index: number): number;
+declare function decodeStats(seed: bigint, count: number): number[];
+declare function decodeCraftedItemStats(itemId: number, seed: bigint): Record<string, number>;
+declare function blendStacks(stacks: StackInput[], statKey: string): number;
+declare function computeComponentStats(componentId: number, categoryStacks: CategoryStacks[]): {
+    key: string;
+    value: number;
+}[];
+declare function blendComponentStacks(stacks: {
+    quantity: number;
+    stats: Record<string, number>;
+}[]): Record<string, number>;
+declare function computeEntityStats(entityRecipeId: string, componentStacks: Record<number, {
+    quantity: number;
+    stats: Record<string, number>;
+}[]>): {
+    key: string;
+    value: number;
+}[];
+declare const categoryItemMass: Record<string, number>;
+declare function computeInputMass(itemId: string | number, itemType: 'component' | 'module' | 'entity'): number;
+declare function blendCrossGroup(sources: {
+    value: number;
+    weight: number;
+}[]): number;
+declare function blendCargoStacks(itemId: number, stacks: {
+    quantity: number;
+    seed: UInt64;
+}[]): UInt64;
+
+declare function hash(seed: Checksum256Type, string: string): Checksum256;
+declare function hash512(seed: Checksum256Type, string: string): Checksum512;
+
+/**
+ * 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 calc_rechargetime(capacity: UInt32Type, energy: UInt32Type, recharge: UInt32Type): UInt32;
+declare function calc_ship_rechargetime(ship: ShipLike): UInt32;
+declare function calc_flighttime(distance: UInt64Type, acceleration: number): UInt32;
+declare function calc_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: 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;
+    };
+}
+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;
+
+interface CargoData {
+    cargo: EntityInventory[];
+}
+declare function totalCargoMass(cargo: EntityInventory[]): UInt64;
+declare function getCargoForItem(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;
+declare function afterRemoveItems(cargo: Types.cargo_item[], goodsToRemove: Array<{
+    goodId: number;
+    quantity: number;
+}>): EntityInventory[];
+declare function afterRemoveAllItems(cargo: Types.cargo_item[]): EntityInventory[];
+
+type cargoUtils_CargoData = CargoData;
+declare const cargoUtils_totalCargoMass: typeof totalCargoMass;
+declare const cargoUtils_getCargoForItem: typeof getCargoForItem;
+declare const cargoUtils_hasSpace: typeof hasSpace;
+declare const cargoUtils_availableCapacity: typeof availableCapacity;
+declare const cargoUtils_isFull: typeof isFull;
+declare const cargoUtils_afterRemoveItems: typeof afterRemoveItems;
+declare const cargoUtils_afterRemoveAllItems: typeof afterRemoveAllItems;
+declare namespace cargoUtils {
+  export {
+    cargoUtils_CargoData as CargoData,
+    cargoUtils_totalCargoMass as totalCargoMass,
+    cargoUtils_getCargoForItem as getCargoForItem,
+    cargoUtils_hasSpace as hasSpace,
+    cargoUtils_availableCapacity as availableCapacity,
+    cargoUtils_isFull as isFull,
+    cargoUtils_afterRemoveItems as afterRemoveItems,
+    cargoUtils_afterRemoveAllItems as afterRemoveAllItems,
+  };
+}
+
+interface Entity {
+    id: UInt64;
+    type: Name;
+    owner: Name;
+    entity_name: string;
+    location: Coordinates | Types.coordinates;
+}
+type ShipEntity = Entity & Partial<MovementCapability> & Partial<EnergyCapability> & StorageCapability & Partial<LoaderCapability> & MassCapability & ScheduleCapability & {
+    extractor?: Types.extractor_stats;
+};
+type WarehouseEntity = Entity & StorageCapability & Partial<LoaderCapability> & MassCapability & ScheduleCapability;
+type ContainerEntity = Entity & StorageCapability & MassCapability & ScheduleCapability;
+type AnyEntity = ShipEntity | WarehouseEntity | ContainerEntity;
+
+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 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, itemMass: number, quantity: number, stratum: number, richness: number): UInt32;
+declare function calc_extraction_energy(extractor: Types.extractor_stats, duration: number): UInt16;
+
+interface CrafterCapability {
+    crafter: Types.crafter_stats;
+}
+declare function capsHasCrafter(caps: EntityCapabilities): boolean;
+declare function calc_craft_duration(speed: number, totalInputMass: number, quantity: number): UInt32;
+declare function calc_craft_energy(drain: number, totalInputMass: number): UInt16;
+
+declare const ITEM_ENGINE_T1 = 10100;
+declare const ITEM_GENERATOR_T1 = 10101;
+declare const ITEM_EXTRACTOR_T1 = 10102;
+declare const ITEM_LOADER_T1 = 10103;
+declare const ITEM_MANUFACTURING_T1 = 10104;
+declare const ITEM_STORAGE_T1 = 10105;
+declare const ITEM_HAULER_T1 = 10106;
+declare const MODULE_ANY = 0;
+declare const MODULE_ENGINE = 1;
+declare const MODULE_GENERATOR = 2;
+declare const MODULE_EXTRACTOR = 3;
+declare const MODULE_LOADER = 4;
+declare const MODULE_WARP = 5;
+declare const MODULE_CRAFTER = 6;
+declare const MODULE_LAUNCHER = 7;
+declare const MODULE_STORAGE = 8;
+declare const MODULE_HAULER = 9;
+interface CargoSeed {
+    itemId: number;
+    seed: bigint;
+}
+interface ModuleEntry {
+    type: number;
+    installed?: CargoSeed;
+}
+declare function moduleAccepts(slotType: number, moduleType: number): boolean;
+declare function getModuleCapabilityType(itemId: number): number;
+declare function isModuleItem(itemId: number): boolean;
+
+declare function computeHaulPenalty(totalThrust: number, haulCount: number, avgEfficiency: number): number;
+declare function computeHaulerDrain(distance: number, drain: number, haulCount: number): number;
+
+declare const categoryColors: Record<ResourceCategory, string>;
+declare const tierColors: Record<ResourceTier, string>;
+declare const categoryIcons: Record<ResourceCategory, string>;
+declare const componentIcon = "\u25A3";
+declare const moduleIcon = "\u2B22";
+declare const itemIcons: Record<number, string>;
+
+type CraftedItemCategory = 'component' | 'module' | 'entity' | 'resource';
+declare const ITEM_TYPE_RESOURCE = 0;
+declare const ITEM_TYPE_COMPONENT = 1;
+declare const ITEM_TYPE_MODULE = 2;
+declare const ITEM_TYPE_ENTITY = 3;
+declare function itemTypeCode(id: number): number;
+declare function itemTier(id: number): number;
+declare function itemOffset(id: number): number;
+declare function itemCategory(id: number): CraftedItemCategory;
+declare function isRelatedItem(a: number, b: number): boolean;
+declare function isCraftedItem(id: number): boolean;
+
+interface CategoryInfo {
+    id: ResourceCategory;
+    name: string;
+    label: string;
+    description: string;
+    color: string;
+}
+declare function getCategoryInfo(): CategoryInfo[];
+declare function getCategoryInfo(id: ResourceCategory): CategoryInfo | undefined;
+
+interface PlanetSubtypeInfo {
+    id: number;
+    label: string;
+    description: string;
+    paletteType: string;
+}
+declare function getPlanetSubtypes(): PlanetSubtypeInfo[];
+declare function getPlanetSubtype(id: number): PlanetSubtypeInfo | undefined;
+
+interface CapabilityAttribute {
+    capability: string;
+    attribute: string;
+    description: string;
+}
+interface StatMapping {
+    stat: string;
+    capability: string;
+    attribute: string;
+    rationale: string;
+}
+declare const capabilityNames: string[];
+declare const capabilityAttributes: CapabilityAttribute[];
+declare const statMappings: StatMapping[];
+declare function isInvertedAttribute(attribute: string): boolean;
+declare function getCapabilityAttributes(capability?: string): CapabilityAttribute[];
+declare function getStatMappings(): StatMapping[];
+declare function getStatMappingsForStat(stat: string): StatMapping[];
+declare function getStatMappingsForCapability(capability: string): StatMapping[];
+
+declare const ITEM_DRILL_SHAFT = 10005;
+declare const ITEM_EXTRACTION_PROBE = 10006;
+declare const ITEM_CARGO_ARM = 10007;
+declare const ITEM_TOOL_BIT = 10008;
+declare const ITEM_REACTION_CHAMBER = 10009;
+declare const ITEM_FOCUSING_ARRAY = 10010;
+declare const ITEM_HULL_PLATES = 10001;
+declare const ITEM_CARGO_LINING = 10002;
+declare const ITEM_CONTAINER_T1_PACKED = 10200;
+declare const ITEM_THRUSTER_CORE = 10003;
+declare const ITEM_POWER_CELL = 10004;
+declare const ITEM_SHIP_T1_PACKED = 10201;
+declare const ITEM_WAREHOUSE_T1_PACKED = 10202;
+declare const ITEM_HULL_PLATES_T2 = 20001;
+declare const ITEM_CARGO_LINING_T2 = 20002;
+declare const ITEM_CONTAINER_T2_PACKED = 20200;
+interface RecipeInput {
+    category?: ResourceCategory;
+    itemId?: number;
+    quantity: number;
+}
+interface ComponentStat {
+    key: string;
+    source: ResourceCategory;
+}
+interface ComponentDefinition {
+    id: number;
+    name: string;
+    description: string;
+    color: string;
+    mass: number;
+    stats: ComponentStat[];
+    recipe: RecipeInput[];
+    usedIn: {
+        type: 'entity' | 'module';
+        name: string;
+    }[];
+}
+interface ModuleSlot {
+    type: number;
+    label?: string;
+}
+interface EntityRecipe {
+    id: string;
+    name: string;
+    description: string;
+    color: string;
+    packedItemId: number;
+    recipe: RecipeInput[];
+    stats: {
+        key: string;
+        sourceComponentId: number;
+        sourceStatKey: string;
+    }[];
+    moduleSlots?: ModuleSlot[];
+}
+interface CraftableItem {
+    type: 'component' | 'entity' | 'module';
+    id: number | string;
+    name: string;
+    description: string;
+    color: string;
+}
+declare const components: ComponentDefinition[];
+declare const entityRecipes: EntityRecipe[];
+interface ModuleRecipe {
+    id: string;
+    name: string;
+    description: string;
+    color: string;
+    itemId: number;
+    moduleType: number;
+    recipe: RecipeInput[];
+    stats: {
+        key: string;
+        sourceComponentId: number;
+        sourceStatKey: string;
+    }[];
+}
+declare const moduleRecipes: ModuleRecipe[];
+declare function getModuleRecipe(id: string): ModuleRecipe | undefined;
+declare function getModuleRecipeByItemId(itemId: number): ModuleRecipe | undefined;
+declare function getComponentById(id: number): ComponentDefinition | undefined;
+declare function getEntityRecipe(id: string): EntityRecipe | undefined;
+declare function getEntityRecipeByItemId(itemId: number): EntityRecipe | undefined;
+declare function getEntitySlotLayout(packedItemId: number): ModuleSlot[];
+declare function getAllCraftableItems(): CraftableItem[];
+declare function getComponentsForCategory(category: ResourceCategory): ComponentDefinition[];
+declare function getComponentsForStat(statKey: string): ComponentDefinition[];
+
+declare function computeShipHullCapabilities(stats: Record<string, number>): {
+    hullmass: number;
+    capacity: number;
+};
+declare function computeEngineCapabilities(stats: Record<string, number>): {
+    thrust: number;
+    drain: number;
+};
+declare function computeGeneratorCapabilities(stats: Record<string, number>): {
+    capacity: number;
+    recharge: number;
+};
+declare function computeExtractorCapabilities(stats: Record<string, number>): {
+    rate: number;
+    drain: number;
+    depth: number;
+    drill: number;
+};
+declare function computeLoaderCapabilities(stats: Record<string, number>): {
+    mass: number;
+    thrust: number;
+    quantity: number;
+};
+declare function computeManufacturingCapabilities(stats: Record<string, number>): {
+    speed: number;
+    drain: number;
+};
+declare function computeHaulerCapabilities(stats: Record<string, number>): {
+    capacity: number;
+    efficiency: number;
+    drain: number;
+};
+declare function computeStorageCapabilities(stats: Record<string, number>, baseCapacity: number): {
+    capacityBonus: number;
+};
+declare function computeWarehouseHullCapabilities(stats: Record<string, number>): {
+    hullmass: number;
+    capacity: number;
+};
+interface ShipCapabilities {
+    engines?: {
+        thrust: number;
+        drain: number;
+    };
+    generator?: {
+        capacity: number;
+        recharge: number;
+    };
+    extractor?: {
+        rate: number;
+        drain: number;
+        depth: number;
+        drill: number;
+    };
+    hauler?: {
+        capacity: number;
+        efficiency: number;
+        drain: number;
+    };
+    loaders?: {
+        mass: number;
+        thrust: number;
+        quantity: number;
+    };
+    crafter?: {
+        speed: number;
+        drain: number;
+    };
+}
+declare function computeShipCapabilities(modules: {
+    itemId: number;
+    seed: bigint;
+}[]): ShipCapabilities;
+
+interface ResolvedItemStat {
+    key: string;
+    label: string;
+    abbreviation: string;
+    value: number;
+    color: string;
+    category: ResourceCategory;
+    inverted?: boolean;
+}
+interface ResolvedAttributeGroup {
+    capability: string;
+    attributes: {
+        label: string;
+        value: number;
+    }[];
+}
+type ResolvedItemType = 'resource' | 'component' | 'module' | 'entity';
+interface ResolvedModuleSlot {
+    name?: string;
+    installed: boolean;
+    attributes?: {
+        label: string;
+        value: number;
+    }[];
+}
+interface ResolvedItem {
+    itemId: number;
+    name: string;
+    icon: string;
+    category?: ResourceCategory;
+    tier: ResourceTier;
+    mass: number;
+    itemType: ResolvedItemType;
+    stats?: ResolvedItemStat[];
+    attributes?: ResolvedAttributeGroup[];
+    moduleSlots?: ResolvedModuleSlot[];
+}
+declare function resolveItem(itemId: UInt16Type, seed?: UInt64Type, modules?: Types.module_entry[]): ResolvedItem;
+
+interface NFTInstalledModule {
+    item_id: number;
+    seed: string;
+}
+interface NFTModuleSlot {
+    type: number;
+    installed?: NFTInstalledModule;
+}
+interface NFTCargoItem {
+    item_id: number;
+    quantity: number;
+    seed: string;
+    modules?: NFTModuleSlot[];
+}
+interface NFTCommonBase {
+    quantity: number;
+    seed: string;
+    origin_x: string;
+    origin_y: string;
+}
+declare function readCommonBase(data: Record<string, any>): NFTCommonBase;
+declare function deserializeScalar(data: Record<string, any>, itemId: number): NFTCargoItem;
+declare const deserializeResource: typeof deserializeScalar;
+declare const deserializeComponent: typeof deserializeScalar;
+declare const deserializeModule: typeof deserializeScalar;
+declare function deserializeEntity(data: Record<string, any>, itemId: number): NFTCargoItem;
+declare function deserializeAsset(data: Record<string, any>, itemId: number): NFTCargoItem;
+
+declare function computeBaseHullmass(seed: bigint): number;
+declare function computeBaseCapacityShip(seed: bigint): number;
+declare function computeBaseCapacityWarehouse(seed: bigint): number;
+declare const computeEngineThrust: (vol: number) => number;
+declare const computeEngineDrain: (thm: number) => number;
+declare const computeGeneratorCap: (res: number) => number;
+declare const computeGeneratorRech: (clr: number) => number;
+declare const computeExtractorRate: (str: number) => number;
+declare const computeExtractorDrain: (con: number) => number;
+declare const computeExtractorDepth: (tol: number) => number;
+declare const computeExtractorDrill: (ref: number) => number;
+declare const computeLoaderMass: (duc: number) => number;
+declare const computeLoaderThrust: (pla: number) => number;
+declare const computeCrafterSpeed: (rea: number) => number;
+declare const computeCrafterDrain: (clr: number) => number;
+declare function entityDisplayName(itemId: number): string;
+declare function moduleDisplayName(itemId: number): string;
+declare function formatModuleLine(slot: number, itemId: number, seed: bigint): string;
+declare function buildEntityDescription(itemId: number, hullSeed: bigint, moduleItems: number[], moduleSeeds: bigint[]): string;
+
+type index_NFTInstalledModule = NFTInstalledModule;
+type index_NFTModuleSlot = NFTModuleSlot;
+type index_NFTCargoItem = NFTCargoItem;
+type index_NFTCommonBase = NFTCommonBase;
+declare const index_readCommonBase: typeof readCommonBase;
+declare const index_deserializeScalar: typeof deserializeScalar;
+declare const index_deserializeResource: typeof deserializeResource;
+declare const index_deserializeComponent: typeof deserializeComponent;
+declare const index_deserializeModule: typeof deserializeModule;
+declare const index_deserializeEntity: typeof deserializeEntity;
+declare const index_deserializeAsset: typeof deserializeAsset;
+declare const index_computeBaseHullmass: typeof computeBaseHullmass;
+declare const index_computeBaseCapacityShip: typeof computeBaseCapacityShip;
+declare const index_computeBaseCapacityWarehouse: typeof computeBaseCapacityWarehouse;
+declare const index_computeEngineThrust: typeof computeEngineThrust;
+declare const index_computeEngineDrain: typeof computeEngineDrain;
+declare const index_computeGeneratorCap: typeof computeGeneratorCap;
+declare const index_computeGeneratorRech: typeof computeGeneratorRech;
+declare const index_computeExtractorRate: typeof computeExtractorRate;
+declare const index_computeExtractorDrain: typeof computeExtractorDrain;
+declare const index_computeExtractorDepth: typeof computeExtractorDepth;
+declare const index_computeExtractorDrill: typeof computeExtractorDrill;
+declare const index_computeLoaderMass: typeof computeLoaderMass;
+declare const index_computeLoaderThrust: typeof computeLoaderThrust;
+declare const index_computeCrafterSpeed: typeof computeCrafterSpeed;
+declare const index_computeCrafterDrain: typeof computeCrafterDrain;
+declare const index_entityDisplayName: typeof entityDisplayName;
+declare const index_moduleDisplayName: typeof moduleDisplayName;
+declare const index_formatModuleLine: typeof formatModuleLine;
+declare const index_buildEntityDescription: typeof buildEntityDescription;
+declare namespace index {
+  export {
+    index_NFTInstalledModule as NFTInstalledModule,
+    index_NFTModuleSlot as NFTModuleSlot,
+    index_NFTCargoItem as NFTCargoItem,
+    index_NFTCommonBase as NFTCommonBase,
+    index_readCommonBase as readCommonBase,
+    index_deserializeScalar as deserializeScalar,
+    index_deserializeResource as deserializeResource,
+    index_deserializeComponent as deserializeComponent,
+    index_deserializeModule as deserializeModule,
+    index_deserializeEntity as deserializeEntity,
+    index_deserializeAsset as deserializeAsset,
+    index_computeBaseHullmass as computeBaseHullmass,
+    index_computeBaseCapacityShip as computeBaseCapacityShip,
+    index_computeBaseCapacityWarehouse as computeBaseCapacityWarehouse,
+    index_computeEngineThrust as computeEngineThrust,
+    index_computeEngineDrain as computeEngineDrain,
+    index_computeGeneratorCap as computeGeneratorCap,
+    index_computeGeneratorRech as computeGeneratorRech,
+    index_computeExtractorRate as computeExtractorRate,
+    index_computeExtractorDrain as computeExtractorDrain,
+    index_computeExtractorDepth as computeExtractorDepth,
+    index_computeExtractorDrill as computeExtractorDrill,
+    index_computeLoaderMass as computeLoaderMass,
+    index_computeLoaderThrust as computeLoaderThrust,
+    index_computeCrafterSpeed as computeCrafterSpeed,
+    index_computeCrafterDrain as computeCrafterDrain,
+    index_entityDisplayName as entityDisplayName,
+    index_moduleDisplayName as moduleDisplayName,
+    index_formatModuleLine as formatModuleLine,
+    index_buildEntityDescription as buildEntityDescription,
+  };
+}
+
+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;
+type container_row = Types.container_row;
+type extractor_stats = Types.extractor_stats;
+type location_static = Types.location_static;
+type location_epoch = Types.location_epoch;
+type location_derived = Types.location_derived;
+type location_row = Types.location_row;
+
+export { ActionsManager, AnyEntity, BASE_ORBITAL_MASS, COMMIT_ALREADY_SET, COMMIT_CANNOT_MATCH, COMMIT_NOT_SET, COMPANY_NOT_FOUND, CONTAINER_Z, CRAFT_ENERGY_DIVISOR, CapabilityAttribute, CargoData, CargoMassInfo, CargoSeed, CategoryInfo, CategoryStacks, ComponentDefinition, ComponentStat, Container, ContainerEntity, ContainerStateInput, Coordinates, CoordinatesType, CraftableItem, CraftedItemCategory, CrafterCapability, DEPTH_THRESHOLD_T1, DEPTH_THRESHOLD_T2, DEPTH_THRESHOLD_T3, DEPTH_THRESHOLD_T4, DEPTH_THRESHOLD_T5, Distance, EPOCH_NON_ZERO, EPOCH_NOT_READY, ERROR_SYSTEM_ALREADY_INITIALIZED, ERROR_SYSTEM_DISABLED, ERROR_SYSTEM_NOT_INITIALIZED, EnergyCapability, EntitiesManager, Entity, EntityCapabilities, EntityInventory, EntityRecipe, EntityRefInput, EntityState, EntityType, EntityTypeName, EpochInfo, EpochsManager, EstimateTravelTimeOptions, EstimatedTravelTime, ExtractorCapability, GAME_NOT_FOUND, GAME_SEED_NOT_SET, GameState, HasCapacity, HasCargo, HasCargomass, HasScheduleAndLocation, INITIAL_CONTAINER_CAPACITY, INITIAL_CONTAINER_HULLMASS, INITIAL_WAREHOUSE_CAPACITY, INSUFFICIENT_BALANCE, INSUFFICIENT_ITEM_QUANTITY, INSUFFICIENT_ITEM_SUPPLY, INVALID_AMOUNT, ITEM_CARGO_ARM, ITEM_CARGO_LINING, ITEM_CARGO_LINING_T2, ITEM_CONTAINER_T1_PACKED, ITEM_CONTAINER_T2_PACKED, ITEM_DOES_NOT_EXIST, ITEM_DRILL_SHAFT, ITEM_ENGINE_T1, ITEM_EXTRACTION_PROBE, ITEM_EXTRACTOR_T1, ITEM_FOCUSING_ARRAY, ITEM_GENERATOR_T1, ITEM_HAULER_T1, ITEM_HULL_PLATES, ITEM_HULL_PLATES_T2, ITEM_LOADER_T1, ITEM_MANUFACTURING_T1, ITEM_NOT_AVAILABLE_AT_LOCATION, ITEM_POWER_CELL, ITEM_REACTION_CHAMBER, ITEM_SHIP_T1_PACKED, ITEM_STORAGE_T1, ITEM_THRUSTER_CORE, ITEM_TOOL_BIT, ITEM_TYPE_COMPONENT, ITEM_TYPE_ENTITY, ITEM_TYPE_MODULE, ITEM_TYPE_RESOURCE, ITEM_WAREHOUSE_T1_PACKED, InventoryAccessor, Item, LOCATION_MAX_DEPTH, LOCATION_MIN_DEPTH, LoadTimeBreakdown, LoaderCapability, Location, LocationType, LocationsManager, MAX_ORBITAL_ALTITUDE, MIN_ORBITAL_ALTITUDE, MODULE_ANY, MODULE_CRAFTER, MODULE_ENGINE, MODULE_EXTRACTOR, MODULE_GENERATOR, MODULE_HAULER, MODULE_LAUNCHER, MODULE_LOADER, MODULE_STORAGE, MODULE_WARP, MassCapability, ModuleEntry, ModuleRecipe, ModuleSlot, MovementCapability, index as NFT, NFTCargoItem, NFTCommonBase, NFTInstalledModule, NFTModuleSlot, NO_SCHEDULE, NamedStats, PLANET_SUBTYPE_GAS_GIANT, PLANET_SUBTYPE_ICY, PLANET_SUBTYPE_INDUSTRIAL, PLANET_SUBTYPE_OCEAN, PLANET_SUBTYPE_ROCKY, PLANET_SUBTYPE_TERRESTRIAL, PLAYER_ALREADY_JOINED, PLAYER_NOT_FOUND, PRECISION, PlanetSubtypeInfo, platform as PlatformContract, Player, PlayerStateInput, PlayersManager, Projectable, ProjectedEntity, REQUIRES_MORE_THAN_ONE, REQUIRES_POSITIVE_VALUE, RecipeInput, ResolvedAttributeGroup, ResolvedItem, ResolvedItemStat, ResolvedItemType, ResolvedModuleSlot, ResourceCategory, ResourceStats, ResourceTier, 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, ShipCapabilities, ShipEntity, ShipLike, ShipStateInput, Shipload, StackInput, StatDefinition, StatMapping, StorageCapability, StratumInfo, TRAVEL_MAX_DURATION, TaskCancelable, TaskType, TransferEntity, WAREHOUSE_ALREADY_AT_LOCATION, WAREHOUSE_CAPACITY_EXCEEDED, WAREHOUSE_NOT_FOUND, WAREHOUSE_Z, Warehouse, WarehouseEntity, WarehouseStateInput, availableCapacity$1 as availableCapacity, availableCapacityFromMass, blendCargoStacks, blendComponentStacks, blendCrossGroup, blendStacks, buildEntityDescription, calcCargoItemMass, calcCargoMass, calcEnergyUsage, calcLoadDuration, calc_acceleration, calc_craft_duration, calc_craft_energy, 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, calculateFlightTime, calculateLoadTimeBreakdown, calculateRefuelingTime, calculateTransferTime, canMove, capabilityAttributes, capabilityNames, capsHasCrafter, capsHasExtractor, capsHasLoaders, capsHasMass, capsHasMovement, capsHasStorage, cargoUtils, cargo_item, categoryColors, categoryIcons, categoryItemMass, componentIcon, components, computeBaseCapacityShip, computeBaseCapacityWarehouse, computeBaseHullmass, computeComponentStats, computeContainerCapabilities, computeContainerT2Capabilities, computeCrafterDrain, computeCrafterSpeed, computeEngineCapabilities, computeEngineDrain, computeEngineThrust, computeEntityStats, computeExtractorCapabilities, computeExtractorDepth, computeExtractorDrain, computeExtractorDrill, computeExtractorRate, computeGeneratorCap, computeGeneratorCapabilities, computeGeneratorRech, computeHaulPenalty, computeHaulerCapabilities, computeHaulerDrain, computeInputMass, computeLoaderCapabilities, computeLoaderMass, computeLoaderThrust, computeManufacturingCapabilities, computeShipCapabilities, computeShipHullCapabilities, computeStorageCapabilities, computeWarehouseHullCapabilities, container_row, coordsToLocationId, createInventoryAccessor, createProjectedEntity, createScheduleAccessor, decodeCraftedItemStats, decodeStat, decodeStats, Shipload as default, depthScaleFactor, deriveLocation, deriveLocationEpoch, deriveLocationSize, deriveLocationStatic, deriveResourceStats, deriveStratum, deserializeAsset, deserializeComponent, deserializeEntity, deserializeModule, deserializeResource, distanceBetweenCoordinates, distanceBetweenPoints, encodeStats, energyPercent, energy_stats, entityDisplayName, entityRecipes, estimateDealTravelTime, estimateTravelTime, extractor_stats, findNearbyPlanets, formatModuleLine, getAllCraftableItems, getCapabilityAttributes, getCategoryInfo, getComponentById, getComponentsForCategory, getComponentsForStat, getCurrentEpoch, getDepthThreshold, getDestinationLocation, getEligibleResources, getEntityRecipe, getEntityRecipeByItemId, getEntitySlotLayout, getEpochInfo, getFlightOrigin, getItem, getItems, getLocationCandidates, getLocationType, getModuleCapabilityType, getModuleRecipe, getModuleRecipeByItemId, getPlanetSubtype, getPlanetSubtypes, getPositionAt, getResourceTier, getResourceWeight, getStatDefinitions, getStatMappings, getStatMappingsForCapability, getStatMappingsForStat, getStatName, getSystemName, hasEnergy, hasEnergyForDistance, hasExtractor, hasLoaders, hasMass, hasSchedule, hasSpace$1 as hasSpace, hasSpaceForMass, hasStorage, hasSystem, hash, hash512, isCraftedItem, isExtractableLocation, isFull$1 as isFull, isFullFromMass, isInvertedAttribute, isModuleItem, isRelatedItem, itemCategory, itemIcons, itemIds, itemOffset, itemTier, itemTypeCode, lerp, loader_stats, location_derived, location_epoch, location_row, location_static, makeContainer, makeShip, makeWarehouse, maxTravelDistance, moduleAccepts, moduleDisplayName, moduleIcon, moduleRecipes, movement_stats, needsRecharge, projectEntity, projectEntityAt, readCommonBase, resolveItem, resolveStats, rotation, schedule, statMappings, task, tierColors, toLocation, warehouse_row };