messages.js

// This file is auto generated by the protocol-buffers compiler

/* eslint-disable quotes */
/* eslint-disable indent */
/* eslint-disable no-redeclare */
/* eslint-disable camelcase */

// Remember to `npm install --save protocol-buffers-encodings`
var encodings = require('protocol-buffers-encodings')
var varint = encodings.varint
var skip = encodings.skip

var Get = exports.Get = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var Put = exports.Put = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var Delete = exports.Delete = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var Batch = exports.Batch = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var Clear = exports.Clear = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var Iterator = exports.Iterator = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var Callback = exports.Callback = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var IteratorData = exports.IteratorData = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var IteratorAck = exports.IteratorAck = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var IteratorSeek = exports.IteratorSeek = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var IteratorEnd = exports.IteratorEnd = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var IteratorError = exports.IteratorError = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var IteratorClose = exports.IteratorClose = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var GetMany = exports.GetMany = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

var GetManyCallback = exports.GetManyCallback = {
  buffer: true,
  encodingLength: null,
  encode: null,
  decode: null
}

defineGet()
definePut()
defineDelete()
defineBatch()
defineClear()
defineIterator()
defineCallback()
defineIteratorData()
defineIteratorAck()
defineIteratorSeek()
defineIteratorEnd()
defineIteratorError()
defineIteratorClose()
defineGetMany()
defineGetManyCallback()

