// This file is autogenerated by the hyperschema compiler
// Schema Version: 2
/* eslint-disable camelcase */
/* eslint-disable quotes */
/* eslint-disable space-before-function-paren */

import { c } from 'hyperschema/runtime'

const VERSION = 2

// eslint-disable-next-line no-unused-vars
let version = VERSION

// @peardata/node
const encoding0 = {
  preencode(state, m) {
    c.string.preencode(state, m.nodeId)
    c.string.preencode(state, m.hostname)
    state.end++ // max flag is 64 so always one byte

    if (m.publicKeyHex) c.string.preencode(state, m.publicKeyHex)
    if (m.platform) c.string.preencode(state, m.platform)
    if (m.arch) c.string.preencode(state, m.arch)
    if (m.cpus) c.uint.preencode(state, m.cpus)
    if (m.totalMemMiB) c.uint.preencode(state, m.totalMemMiB)
    if (m.agentVersion) c.string.preencode(state, m.agentVersion)
    if (m.labelsJson) c.string.preencode(state, m.labelsJson)
    c.uint.preencode(state, m.updatedAt)
  },
  encode(state, m) {
    const flags =
      (m.publicKeyHex ? 1 : 0) |
      (m.platform ? 2 : 0) |
      (m.arch ? 4 : 0) |
      (m.cpus ? 8 : 0) |
      (m.totalMemMiB ? 16 : 0) |
      (m.agentVersion ? 32 : 0) |
      (m.labelsJson ? 64 : 0)

    c.string.encode(state, m.nodeId)
    c.string.encode(state, m.hostname)
    c.uint.encode(state, flags)

    if (m.publicKeyHex) c.string.encode(state, m.publicKeyHex)
    if (m.platform) c.string.encode(state, m.platform)
    if (m.arch) c.string.encode(state, m.arch)
    if (m.cpus) c.uint.encode(state, m.cpus)
    if (m.totalMemMiB) c.uint.encode(state, m.totalMemMiB)
    if (m.agentVersion) c.string.encode(state, m.agentVersion)
    if (m.labelsJson) c.string.encode(state, m.labelsJson)
    c.uint.encode(state, m.updatedAt)
  },
  decode(state) {
    const r0 = c.string.decode(state)
    const r1 = c.string.decode(state)
    const flags = c.uint.decode(state)

    return {
      nodeId: r0,
      hostname: r1,
      publicKeyHex: (flags & 1) !== 0 ? c.string.decode(state) : null,
      platform: (flags & 2) !== 0 ? c.string.decode(state) : null,
      arch: (flags & 4) !== 0 ? c.string.decode(state) : null,
      cpus: (flags & 8) !== 0 ? c.uint.decode(state) : 0,
      totalMemMiB: (flags & 16) !== 0 ? c.uint.decode(state) : 0,
      agentVersion: (flags & 32) !== 0 ? c.string.decode(state) : null,
      labelsJson: (flags & 64) !== 0 ? c.string.decode(state) : null,
      updatedAt: c.uint.decode(state)
    }
  }
}

