spacetraders_api - v1.1.0

spacetraders_api

Types

AgentRegistered

</> 
pub type AgentRegistered {
  AgentRegistered(
    token: agent_token.AgentToken,
    agent: agent.Agent,
    faction: faction.Faction,
    contract: contract.Contract,
    ships: List(ship.Ship),
  )
}

Constructors

Announcement

</> 
pub type Announcement {
  Announcement(title: String, body: String)
}

Constructors 

  • Announcement(title: String, body: String)

ApiError

</> 
pub type ApiError {
  JsonDecodeError(json.DecodeError)
  ServerError(spacetraders_error.SpacetradersError)
}

Constructors

ApiResponse

</> 
pub type ApiResponse(data) =
  Result(data, ApiError)

CargoPurchased

</> 
pub type CargoPurchased {
  CargoPurchased(
    cargo: ship_cargo.ShipCargo,
    transaction: market_transaction.MarketTransaction,
    agent: agent.Agent,
  )
}

Constructors

CargoSold

</> 
pub type CargoSold {
  CargoSold(
    cargo: ship_cargo.ShipCargo,
    transaction: market_transaction.MarketTransaction,
    agent: agent.Agent,
  )
}

Constructors

CargoTransferred

</> 
pub type CargoTransferred {
  CargoTransferred(
    cargo: ship_cargo.ShipCargo,
    target_cargo: ship_cargo.ShipCargo,
  )
}

Constructors

ChartCreated

</> 
pub type ChartCreated {
  ChartCreated(
    chart: chart.Chart,
    waypoint: waypoint.Waypoint,
    transaction: chart_transaction.ChartTransaction,
    agent: agent.Agent,
  )
}

Constructors

ChartLeaderboardEntry

</> 
pub type ChartLeaderboardEntry {
  ChartLeaderboardEntry(
    agent_symbol: agent_symbol.AgentSymbol,
    chart_count: Int,
  )
}

Constructors

ConstructionSiteSupplied

</> 
pub type ConstructionSiteSupplied {
  ConstructionSiteSupplied(
    construction: construction.Construction,
    cargo: ship_cargo.ShipCargo,
  )
}

Constructors

ContractAccepted

</> 
pub type ContractAccepted {
  ContractAccepted(
    contract: contract.Contract,
    agent: agent.Agent,
  )
}

Constructors

ContractCargoDelivered

</> 
pub type ContractCargoDelivered {
  ContractCargoDelivered(
    contract: contract.Contract,
    cargo: ship_cargo.ShipCargo,
  )
}

Constructors

ContractFulfilled

</> 
pub type ContractFulfilled {
  ContractFulfilled(
    contract: contract.Contract,
    agent: agent.Agent,
  )
}

Constructors

CreditLeaderboardEntry

</> 
pub type CreditLeaderboardEntry {
  CreditLeaderboardEntry(
    agent_symbol: agent_symbol.AgentSymbol,
    credits: Int,
  )
}

Constructors

ErrorCode

</> 
pub type ErrorCode {
  ErrorCode(code: Int, name: String)
}

Constructors 

  • ErrorCode(code: Int, name: String)

ExportToImportMap

</> 
pub type ExportToImportMap =
  dict.Dict(
    trade_symbol.TradeSymbol,
    List(trade_symbol.TradeSymbol),
  )

FactionReputation

</> 
pub type FactionReputation {
  FactionReputation(
    symbol: faction_symbol.FactionSymbol,
    reputation: Int,
  )
}

Constructors

Health

</> 
pub type Health {
  Health(last_market_update: option.Option(timestamp.Timestamp))
}

Constructors

Leaderboards

</> 
pub type Leaderboards {
  Leaderboards(
    most_credits: List(CreditLeaderboardEntry),
    most_submitted_charts: List(ChartLeaderboardEntry),
  )
}

Constructors

</> 
pub type Link {
  Link(name: String, url: uri.Uri)
}

Constructors

ResourcesExtracted

