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 */

var encodings = require('hrpc-runtime/encodings')
var varint = encodings.varint
var skip = encodings.skip

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

definePeer()
defineHyperspaceStatusResponse()
defineOpenRequest()
defineOpenResponse()
defineFeedEvent()
defineOpenNetworkResponse()
defineNetworkStatus()
defineConfigureNetworkRequest()
defineNetworkStatusRequest()
defineNetworkStatusResponse()
defineAllNetworkStatusesResponse()
defineRegisterNetworkExtensionRequest()
defineNetworkExtensionMessage()
defineCloseRequest()
defineGetRequest()
defineGetResponse()
defineAppendRequest()
defineAppendResponse()
defineUpdateRequest()
defineSeekRequest()
defineSeekResponse()
defineHasRequest()
defineHasResponse()
defineCancelRequest()
defineDownloadRequest()
defineDownloadedRequest()
defineDownloadedResponse()
defineUndownloadRequest()
defineLockRequest()
defineWatchDownloadsRequest()
defineUnwatchDownloadsRequest()
defineWatchUploadsRequest()
defineUnwatchUploadsRequest()
defineAppendEvent()
definePeerEvent()
defineCloseEvent()
defineWaitEvent()
defineDownloadEvent()
defineUploadEvent()
defineRegisterExtensionRequest()
defineUnregisterExtensionRequest()
defineExtensionMessage()
defineRPCError()