// @peardata/peer-link
const encoding1 = {
  preencode(state, m) {
    c.string.preencode(state, m.localNodeId)
    c.string.preencode(state, m.remotePublicKey)
    state.end++ // max flag is 32 so always one byte

    if (m.role) c.string.preencode(state, m.role)
    if (m.alias) c.string.preencode(state, m.alias)
    if (m.dbKeyHex) c.string.preencode(state, m.dbKeyHex)
    if (m.syncMode) c.string.preencode(state, m.syncMode)
    c.uint.preencode(state, m.linkedAt)
    if (m.lastSeen) c.uint.preencode(state, m.lastSeen)
    if (version >= 2 && m.discoveryKeyHex) c.string.preencode(state, m.discoveryKeyHex)
  },
  encode(state, m) {
    const flags =
      (m.role ? 1 : 0) |
      (m.alias ? 2 : 0) |
      (m.dbKeyHex ? 4 : 0) |
      (m.syncMode ? 8 : 0) |
      (m.lastSeen ? 16 : 0) |
      ((version >= 2 && m.discoveryKeyHex) ? 32 : 0)

    c.string.encode(state, m.localNodeId)
    c.string.encode(state, m.remotePublicKey)
    c.uint.encode(state, flags)

    if (m.role) c.string.encode(state, m.role)
    if (m.alias) c.string.encode(state, m.alias)
    if (m.dbKeyHex) c.string.encode(state, m.dbKeyHex)
    if (m.syncMode) c.string.encode(state, m.syncMode)
    c.uint.encode(state, m.linkedAt)
    if (m.lastSeen) c.uint.encode(state, m.lastSeen)
    if (version >= 2 && m.discoveryKeyHex) c.string.encode(state, m.discoveryKeyHex)
  },
  decode(state) {
    const r0 = c.string.decode(state)
    const r1 = c.string.decode(state)
    const flags = c.uint.decode(state)

    return {
      localNodeId: r0,
      remotePublicKey: r1,
      role: (flags & 1) !== 0 ? c.string.decode(state) : null,
      alias: (flags & 2) !== 0 ? c.string.decode(state) : null,
      dbKeyHex: (flags & 4) !== 0 ? c.string.decode(state) : null,
      syncMode: (flags & 8) !== 0 ? c.string.decode(state) : null,
      linkedAt: c.uint.decode(state),
      lastSeen: (flags & 16) !== 0 ? c.uint.decode(state) : 0,
      discoveryKeyHex: (version >= 2 && (flags & 32) !== 0) ? c.string.decode(state) : null
    }
  }
}

// @peardata/alert-config
const encoding2 = {
  preencode(state, m) {
    c.string.preencode(state, m.id)
    c.string.preencode(state, m.chart)
    c.string.preencode(state, m.dimension)
    state.end++ // max flag is 16 so always one byte

    if (m.warn) c.float64.preencode(state, m.warn)
    if (m.crit) c.float64.preencode(state, m.crit)
    if (m.comparator) c.string.preencode(state, m.comparator)
    if (m.info) c.string.preencode(state, m.info)
    c.uint.preencode(state, m.updatedAt)
  },
  encode(state, m) {
    const flags =
      (m.warn ? 1 : 0) |
      (m.crit ? 2 : 0) |
      (m.comparator ? 4 : 0) |
      (m.enabled ? 8 : 0) |
      (m.info ? 16 : 0)

    c.string.encode(state, m.id)
    c.string.encode(state, m.chart)
    c.string.encode(state, m.dimension)
    c.uint.encode(state, flags)

    if (m.warn) c.float64.encode(state, m.warn)
    if (m.crit) c.float64.encode(state, m.crit)
    if (m.comparator) c.string.encode(state, m.comparator)
    if (m.info) c.string.encode(state, m.info)
    c.uint.encode(state, m.updatedAt)
  },
  decode(state) {
    const r0 = c.string.decode(state)
    const r1 = c.string.decode(state)
    const r2 = c.string.decode(state)
    const flags = c.uint.decode(state)

    return {
      id: r0,
      chart: r1,
      dimension: r2,
      warn: (flags & 1) !== 0 ? c.float64.decode(state) : 0,
      crit: (flags & 2) !== 0 ? c.float64.decode(state) : 0,
      comparator: (flags & 4) !== 0 ? c.string.decode(state) : null,
      enabled: (flags & 8) !== 0,
      info: (flags & 16) !== 0 ? c.string.decode(state) : null,
      updatedAt: c.uint.decode(state)
    }
  }
}