</> 
pub type ResourcesExtracted {
  ResourcesExtracted(
    extraction: extraction.Extraction,
    cooldown: cooldown.Cooldown,
    cargo: ship_cargo.ShipCargo,
    modifiers: List(waypoint_modifier.WaypointModifier),
    events: List(ship_condition_event.ShipConditionEvent),
  )
}

Constructors

ResourcesSiphoned

</> 
pub type ResourcesSiphoned {
  ResourcesSiphoned(
    siphon: siphon.Siphon,
    cooldown: cooldown.Cooldown,
    cargo: ship_cargo.ShipCargo,
    events: List(ship_condition_event.ShipConditionEvent),
  )
}

Constructors

Scan

</> 
pub type Scan(data) {
  Scan(cooldown: cooldown.Cooldown, data: List(data))
}

Constructors

ServerResets

</> 
pub type ServerResets {
  ServerResets(next: timestamp.Timestamp, frequency: String)
}

Constructors

ServerStatus

</> 
pub type ServerStatus {
  ServerStatus(
    status: String,
    version: String,
    reset_date: calendar.Date,
    description: String,
    stats: Stats,
    health: Health,
    leaderboards: Leaderboards,
    server_resets: ServerResets,
    announcements: List(Announcement),
    links: List(Link),
  )
}

Constructors

ShipJumped

</> 
pub type ShipJumped {
  ShipJumped(
    nav: ship_nav.ShipNav,
    cooldown: cooldown.Cooldown,
    transaction: market_transaction.MarketTransaction,
    agent: agent.Agent,
  )
}

Constructors

ShipModuleInstalled

</> 
pub type ShipModuleInstalled {
  ShipModuleInstalled(
    agent: agent.Agent,
    modules: List(ship_module.ShipModule),
    cargo: ship_cargo.ShipCargo,
    transaction: ship_modification_transaction.ShipModificationTransaction,
  )
}

Constructors

ShipModuleRemoved

</> 
pub type ShipModuleRemoved {
  ShipModuleRemoved(
    agent: agent.Agent,
    modules: List(ship_module.ShipModule),
    cargo: ship_cargo.ShipCargo,
    transaction: ship_modification_transaction.ShipModificationTransaction,
  )
}

Constructors

ShipMountInstalled

</> 
pub type ShipMountInstalled {
  ShipMountInstalled(
    agent: agent.Agent,
    mounts: List(ship_mount.ShipMount),
    cargo: ship_cargo.ShipCargo,
    transaction: ship_modification_transaction.ShipModificationTransaction,
  )
}

Constructors

ShipMountRemoved

</> 
pub type ShipMountRemoved {
  ShipMountRemoved(
    agent: agent.Agent,
    mounts: List(ship_mount.ShipMount),
    cargo: ship_cargo.ShipCargo,
    transaction: ship_modification_transaction.ShipModificationTransaction,
  )
}

Constructors

ShipNavPatched

</> 
pub type ShipNavPatched {
  ShipNavPatched(
    nav: ship_nav.ShipNav,
    fuel: ship_fuel.ShipFuel,
    events: List(ship_condition_event.ShipConditionEvent),
  )
}

Constructors

ShipNavigated

</> 
pub type ShipNavigated {
  ShipNavigated(
    nav: ship_nav.ShipNav,
    fuel: ship_fuel.ShipFuel,
    events: List(ship_condition_event.ShipConditionEvent),
  )
}

Constructors

ShipPurchased

</> 
pub type ShipPurchased {
  ShipPurchased(
    ship: ship.Ship,
    agent: agent.Agent,
    transaction: shipyard_transaction.ShipyardTransaction,
  )
}

Constructors

ShipRefined

</> 
pub type ShipRefined {
  ShipRefined(
    cargo: ship_cargo.ShipCargo,
    cooldown: cooldown.Cooldown,
    produced: List(refinement_yield.RefinementYield),
    consumed: List(refinement_yield.RefinementYield),
  )
}

Constructors

