spacetraders_api_fetch - v1.1.0

spacetraders_api_fetch

Types

FetchApiError

</> 
pub type FetchApiError {
  ClientError(fetch.FetchError)
  JsonDecodeError(json.DecodeError)
  ServerError(spacetraders_error.SpacetradersError)
}

Constructors

FetchApiResponse

</> 
pub type FetchApiResponse(data) =
  promise.Promise(Result(data, FetchApiError))

Values

accept_contract

</> 
pub fn accept_contract(
  token: agent_token.AgentToken,
  contract_id: contract_id.ContractId,
) -> promise.Promise(
  Result(spacetraders_api.ContractAccepted, FetchApiError),
)

create_chart

</> 
pub fn create_chart(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ChartCreated, FetchApiError),
)

create_survey

</> 
pub fn create_survey(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(spacetraders_api.SurveyCreated, FetchApiError),
)

deliver_contract_cargo

</> 
pub fn deliver_contract_cargo(
  token: agent_token.AgentToken,
  contract_id: contract_id.ContractId,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
  units: Int,
) -> promise.Promise(
  Result(spacetraders_api.ContractCargoDelivered, FetchApiError),
)

dock_ship

</> 
pub fn dock_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(Result(ship_nav.ShipNav, FetchApiError))

extract_resources

</> 
pub fn extract_resources(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ResourcesExtracted, FetchApiError),
)

extract_resources_with_survey

</> 
pub fn extract_resources_with_survey(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  survey: survey.Survey,
) -> promise.Promise(
  Result(spacetraders_api.ResourcesExtracted, FetchApiError),
)

fulfill_contract

</> 
pub fn fulfill_contract(
  token: agent_token.AgentToken,
  contract_id: contract_id.ContractId,
) -> promise.Promise(
  Result(spacetraders_api.ContractFulfilled, FetchApiError),
)

get_account

</> 
pub fn get_account(
  token: agent_token.AgentToken,
) -> promise.Promise(Result(account.Account, FetchApiError))

get_agent

</> 
pub fn get_agent(
  token: agent_token.AgentToken,
) -> promise.Promise(Result(agent.Agent, FetchApiError))

get_agent_events

</> 
pub fn get_agent_events(
  token: agent_token.AgentToken,
) -> promise.Promise(
  Result(List(agent_event.AgentEvent), FetchApiError),
)

get_construction_site

