pub(open) trait Enum {
  fn descriptor(Self) -> EnumDescriptor
  fn enum_type(Self) -> &EnumType
  fn number(Self) -> Int
}

pub(open) trait EnumType {
  fn new_enum(Self, Int) -> &Enum
  fn descriptor(Self) -> EnumDescriptor
}

pub(open) trait ExtensionType {
  fn new_value(Self) -> Value
  fn zero(Self) -> Value
  fn descriptor(Self) -> FieldDescriptor
  fn is_valid_value(Self, Value) -> Bool
}

pub(open) trait Fresh {
  fn fresh(Self) -> Self
}

pub(open) trait ListField {
  fn length(Self) -> Int
  fn get(Self, Int) -> Value
  fn set(Self, Int, Value) -> Unit
  fn append(Self, Value) -> Unit
  fn append_mutable(Self) -> Value
  fn truncate(Self, Int) -> Unit
  fn new_element(Self) -> Value
  fn is_valid(Self) -> Bool
}

pub(open) trait MapField {
  fn length(Self) -> Int
  fn range(Self, (MapKey, Value) -> Bool) -> Unit
  fn has(Self, MapKey) -> Bool
  fn clear(Self, MapKey) -> Unit
  fn get(Self, MapKey) -> Value
  fn set(Self, MapKey, Value) -> Unit
  fn mutable(Self, MapKey) -> Value
  fn new_value(Self) -> Value
  fn is_valid(Self) -> Bool
}

pub(open) trait Message {
  fn descriptor(Self) -> MessageDescriptor
  fn message_type(Self) -> &MessageType
  fn is_valid(Self) -> Bool
  fn range(Self, (FieldDescriptor, Value) -> Bool) -> Unit
  fn range_extensions(Self, (FieldDescriptor, Value) -> Bool) -> Unit
  fn has(Self, FieldDescriptor) -> Bool
  fn clear(Self, FieldDescriptor) -> Unit
  fn get(Self, FieldDescriptor) -> Value
  fn set(Self, FieldDescriptor, Value) -> Unit
  fn mutable(Self, FieldDescriptor) -> Value
  fn new_field(Self, FieldDescriptor) -> Value
  fn which_oneof(Self, OneofDescriptor) -> Int?
  fn get_unknown(Self) -> RawFields
  fn set_unknown(Self, RawFields) -> Unit
}

pub(open) trait MessageType {
  fn new_message(Self) -> &Message
  fn zero(Self) -> &Message
  fn descriptor(Self) -> MessageDescriptor
}

pub(all) suberror Refused {
  Conflict(String)
}

pub(all) enum Cardinality {
  Optional
  Required
  Repeated
} derive(Eq)

pub(all) struct Element[T] {
  to_value : (T) -> Value
  from_value : (Value) -> T
  make : () -> T
  copy_into : (T, &Message) -> Unit
  is_message : Bool
}

pub(all) struct EnumDescriptor {
  name : String
  full_name : String
  values : Array[EnumValueDescriptor]
  closed : Bool
  file_path : String
}

pub(all) struct EnumValueDescriptor {
  name : String
  number : Int
  full_name : String
}

pub(all) struct FieldDescriptor {
  name : String
  full_name : String
  number : Int
  kind : Kind
  cardinality : Cardinality
  json_name : String
  text_name : String
  has_presence : Bool
  is_extension : Bool
  is_map : Bool
  packed : Bool
  oneof_index : Int?
  message_type : String?
  enum_type : String?
  has_default : Bool
  default_value : Value
  default_enum_name : String?
  containing_message : String
  map_key_field : FieldDescriptor?
  map_value_field : FieldDescriptor?
}

pub(all) struct FileDescriptor {
  path : String
  package_name : String
  syntax : Syntax
  messages : Array[MessageDescriptor]
  enums : Array[EnumDescriptor]
  services : Array[ServiceDescriptor]
  extensions : Array[FieldDescriptor]
  dependencies : Array[String]
  public_dependencies : Array[String]
  edition : String?
  option_map : Array[(String, Array[(String, String)])]
}

pub struct Files {
  files : Array[FileDescriptor]
}

pub(all) enum Kind {
  Double
  Float
  Int64
  Uint64
  Int32
  Fixed64
  Fixed32
  Bool
  String
  Group
  Message
  Bytes
  Uint32
  Enum
  Sfixed32
  Sfixed64
  Sint32
  Sint64
} derive(Eq)

pub(all) enum MapKey {
  Bool(Bool)
  Int32(Int)
  Int64(Int64)
  Uint32(UInt)
  Uint64(UInt64)
  String(String)
} derive(Eq)

pub(all) struct MessageDescriptor {
  name : String
  full_name : String
  syntax : Syntax
  fields : Array[FieldDescriptor]
  oneofs : Array[OneofDescriptor]
  is_map_entry : Bool
  reserved_names : Array[String]
  reserved_ranges : Array[(Int, Int)]
  required_numbers : Array[Int]
  extension_ranges : Array[(Int, Int)]
  nested_messages : Array[MessageDescriptor]
  nested_enums : Array[EnumDescriptor]
  nested_extensions : Array[FieldDescriptor]
  file_path : String
  map_key : FieldDescriptor?
  map_value : FieldDescriptor?
}

pub(all) struct MethodDescriptor {
  name : String
  full_name : String
  input_type : String
  output_type : String
  streaming_client : Bool
  streaming_server : Bool
}

pub(all) struct OneofDescriptor {
  name : String
  synthetic : Bool
  field_numbers : Array[Int]
}

pub(all) struct RawFields(Bytes)

pub(all) struct ServiceDescriptor {
  name : String
  full_name : String
  methods : Array[MethodDescriptor]
  file_path : String
}

pub(all) enum Syntax {
  Proto2
  Proto3
  Editions
} derive(Eq)

pub struct TypedList[T] {
  items : Array[T]
  element : Element[T]
}

pub struct TypedMap[K, V] {
  entries : Map[K, V]
  key_value : (K) -> MapKey
  key_of : (MapKey) -> K
  element : Element[V]
}

pub struct Types {
  messages : Array[(String, &MessageType)]
  enums : Array[(String, &EnumType)]
  extensions : Array[(String, &ExtensionType)]
  extensions_by_number : Array[(String, &ExtensionType)]
}

pub(all) enum Value {
  Invalid
  Bool(Bool)
  Int32(Int)
  Int64(Int64)
  Uint32(UInt)
  Uint64(UInt64)
  Float(Float)
  Double(Double)
  String(String)
  Bytes(Bytes)
  Enum(Int)
  Message(&Message)
  ListView(&ListField)
  MapView(&MapField)
}

pub struct ValueList {
  element_kind : Kind
  element_message_type : String?
  items : Array[Value]
}