ShipRefueled

</> 
pub type ShipRefueled {
  ShipRefueled(
    agent: agent.Agent,
    fuel: ship_fuel.ShipFuel,
    cargo: ship_cargo.ShipCargo,
    transaction: market_transaction.MarketTransaction,
  )
}

Constructors

ShipRepaired

</> 
pub type ShipRepaired {
  ShipRepaired(
    agent: agent.Agent,
    ship: ship.Ship,
    transaction: repair_transaction.RepairTransaction,
  )
}

Constructors

ShipScrapped

</> 
pub type ShipScrapped {
  ShipScrapped(
    agent: agent.Agent,
    transaction: scrap_transaction.ScrapTransaction,
  )
}

Constructors

ShipWarped

</> 
pub type ShipWarped {
  ShipWarped(
    nav: ship_nav.ShipNav,
    fuel: ship_fuel.ShipFuel,
    events: List(ship_condition_event.ShipConditionEvent),
  )
}

Constructors

Stats

</> 
pub type Stats {
  Stats(
    accounts: option.Option(Int),
    agents: Int,
    ships: Int,
    systems: Int,
    waypoints: Int,
  )
}

Constructors 

  • Stats(
  accounts: option.Option(Int),
  agents: Int,
  ships: Int,
  systems: Int,
  waypoints: Int,
)

SurveyCreated

</> 
pub type SurveyCreated {
  SurveyCreated(
    cooldown: cooldown.Cooldown,
    surveys: List(survey.Survey),
  )
}

Constructors

Values

accept_contract_request

</> 
pub fn accept_contract_request(
  token: agent_token.AgentToken,
  contract_id: contract_id.ContractId,
) -> request.Request(BitArray)

accept_contract_response

</> 
pub fn accept_contract_response(
  response: response.Response(BitArray),
) -> Result(ContractAccepted, ApiError)

create_chart_request

</> 
pub fn create_chart_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

create_chart_response

</> 
pub fn create_chart_response(
  response: response.Response(BitArray),
) -> Result(ChartCreated, ApiError)

create_survey_request

</> 
pub fn create_survey_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

create_survey_response

</> 
pub fn create_survey_response(
  response: response.Response(BitArray),
) -> Result(SurveyCreated, ApiError)

deliver_contract_cargo_request

</> 
pub fn deliver_contract_cargo_request(
  token: agent_token.AgentToken,
  contract_id: contract_id.ContractId,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
  units: Int,
) -> request.Request(BitArray)

deliver_contract_cargo_response

</> 
pub fn deliver_contract_cargo_response(
  response: response.Response(BitArray),
) -> Result(ContractCargoDelivered, ApiError)

dock_ship_request

</> 
pub fn dock_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

dock_ship_response

</> 
pub fn dock_ship_response(
  response: response.Response(BitArray),
) -> Result(ship_nav.ShipNav, ApiError)

extract_resources_request

</> 
pub fn extract_resources_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

extract_resources_response

</> 
pub fn extract_resources_response(
  response: response.Response(BitArray),
) -> Result(ResourcesExtracted, ApiError)

extract_resources_with_survey_request

</> 
pub fn extract_resources_with_survey_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  survey: survey.Survey,
) -> request.Request(BitArray)

extract_resources_with_survey_response

</> 
pub fn extract_resources_with_survey_response(
  response: response.Response(BitArray),
) -> Result(ResourcesExtracted, ApiError)

fulfill_contract_request

</> 
pub fn fulfill_contract_request(
  token: agent_token.AgentToken,
  contract_id: contract_id.ContractId,
) -> request.Request(BitArray)

fulfill_contract_response

</> 
pub fn fulfill_contract_response(
  response: response.Response(BitArray),
) -> Result(ContractFulfilled, ApiError)

get_account_request

</> 
pub fn get_account_request(
  token: agent_token.AgentToken,
) -> request.Request(BitArray)

get_account_response