</> 
pub fn get_construction_site(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> promise.Promise(
  Result(construction.Construction, FetchApiError),
)

get_contract

</> 
pub fn get_contract(
  token: agent_token.AgentToken,
  contract_id: contract_id.ContractId,
) -> promise.Promise(Result(contract.Contract, FetchApiError))

get_faction

</> 
pub fn get_faction(
  symbol: faction_symbol.FactionSymbol,
) -> promise.Promise(Result(faction.Faction, FetchApiError))

get_jump_gate

</> 
pub fn get_jump_gate(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> promise.Promise(Result(jump_gate.JumpGate, FetchApiError))

get_market

</> 
pub fn get_market(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> promise.Promise(Result(market.Market, FetchApiError))

get_my_factions

</> 
pub fn get_my_factions(
  token: agent_token.AgentToken,
  page: option.Option(Int),
  limit: option.Option(Int),
) -> promise.Promise(
  Result(
    paged_data.PagedData(List(spacetraders_api.FactionReputation)),
    FetchApiError,
  ),
)

get_public_agent

</> 
pub fn get_public_agent(
  agent_symbol: agent_symbol.AgentSymbol,
) -> promise.Promise(
  Result(public_agent.PublicAgent, FetchApiError),
)

get_repair_ship

</> 
pub fn get_repair_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(repair_transaction.RepairTransaction, FetchApiError),
)

get_scrap_ship

</> 
pub fn get_scrap_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(scrap_transaction.ScrapTransaction, FetchApiError),
)

get_server_status

</> 
pub fn get_server_status(
  ,
) -> promise.Promise(
  Result(spacetraders_api.ServerStatus, FetchApiError),
)

get_ship

</> 
pub fn get_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(Result(ship.Ship, FetchApiError))

get_ship_cargo

</> 
pub fn get_ship_cargo(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(Result(ship_cargo.ShipCargo, FetchApiError))

get_ship_cooldown

</> 
pub fn get_ship_cooldown(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(option.Option(cooldown.Cooldown), FetchApiError),
)

get_ship_modules

</> 
pub fn get_ship_modules(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(List(ship_module.ShipModule), FetchApiError),
)

get_ship_mounts

</> 
pub fn get_ship_mounts(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(List(ship_mount.ShipMount), FetchApiError),
)

get_ship_nav

</> 
pub fn get_ship_nav(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(Result(ship_nav.ShipNav, FetchApiError))

get_shipyard

</> 
pub fn get_shipyard(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> promise.Promise(Result(shipyard.Shipyard, FetchApiError))

get_supply_chain

</> 
pub fn get_supply_chain(
  ,
) -> promise.Promise(
  Result(
    dict.Dict(
      trade_symbol.TradeSymbol,
      List(trade_symbol.TradeSymbol),
    ),
    FetchApiError,
  ),
)

get_system

</> 
pub fn get_system(
  system_symbol: system_symbol.SystemSymbol,
) -> promise.Promise(Result(system.System, FetchApiError))

get_waypoint

</> 
pub fn get_waypoint(
  system_symbol: system_symbol.SystemSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> promise.Promise(Result(waypoint.Waypoint, FetchApiError))

install_ship_module

</> 
pub fn install_ship_module(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  module_symbol: module_symbol.ModuleSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipModuleInstalled, FetchApiError),
)

install_ship_mount

</> 
pub fn install_ship_mount(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  mount_symbol: mount_symbol.MountSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipMountInstalled, FetchApiError),
)

jettison_cargo

</> 
pub fn jettison_cargo(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
  units: Int,
) -> promise.Promise(Result(ship_cargo.ShipCargo, FetchApiError))

jump_ship

</> 
pub fn jump_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipJumped, FetchApiError),
)

list_contracts

</> 
pub fn list_contracts(
  token: agent_token.AgentToken,
  page: option.Option(Int),
  limit: option.Option(Int),
) -> promise.Promise(
  Result(
    paged_data.PagedData(List(contract.Contract)),
    FetchApiError,
  ),
)

list_error_codes

</> 
pub fn list_error_codes(
  ,
) -> promise.Promise(
  Result(List(spacetraders_api.ErrorCode), FetchApiError),
)

list_factions

</> 
pub fn list_factions(
  page: option.Option(Int),
  limit: option.Option(Int),
) -> promise.Promise(
  Result(
    paged_data.PagedData(List(faction.Faction)),
    FetchApiError,
  ),
)

list_public_agents

</> 
pub fn list_public_agents(
  page: option.Option(Int),
  limit: option.Option(Int),
) -> promise.Promise(
  Result(
    paged_data.PagedData(List(public_agent.PublicAgent)),
    FetchApiError,
  ),
)

list_ships

</> 
pub fn list_ships(
  token: agent_token.AgentToken,
  page: option.Option(Int),
  limit: option.Option(Int),
) -> promise.Promise(
  Result(paged_data.PagedData(List(ship.Ship)), FetchApiError),
)

list_system_waypoints

</> 
pub fn list_system_waypoints(
  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),
) -> promise.Promise(
  Result(
    paged_data.PagedData(List(waypoint.Waypoint)),
    FetchApiError,
  ),
)

list_systems

</> 
pub fn list_systems(
  page: option.Option(Int),
  limit: option.Option(Int),
) -> promise.Promise(
  Result(paged_data.PagedData(List(system.System)), FetchApiError),
)
</> 
pub fn navigate_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipNavigated, FetchApiError),
)