function definePeer () {
  Peer.encodingLength = encodingLength
  Peer.encode = encode
  Peer.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.remotePublicKey)) throw new Error("remotePublicKey is required")
    var len = encodings.bytes.encodingLength(obj.remotePublicKey)
    length += 1 + len
    if (!defined(obj.remoteAddress)) throw new Error("remoteAddress is required")
    var len = encodings.string.encodingLength(obj.remoteAddress)
    length += 1 + len
    if (!defined(obj.type)) throw new Error("type is required")
    var len = encodings.string.encodingLength(obj.type)
    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.remotePublicKey)) throw new Error("remotePublicKey is required")
    buf[offset++] = 10
    encodings.bytes.encode(obj.remotePublicKey, buf, offset)
    offset += encodings.bytes.encode.bytes
    if (!defined(obj.remoteAddress)) throw new Error("remoteAddress is required")
    buf[offset++] = 18
    encodings.string.encode(obj.remoteAddress, buf, offset)
    offset += encodings.string.encode.bytes
    if (!defined(obj.type)) throw new Error("type is required")
    buf[offset++] = 26
    encodings.string.encode(obj.type, 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 = {
      remotePublicKey: null,
      remoteAddress: "",
      type: ""
    }
    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.remotePublicKey = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found0 = true
        break
        case 2:
        obj.remoteAddress = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        found1 = true
        break
        case 3:
        obj.type = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        found2 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineHyperspaceStatusResponse () {
  HyperspaceStatusResponse.encodingLength = encodingLength
  HyperspaceStatusResponse.encode = encode
  HyperspaceStatusResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.apiVersion)) throw new Error("apiVersion is required")
    var len = encodings.string.encodingLength(obj.apiVersion)
    length += 1 + len
    if (defined(obj.holepunchable)) {
      var len = encodings.bool.encodingLength(obj.holepunchable)
      length += 1 + len
    }
    if (defined(obj.remoteAddress)) {
      var len = encodings.string.encodingLength(obj.remoteAddress)
      length += 1 + len
    }
    if (defined(obj.version)) {
      var len = encodings.string.encodingLength(obj.version)
      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.apiVersion)) throw new Error("apiVersion is required")
    buf[offset++] = 10
    encodings.string.encode(obj.apiVersion, buf, offset)
    offset += encodings.string.encode.bytes
    if (defined(obj.holepunchable)) {
      buf[offset++] = 16
      encodings.bool.encode(obj.holepunchable, buf, offset)
      offset += encodings.bool.encode.bytes
    }
    if (defined(obj.remoteAddress)) {
      buf[offset++] = 26
      encodings.string.encode(obj.remoteAddress, buf, offset)
      offset += encodings.string.encode.bytes
    }
    if (defined(obj.version)) {
      buf[offset++] = 34
      encodings.string.encode(obj.version, 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 = {
      apiVersion: "",
      holepunchable: false,
      remoteAddress: "",
      version: ""
    }
    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.apiVersion = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        found0 = true
        break
        case 2:
        obj.holepunchable = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        case 3:
        obj.remoteAddress = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        break
        case 4:
        obj.version = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineOpenRequest () {
  OpenRequest.encodingLength = encodingLength
  OpenRequest.encode = encode
  OpenRequest.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)) {
      var len = encodings.bytes.encodingLength(obj.key)
      length += 1 + len
    }
    if (defined(obj.name)) {
      var len = encodings.string.encodingLength(obj.name)
      length += 1 + len
    }
    if (defined(obj.weak)) {
      var len = encodings.bool.encodingLength(obj.weak)
      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)) {
      buf[offset++] = 18
      encodings.bytes.encode(obj.key, buf, offset)
      offset += encodings.bytes.encode.bytes
    }
    if (defined(obj.name)) {
      buf[offset++] = 26
      encodings.string.encode(obj.name, buf, offset)
      offset += encodings.string.encode.bytes
    }
    if (defined(obj.weak)) {
      buf[offset++] = 32
      encodings.bool.encode(obj.weak, 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 = {
      id: 0,
      key: null,
      name: "",
      weak: false
    }
    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.key = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        case 3:
        obj.name = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        break
        case 4:
        obj.weak = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineOpenResponse () {
  OpenResponse.encodingLength = encodingLength
  OpenResponse.encode = encode
  OpenResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.key)) throw new Error("key is required")
    var len = encodings.bytes.encodingLength(obj.key)
    length += 1 + len
    if (!defined(obj.length)) throw new Error("length is required")
    var len = encodings.varint.encodingLength(obj.length)
    length += 1 + len
    if (!defined(obj.byteLength)) throw new Error("byteLength is required")
    var len = encodings.varint.encodingLength(obj.byteLength)
    length += 1 + len
    if (!defined(obj.writable)) throw new Error("writable is required")
    var len = encodings.bool.encodingLength(obj.writable)
    length += 1 + len
    if (defined(obj.peers)) {
      for (var i = 0; i < obj.peers.length; i++) {
        if (!defined(obj.peers[i])) continue
        var len = Peer.encodingLength(obj.peers[i])
        length += varint.encodingLength(len)
        length += 1 + len
      }
    }
    if (defined(obj.discoveryKey)) {
      var len = encodings.bytes.encodingLength(obj.discoveryKey)
      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.key)) throw new Error("key is required")
    buf[offset++] = 10
    encodings.bytes.encode(obj.key, buf, offset)
    offset += encodings.bytes.encode.bytes
    if (!defined(obj.length)) throw new Error("length is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.length, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.byteLength)) throw new Error("byteLength is required")
    buf[offset++] = 24
    encodings.varint.encode(obj.byteLength, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.writable)) throw new Error("writable is required")
    buf[offset++] = 32
    encodings.bool.encode(obj.writable, buf, offset)
    offset += encodings.bool.encode.bytes
    if (defined(obj.peers)) {
      for (var i = 0; i < obj.peers.length; i++) {
        if (!defined(obj.peers[i])) continue
        buf[offset++] = 42
        varint.encode(Peer.encodingLength(obj.peers[i]), buf, offset)
        offset += varint.encode.bytes
        Peer.encode(obj.peers[i], buf, offset)
        offset += Peer.encode.bytes
      }
    }
    if (defined(obj.discoveryKey)) {
      buf[offset++] = 50
      encodings.bytes.encode(obj.discoveryKey, 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 = {
      key: null,
      length: 0,
      byteLength: 0,
      writable: false,
      peers: [],
      discoveryKey: 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.key = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found0 = true
        break
        case 2:
        obj.length = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.byteLength = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found2 = true
        break
        case 4:
        obj.writable = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        found3 = true
        break
        case 5:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.peers.push(Peer.decode(buf, offset, offset + len))
        offset += Peer.decode.bytes
        break
        case 6:
        obj.discoveryKey = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineFeedEvent () {
  FeedEvent.encodingLength = encodingLength
  FeedEvent.encode = encode
  FeedEvent.decode = decode

  function encodingLength (obj) {
    var length = 0
    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.key)) throw new Error("key is required")
    buf[offset++] = 10
    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 = {
      key: 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.key = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found0 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineOpenNetworkResponse () {
  OpenNetworkResponse.encodingLength = encodingLength
  OpenNetworkResponse.encode = encode
  OpenNetworkResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.publicKey)) throw new Error("publicKey is required")
    var len = encodings.bytes.encodingLength(obj.publicKey)
    length += 1 + len
    if (defined(obj.peers)) {
      for (var i = 0; i < obj.peers.length; i++) {
        if (!defined(obj.peers[i])) continue
        var len = Peer.encodingLength(obj.peers[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.publicKey)) throw new Error("publicKey is required")
    buf[offset++] = 10
    encodings.bytes.encode(obj.publicKey, buf, offset)
    offset += encodings.bytes.encode.bytes
    if (defined(obj.peers)) {
      for (var i = 0; i < obj.peers.length; i++) {
        if (!defined(obj.peers[i])) continue
        buf[offset++] = 18
        varint.encode(Peer.encodingLength(obj.peers[i]), buf, offset)
        offset += varint.encode.bytes
        Peer.encode(obj.peers[i], buf, offset)
        offset += Peer.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 = {
      publicKey: null,
      peers: []
    }
    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.publicKey = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found0 = true
        break
        case 2:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.peers.push(Peer.decode(buf, offset, offset + len))
        offset += Peer.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineNetworkStatus () {
  NetworkStatus.encodingLength = encodingLength
  NetworkStatus.encode = encode
  NetworkStatus.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.discoveryKey)) throw new Error("discoveryKey is required")
    var len = encodings.bytes.encodingLength(obj.discoveryKey)
    length += 1 + len
    if (defined(obj.announce)) {
      var len = encodings.bool.encodingLength(obj.announce)
      length += 1 + len
    }
    if (defined(obj.lookup)) {
      var len = encodings.bool.encodingLength(obj.lookup)
      length += 1 + len
    }
    if (defined(obj.remember)) {
      var len = encodings.bool.encodingLength(obj.remember)
      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.discoveryKey)) throw new Error("discoveryKey is required")
    buf[offset++] = 10
    encodings.bytes.encode(obj.discoveryKey, buf, offset)
    offset += encodings.bytes.encode.bytes
    if (defined(obj.announce)) {
      buf[offset++] = 16
      encodings.bool.encode(obj.announce, buf, offset)
      offset += encodings.bool.encode.bytes
    }
    if (defined(obj.lookup)) {
      buf[offset++] = 24
      encodings.bool.encode(obj.lookup, buf, offset)
      offset += encodings.bool.encode.bytes
    }
    if (defined(obj.remember)) {
      buf[offset++] = 32
      encodings.bool.encode(obj.remember, 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 = {
      discoveryKey: null,
      announce: false,
      lookup: false,
      remember: false
    }
    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.discoveryKey = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found0 = true
        break
        case 2:
        obj.announce = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        case 3:
        obj.lookup = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        case 4:
        obj.remember = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineConfigureNetworkRequest () {
  ConfigureNetworkRequest.encodingLength = encodingLength
  ConfigureNetworkRequest.encode = encode
  ConfigureNetworkRequest.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.configuration)) throw new Error("configuration is required")
    var len = NetworkStatus.encodingLength(obj.configuration)
    length += varint.encodingLength(len)
    length += 1 + len
    if (defined(obj.flush)) {
      var len = encodings.bool.encodingLength(obj.flush)
      length += 1 + len
    }
    if (defined(obj.copyFrom)) {
      var len = encodings.bytes.encodingLength(obj.copyFrom)
      length += 1 + len
    }
    if (defined(obj.overwrite)) {
      var len = encodings.bool.encodingLength(obj.overwrite)
      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.configuration)) throw new Error("configuration is required")
    buf[offset++] = 10
    varint.encode(NetworkStatus.encodingLength(obj.configuration), buf, offset)
    offset += varint.encode.bytes
    NetworkStatus.encode(obj.configuration, buf, offset)
    offset += NetworkStatus.encode.bytes
    if (defined(obj.flush)) {
      buf[offset++] = 16
      encodings.bool.encode(obj.flush, buf, offset)
      offset += encodings.bool.encode.bytes
    }
    if (defined(obj.copyFrom)) {
      buf[offset++] = 26
      encodings.bytes.encode(obj.copyFrom, buf, offset)
      offset += encodings.bytes.encode.bytes
    }
    if (defined(obj.overwrite)) {
      buf[offset++] = 32
      encodings.bool.encode(obj.overwrite, 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 = {
      configuration: null,
      flush: false,
      copyFrom: null,
      overwrite: true
    }
    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:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.configuration = NetworkStatus.decode(buf, offset, offset + len)
        offset += NetworkStatus.decode.bytes
        found0 = true
        break
        case 2:
        obj.flush = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        case 3:
        obj.copyFrom = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        case 4:
        obj.overwrite = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineNetworkStatusRequest () {
  NetworkStatusRequest.encodingLength = encodingLength
  NetworkStatusRequest.encode = encode
  NetworkStatusRequest.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.discoveryKey)) throw new Error("discoveryKey is required")
    var len = encodings.bytes.encodingLength(obj.discoveryKey)
    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.discoveryKey)) throw new Error("discoveryKey is required")
    buf[offset++] = 10
    encodings.bytes.encode(obj.discoveryKey, 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 = {
      discoveryKey: 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.discoveryKey = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found0 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineNetworkStatusResponse () {
  NetworkStatusResponse.encodingLength = encodingLength
  NetworkStatusResponse.encode = encode
  NetworkStatusResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (defined(obj.status)) {
      var len = NetworkStatus.encodingLength(obj.status)
      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.status)) {
      buf[offset++] = 10
      varint.encode(NetworkStatus.encodingLength(obj.status), buf, offset)
      offset += varint.encode.bytes
      NetworkStatus.encode(obj.status, buf, offset)
      offset += NetworkStatus.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 = {
      status: 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:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.status = NetworkStatus.decode(buf, offset, offset + len)
        offset += NetworkStatus.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineAllNetworkStatusesResponse () {
  AllNetworkStatusesResponse.encodingLength = encodingLength
  AllNetworkStatusesResponse.encode = encode
  AllNetworkStatusesResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (defined(obj.statuses)) {
      for (var i = 0; i < obj.statuses.length; i++) {
        if (!defined(obj.statuses[i])) continue
        var len = NetworkStatus.encodingLength(obj.statuses[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.statuses)) {
      for (var i = 0; i < obj.statuses.length; i++) {
        if (!defined(obj.statuses[i])) continue
        buf[offset++] = 10
        varint.encode(NetworkStatus.encodingLength(obj.statuses[i]), buf, offset)
        offset += varint.encode.bytes
        NetworkStatus.encode(obj.statuses[i], buf, offset)
        offset += NetworkStatus.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 = {
      statuses: []
    }
    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:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.statuses.push(NetworkStatus.decode(buf, offset, offset + len))
        offset += NetworkStatus.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineRegisterNetworkExtensionRequest () {
  RegisterNetworkExtensionRequest.encodingLength = encodingLength
  RegisterNetworkExtensionRequest.encode = encode
  RegisterNetworkExtensionRequest.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.resourceId)) throw new Error("resourceId is required")
    var len = encodings.varint.encodingLength(obj.resourceId)
    length += 1 + len
    if (!defined(obj.name)) throw new Error("name is required")
    var len = encodings.string.encodingLength(obj.name)
    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.resourceId)) throw new Error("resourceId is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.resourceId, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.name)) throw new Error("name is required")
    buf[offset++] = 18
    encodings.string.encode(obj.name, 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 = {
      resourceId: 0,
      name: ""
    }
    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.resourceId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.name = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        found1 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineNetworkExtensionMessage () {
  NetworkExtensionMessage.encodingLength = encodingLength
  NetworkExtensionMessage.encode = encode
  NetworkExtensionMessage.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.resourceId)) throw new Error("resourceId is required")
    var len = encodings.varint.encodingLength(obj.resourceId)
    length += 1 + len
    if (defined(obj.remotePublicKey)) {
      var len = encodings.bytes.encodingLength(obj.remotePublicKey)
      length += 1 + len
    }
    if (!defined(obj.data)) throw new Error("data is required")
    var len = encodings.bytes.encodingLength(obj.data)
    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.resourceId)) throw new Error("resourceId is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.resourceId, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.remotePublicKey)) {
      buf[offset++] = 26
      encodings.bytes.encode(obj.remotePublicKey, buf, offset)
      offset += encodings.bytes.encode.bytes
    }
    if (!defined(obj.data)) throw new Error("data is required")
    buf[offset++] = 34
    encodings.bytes.encode(obj.data, 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,
      resourceId: 0,
      remotePublicKey: null,
      data: null
    }
    var found0 = false
    var found1 = false
    var found3 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1 || !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.resourceId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.remotePublicKey = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        case 4:
        obj.data = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found3 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineCloseRequest () {
  CloseRequest.encodingLength = encodingLength
  CloseRequest.encode = encode
  CloseRequest.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 defineGetRequest () {
  GetRequest.encodingLength = encodingLength
  GetRequest.encode = encode
  GetRequest.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.resourceId)) throw new Error("resourceId is required")
    var len = encodings.varint.encodingLength(obj.resourceId)
    length += 1 + len
    if (defined(obj.wait)) {
      var len = encodings.bool.encodingLength(obj.wait)
      length += 1 + len
    }
    if (defined(obj.ifAvailable)) {
      var len = encodings.bool.encodingLength(obj.ifAvailable)
      length += 1 + len
    }
    if (defined(obj.onWaitId)) {
      var len = encodings.varint.encodingLength(obj.onWaitId)
      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.resourceId)) throw new Error("resourceId is required")
    buf[offset++] = 24
    encodings.varint.encode(obj.resourceId, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.wait)) {
      buf[offset++] = 32
      encodings.bool.encode(obj.wait, buf, offset)
      offset += encodings.bool.encode.bytes
    }
    if (defined(obj.ifAvailable)) {
      buf[offset++] = 40
      encodings.bool.encode(obj.ifAvailable, buf, offset)
      offset += encodings.bool.encode.bytes
    }
    if (defined(obj.onWaitId)) {
      buf[offset++] = 48
      encodings.varint.encode(obj.onWaitId, 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,
      resourceId: 0,
      wait: true,
      ifAvailable: true,
      onWaitId: 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.resourceId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found2 = true
        break
        case 4:
        obj.wait = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        case 5:
        obj.ifAvailable = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        case 6:
        obj.onWaitId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineGetResponse () {
  GetResponse.encodingLength = encodingLength
  GetResponse.encode = encode
  GetResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (defined(obj.block)) {
      var len = encodings.bytes.encodingLength(obj.block)
      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.block)) {
      buf[offset++] = 10
      encodings.bytes.encode(obj.block, 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 = {
      block: 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.block = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineAppendRequest () {
  AppendRequest.encodingLength = encodingLength
  AppendRequest.encode = encode
  AppendRequest.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.blocks)) {
      for (var i = 0; i < obj.blocks.length; i++) {
        if (!defined(obj.blocks[i])) continue
        var len = encodings.bytes.encodingLength(obj.blocks[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.blocks)) {
      for (var i = 0; i < obj.blocks.length; i++) {
        if (!defined(obj.blocks[i])) continue
        buf[offset++] = 18
        encodings.bytes.encode(obj.blocks[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,
      blocks: []
    }
    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.blocks.push(encodings.bytes.decode(buf, offset))
        offset += encodings.bytes.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineAppendResponse () {
  AppendResponse.encodingLength = encodingLength
  AppendResponse.encode = encode
  AppendResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.length)) throw new Error("length is required")
    var len = encodings.varint.encodingLength(obj.length)
    length += 1 + len
    if (!defined(obj.byteLength)) throw new Error("byteLength is required")
    var len = encodings.varint.encodingLength(obj.byteLength)
    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.length)) throw new Error("length is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.length, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.byteLength)) throw new Error("byteLength is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.byteLength, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.seq)) throw new Error("seq is required")
    buf[offset++] = 24
    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 = {
      length: 0,
      byteLength: 0,
      seq: 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.length = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.byteLength = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.seq = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found2 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineUpdateRequest () {
  UpdateRequest.encodingLength = encodingLength
  UpdateRequest.encode = encode
  UpdateRequest.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.minLength)) {
      var len = encodings.varint.encodingLength(obj.minLength)
      length += 1 + len
    }
    if (defined(obj.ifAvailable)) {
      var len = encodings.bool.encodingLength(obj.ifAvailable)
      length += 1 + len
    }
    if (defined(obj.hash)) {
      var len = encodings.bool.encodingLength(obj.hash)
      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.minLength)) {
      buf[offset++] = 16
      encodings.varint.encode(obj.minLength, buf, offset)
      offset += encodings.varint.encode.bytes
    }
    if (defined(obj.ifAvailable)) {
      buf[offset++] = 24
      encodings.bool.encode(obj.ifAvailable, buf, offset)
      offset += encodings.bool.encode.bytes
    }
    if (defined(obj.hash)) {
      buf[offset++] = 32
      encodings.bool.encode(obj.hash, 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 = {
      id: 0,
      minLength: 0,
      ifAvailable: true,
      hash: true
    }
    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.minLength = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        break
        case 3:
        obj.ifAvailable = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        case 4:
        obj.hash = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineSeekRequest () {
  SeekRequest.encodingLength = encodingLength
  SeekRequest.encode = encode
  SeekRequest.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.byteOffset)) throw new Error("byteOffset is required")
    var len = encodings.varint.encodingLength(obj.byteOffset)
    length += 1 + len
    if (defined(obj.start)) {
      var len = encodings.varint.encodingLength(obj.start)
      length += 1 + len
    }
    if (defined(obj.end)) {
      var len = encodings.varint.encodingLength(obj.end)
      length += 1 + len
    }
    if (defined(obj.wait)) {
      var len = encodings.bool.encodingLength(obj.wait)
      length += 1 + len
    }
    if (defined(obj.ifAvailable)) {
      var len = encodings.bool.encodingLength(obj.ifAvailable)
      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.byteOffset)) throw new Error("byteOffset is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.byteOffset, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.start)) {
      buf[offset++] = 24
      encodings.varint.encode(obj.start, buf, offset)
      offset += encodings.varint.encode.bytes
    }
    if (defined(obj.end)) {
      buf[offset++] = 32
      encodings.varint.encode(obj.end, buf, offset)
      offset += encodings.varint.encode.bytes
    }
    if (defined(obj.wait)) {
      buf[offset++] = 40
      encodings.bool.encode(obj.wait, buf, offset)
      offset += encodings.bool.encode.bytes
    }
    if (defined(obj.ifAvailable)) {
      buf[offset++] = 48
      encodings.bool.encode(obj.ifAvailable, 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 = {
      id: 0,
      byteOffset: 0,
      start: 0,
      end: 0,
      wait: true,
      ifAvailable: true
    }
    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.byteOffset = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.start = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        break
        case 4:
        obj.end = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        break
        case 5:
        obj.wait = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        case 6:
        obj.ifAvailable = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineSeekResponse () {
  SeekResponse.encodingLength = encodingLength
  SeekResponse.encode = encode
  SeekResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.seq)) throw new Error("seq is required")
    var len = encodings.varint.encodingLength(obj.seq)
    length += 1 + len
    if (!defined(obj.blockOffset)) throw new Error("blockOffset is required")
    var len = encodings.varint.encodingLength(obj.blockOffset)
    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.seq)) throw new Error("seq is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.seq, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.blockOffset)) throw new Error("blockOffset is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.blockOffset, 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 = {
      seq: 0,
      blockOffset: 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.seq = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        case 2:
        obj.blockOffset = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineHasRequest () {
  HasRequest.encodingLength = encodingLength
  HasRequest.encode = encode
  HasRequest.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 defineHasResponse () {
  HasResponse.encodingLength = encodingLength
  HasResponse.encode = encode
  HasResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.has)) throw new Error("has is required")
    var len = encodings.bool.encodingLength(obj.has)
    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.has)) throw new Error("has is required")
    buf[offset++] = 8
    encodings.bool.encode(obj.has, 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 = {
      has: false
    }
    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.has = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        found0 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineCancelRequest () {
  CancelRequest.encodingLength = encodingLength
  CancelRequest.encode = encode
  CancelRequest.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.resourceId)) throw new Error("resourceId is required")
    var len = encodings.varint.encodingLength(obj.resourceId)
    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.resourceId)) throw new Error("resourceId is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.resourceId, 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,
      resourceId: 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.resourceId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineDownloadRequest () {
  DownloadRequest.encodingLength = encodingLength
  DownloadRequest.encode = encode
  DownloadRequest.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.resourceId)) throw new Error("resourceId is required")
    var len = encodings.varint.encodingLength(obj.resourceId)
    length += 1 + len
    if (defined(obj.start)) {
      var len = encodings.varint.encodingLength(obj.start)
      length += 1 + len
    }
    if (defined(obj.end)) {
      var len = encodings.varint.encodingLength(obj.end)
      length += 1 + len
    }
    if (defined(obj.blocks)) {
      for (var i = 0; i < obj.blocks.length; i++) {
        if (!defined(obj.blocks[i])) continue
        var len = encodings.varint.encodingLength(obj.blocks[i])
        length += 1 + len
      }
    }
    if (defined(obj.linear)) {
      var len = encodings.bool.encodingLength(obj.linear)
      length += 1 + len
    }
    if (defined(obj.live)) {
      var len = encodings.bool.encodingLength(obj.live)
      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.resourceId)) throw new Error("resourceId is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.resourceId, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.start)) {
      buf[offset++] = 24
      encodings.varint.encode(obj.start, buf, offset)
      offset += encodings.varint.encode.bytes
    }
    if (defined(obj.end)) {
      buf[offset++] = 32
      encodings.varint.encode(obj.end, buf, offset)
      offset += encodings.varint.encode.bytes
    }
    if (defined(obj.blocks)) {
      for (var i = 0; i < obj.blocks.length; i++) {
        if (!defined(obj.blocks[i])) continue
        buf[offset++] = 40
        encodings.varint.encode(obj.blocks[i], buf, offset)
        offset += encodings.varint.encode.bytes
      }
    }
    if (defined(obj.linear)) {
      buf[offset++] = 48
      encodings.bool.encode(obj.linear, buf, offset)
      offset += encodings.bool.encode.bytes
    }
    if (defined(obj.live)) {
      buf[offset++] = 56
      encodings.bool.encode(obj.live, 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 = {
      id: 0,
      resourceId: 0,
      start: 0,
      end: 0,
      blocks: [],
      linear: false,
      live: false
    }
    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.resourceId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.start = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        break
        case 4:
        obj.end = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        break
        case 5:
        obj.blocks.push(encodings.varint.decode(buf, offset))
        offset += encodings.varint.decode.bytes
        break
        case 6:
        obj.linear = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        case 7:
        obj.live = encodings.bool.decode(buf, offset)
        offset += encodings.bool.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineDownloadedRequest () {
  DownloadedRequest.encodingLength = encodingLength
  DownloadedRequest.encode = encode
  DownloadedRequest.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.start)) {
      var len = encodings.varint.encodingLength(obj.start)
      length += 1 + len
    }
    if (defined(obj.end)) {
      var len = encodings.varint.encodingLength(obj.end)
      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.start)) {
      buf[offset++] = 16
      encodings.varint.encode(obj.start, buf, offset)
      offset += encodings.varint.encode.bytes
    }
    if (defined(obj.end)) {
      buf[offset++] = 24
      encodings.varint.encode(obj.end, 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,
      start: 0,
      end: 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
        case 2:
        obj.start = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        break
        case 3:
        obj.end = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineDownloadedResponse () {
  DownloadedResponse.encodingLength = encodingLength
  DownloadedResponse.encode = encode
  DownloadedResponse.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.bytes)) throw new Error("bytes is required")
    var len = encodings.varint.encodingLength(obj.bytes)
    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.bytes)) throw new Error("bytes is required")
    buf[offset++] = 8
    encodings.varint.encode(obj.bytes, 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 = {
      bytes: 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.bytes = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found0 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineUndownloadRequest () {
  UndownloadRequest.encodingLength = encodingLength
  UndownloadRequest.encode = encode
  UndownloadRequest.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.resourceId)) throw new Error("resourceId is required")
    var len = encodings.varint.encodingLength(obj.resourceId)
    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.resourceId)) throw new Error("resourceId is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.resourceId, 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,
      resourceId: 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.resourceId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineLockRequest () {
  LockRequest.encodingLength = encodingLength
  LockRequest.encode = encode
  LockRequest.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 defineWatchDownloadsRequest () {
  WatchDownloadsRequest.encodingLength = encodingLength
  WatchDownloadsRequest.encode = encode
  WatchDownloadsRequest.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 defineUnwatchDownloadsRequest () {
  UnwatchDownloadsRequest.encodingLength = encodingLength
  UnwatchDownloadsRequest.encode = encode
  UnwatchDownloadsRequest.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 defineWatchUploadsRequest () {
  WatchUploadsRequest.encodingLength = encodingLength
  WatchUploadsRequest.encode = encode
  WatchUploadsRequest.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 defineUnwatchUploadsRequest () {
  UnwatchUploadsRequest.encodingLength = encodingLength
  UnwatchUploadsRequest.encode = encode
  UnwatchUploadsRequest.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 defineAppendEvent () {
  AppendEvent.encodingLength = encodingLength
  AppendEvent.encode = encode
  AppendEvent.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.length)) throw new Error("length is required")
    var len = encodings.varint.encodingLength(obj.length)
    length += 1 + len
    if (!defined(obj.byteLength)) throw new Error("byteLength is required")
    var len = encodings.varint.encodingLength(obj.byteLength)
    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.length)) throw new Error("length is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.length, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.byteLength)) throw new Error("byteLength is required")
    buf[offset++] = 24
    encodings.varint.encode(obj.byteLength, 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,
      length: 0,
      byteLength: 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.length = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.byteLength = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found2 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function definePeerEvent () {
  PeerEvent.encodingLength = encodingLength
  PeerEvent.encode = encode
  PeerEvent.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.peer)) throw new Error("peer is required")
    var len = Peer.encodingLength(obj.peer)
    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.peer)) throw new Error("peer is required")
    buf[offset++] = 18
    varint.encode(Peer.encodingLength(obj.peer), buf, offset)
    offset += varint.encode.bytes
    Peer.encode(obj.peer, buf, offset)
    offset += Peer.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,
      peer: 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:
        var len = varint.decode(buf, offset)
        offset += varint.decode.bytes
        obj.peer = Peer.decode(buf, offset, offset + len)
        offset += Peer.decode.bytes
        found1 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineCloseEvent () {
  CloseEvent.encodingLength = encodingLength
  CloseEvent.encode = encode
  CloseEvent.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 defineWaitEvent () {
  WaitEvent.encodingLength = encodingLength
  WaitEvent.encode = encode
  WaitEvent.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.onWaitId)) throw new Error("onWaitId is required")
    var len = encodings.varint.encodingLength(obj.onWaitId)
    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.onWaitId)) throw new Error("onWaitId is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.onWaitId, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.seq)) throw new Error("seq is required")
    buf[offset++] = 24
    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,
      onWaitId: 0,
      seq: 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.onWaitId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.seq = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found2 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineDownloadEvent () {
  DownloadEvent.encodingLength = encodingLength
  DownloadEvent.encode = encode
  DownloadEvent.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.byteLength)) {
      var len = encodings.varint.encodingLength(obj.byteLength)
      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.byteLength)) {
      buf[offset++] = 24
      encodings.varint.encode(obj.byteLength, 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,
      byteLength: 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
        case 3:
        obj.byteLength = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineUploadEvent () {
  UploadEvent.encodingLength = encodingLength
  UploadEvent.encode = encode
  UploadEvent.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.byteLength)) throw new Error("byteLength is required")
    var len = encodings.varint.encodingLength(obj.byteLength)
    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.byteLength)) throw new Error("byteLength is required")
    buf[offset++] = 24
    encodings.varint.encode(obj.byteLength, 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,
      byteLength: 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.byteLength = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found2 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineRegisterExtensionRequest () {
  RegisterExtensionRequest.encodingLength = encodingLength
  RegisterExtensionRequest.encode = encode
  RegisterExtensionRequest.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.resourceId)) throw new Error("resourceId is required")
    var len = encodings.varint.encodingLength(obj.resourceId)
    length += 1 + len
    if (!defined(obj.name)) throw new Error("name is required")
    var len = encodings.string.encodingLength(obj.name)
    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.resourceId)) throw new Error("resourceId is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.resourceId, buf, offset)
    offset += encodings.varint.encode.bytes
    if (!defined(obj.name)) throw new Error("name is required")
    buf[offset++] = 26
    encodings.string.encode(obj.name, 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,
      resourceId: 0,
      name: ""
    }
    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.resourceId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.name = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        found2 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineUnregisterExtensionRequest () {
  UnregisterExtensionRequest.encodingLength = encodingLength
  UnregisterExtensionRequest.encode = encode
  UnregisterExtensionRequest.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.resourceId)) throw new Error("resourceId is required")
    var len = encodings.varint.encodingLength(obj.resourceId)
    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.resourceId)) throw new Error("resourceId is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.resourceId, 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,
      resourceId: 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.resourceId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineExtensionMessage () {
  ExtensionMessage.encodingLength = encodingLength
  ExtensionMessage.encode = encode
  ExtensionMessage.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.resourceId)) throw new Error("resourceId is required")
    var len = encodings.varint.encodingLength(obj.resourceId)
    length += 1 + len
    if (defined(obj.remotePublicKey)) {
      var len = encodings.bytes.encodingLength(obj.remotePublicKey)
      length += 1 + len
    }
    if (!defined(obj.data)) throw new Error("data is required")
    var len = encodings.bytes.encodingLength(obj.data)
    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.resourceId)) throw new Error("resourceId is required")
    buf[offset++] = 16
    encodings.varint.encode(obj.resourceId, buf, offset)
    offset += encodings.varint.encode.bytes
    if (defined(obj.remotePublicKey)) {
      buf[offset++] = 26
      encodings.bytes.encode(obj.remotePublicKey, buf, offset)
      offset += encodings.bytes.encode.bytes
    }
    if (!defined(obj.data)) throw new Error("data is required")
    buf[offset++] = 34
    encodings.bytes.encode(obj.data, 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,
      resourceId: 0,
      remotePublicKey: null,
      data: null
    }
    var found0 = false
    var found1 = false
    var found3 = false
    while (true) {
      if (end <= offset) {
        if (!found0 || !found1 || !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.resourceId = encodings.varint.decode(buf, offset)
        offset += encodings.varint.decode.bytes
        found1 = true
        break
        case 3:
        obj.remotePublicKey = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        break
        case 4:
        obj.data = encodings.bytes.decode(buf, offset)
        offset += encodings.bytes.decode.bytes
        found3 = true
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

function defineRPCError () {
  RPCError.encodingLength = encodingLength
  RPCError.encode = encode
  RPCError.decode = decode

  function encodingLength (obj) {
    var length = 0
    if (!defined(obj.message)) throw new Error("message is required")
    var len = encodings.string.encodingLength(obj.message)
    length += 1 + len
    if (defined(obj.code)) {
      var len = encodings.string.encodingLength(obj.code)
      length += 1 + len
    }
    if (defined(obj.errno)) {
      var len = encodings.int32.encodingLength(obj.errno)
      length += 1 + len
    }
    if (defined(obj.details)) {
      var len = encodings.string.encodingLength(obj.details)
      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.message)) throw new Error("message is required")
    buf[offset++] = 10
    encodings.string.encode(obj.message, buf, offset)
    offset += encodings.string.encode.bytes
    if (defined(obj.code)) {
      buf[offset++] = 18
      encodings.string.encode(obj.code, buf, offset)
      offset += encodings.string.encode.bytes
    }
    if (defined(obj.errno)) {
      buf[offset++] = 24
      encodings.int32.encode(obj.errno, buf, offset)
      offset += encodings.int32.encode.bytes
    }
    if (defined(obj.details)) {
      buf[offset++] = 34
      encodings.string.encode(obj.details, 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 = {
      message: "",
      code: "",
      errno: 0,
      details: ""
    }
    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.message = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        found0 = true
        break
        case 2:
        obj.code = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        break
        case 3:
        obj.errno = encodings.int32.decode(buf, offset)
        offset += encodings.int32.decode.bytes
        break
        case 4:
        obj.details = encodings.string.decode(buf, offset)
        offset += encodings.string.decode.bytes
        break
        default:
        offset = skip(prefix & 7, buf, offset)
      }
    }
  }
}

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