</> 
pub fn get_account_response(
  response: response.Response(BitArray),
) -> Result(account.Account, ApiError)

get_agent_events_request

</> 
pub fn get_agent_events_request(
  token: agent_token.AgentToken,
) -> request.Request(BitArray)

get_agent_events_response

</> 
pub fn get_agent_events_response(
  response: response.Response(BitArray),
) -> Result(List(agent_event.AgentEvent), ApiError)

get_agent_request

</> 
pub fn get_agent_request(
  token: agent_token.AgentToken,
) -> request.Request(BitArray)

get_agent_response

</> 
pub fn get_agent_response(
  response: response.Response(BitArray),
) -> Result(agent.Agent, ApiError)

get_construction_site_request

</> 
pub fn get_construction_site_request(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> request.Request(BitArray)

get_construction_site_response

</> 
pub fn get_construction_site_response(
  response: response.Response(BitArray),
) -> Result(construction.Construction, ApiError)

get_contract_request

</> 
pub fn get_contract_request(
  token: agent_token.AgentToken,
  contract_id: contract_id.ContractId,
) -> request.Request(BitArray)

get_contract_response

</> 
pub fn get_contract_response(
  response: response.Response(BitArray),
) -> Result(contract.Contract, ApiError)

get_faction_request

</> 
pub fn get_faction_request(
  symbol: faction_symbol.FactionSymbol,
) -> request.Request(BitArray)

get_faction_response

</> 
pub fn get_faction_response(
  response: response.Response(BitArray),
) -> Result(faction.Faction, ApiError)

get_jump_gate_request

</> 
pub fn get_jump_gate_request(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> request.Request(BitArray)

get_jump_gate_response

</> 
pub fn get_jump_gate_response(
  response: response.Response(BitArray),
) -> Result(jump_gate.JumpGate, ApiError)

get_market_request

</> 
pub fn get_market_request(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> request.Request(BitArray)

get_market_response

</> 
pub fn get_market_response(
  response: response.Response(BitArray),
) -> Result(market.Market, ApiError)

get_my_factions_request

</> 
pub fn get_my_factions_request(
  token: agent_token.AgentToken,
  page: option.Option(Int),
  limit: option.Option(Int),
) -> request.Request(BitArray)

get_my_factions_response

</> 
pub fn get_my_factions_response(
  response: response.Response(BitArray),
) -> Result(
  paged_data.PagedData(List(FactionReputation)),
  ApiError,
)

get_public_agent_request

</> 
pub fn get_public_agent_request(
  agent_symbol: agent_symbol.AgentSymbol,
) -> request.Request(BitArray)

get_public_agent_response

</> 
pub fn get_public_agent_response(
  response: response.Response(BitArray),
) -> Result(public_agent.PublicAgent, ApiError)

get_repair_ship_request

</> 
pub fn get_repair_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

get_repair_ship_response

</> 
pub fn get_repair_ship_response(
  response: response.Response(BitArray),
) -> Result(repair_transaction.RepairTransaction, ApiError)

get_scrap_ship_request

</> 
pub fn get_scrap_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

get_scrap_ship_response

</> 
pub fn get_scrap_ship_response(
  response: response.Response(BitArray),
) -> Result(scrap_transaction.ScrapTransaction, ApiError)

get_server_status_request

</> 
pub fn get_server_status_request() -> request.Request(BitArray)

get_server_status_response

</> 
pub fn get_server_status_response(
  response: response.Response(BitArray),
) -> Result(ServerStatus, ApiError)

get_ship_cargo_request

</> 
pub fn get_ship_cargo_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

get_ship_cargo_response

</> 
pub fn get_ship_cargo_response(
  response: response.Response(BitArray),
) -> Result(ship_cargo.ShipCargo, ApiError)

get_ship_cooldown_request

</> 
pub fn get_ship_cooldown_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

get_ship_cooldown_response

</> 
pub fn get_ship_cooldown_response(
  response: response.Response(BitArray),
) -> Result(option.Option(cooldown.Cooldown), ApiError)

get_ship_modules_request

</> 
pub fn get_ship_modules_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

get_ship_modules_response

</> 
pub fn get_ship_modules_response(
  response: response.Response(BitArray),
) -> Result(List(ship_module.ShipModule), ApiError)

get_ship_mounts_request

</> 
pub fn get_ship_mounts_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

get_ship_mounts_response

</> 
pub fn get_ship_mounts_response(
  response: response.Response(BitArray),
) -> Result(List(ship_mount.ShipMount), ApiError)

get_ship_nav_request

</> 
pub fn get_ship_nav_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

get_ship_nav_response

</> 
pub fn get_ship_nav_response(
  response: response.Response(BitArray),
) -> Result(ship_nav.ShipNav, ApiError)

get_ship_request

</> 
pub fn get_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

get_ship_response

</> 
pub fn get_ship_response(
  response: response.Response(BitArray),
) -> Result(ship.Ship, ApiError)

get_shipyard_request

</> 
pub fn get_shipyard_request(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> request.Request(BitArray)

get_shipyard_response

</> 
pub fn get_shipyard_response(
  response: response.Response(BitArray),
) -> Result(shipyard.Shipyard, ApiError)

get_supply_chain_request

</> 
pub fn get_supply_chain_request() -> request.Request(BitArray)

get_supply_chain_response

</> 
pub fn get_supply_chain_response(
  response: response.Response(BitArray),
) -> Result(
  dict.Dict(
    trade_symbol.TradeSymbol,
    List(trade_symbol.TradeSymbol),
  ),
  ApiError,
)

get_system_request

</> 
pub fn get_system_request(
  system_symbol: system_symbol.SystemSymbol,
) -> request.Request(BitArray)

get_system_response

</> 
pub fn get_system_response(
  response: response.Response(BitArray),
) -> Result(system.System, ApiError)

get_waypoint_request

</> 
pub fn get_waypoint_request(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> request.Request(BitArray)

get_waypoint_response

</> 
pub fn get_waypoint_response(
  response: response.Response(BitArray),
) -> Result(waypoint.Waypoint, ApiError)

install_ship_module_request

</> 
pub fn install_ship_module_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  module_symbol: module_symbol.ModuleSymbol,
) -> request.Request(BitArray)

install_ship_module_response

</> 
pub fn install_ship_module_response(
  response: response.Response(BitArray),
) -> Result(ShipModuleInstalled, ApiError)

install_ship_mount_request

</> 
pub fn install_ship_mount_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  mount_symbol: mount_symbol.MountSymbol,
) -> request.Request(BitArray)

install_ship_mount_response

</> 
pub fn install_ship_mount_response(
  response: response.Response(BitArray),
) -> Result(ShipMountInstalled, ApiError)

jettison_cargo_request

</> 
pub fn jettison_cargo_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
  units: Int,
) -> request.Request(BitArray)

jettison_cargo_response

</> 
pub fn jettison_cargo_response(
  response: response.Response(BitArray),
) -> Result(ship_cargo.ShipCargo, ApiError)

jump_ship_request

</> 
pub fn jump_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> request.Request(BitArray)

jump_ship_response

</> 
pub fn jump_ship_response(
  response: response.Response(BitArray),
) -> Result(ShipJumped, ApiError)

list_contracts_request

</> 
pub fn list_contracts_request(
  token: agent_token.AgentToken,
  page: option.Option(Int),
  limit: option.Option(Int),
) -> request.Request(BitArray)

list_contracts_response

</> 
pub fn list_contracts_response(
  response: response.Response(BitArray),
) -> Result(
  paged_data.PagedData(List(contract.Contract)),
  ApiError,
)

list_error_codes_request

</> 
pub fn list_error_codes_request() -> request.Request(BitArray)

list_error_codes_response

</> 
pub fn list_error_codes_response(
  response: response.Response(BitArray),
) -> Result(List(ErrorCode), ApiError)

list_factions_request

</> 
pub fn list_factions_request(
  page: option.Option(Int),
  limit: option.Option(Int),
) -> request.Request(BitArray)

list_factions_response

</> 
pub fn list_factions_response(
  response: response.Response(BitArray),
) -> Result(paged_data.PagedData(List(faction.Faction)), ApiError)

list_public_agents_request

</> 
pub fn list_public_agents_request(
  page: option.Option(Int),
  limit: option.Option(Int),
) -> request.Request(BitArray)

list_public_agents_response

</> 
pub fn list_public_agents_response(
  response: response.Response(BitArray),
) -> Result(
  paged_data.PagedData(List(public_agent.PublicAgent)),
  ApiError,
)

list_ships_request

</> 
pub fn list_ships_request(
  token: agent_token.AgentToken,
  page: option.Option(Int),
  limit: option.Option(Int),
) -> request.Request(BitArray)

list_ships_response

</> 
pub fn list_ships_response(
  response: response.Response(BitArray),
) -> Result(paged_data.PagedData(List(ship.Ship)), ApiError)

list_system_waypoints_request

</> 
pub fn list_system_waypoints_request(
  system_symbol: system_symbol.SystemSymbol,
  page: option.Option(Int),
  limit: option.Option(Int),
  type_: option.Option(waypoint_type.WaypointType),
  traits: List(waypoint_trait_symbol.WaypointTraitSymbol),
) -> request.Request(BitArray)

list_system_waypoints_response

</> 
pub fn list_system_waypoints_response(
  response: response.Response(BitArray),
) -> Result(
  paged_data.PagedData(List(waypoint.Waypoint)),
  ApiError,
)

list_systems_request

</> 
pub fn list_systems_request(
  page: option.Option(Int),
  limit: option.Option(Int),
) -> request.Request(BitArray)

list_systems_response

</> 
pub fn list_systems_response(
  response: response.Response(BitArray),
) -> Result(paged_data.PagedData(List(system.System)), ApiError)
</> 
pub fn navigate_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> request.Request(BitArray)
</> 
pub fn navigate_ship_response(
  response: response.Response(BitArray),
) -> Result(ShipNavigated, ApiError)

negotiate_contract_request

</> 
pub fn negotiate_contract_request(
  token: agent_token.AgentToken,
  ship_symbol: String,
) -> request.Request(BitArray)

negotiate_contract_response

</> 
pub fn negotiate_contract_response(
  response: response.Response(BitArray),
) -> Result(contract.Contract, ApiError)

orbit_ship_request

</> 
pub fn orbit_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

orbit_ship_response

</> 
pub fn orbit_ship_response(
  response: response.Response(BitArray),
) -> Result(ship_nav.ShipNav, ApiError)

patch_ship_nav_request

</> 
pub fn patch_ship_nav_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  flight_mode: ship_nav_flight_mode.ShipNavFlightMode,
) -> request.Request(BitArray)

patch_ship_nav_response

</> 
pub fn patch_ship_nav_response(
  response: response.Response(BitArray),
) -> Result(ShipNavPatched, ApiError)

purchase_cargo_request

</> 
pub fn purchase_cargo_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
) -> request.Request(BitArray)

