pub(all) suberror DtbError {
  UnexpectedEnd(offset~ : Int64, needed~ : Int64, available~ : Int64)
  BadMagic(magic~ : UInt)
  BadValue(field~ : String, value~ : Int64)
  OutOfBounds(what~ : String, offset~ : Int64, size~ : Int64, limit~ : Int64)
  BadName(offset~ : Int64)
  Inconsistent(what~ : String, detail~ : String)
  LimitExceeded(what~ : String, limit~ : Int64)
  Unsupported(what~ : String)
}

pub(all) suberror LexerError {
  UnexpectedChar(char~ : Char, span~ : Span)
  UnterminatedComment(start~ : Span)
  UnterminatedString(start~ : Span)
  BadEscape(char~ : Char, span~ : Span)
  BadNumber(text~ : String, span~ : Span)
}

pub(all) suberror OverlayError {
  UnknownSymbol(label~ : String)
  MissingTarget(path~ : String)
  BadFixup(detail~ : String)
  NoSymbols
  BadFragment(name~ : String)
  Resolve(inner~ : ResolveError)
}

pub(all) suberror ParseError {
  Unexpected(token~ : TokenKind, expected~ : String, span~ : Span)
  Lexical(inner~ : LexerError)
  BadValue(detail~ : String, span~ : Span)
  LimitExceeded(what~ : String, limit~ : Int)
  Unsupported(what~ : String, span~ : Span)
}

pub(all) suberror ResolveError {
  UnknownLabel(label~ : String)
  UnknownPath(path~ : String)
  DuplicateLabel(label~ : String, first~ : String, second~ : String)
  DuplicatePhandle(value~ : UInt, first~ : String, second~ : String)
  BadPhandle(value~ : UInt, node~ : String)
}

pub(all) struct Bounds {
  bytes : Bytes
  start : Int64
  limit : Int64
}

pub(all) struct Cursor {
  pos : Int64
  endian : Endian
}

pub(all) enum Endian {
  Little
  Big
}

pub(all) struct Fragment {
  target : ValuePart
  span : Span
  node : SourceNode
}

pub(all) struct Header {
  totalsize : Int64
  off_dt_struct : Int64
  off_dt_strings : Int64
  off_mem_rsvmap : Int64
  version : UInt
  last_comp_version : UInt
  boot_cpuid_phys : UInt
  size_dt_strings : Int64
  size_dt_struct : Int64
}

pub(all) struct LabelTable {
  labels : Map[String, String]
  explicit : Map[String, UInt]
}

pub(all) struct Lexer {
  source : String
  pos : Int
  line : Int
  column : Int
  in_bytes : Bool
}

pub(all) struct Node {
  name : String
  properties : Array[Property]
  children : Array[Node]
}

pub(all) struct Parser {
  lexer : Lexer
  current : Token
}

pub(all) struct Property {
  name : String
  value : Bytes
  offset : Int64
}

pub(all) struct SourceFile {
  root : SourceNode
  memreserves : Array[(UInt64, UInt64)]
  is_plugin : Bool
  fragments : Array[Fragment]
}

pub(all) struct SourceNode {
  name : String
  labels : Array[String]
  properties : Array[SourceProperty]
  children : Array[SourceNode]
}

pub(all) struct SourceProperty {
  name : String
  value : Value
  span : Span
}

pub(all) struct Span {
  line : Int
  column : Int
}

pub(all) struct StringTable {
  bytes : 
@moonbitlang/core/buffer.Buffer
Buffer
  offsets : Map[String, Int]
}

pub(all) enum StructTag {
  BeginNode
  EndNode
  Prop
  Nop
  End
}

pub(all) struct Token {
  kind : TokenKind
  span : Span
}

pub(all) enum TokenKind {
  Ident(String)
  String(String)
  Number(UInt64)
  LBrace
  RBrace
  LAngle
  RAngle
  LBracket
  RBracket
  LParen
  RParen
  Comma
  Semicolon
  Equals
  Slash
  Amp
  Colon
  Minus
  HexByte(Byte)
  Eof
}

pub(all) struct Tree {
  root : Node
  warnings : Array[Warning]
}

pub(all) struct Value {
  parts : Array[ValuePart]
}

pub(all) enum ValuePart {
  Text(String)
  Cells(Array[UInt64])
  Bytes(Array[Byte])
  Ref(String)
  PathRef(String)
  Refs(Array[ValuePart])
  TypedCells(UInt64, Array[UInt64])
}

pub(all) enum Warning {
  MissingEnd(offset~ : Int64)
  TrailingData(offset~ : Int64, remaining~ : Int64)
}

fn build_overlay(file : SourceFile) -> SourceFile raise OverlayError

fn encode_blob(file : SourceFile) -> Bytes raise DtbError

fn parse_header(bytes : Bytes) -> Header raise DtbError

fn parse_source(source : String) -> SourceFile raise ParseError

fn parse_struct(struct_bounds : Bounds, strings_bounds : Bounds) -> Tree raise DtbError

fn resolve_references(file : SourceFile) -> SourceFile raise ResolveError