pub suberror ParseError {
  Message(String, Int)
}

pub struct Field {
  name : String
  ty : TypeExpr
}

pub struct Function {
  name : String
  kind : FunctionKind
  params : Array[Param]
  result : TypeExpr?
  docs : String?
}

pub enum FunctionKind {
  Freestanding
  Constructor(String)
  Method(String)
  Static(String)
}

pub struct IncludeDecl {
  path : UsePath
  renames : Array[IncludeRename]
}

pub struct IncludeRename {
  from : String
  to : String
}

pub struct InlineInterface {
  name : String
  docs : String?
  items : Array[InterfaceItem]
}

pub struct Interface {
  name : String
  docs : String?
  items : Array[InterfaceItem]
}

pub enum InterfaceItem {
  Use(UseDecl)
  TypeDef(TypeDef)
  Function(Function)
}

pub struct PackageName {
  ns : String
  name : String
  version : String?
}

pub struct Param {
  name : String
  ty : TypeExpr
}

pub struct RFunction {
  name : String
  kind : RFunctionKind
  params : Array[(String, RType)]
  result : RType?
  docs : String?
}

pub enum RFunctionKind {
  Freestanding
  Constructor(Int)
  Method(Int)
  Static(Int)
}

pub enum RHandleKind {
  Own(Int)
  Borrow(Int)
}

pub struct RInterface {
  name : String?
  docs : String?
  functions : Map[String, RFunction]
  types : Map[String, Int]
  pkg : Int?
}

pub struct RInterfaceRef {
  id : Int
}

pub struct RPackage {
  name : RPackageName
  interfaces : Map[String, Int]
  worlds : Map[String, Int]
}

pub struct RPackageName {
  ns : String
  name : String
  version : String?
}

pub struct RRecordField {
  name : String
  field_type : RType
}

pub enum RType {
  Bool
  U8
  U16
  U32
  U64
  S8
  S16
  S32
  S64
  F32
  F64
  Char
  String_
  Id(Int)
}

pub struct RTypeDef {
  name : String?
  kind : RTypeKind
  owner : RTypeOwner
  docs : String?
}

pub enum RTypeKind {
  Record(Array[RRecordField])
  Variant(Array[RVariantCase])
  List(RType)
  Option(RType)
  Future(RType)
  Stream(RType)
  Result(RType?, RType?)
  Tuple(Array[RType])
  Flags(Array[String])
  Enum(Array[String])
  Alias(RType)
  Resource
  Handle(RHandleKind)
}

pub enum RTypeOwner {
  Interface(Int)
  World(Int)
  None
}

pub struct RVariantCase {
  name : String
  case_type : RType?
}

pub struct RWorld {
  name : String
  docs : String?
  imports : Map[String, RWorldItem]
  exports : Map[String, RWorldItem]
  pkg : Int?
}

pub enum RWorldItem {
  Interface(RInterfaceRef)
  Function(RFunction)
  Type(Int)
}

pub struct Resolve {
  worlds : Array[RWorld]
  interfaces : Array[RInterface]
  types : Array[RTypeDef]
  packages : Array[RPackage]
}

pub struct ResolveInput {
  resolve : Resolve
  world_id : Int
}

pub struct ResolvedInterfaceInfo {
  interface_id : Int
  name : String?
  docs : String?
  package_name : RPackageName?
  functions : Map[String, RFunction]
  types : Map[String, ResolvedTypeInfo]
}

pub struct ResolvedTypeInfo {
  local_name : String
  type_id : Int
  type_name : String?
  type_kind : RTypeKind
  owner : RTypeOwner
  owner_package : RPackageName?
  owner_interface : String?
  owner_world : String?
}

pub struct Resource {
  funcs : Array[Function]
}

pub struct Token {
  token_type : TokenType
  offset : Int
}

pub enum TokenType {
  Ident(String)
  Keyword(String)
  Symbol(String)
  StringLit(String)
  Number(String)
  Doc(String)
  Eof
}

pub struct TypeDef {
  name : String
  kind : TypeDefKind
  docs : String?
}

pub enum TypeDefKind {
  Record(Array[Field])
  Enum(Array[String])
  Flags(Array[String])
  Variant(Array[VariantCase])
  Alias(TypeExpr)
  Resource(Resource)
}

pub enum TypeExpr {
  Bool
  U8
  U16
  U32
  U64
  S8
  S16
  S32
  S64
  F32
  F64
  Char
  String_
  Id(String)
  List(TypeExpr)
  Option(TypeExpr)
  Future(TypeExpr)
  Stream(TypeExpr)
  Result(TypeExpr, TypeExpr?)
  Tuple(Array[TypeExpr])
  Own(String)
  Borrow(String)
}

pub struct UseDecl {
  from : UsePath
  names : Array[String]
}

pub struct UsePath {
  pkg : PackageName?
  interface : String
}

pub struct VariantCase {
  name : String
  ty : TypeExpr?
}

pub struct WitFile {
  pkg : PackageName?
  interfaces : Array[Interface]
  worlds : Array[World]
}

pub struct World {
  name : String
  docs : String?
  types : Array[TypeDef]
  imports : Array[WorldItem]
  exports : Array[WorldItem]
}

pub enum WorldItem {
  Interface(UsePath)
  Function(Function)
  InlineInterface(InlineInterface)
  Include(IncludeDecl)
}

fn interface_infos(resolve : Resolve) -> Array[ResolvedInterfaceInfo]

fn parse(source : String) -> Result[WitFile, ParseError]

fn parse_path(path : String) -> Result[WitFile, ParseError]

fn resolve(source : String) -> Result[Resolve, ParseError]

fn resolve_interface_infos(source : String) -> Result[Array[ResolvedInterfaceInfo], ParseError]

fn resolve_multi(asts : Array[WitFile]) -> Result[Resolve, ParseError]

fn resolve_path(path : String, world? : String) -> Result[ResolveInput, ParseError]

fn resolve_path_interface_infos(path : String, world? : String) -> Result[Array[ResolvedInterfaceInfo], ParseError]

fn tokenize(source : String) -> Result[Array[Token], ParseError]