purchase_cargo_response

</> 
pub fn purchase_cargo_response(
  response: response.Response(BitArray),
) -> Result(CargoPurchased, ApiError)

purchase_ship_request

</> 
pub fn purchase_ship_request(
  token: agent_token.AgentToken,
  ship_type: ship_type.ShipType,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> request.Request(BitArray)

purchase_ship_response

</> 
pub fn purchase_ship_response(
  response: response.Response(BitArray),
) -> Result(ShipPurchased, ApiError)

refine_ship_request

</> 
pub fn refine_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  produce: refinement_produce.RefinementProduce,
) -> request.Request(BitArray)

refine_ship_response

</> 
pub fn refine_ship_response(
  response: response.Response(BitArray),
) -> Result(ShipRefined, ApiError)

refuel_ship_request

</> 
pub fn refuel_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  units: option.Option(Int),
  from_cargo: option.Option(Bool),
) -> request.Request(BitArray)

refuel_ship_response

</> 
pub fn refuel_ship_response(
  response: response.Response(BitArray),
) -> Result(ShipRefueled, ApiError)

register_new_agent_request

</> 
pub fn register_new_agent_request(
  token: account_token.AccountToken,
  agent_symbol: agent_symbol.AgentSymbol,
  faction_symbol: faction_symbol.FactionSymbol,
) -> request.Request(BitArray)