// @peardata/alert-event
const encoding3 = {
  preencode(state, m) {
    c.string.preencode(state, m.id)
    c.uint.preencode(state, m.ts)
    c.string.preencode(state, m.chart)
    state.end++ // max flag is 16 so always one byte

    if (m.dimension) c.string.preencode(state, m.dimension)
    c.string.preencode(state, m.severity)
    if (m.value) c.float64.preencode(state, m.value)
    if (m.threshold) c.float64.preencode(state, m.threshold)
    if (m.message) c.string.preencode(state, m.message)
  },
  encode(state, m) {
    const flags =
      (m.dimension ? 1 : 0) |
      (m.value ? 2 : 0) |
      (m.threshold ? 4 : 0) |
      (m.message ? 8 : 0) |
      (m.cleared ? 16 : 0)

    c.string.encode(state, m.id)
    c.uint.encode(state, m.ts)
    c.string.encode(state, m.chart)
    c.uint.encode(state, flags)

    if (m.dimension) c.string.encode(state, m.dimension)
    c.string.encode(state, m.severity)
    if (m.value) c.float64.encode(state, m.value)
    if (m.threshold) c.float64.encode(state, m.threshold)
    if (m.message) c.string.encode(state, m.message)
  },
  decode(state) {
    const r0 = c.string.decode(state)
    const r1 = c.uint.decode(state)
    const r2 = c.string.decode(state)
    const flags = c.uint.decode(state)

    return {
      id: r0,
      ts: r1,
      chart: r2,
      dimension: (flags & 1) !== 0 ? c.string.decode(state) : null,
      severity: c.string.decode(state),
      value: (flags & 2) !== 0 ? c.float64.decode(state) : 0,
      threshold: (flags & 4) !== 0 ? c.float64.decode(state) : 0,
      message: (flags & 8) !== 0 ? c.string.decode(state) : null,
      cleared: (flags & 16) !== 0
    }
  }
}

// @peardata/metric-point
const encoding4 = {
  preencode(state, m) {
    c.string.preencode(state, m.chart)
    c.uint.preencode(state, m.ts)
    c.string.preencode(state, m.context)
    c.uint.preencode(state, m.tier)
    c.string.preencode(state, m.valuesJson)
  },
  encode(state, m) {
    c.string.encode(state, m.chart)
    c.uint.encode(state, m.ts)
    c.string.encode(state, m.context)
    c.uint.encode(state, m.tier)
    c.string.encode(state, m.valuesJson)
  },
  decode(state) {
    const r0 = c.string.decode(state)
    const r1 = c.uint.decode(state)
    const r2 = c.string.decode(state)
    const r3 = c.uint.decode(state)
    const r4 = c.string.decode(state)

    return {
      chart: r0,
      ts: r1,
      context: r2,
      tier: r3,
      valuesJson: r4
    }
  }
}

// @peardata/job
const encoding5 = {
  preencode(state, m) {
    c.string.preencode(state, m.id)
    c.string.preencode(state, m.name)
    c.string.preencode(state, m.status)
    state.end++ // max flag is 8 so always one byte

    if (m.startedAt) c.uint.preencode(state, m.startedAt)
    if (m.finishedAt) c.uint.preencode(state, m.finishedAt)
    if (m.resultJson) c.string.preencode(state, m.resultJson)
    if (m.error) c.string.preencode(state, m.error)
  },
  encode(state, m) {
    const flags =
      (m.startedAt ? 1 : 0) | (m.finishedAt ? 2 : 0) | (m.resultJson ? 4 : 0) | (m.error ? 8 : 0)

    c.string.encode(state, m.id)
    c.string.encode(state, m.name)
    c.string.encode(state, m.status)
    c.uint.encode(state, flags)

    if (m.startedAt) c.uint.encode(state, m.startedAt)
    if (m.finishedAt) c.uint.encode(state, m.finishedAt)
    if (m.resultJson) c.string.encode(state, m.resultJson)
    if (m.error) c.string.encode(state, m.error)
  },
  decode(state) {
    const r0 = c.string.decode(state)
    const r1 = c.string.decode(state)
    const r2 = c.string.decode(state)
    const flags = c.uint.decode(state)

    return {
      id: r0,
      name: r1,
      status: r2,
      startedAt: (flags & 1) !== 0 ? c.uint.decode(state) : 0,
      finishedAt: (flags & 2) !== 0 ? c.uint.decode(state) : 0,
      resultJson: (flags & 4) !== 0 ? c.string.decode(state) : null,
      error: (flags & 8) !== 0 ? c.string.decode(state) : null
    }
  }
}

