ProtoBuffer = object
  options: set[ProtoFlags]
  buffer*: seq[byte]
  offset*: int
  length*: int
  maxSize*: uint

ProtoError {.pure.} = enum
  VarintDecode, MessageIncomplete, BufferOverflow, MessageTooBig, BadWireType,
  IncorrectBlob, RequiredFieldMissing

ProtoField = object
  index*: int
  case kind*: ProtoFieldKind
  of Varint:
      vint*: uint64

  of Fixed64:
      vfloat64*: float64

  of Length:
      vbuffer*: seq[byte]

  of Fixed32:
      vfloat32*: float32

  of StartGroup, EndGroup:
      nil

  

ProtoFieldKind = enum
  Varint, Fixed64, Length, StartGroup, EndGroup, Fixed32

ProtoFlags = enum
  WithVarintLength, WithUint32BeLength, WithUint32LeLength

ProtoHeader = object
  wire*: ProtoFieldKind
  index*: uint64

ProtoResult[T] = Result[T, ProtoError]

ProtoScalar = uint | uint32 | uint64 | zint | zint32 | zint64 | hint | hint32 |
    hint64 |
    float32 |
    float64

SupportedWireTypes = [0, 1, 2, 5]

proc finish(pb: var ProtoBuffer) {....raises: [], public, ...tags: [].}

proc getField(pb: ProtoBuffer; field: int; output: var ProtoBuffer): ProtoResult[
    bool] {.inline, ...raises: [], public, ...tags: [].}

proc getField[T: byte | char](data: ProtoBuffer; field: int;
                              output: var openArray[T]; outlen: var int): ProtoResult[
    bool] {....raises: [], public.}

proc getField[T: ProtoScalar](data: ProtoBuffer; field: int; output: var T): ProtoResult[
    bool] {....raises: [], public.}

proc getField[T: seq[byte] | string](data: ProtoBuffer; field: int;
                                     output: var T): ProtoResult[bool] {.
    ...raises: [], public.}

proc getPackedRepeatedField[T: ProtoScalar](data: ProtoBuffer; field: int;
    output: var seq[T]): ProtoResult[bool] {....raises: [], public.}

proc getRepeatedField[T: ProtoScalar](data: ProtoBuffer; field: int;
                                      output: var seq[T]): ProtoResult[bool] {.
    ...raises: [], public.}

proc getRepeatedField[T: seq[byte] | string](data: ProtoBuffer; field: int;
    output: var seq[T]): ProtoResult[bool] {....raises: [], public.}

proc getRequiredField[T](pb: ProtoBuffer; field: int; output: var T): ProtoResult[
    void] {.inline, ...raises: [], public.}

proc getRequiredRepeatedField[T](pb: ProtoBuffer; field: int; output: var seq[T]): ProtoResult[
    void] {.inline, ...raises: [], public.}

proc initProtoBuffer(data: openArray[byte]; offset = 0;
                     options: set[ProtoFlags] = {}; maxSize = MaxMessageSize): ProtoBuffer {.
    ...raises: [], public, ...tags: [].}

proc initProtoBuffer(data: seq[byte]; offset = 0; options: set[ProtoFlags] = {};
                     maxSize = MaxMessageSize): ProtoBuffer {....raises: [],
    public, ...tags: [].}

proc initProtoBuffer(options: set[ProtoFlags] = {}; maxSize = MaxMessageSize): ProtoBuffer {.
    ...raises: [], public, ...tags: [].}

proc vsizeof(field: ProtoField): int {.inline, ...raises: [], public, ...tags: [].}

proc write(pb: var ProtoBuffer; field: int; value: ProtoBuffer) {.inline,
    ...raises: [], public, ...tags: [].}

proc write[T: byte | char](pb: var ProtoBuffer; field: int; value: openArray[T]) {.
    ...raises: [], public.}

proc write[T: ProtoScalar](pb: var ProtoBuffer; field: int; value: T) {.
    ...raises: [], public.}

proc writePacked[T: ProtoScalar](pb: var ProtoBuffer; field: int;
                                 value: openArray[T]) {....raises: [], public.}

template checkFieldNumber(i: int)

template getLen(pb: ProtoBuffer): int

template getProtoHeader(field: ProtoField): uint64

template getProtoHeader(index: int; wire: ProtoFieldKind): uint64

template getPtr(pb: ProtoBuffer): pointer

template isEmpty(pb: ProtoBuffer): bool

template isEnough(pb: ProtoBuffer; length: int): bool

template toOpenArray(pb: ProtoBuffer): untyped