register_new_agent_response

</> 
pub fn register_new_agent_response(
  response: response.Response(BitArray),
) -> Result(AgentRegistered, ApiError)

remove_ship_module_request

</> 
pub fn remove_ship_module_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  module_symbol: module_symbol.ModuleSymbol,
) -> request.Request(BitArray)

remove_ship_module_response

</> 
pub fn remove_ship_module_response(
  response: response.Response(BitArray),
) -> Result(ShipModuleRemoved, ApiError)

remove_ship_mount_request

</> 
pub fn remove_ship_mount_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  mount_symbol: mount_symbol.MountSymbol,
) -> request.Request(BitArray)

remove_ship_mount_response

</> 
pub fn remove_ship_mount_response(
  response: response.Response(BitArray),
) -> Result(ShipMountRemoved, ApiError)

repair_ship_request

</> 
pub fn repair_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

repair_ship_response

</> 
pub fn repair_ship_response(
  response: response.Response(BitArray),
) -> Result(ShipRepaired, ApiError)

scan_ships_request

</> 
pub fn scan_ships_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

scan_ships_response

</> 
pub fn scan_ships_response(
  response: response.Response(BitArray),
) -> Result(Scan(scanned_ship.ScannedShip), ApiError)

scan_systems_request

</> 
pub fn scan_systems_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