// @peardata/node/hyperdb#0
const encoding6 = {
  preencode(state, m) {
    c.string.preencode(state, m.hostname)
    state.end++ // max flag is 64 so always one byte

    if (m.publicKeyHex) c.string.preencode(state, m.publicKeyHex)
    if (m.platform) c.string.preencode(state, m.platform)
    if (m.arch) c.string.preencode(state, m.arch)
    if (m.cpus) c.uint.preencode(state, m.cpus)
    if (m.totalMemMiB) c.uint.preencode(state, m.totalMemMiB)
    if (m.agentVersion) c.string.preencode(state, m.agentVersion)
    if (m.labelsJson) c.string.preencode(state, m.labelsJson)
    c.uint.preencode(state, m.updatedAt)
  },
  encode(state, m) {
    const flags =
      (m.publicKeyHex ? 1 : 0) |
      (m.platform ? 2 : 0) |
      (m.arch ? 4 : 0) |
      (m.cpus ? 8 : 0) |
      (m.totalMemMiB ? 16 : 0) |
      (m.agentVersion ? 32 : 0) |
      (m.labelsJson ? 64 : 0)

    c.string.encode(state, m.hostname)
    c.uint.encode(state, flags)

    if (m.publicKeyHex) c.string.encode(state, m.publicKeyHex)
    if (m.platform) c.string.encode(state, m.platform)
    if (m.arch) c.string.encode(state, m.arch)
    if (m.cpus) c.uint.encode(state, m.cpus)
    if (m.totalMemMiB) c.uint.encode(state, m.totalMemMiB)
    if (m.agentVersion) c.string.encode(state, m.agentVersion)
    if (m.labelsJson) c.string.encode(state, m.labelsJson)
    c.uint.encode(state, m.updatedAt)
  },
  decode(state) {
    const r1 = c.string.decode(state)
    const flags = c.uint.decode(state)

    return {
      nodeId: null,
      hostname: r1,
      publicKeyHex: (flags & 1) !== 0 ? c.string.decode(state) : null,
      platform: (flags & 2) !== 0 ? c.string.decode(state) : null,
      arch: (flags & 4) !== 0 ? c.string.decode(state) : null,
      cpus: (flags & 8) !== 0 ? c.uint.decode(state) : 0,
      totalMemMiB: (flags & 16) !== 0 ? c.uint.decode(state) : 0,
      agentVersion: (flags & 32) !== 0 ? c.string.decode(state) : null,
      labelsJson: (flags & 64) !== 0 ? c.string.decode(state) : null,
      updatedAt: c.uint.decode(state)
    }
  }
}

// @peardata/peer-link/hyperdb#1
const encoding7 = {
  preencode(state, m) {
    state.end++ // max flag is 32 so always one byte

    if (m.role) c.string.preencode(state, m.role)
    if (m.alias) c.string.preencode(state, m.alias)
    if (m.dbKeyHex) c.string.preencode(state, m.dbKeyHex)
    if (m.syncMode) c.string.preencode(state, m.syncMode)
    c.uint.preencode(state, m.linkedAt)
    if (m.lastSeen) c.uint.preencode(state, m.lastSeen)
    if (version >= 2 && m.discoveryKeyHex) c.string.preencode(state, m.discoveryKeyHex)
  },
  encode(state, m) {
    const flags =
      (m.role ? 1 : 0) |
      (m.alias ? 2 : 0) |
      (m.dbKeyHex ? 4 : 0) |
      (m.syncMode ? 8 : 0) |
      (m.lastSeen ? 16 : 0) |
      ((version >= 2 && m.discoveryKeyHex) ? 32 : 0)

    c.uint.encode(state, flags)

    if (m.role) c.string.encode(state, m.role)
    if (m.alias) c.string.encode(state, m.alias)
    if (m.dbKeyHex) c.string.encode(state, m.dbKeyHex)
    if (m.syncMode) c.string.encode(state, m.syncMode)
    c.uint.encode(state, m.linkedAt)
    if (m.lastSeen) c.uint.encode(state, m.lastSeen)
    if (version >= 2 && m.discoveryKeyHex) c.string.encode(state, m.discoveryKeyHex)
  },
  decode(state) {
    const flags = c.uint.decode(state)

    return {
      localNodeId: null,
      remotePublicKey: null,
      role: (flags & 1) !== 0 ? c.string.decode(state) : null,
      alias: (flags & 2) !== 0 ? c.string.decode(state) : null,
      dbKeyHex: (flags & 4) !== 0 ? c.string.decode(state) : null,
      syncMode: (flags & 8) !== 0 ? c.string.decode(state) : null,
      linkedAt: c.uint.decode(state),
      lastSeen: (flags & 16) !== 0 ? c.uint.decode(state) : 0,
      discoveryKeyHex: (version >= 2 && (flags & 32) !== 0) ? c.string.decode(state) : null
    }
  }
}