negotiate_contract

</> 
pub fn negotiate_contract(
  token: agent_token.AgentToken,
  ship_symbol: String,
) -> promise.Promise(Result(contract.Contract, FetchApiError))

orbit_ship

</> 
pub fn orbit_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(Result(ship_nav.ShipNav, FetchApiError))

patch_ship_nav

</> 
pub fn patch_ship_nav(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  flight_mode: ship_nav_flight_mode.ShipNavFlightMode,
) -> promise.Promise(
  Result(spacetraders_api.ShipNavPatched, FetchApiError),
)

purchase_cargo

</> 
pub fn purchase_cargo(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
) -> promise.Promise(
  Result(spacetraders_api.CargoPurchased, FetchApiError),
)

purchase_ship

</> 
pub fn purchase_ship(
  token: agent_token.AgentToken,
  ship_type: ship_type.ShipType,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipPurchased, FetchApiError),
)

refine_ship

</> 
pub fn refine_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  produce: refinement_produce.RefinementProduce,
) -> promise.Promise(
  Result(spacetraders_api.ShipRefined, FetchApiError),
)

refuel_ship

</> 
pub fn refuel_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  units: option.Option(Int),
  from_cargo: option.Option(Bool),
) -> promise.Promise(
  Result(spacetraders_api.ShipRefueled, FetchApiError),
)

register_new_agent

</> 
pub fn register_new_agent(
  token: account_token.AccountToken,
  agent_symbol: agent_symbol.AgentSymbol,
  faction_symbol: faction_symbol.FactionSymbol,
) -> promise.Promise(
  Result(spacetraders_api.AgentRegistered, FetchApiError),
)

remove_ship_module

</> 
pub fn remove_ship_module(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  module_symbol: module_symbol.ModuleSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipModuleRemoved, FetchApiError),
)

remove_ship_mount

</> 
pub fn remove_ship_mount(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  mount_symbol: mount_symbol.MountSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipMountRemoved, FetchApiError),
)

repair_ship

</> 
pub fn repair_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipRepaired, FetchApiError),
)

scan_ships

</> 
pub fn scan_ships(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(
    spacetraders_api.Scan(scanned_ship.ScannedShip),
    FetchApiError,
  ),
)

scan_systems

</> 
pub fn scan_systems(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(
    spacetraders_api.Scan(scanned_system.ScannedSystem),
    FetchApiError,
  ),
)

scan_waypoints

</> 
pub fn scan_waypoints(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(
    spacetraders_api.Scan(scanned_waypoint.ScannedWaypoint),
    FetchApiError,
  ),
)

scrap_ship

</> 
pub fn scrap_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipScrapped, FetchApiError),
)

sell_cargo

</> 
pub fn sell_cargo(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
  units: Int,
) -> promise.Promise(
  Result(spacetraders_api.CargoSold, FetchApiError),
)

siphon_resources

</> 
pub fn siphon_resources(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ResourcesSiphoned, FetchApiError),
)

supply_construction_site

</> 
pub fn supply_construction_site(
  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,
) -> promise.Promise(
  Result(spacetraders_api.ConstructionSiteSupplied, FetchApiError),
)

transfer_cargo

</> 
pub fn transfer_cargo(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  trade_symbol: trade_symbol.TradeSymbol,
  units: Int,
  target_ship_symbol: ship_symbol.ShipSymbol,
) -> promise.Promise(
  Result(spacetraders_api.CargoTransferred, FetchApiError),
)

warp_ship

</> 
pub fn warp_ship(
  token: agent_token.AgentToken,
  ship_symbol: ship_symbol.ShipSymbol,
  waypoint_symbol: waypoint_symbol.WaypointSymbol,
) -> promise.Promise(
  Result(spacetraders_api.ShipWarped, FetchApiError),
)
✨ Search Document