scan_systems_response

</> 
pub fn scan_systems_response(
  response: response.Response(BitArray),
) -> Result(Scan(scanned_system.ScannedSystem), ApiError)

scan_waypoints_request

</> 
pub fn scan_waypoints_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

scan_waypoints_response

</> 
pub fn scan_waypoints_response(
  response: response.Response(BitArray),
) -> Result(Scan(scanned_waypoint.ScannedWaypoint), ApiError)

scrap_ship_request

</> 
pub fn scrap_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

scrap_ship_response

</> 
pub fn scrap_ship_response(
  response: response.Response(BitArray),
) -> Result(ShipScrapped, ApiError)

sell_cargo_request

</> 
pub fn sell_cargo_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
  units: Int,
) -> request.Request(BitArray)

sell_cargo_response

</> 
pub fn sell_cargo_response(
  response: response.Response(BitArray),
) -> Result(CargoSold, ApiError)

siphon_resources_request

</> 
pub fn siphon_resources_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

siphon_resources_response

</> 
pub fn siphon_resources_response(
  response: response.Response(BitArray),
) -> Result(ResourcesSiphoned, ApiError)

supply_construction_site_request

</> 
pub fn supply_construction_site_request(
  token: agent_token.AgentToken,
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
  units: Int,
) -> request.Request(BitArray)

supply_construction_site_response

</> 
pub fn supply_construction_site_response(
  response: response.Response(BitArray),
) -> Result(ConstructionSiteSupplied, ApiError)

transfer_cargo_request

</> 
pub fn transfer_cargo_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
  units: Int,
  target_ship_symbol: ship_symbol.ShipSymbol,
) -> request.Request(BitArray)

transfer_cargo_response

</> 
pub fn transfer_cargo_response(
  response: response.Response(BitArray),
) -> Result(CargoTransferred, ApiError)

warp_ship_request

</> 
pub fn warp_ship_request(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> request.Request(BitArray)

warp_ship_response

</> 
pub fn warp_ship_response(
  response: response.Response(BitArray),
) -> Result(ShipWarped, ApiError)
✨ Search Document