// @peardata/alert-config/hyperdb#2
const encoding8 = {
  preencode(state, m) {
    c.string.preencode(state, m.chart)
    c.string.preencode(state, m.dimension)
    state.end++ // max flag is 16 so always one byte

    if (m.warn) c.float64.preencode(state, m.warn)
    if (m.crit) c.float64.preencode(state, m.crit)
    if (m.comparator) c.string.preencode(state, m.comparator)
    if (m.info) c.string.preencode(state, m.info)
    c.uint.preencode(state, m.updatedAt)
  },
  encode(state, m) {
    const flags =
      (m.warn ? 1 : 0) |
      (m.crit ? 2 : 0) |
      (m.comparator ? 4 : 0) |
      (m.enabled ? 8 : 0) |
      (m.info ? 16 : 0)

    c.string.encode(state, m.chart)
    c.string.encode(state, m.dimension)
    c.uint.encode(state, flags)

    if (m.warn) c.float64.encode(state, m.warn)
    if (m.crit) c.float64.encode(state, m.crit)
    if (m.comparator) c.string.encode(state, m.comparator)
    if (m.info) c.string.encode(state, m.info)
    c.uint.encode(state, m.updatedAt)
  },
  decode(state) {
    const r1 = c.string.decode(state)
    const r2 = c.string.decode(state)
    const flags = c.uint.decode(state)

    return {
      id: null,
      chart: r1,
      dimension: r2,
      warn: (flags & 1) !== 0 ? c.float64.decode(state) : 0,
      crit: (flags & 2) !== 0 ? c.float64.decode(state) : 0,
      comparator: (flags & 4) !== 0 ? c.string.decode(state) : null,
      enabled: (flags & 8) !== 0,
      info: (flags & 16) !== 0 ? c.string.decode(state) : null,
      updatedAt: c.uint.decode(state)
    }
  }
}

// @peardata/alert-event/hyperdb#3
const encoding9 = {
  preencode(state, m) {
    c.string.preencode(state, m.chart)
    state.end++ // max flag is 16 so always one byte

    if (m.dimension) c.string.preencode(state, m.dimension)
    c.string.preencode(state, m.severity)
    if (m.value) c.float64.preencode(state, m.value)
    if (m.threshold) c.float64.preencode(state, m.threshold)
    if (m.message) c.string.preencode(state, m.message)
  },
  encode(state, m) {
    const flags =
      (m.dimension ? 1 : 0) |
      (m.value ? 2 : 0) |
      (m.threshold ? 4 : 0) |
      (m.message ? 8 : 0) |
      (m.cleared ? 16 : 0)

    c.string.encode(state, m.chart)
    c.uint.encode(state, flags)

    if (m.dimension) c.string.encode(state, m.dimension)
    c.string.encode(state, m.severity)
    if (m.value) c.float64.encode(state, m.value)
    if (m.threshold) c.float64.encode(state, m.threshold)
    if (m.message) c.string.encode(state, m.message)
  },
  decode(state) {
    const r2 = c.string.decode(state)
    const flags = c.uint.decode(state)

    return {
      id: null,
      ts: 0,
      chart: r2,
      dimension: (flags & 1) !== 0 ? c.string.decode(state) : null,
      severity: c.string.decode(state),
      value: (flags & 2) !== 0 ? c.float64.decode(state) : 0,
      threshold: (flags & 4) !== 0 ? c.float64.decode(state) : 0,
      message: (flags & 8) !== 0 ? c.string.decode(state) : null,
      cleared: (flags & 16) !== 0
    }
  }
}