function defineGet () {
  Get.encodingLength = encodingLength
  Get.encode = encode
  Get.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (!defined(obj.key)) throw new Error("key is required")
    var len = encodings.bytes.encodingLength(obj.key)
    length += 1 + len
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.key)) throw new Error("key is required")
    buf[offset++] = 18
    encodings.bytes.encode(obj.key, buf, offset)
    offset += encodings.bytes.encode.bytes
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      key: null
    }
    var found0 = false
    var found1 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.key = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found1 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function definePut () {
  Put.encodingLength = encodingLength
  Put.encode = encode
  Put.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (!defined(obj.key)) throw new Error("key is required")
    var len = encodings.bytes.encodingLength(obj.key)
    length += 1 + len
    if (defined(obj.value)) {
      var len = encodings.bytes.encodingLength(obj.value)
      length += 1 + len
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.key)) throw new Error("key is required")
    buf[offset++] = 18
    encodings.bytes.encode(obj.key, buf, offset)
    offset += encodings.bytes.encode.bytes
    if (defined(obj.value)) {
      buf[offset++] = 26
      encodings.bytes.encode(obj.value, buf, offset)
      offset += encodings.bytes.encode.bytes
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      key: null,
      value: null
    }
    var found0 = false
    var found1 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.key = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found1 = true
        break
        case 3:
        obj.value = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineDelete () {
  Delete.encodingLength = encodingLength
  Delete.encode = encode
  Delete.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (!defined(obj.key)) throw new Error("key is required")
    var len = encodings.bytes.encodingLength(obj.key)
    length += 1 + len
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.key)) throw new Error("key is required")
    buf[offset++] = 18
    encodings.bytes.encode(obj.key, buf, offset)
    offset += encodings.bytes.encode.bytes
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      key: null
    }
    var found0 = false
    var found1 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.key = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found1 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineBatch () {
  var Operation = Batch.Operation = {
    buffer: true,
    encodingLength: null,
    encode: null,
    decode: null
  }

  defineOperation()

  function defineOperation () {
    Operation.encodingLength = encodingLength
    Operation.encode = encode
    Operation.decode = decode

    function encodingLength (obj) {
      var length = 0
      if (!defined(obj.type)) throw new Error("type is required")
      var len = encodings.string.encodingLength(obj.type)
      length += 1 + len
      if (!defined(obj.key)) throw new Error("key is required")
      var len = encodings.bytes.encodingLength(obj.key)
      length += 1 + len
      if (defined(obj.value)) {
        var len = encodings.bytes.encodingLength(obj.value)
        length += 1 + len
      }
      return length
    }

    function encode (obj, buf, offset) {
      if (!offset) offset = 0
      if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
      var oldOffset = offset
      if (!defined(obj.type)) throw new Error("type is required")
      buf[offset++] = 10
      encodings.string.encode(obj.type, buf, offset)
      offset += encodings.string.encode.bytes
      if (!defined(obj.key)) throw new Error("key is required")
      buf[offset++] = 18
      encodings.bytes.encode(obj.key, buf, offset)
      offset += encodings.bytes.encode.bytes
      if (defined(obj.value)) {
        buf[offset++] = 26
        encodings.bytes.encode(obj.value, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      encode.bytes = offset - oldOffset
      return buf
    }

    function decode (buf, offset, end) {
      if (!offset) offset = 0
      if (!end) end = buf.length
      if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
      var oldOffset = offset
      var obj = {
        type: "",
        key: null,
        value: null
      }
      var found0 = false
      var found1 = false
      while (true) {
        if (end <= offset) {
          if (!found0 || !found1) throw new Error("Decoded message is not valid")
          decode.bytes = offset - oldOffset
          return obj
        }
        var prefix = varint.decode(buf, offset)
        offset += varint.decode.bytes
        var tag = prefix >> 3
        switch (tag) {
          case 1:
          obj.type = encodings.string.decode(buf, offset)
          offset += encodings.string.decode.bytes
          found0 = true
          break
          case 2:
          obj.key = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          found1 = true
          break
          case 3:
          obj.value = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          default:
          offset = skip(prefix & 7, buf, offset)
        }
      }
    }
  }

  Batch.encodingLength = encodingLength
  Batch.encode = encode
  Batch.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (defined(obj.ops)) {
      for (var i = 0; i < obj.ops.length; i++) {
        if (!defined(obj.ops[i])) continue
        var len = Operation.encodingLength(obj.ops[i])
        length += varint.encodingLength(len)
        length += 1 + len
      }
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.ops)) {
      for (var i = 0; i < obj.ops.length; i++) {
        if (!defined(obj.ops[i])) continue
        buf[offset++] = 18
        varint.encode(Operation.encodingLength(obj.ops[i]), buf, offset)
        offset += varint.encode.bytes
        Operation.encode(obj.ops[i], buf, offset)
        offset += Operation.encode.bytes
      }
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      ops: []
    }
    var found0 = false
    while (true) {
      if (end <= offset) {
        if (!found0) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.ops.push(Operation.decode(buf, offset, offset + len))
        offset += Operation.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineClear () {
  var ClearOptions = Clear.ClearOptions = {
    buffer: true,
    encodingLength: null,
    encode: null,
    decode: null
  }

  defineClearOptions()

  function defineClearOptions () {
    ClearOptions.encodingLength = encodingLength
    ClearOptions.encode = encode
    ClearOptions.decode = decode

    function encodingLength (obj) {
      var length = 0
      if (defined(obj.gt)) {
        var len = encodings.bytes.encodingLength(obj.gt)
        length += 1 + len
      }
      if (defined(obj.gte)) {
        var len = encodings.bytes.encodingLength(obj.gte)
        length += 1 + len
      }
      if (defined(obj.lt)) {
        var len = encodings.bytes.encodingLength(obj.lt)
        length += 1 + len
      }
      if (defined(obj.lte)) {
        var len = encodings.bytes.encodingLength(obj.lte)
        length += 1 + len
      }
      if (defined(obj.limit)) {
        var len = encodings.sint64.encodingLength(obj.limit)
        length += 1 + len
      }
      if (defined(obj.reverse)) {
        var len = encodings.bool.encodingLength(obj.reverse)
        length += 1 + len
      }
      return length
    }

    function encode (obj, buf, offset) {
      if (!offset) offset = 0
      if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
      var oldOffset = offset
      if (defined(obj.gt)) {
        buf[offset++] = 26
        encodings.bytes.encode(obj.gt, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      if (defined(obj.gte)) {
        buf[offset++] = 34
        encodings.bytes.encode(obj.gte, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      if (defined(obj.lt)) {
        buf[offset++] = 42
        encodings.bytes.encode(obj.lt, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      if (defined(obj.lte)) {
        buf[offset++] = 50
        encodings.bytes.encode(obj.lte, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      if (defined(obj.limit)) {
        buf[offset++] = 56
        encodings.sint64.encode(obj.limit, buf, offset)
        offset += encodings.sint64.encode.bytes
      }
      if (defined(obj.reverse)) {
        buf[offset++] = 64
        encodings.bool.encode(obj.reverse, buf, offset)
        offset += encodings.bool.encode.bytes
      }
      encode.bytes = offset - oldOffset
      return buf
    }

    function decode (buf, offset, end) {
      if (!offset) offset = 0
      if (!end) end = buf.length
      if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
      var oldOffset = offset
      var obj = {
        gt: null,
        gte: null,
        lt: null,
        lte: null,
        limit: 0,
        reverse: false
      }
      while (true) {
        if (end <= offset) {
          decode.bytes = offset - oldOffset
          return obj
        }
        var prefix = varint.decode(buf, offset)
        offset += varint.decode.bytes
        var tag = prefix >> 3
        switch (tag) {
          case 3:
          obj.gt = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          case 4:
          obj.gte = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          case 5:
          obj.lt = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          case 6:
          obj.lte = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          case 7:
          obj.limit = encodings.sint64.decode(buf, offset)
          offset += encodings.sint64.decode.bytes
          break
          case 8:
          obj.reverse = encodings.bool.decode(buf, offset)
          offset += encodings.bool.decode.bytes
          break
          default:
          offset = skip(prefix & 7, buf, offset)
        }
      }
    }
  }

  Clear.encodingLength = encodingLength
  Clear.encode = encode
  Clear.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (defined(obj.options)) {
      var len = ClearOptions.encodingLength(obj.options)
      length += varint.encodingLength(len)
      length += 1 + len
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.options)) {
      buf[offset++] = 18
      varint.encode(ClearOptions.encodingLength(obj.options), buf, offset)
      offset += varint.encode.bytes
      ClearOptions.encode(obj.options, buf, offset)
      offset += ClearOptions.encode.bytes
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      options: null
    }
    var found0 = false
    while (true) {
      if (end <= offset) {
        if (!found0) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.options = ClearOptions.decode(buf, offset, offset + len)
        offset += ClearOptions.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineIterator () {
  var Options = Iterator.Options = {
    buffer: true,
    encodingLength: null,
    encode: null,
    decode: null
  }

  defineOptions()

  function defineOptions () {
    Options.encodingLength = encodingLength
    Options.encode = encode
    Options.decode = decode

    function encodingLength (obj) {
      var length = 0
      if (defined(obj.keys)) {
        var len = encodings.bool.encodingLength(obj.keys)
        length += 1 + len
      }
      if (defined(obj.values)) {
        var len = encodings.bool.encodingLength(obj.values)
        length += 1 + len
      }
      if (defined(obj.gt)) {
        var len = encodings.bytes.encodingLength(obj.gt)
        length += 1 + len
      }
      if (defined(obj.gte)) {
        var len = encodings.bytes.encodingLength(obj.gte)
        length += 1 + len
      }
      if (defined(obj.lt)) {
        var len = encodings.bytes.encodingLength(obj.lt)
        length += 1 + len
      }
      if (defined(obj.lte)) {
        var len = encodings.bytes.encodingLength(obj.lte)
        length += 1 + len
      }
      if (defined(obj.limit)) {
        var len = encodings.sint64.encodingLength(obj.limit)
        length += 1 + len
      }
      if (defined(obj.reverse)) {
        var len = encodings.bool.encodingLength(obj.reverse)
        length += 1 + len
      }
      return length
    }

    function encode (obj, buf, offset) {
      if (!offset) offset = 0
      if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
      var oldOffset = offset
      if (defined(obj.keys)) {
        buf[offset++] = 8
        encodings.bool.encode(obj.keys, buf, offset)
        offset += encodings.bool.encode.bytes
      }
      if (defined(obj.values)) {
        buf[offset++] = 16
        encodings.bool.encode(obj.values, buf, offset)
        offset += encodings.bool.encode.bytes
      }
      if (defined(obj.gt)) {
        buf[offset++] = 26
        encodings.bytes.encode(obj.gt, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      if (defined(obj.gte)) {
        buf[offset++] = 34
        encodings.bytes.encode(obj.gte, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      if (defined(obj.lt)) {
        buf[offset++] = 42
        encodings.bytes.encode(obj.lt, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      if (defined(obj.lte)) {
        buf[offset++] = 50
        encodings.bytes.encode(obj.lte, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      if (defined(obj.limit)) {
        buf[offset++] = 56
        encodings.sint64.encode(obj.limit, buf, offset)
        offset += encodings.sint64.encode.bytes
      }
      if (defined(obj.reverse)) {
        buf[offset++] = 64
        encodings.bool.encode(obj.reverse, buf, offset)
        offset += encodings.bool.encode.bytes
      }
      encode.bytes = offset - oldOffset
      return buf
    }

    function decode (buf, offset, end) {
      if (!offset) offset = 0
      if (!end) end = buf.length
      if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
      var oldOffset = offset
      var obj = {
        keys: false,
        values: false,
        gt: null,
        gte: null,
        lt: null,
        lte: null,
        limit: 0,
        reverse: false
      }
      while (true) {
        if (end <= offset) {
          decode.bytes = offset - oldOffset
          return obj
        }
        var prefix = varint.decode(buf, offset)
        offset += varint.decode.bytes
        var tag = prefix >> 3
        switch (tag) {
          case 1:
          obj.keys = encodings.bool.decode(buf, offset)
          offset += encodings.bool.decode.bytes
          break
          case 2:
          obj.values = encodings.bool.decode(buf, offset)
          offset += encodings.bool.decode.bytes
          break
          case 3:
          obj.gt = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          case 4:
          obj.gte = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          case 5:
          obj.lt = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          case 6:
          obj.lte = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          case 7:
          obj.limit = encodings.sint64.decode(buf, offset)
          offset += encodings.sint64.decode.bytes
          break
          case 8:
          obj.reverse = encodings.bool.decode(buf, offset)
          offset += encodings.bool.decode.bytes
          break
          default:
          offset = skip(prefix & 7, buf, offset)
        }
      }
    }
  }

  Iterator.encodingLength = encodingLength
  Iterator.encode = encode
  Iterator.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (!defined(obj.seq)) throw new Error("seq is required")
    var len = encodings.varint.encodingLength(obj.seq)
    length += 1 + len
    if (!defined(obj.options)) throw new Error("options is required")
    var len = Options.encodingLength(obj.options)
    length += varint.encodingLength(len)
    length += 1 + len
    if (!defined(obj.consumed)) throw new Error("consumed is required")
    var len = encodings.varint.encodingLength(obj.consumed)
    length += 1 + len
    if (defined(obj.bookmark)) {
      var len = encodings.bytes.encodingLength(obj.bookmark)
      length += 1 + len
    }
    if (defined(obj.seek)) {
      var len = encodings.bytes.encodingLength(obj.seek)
      length += 1 + len
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.seq)) throw new Error("seq is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.seq, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.options)) throw new Error("options is required")
    buf[offset++] = 26
    varint.encode(Options.encodingLength(obj.options), buf, offset)
    offset += varint.encode.bytes
    Options.encode(obj.options, buf, offset)
    offset += Options.encode.bytes
    if (!defined(obj.consumed)) throw new Error("consumed is required")
    buf[offset++] = 32
    encodings.varint.encode(obj.consumed, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.bookmark)) {
      buf[offset++] = 42
      encodings.bytes.encode(obj.bookmark, buf, offset)
      offset += encodings.bytes.encode.bytes
    }
    if (defined(obj.seek)) {
      buf[offset++] = 50
      encodings.bytes.encode(obj.seek, buf, offset)
      offset += encodings.bytes.encode.bytes
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      seq: 0,
      options: null,
      consumed: 0,
      bookmark: null,
      seek: null
    }
    var found0 = false
    var found1 = false
    var found2 = false
    var found3 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1 || !found2 || !found3) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.seq = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.options = Options.decode(buf, offset, offset + len)
        offset += Options.decode.bytes
        found2 = true
        break
        case 4:
        obj.consumed = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found3 = true
        break
        case 5:
        obj.bookmark = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        case 6:
        obj.seek = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineCallback () {
  Callback.encodingLength = encodingLength
  Callback.encode = encode
  Callback.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (defined(obj.error)) {
      var len = encodings.string.encodingLength(obj.error)
      length += 1 + len
    }
    if (defined(obj.value)) {
      var len = encodings.bytes.encodingLength(obj.value)
      length += 1 + len
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.error)) {
      buf[offset++] = 18
      encodings.string.encode(obj.error, buf, offset)
      offset += encodings.string.encode.bytes
    }
    if (defined(obj.value)) {
      buf[offset++] = 26
      encodings.bytes.encode(obj.value, buf, offset)
      offset += encodings.bytes.encode.bytes
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      error: "",
      value: null
    }
    var found0 = false
    while (true) {
      if (end <= offset) {
        if (!found0) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.error = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        break
        case 3:
        obj.value = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineIteratorData () {
  IteratorData.encodingLength = encodingLength
  IteratorData.encode = encode
  IteratorData.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (!defined(obj.seq)) throw new Error("seq is required")
    var len = encodings.varint.encodingLength(obj.seq)
    length += 1 + len
    if (defined(obj.data)) {
      for (var i = 0; i < obj.data.length; i++) {
        if (!defined(obj.data[i])) continue
        var len = encodings.bytes.encodingLength(obj.data[i])
        length += 1 + len
      }
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.seq)) throw new Error("seq is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.seq, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.data)) {
      for (var i = 0; i < obj.data.length; i++) {
        if (!defined(obj.data[i])) continue
        buf[offset++] = 26
        encodings.bytes.encode(obj.data[i], buf, offset)
        offset += encodings.bytes.encode.bytes
      }
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      seq: 0,
      data: []
    }
    var found0 = false
    var found1 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.seq = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.data.push(encodings.bytes.decode(buf, offset))
        offset += encodings.bytes.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineIteratorAck () {
  IteratorAck.encodingLength = encodingLength
  IteratorAck.encode = encode
  IteratorAck.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (!defined(obj.seq)) throw new Error("seq is required")
    var len = encodings.varint.encodingLength(obj.seq)
    length += 1 + len
    if (!defined(obj.consumed)) throw new Error("consumed is required")
    var len = encodings.varint.encodingLength(obj.consumed)
    length += 1 + len
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.seq)) throw new Error("seq is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.seq, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.consumed)) throw new Error("consumed is required")
    buf[offset++] = 24
    encodings.varint.encode(obj.consumed, buf, offset)
    offset += encodings.varint.encode.bytes
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      seq: 0,
      consumed: 0
    }
    var found0 = false
    var found1 = false
    var found2 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1 || !found2) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.seq = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.consumed = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found2 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineIteratorSeek () {
  IteratorSeek.encodingLength = encodingLength
  IteratorSeek.encode = encode
  IteratorSeek.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (!defined(obj.seq)) throw new Error("seq is required")
    var len = encodings.varint.encodingLength(obj.seq)
    length += 1 + len
    if (!defined(obj.target)) throw new Error("target is required")
    var len = encodings.bytes.encodingLength(obj.target)
    length += 1 + len
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.seq)) throw new Error("seq is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.seq, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.target)) throw new Error("target is required")
    buf[offset++] = 26
    encodings.bytes.encode(obj.target, buf, offset)
    offset += encodings.bytes.encode.bytes
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      seq: 0,
      target: null
    }
    var found0 = false
    var found1 = false
    var found2 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1 || !found2) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.seq = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.target = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found2 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineIteratorEnd () {
  IteratorEnd.encodingLength = encodingLength
  IteratorEnd.encode = encode
  IteratorEnd.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (!defined(obj.seq)) throw new Error("seq is required")
    var len = encodings.varint.encodingLength(obj.seq)
    length += 1 + len
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.seq)) throw new Error("seq is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.seq, buf, offset)
    offset += encodings.varint.encode.bytes
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      seq: 0
    }
    var found0 = false
    var found1 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.seq = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineIteratorError () {
  IteratorError.encodingLength = encodingLength
  IteratorError.encode = encode
  IteratorError.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (!defined(obj.seq)) throw new Error("seq is required")
    var len = encodings.varint.encodingLength(obj.seq)
    length += 1 + len
    if (!defined(obj.error)) throw new Error("error is required")
    var len = encodings.string.encodingLength(obj.error)
    length += 1 + len
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.seq)) throw new Error("seq is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.seq, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.error)) throw new Error("error is required")
    buf[offset++] = 26
    encodings.string.encode(obj.error, buf, offset)
    offset += encodings.string.encode.bytes
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      seq: 0,
      error: ""
    }
    var found0 = false
    var found1 = false
    var found2 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1 || !found2) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.seq = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.error = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        found2 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineIteratorClose () {
  IteratorClose.encodingLength = encodingLength
  IteratorClose.encode = encode
  IteratorClose.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0
    }
    var found0 = false
    while (true) {
      if (end <= offset) {
        if (!found0) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineGetMany () {
  GetMany.encodingLength = encodingLength
  GetMany.encode = encode
  GetMany.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (defined(obj.keys)) {
      for (var i = 0; i < obj.keys.length; i++) {
        if (!defined(obj.keys[i])) continue
        var len = encodings.bytes.encodingLength(obj.keys[i])
        length += 1 + len
      }
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.keys)) {
      for (var i = 0; i < obj.keys.length; i++) {
        if (!defined(obj.keys[i])) continue
        buf[offset++] = 18
        encodings.bytes.encode(obj.keys[i], buf, offset)
        offset += encodings.bytes.encode.bytes
      }
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      keys: []
    }
    var found0 = false
    while (true) {
      if (end <= offset) {
        if (!found0) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.keys.push(encodings.bytes.decode(buf, offset))
        offset += encodings.bytes.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineGetManyCallback () {
  var Value = GetManyCallback.Value = {
    buffer: true,
    encodingLength: null,
    encode: null,
    decode: null
  }

  defineValue()

  function defineValue () {
    Value.encodingLength = encodingLength
    Value.encode = encode
    Value.decode = decode

    function encodingLength (obj) {
      var length = 0
      if (defined(obj.value)) {
        var len = encodings.bytes.encodingLength(obj.value)
        length += 1 + len
      }
      return length
    }

    function encode (obj, buf, offset) {
      if (!offset) offset = 0
      if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
      var oldOffset = offset
      if (defined(obj.value)) {
        buf[offset++] = 10
        encodings.bytes.encode(obj.value, buf, offset)
        offset += encodings.bytes.encode.bytes
      }
      encode.bytes = offset - oldOffset
      return buf
    }

    function decode (buf, offset, end) {
      if (!offset) offset = 0
      if (!end) end = buf.length
      if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
      var oldOffset = offset
      var obj = {
        value: null
      }
      while (true) {
        if (end <= offset) {
          decode.bytes = offset - oldOffset
          return obj
        }
        var prefix = varint.decode(buf, offset)
        offset += varint.decode.bytes
        var tag = prefix >> 3
        switch (tag) {
          case 1:
          obj.value = encodings.bytes.decode(buf, offset)
          offset += encodings.bytes.decode.bytes
          break
          default:
          offset = skip(prefix & 7, buf, offset)
        }
      }
    }
  }

  GetManyCallback.encodingLength = encodingLength
  GetManyCallback.encode = encode
  GetManyCallback.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.id)) throw new Error("id is required")
    var len = encodings.varint.encodingLength(obj.id)
    length += 1 + len
    if (defined(obj.error)) {
      var len = encodings.string.encodingLength(obj.error)
      length += 1 + len
    }
    if (defined(obj.values)) {
      for (var i = 0; i < obj.values.length; i++) {
        if (!defined(obj.values[i])) continue
        var len = Value.encodingLength(obj.values[i])
        length += varint.encodingLength(len)
        length += 1 + len
      }
    }
    return length
  }

  function encode (obj, buf, offset) {
    if (!offset) offset = 0
    if (!buf) buf = Buffer.allocUnsafe(encodingLength(obj))
    var oldOffset = offset
    if (!defined(obj.id)) throw new Error("id is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.id, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.error)) {
      buf[offset++] = 18
      encodings.string.encode(obj.error, buf, offset)
      offset += encodings.string.encode.bytes
    }
    if (defined(obj.values)) {
      for (var i = 0; i < obj.values.length; i++) {
        if (!defined(obj.values[i])) continue
        buf[offset++] = 26
        varint.encode(Value.encodingLength(obj.values[i]), buf, offset)
        offset += varint.encode.bytes
        Value.encode(obj.values[i], buf, offset)
        offset += Value.encode.bytes
      }
    }
    encode.bytes = offset - oldOffset
    return buf
  }

  function decode (buf, offset, end) {
    if (!offset) offset = 0
    if (!end) end = buf.length
    if (!(end <= buf.length && offset <= buf.length)) throw new Error("Decoded message is not valid")
    var oldOffset = offset
    var obj = {
      id: 0,
      error: "",
      values: []
    }
    var found0 = false
    while (true) {
      if (end <= offset) {
        if (!found0) throw new Error("Decoded message is not valid")
        decode.bytes = offset - oldOffset
        return obj
      }
      var prefix = varint.decode(buf, offset)
      offset += varint.decode.bytes
      var tag = prefix >> 3
      switch (tag) {
        case 1:
        obj.id = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.error = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        break
        case 3:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.values.push(Value.decode(buf, offset, offset + len))
        offset += Value.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defined (val) {
  return val !== null && val !== undefined && (typeof val !== 'number' || !isNaN(val))
}