// @peardata/metric-point/hyperdb#4
const encoding10 = {
  preencode(state, m) {
    c.string.preencode(state, m.context)
    c.uint.preencode(state, m.tier)
    c.string.preencode(state, m.valuesJson)
  },
  encode(state, m) {
    c.string.encode(state, m.context)
    c.uint.encode(state, m.tier)
    c.string.encode(state, m.valuesJson)
  },
  decode(state) {
    const r2 = c.string.decode(state)
    const r3 = c.uint.decode(state)
    const r4 = c.string.decode(state)

    return {
      chart: null,
      ts: 0,
      context: r2,
      tier: r3,
      valuesJson: r4
    }
  }
}

// @peardata/job/hyperdb#5
const encoding11 = {
  preencode(state, m) {
    c.string.preencode(state, m.name)
    c.string.preencode(state, m.status)
    state.end++ // max flag is 8 so always one byte

    if (m.startedAt) c.uint.preencode(state, m.startedAt)
    if (m.finishedAt) c.uint.preencode(state, m.finishedAt)
    if (m.resultJson) c.string.preencode(state, m.resultJson)
    if (m.error) c.string.preencode(state, m.error)
  },
  encode(state, m) {
    const flags =
      (m.startedAt ? 1 : 0) | (m.finishedAt ? 2 : 0) | (m.resultJson ? 4 : 0) | (m.error ? 8 : 0)

    c.string.encode(state, m.name)
    c.string.encode(state, m.status)
    c.uint.encode(state, flags)

    if (m.startedAt) c.uint.encode(state, m.startedAt)
    if (m.finishedAt) c.uint.encode(state, m.finishedAt)
    if (m.resultJson) c.string.encode(state, m.resultJson)
    if (m.error) c.string.encode(state, m.error)
  },
  decode(state) {
    const r1 = c.string.decode(state)
    const r2 = c.string.decode(state)
    const flags = c.uint.decode(state)

    return {
      id: null,
      name: r1,
      status: r2,
      startedAt: (flags & 1) !== 0 ? c.uint.decode(state) : 0,
      finishedAt: (flags & 2) !== 0 ? c.uint.decode(state) : 0,
      resultJson: (flags & 4) !== 0 ? c.string.decode(state) : null,
      error: (flags & 8) !== 0 ? c.string.decode(state) : null
    }
  }
}

function setVersion(v) {
  version = v
}

function encode(name, value, v = VERSION) {
  version = v
  return c.encode(getEncoding(name), value)
}

function decode(name, buffer, v = VERSION) {
  version = v
  return c.decode(getEncoding(name), buffer)
}

function getEnum(name) {
  switch (name) {
    default:
      throw new Error('Enum not found ' + name)
  }
}

function getEncoding(name) {
  switch (name) {
    case '@peardata/node':
      return encoding0
    case '@peardata/peer-link':
      return encoding1
    case '@peardata/alert-config':
      return encoding2
    case '@peardata/alert-event':
      return encoding3
    case '@peardata/metric-point':
      return encoding4
    case '@peardata/job':
      return encoding5
    case '@peardata/node/hyperdb#0':
      return encoding6
    case '@peardata/peer-link/hyperdb#1':
      return encoding7
    case '@peardata/alert-config/hyperdb#2':
      return encoding8
    case '@peardata/alert-event/hyperdb#3':
      return encoding9
    case '@peardata/metric-point/hyperdb#4':
      return encoding10
    case '@peardata/job/hyperdb#5':
      return encoding11
    default:
      throw new Error('Encoder not found ' + name)
  }
}

function getStruct(name, v = VERSION) {
  const enc = getEncoding(name)
  return {
    preencode(state, m) {
      version = v
      enc.preencode(state, m)
    },
    encode(state, m) {
      version = v
      enc.encode(state, m)
    },
    decode(state) {
      version = v
      return enc.decode(state)
    }
  }
}

const resolveStruct = getStruct // compat

export { resolveStruct, getStruct, getEnum, getEncoding, encode, decode, setVersion, version }