api.pb.go

// Code generated by protoc-gen-gogo.
// source: github.com/TheThingsNetwork/ttn/api/api.proto
// DO NOT EDIT!

/*
	Package api is a generated protocol buffer package.

	It is generated from these files:
		github.com/TheThingsNetwork/ttn/api/api.proto

	It has these top-level messages:
		Percentiles
		Rates
		SystemStats
		ComponentStats
*/
package api

import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package

type Percentiles struct {
	Percentile1  float32 `protobuf:"fixed32,1,opt,name=percentile1,proto3" json:"percentile1,omitempty"`
	Percentile5  float32 `protobuf:"fixed32,2,opt,name=percentile5,proto3" json:"percentile5,omitempty"`
	Percentile10 float32 `protobuf:"fixed32,3,opt,name=percentile10,proto3" json:"percentile10,omitempty"`
	Percentile25 float32 `protobuf:"fixed32,4,opt,name=percentile25,proto3" json:"percentile25,omitempty"`
	Percentile50 float32 `protobuf:"fixed32,5,opt,name=percentile50,proto3" json:"percentile50,omitempty"`
	Percentile75 float32 `protobuf:"fixed32,6,opt,name=percentile75,proto3" json:"percentile75,omitempty"`
	Percentile90 float32 `protobuf:"fixed32,7,opt,name=percentile90,proto3" json:"percentile90,omitempty"`
	Percentile95 float32 `protobuf:"fixed32,8,opt,name=percentile95,proto3" json:"percentile95,omitempty"`
	Percentile99 float32 `protobuf:"fixed32,9,opt,name=percentile99,proto3" json:"percentile99,omitempty"`
}

func (m *Percentiles) Reset()                    { *m = Percentiles{} }
func (m *Percentiles) String() string            { return proto.CompactTextString(m) }
func (*Percentiles) ProtoMessage()               {}
func (*Percentiles) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{0} }

type Rates struct {
	Rate1  float32 `protobuf:"fixed32,1,opt,name=rate1,proto3" json:"rate1,omitempty"`
	Rate5  float32 `protobuf:"fixed32,2,opt,name=rate5,proto3" json:"rate5,omitempty"`
	Rate15 float32 `protobuf:"fixed32,3,opt,name=rate15,proto3" json:"rate15,omitempty"`
}

func (m *Rates) Reset()                    { *m = Rates{} }
func (m *Rates) String() string            { return proto.CompactTextString(m) }
func (*Rates) ProtoMessage()               {}
func (*Rates) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{1} }

type SystemStats struct {
	Load   *SystemStats_Loadstats   `protobuf:"bytes,1,opt,name=load" json:"load,omitempty"`
	Cpu    *SystemStats_CPUStats    `protobuf:"bytes,2,opt,name=cpu" json:"cpu,omitempty"`
	Memory *SystemStats_MemoryStats `protobuf:"bytes,3,opt,name=memory" json:"memory,omitempty"`
}

func (m *SystemStats) Reset()                    { *m = SystemStats{} }
func (m *SystemStats) String() string            { return proto.CompactTextString(m) }
func (*SystemStats) ProtoMessage()               {}
func (*SystemStats) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{2} }

func (m *SystemStats) GetLoad() *SystemStats_Loadstats {
	if m != nil {
		return m.Load
	}
	return nil
}

func (m *SystemStats) GetCpu() *SystemStats_CPUStats {
	if m != nil {
		return m.Cpu
	}
	return nil
}

func (m *SystemStats) GetMemory() *SystemStats_MemoryStats {
	if m != nil {
		return m.Memory
	}
	return nil
}

type SystemStats_Loadstats struct {
	Load1  float32 `protobuf:"fixed32,1,opt,name=load1,proto3" json:"load1,omitempty"`
	Load5  float32 `protobuf:"fixed32,2,opt,name=load5,proto3" json:"load5,omitempty"`
	Load15 float32 `protobuf:"fixed32,3,opt,name=load15,proto3" json:"load15,omitempty"`
}

func (m *SystemStats_Loadstats) Reset()                    { *m = SystemStats_Loadstats{} }
func (m *SystemStats_Loadstats) String() string            { return proto.CompactTextString(m) }
func (*SystemStats_Loadstats) ProtoMessage()               {}
func (*SystemStats_Loadstats) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{2, 0} }

type SystemStats_CPUStats struct {
	User   float32 `protobuf:"fixed32,1,opt,name=user,proto3" json:"user,omitempty"`
	System float32 `protobuf:"fixed32,2,opt,name=system,proto3" json:"system,omitempty"`
	Idle   float32 `protobuf:"fixed32,3,opt,name=idle,proto3" json:"idle,omitempty"`
}

func (m *SystemStats_CPUStats) Reset()                    { *m = SystemStats_CPUStats{} }
func (m *SystemStats_CPUStats) String() string            { return proto.CompactTextString(m) }
func (*SystemStats_CPUStats) ProtoMessage()               {}
func (*SystemStats_CPUStats) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{2, 1} }

type SystemStats_MemoryStats struct {
	Total     uint64 `protobuf:"varint,1,opt,name=total,proto3" json:"total,omitempty"`
	Available uint64 `protobuf:"varint,2,opt,name=available,proto3" json:"available,omitempty"`
	Used      uint64 `protobuf:"varint,3,opt,name=used,proto3" json:"used,omitempty"`
}

func (m *SystemStats_MemoryStats) Reset()                    { *m = SystemStats_MemoryStats{} }
func (m *SystemStats_MemoryStats) String() string            { return proto.CompactTextString(m) }
func (*SystemStats_MemoryStats) ProtoMessage()               {}
func (*SystemStats_MemoryStats) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{2, 2} }

type ComponentStats struct {
	Cpu           *ComponentStats_CPUStats    `protobuf:"bytes,1,opt,name=cpu" json:"cpu,omitempty"`
	Memory        *ComponentStats_MemoryStats `protobuf:"bytes,3,opt,name=memory" json:"memory,omitempty"`
	Goroutines    uint64                      `protobuf:"varint,4,opt,name=goroutines,proto3" json:"goroutines,omitempty"`
	GcCpuFraction float32                     `protobuf:"fixed32,5,opt,name=gc_cpu_fraction,json=gcCpuFraction,proto3" json:"gc_cpu_fraction,omitempty"`
}

func (m *ComponentStats) Reset()                    { *m = ComponentStats{} }
func (m *ComponentStats) String() string            { return proto.CompactTextString(m) }
func (*ComponentStats) ProtoMessage()               {}
func (*ComponentStats) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{3} }

func (m *ComponentStats) GetCpu() *ComponentStats_CPUStats {
	if m != nil {
		return m.Cpu
	}
	return nil
}

func (m *ComponentStats) GetMemory() *ComponentStats_MemoryStats {
	if m != nil {
		return m.Memory
	}
	return nil
}

type ComponentStats_CPUStats struct {
	User   float32 `protobuf:"fixed32,1,opt,name=user,proto3" json:"user,omitempty"`
	System float32 `protobuf:"fixed32,2,opt,name=system,proto3" json:"system,omitempty"`
	Idle   float32 `protobuf:"fixed32,3,opt,name=idle,proto3" json:"idle,omitempty"`
}

func (m *ComponentStats_CPUStats) Reset()                    { *m = ComponentStats_CPUStats{} }
func (m *ComponentStats_CPUStats) String() string            { return proto.CompactTextString(m) }
func (*ComponentStats_CPUStats) ProtoMessage()               {}
func (*ComponentStats_CPUStats) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{3, 0} }

type ComponentStats_MemoryStats struct {
	Memory uint64 `protobuf:"varint,1,opt,name=memory,proto3" json:"memory,omitempty"`
	Swap   uint64 `protobuf:"varint,2,opt,name=swap,proto3" json:"swap,omitempty"`
}

func (m *ComponentStats_MemoryStats) Reset()                    { *m = ComponentStats_MemoryStats{} }
func (m *ComponentStats_MemoryStats) String() string            { return proto.CompactTextString(m) }
func (*ComponentStats_MemoryStats) ProtoMessage()               {}
func (*ComponentStats_MemoryStats) Descriptor() ([]byte, []int) { return fileDescriptorApi, []int{3, 1} }

func init() {
	proto.RegisterType((*Percentiles)(nil), "api.Percentiles")
	proto.RegisterType((*Rates)(nil), "api.Rates")
	proto.RegisterType((*SystemStats)(nil), "api.SystemStats")
	proto.RegisterType((*SystemStats_Loadstats)(nil), "api.SystemStats.Loadstats")
	proto.RegisterType((*SystemStats_CPUStats)(nil), "api.SystemStats.CPUStats")
	proto.RegisterType((*SystemStats_MemoryStats)(nil), "api.SystemStats.MemoryStats")
	proto.RegisterType((*ComponentStats)(nil), "api.ComponentStats")
	proto.RegisterType((*ComponentStats_CPUStats)(nil), "api.ComponentStats.CPUStats")
	proto.RegisterType((*ComponentStats_MemoryStats)(nil), "api.ComponentStats.MemoryStats")
}
func (m *Percentiles) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Percentiles) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Percentile1 != 0 {
		dAtA[i] = 0xd
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Percentile1))))
	}
	if m.Percentile5 != 0 {
		dAtA[i] = 0x15
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Percentile5))))
	}
	if m.Percentile10 != 0 {
		dAtA[i] = 0x1d
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Percentile10))))
	}
	if m.Percentile25 != 0 {
		dAtA[i] = 0x25
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Percentile25))))
	}
	if m.Percentile50 != 0 {
		dAtA[i] = 0x2d
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Percentile50))))
	}
	if m.Percentile75 != 0 {
		dAtA[i] = 0x35
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Percentile75))))
	}
	if m.Percentile90 != 0 {
		dAtA[i] = 0x3d
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Percentile90))))
	}
	if m.Percentile95 != 0 {
		dAtA[i] = 0x45
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Percentile95))))
	}
	if m.Percentile99 != 0 {
		dAtA[i] = 0x4d
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Percentile99))))
	}
	return i, nil
}

func (m *Rates) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *Rates) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Rate1 != 0 {
		dAtA[i] = 0xd
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Rate1))))
	}
	if m.Rate5 != 0 {
		dAtA[i] = 0x15
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Rate5))))
	}
	if m.Rate15 != 0 {
		dAtA[i] = 0x1d
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Rate15))))
	}
	return i, nil
}

func (m *SystemStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SystemStats) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Load != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Load.Size()))
		n1, err := m.Load.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.Cpu != nil {
		dAtA[i] = 0x12
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Cpu.Size()))
		n2, err := m.Cpu.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.Memory != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Memory.Size()))
		n3, err := m.Memory.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	return i, nil
}

func (m *SystemStats_Loadstats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SystemStats_Loadstats) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Load1 != 0 {
		dAtA[i] = 0xd
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Load1))))
	}
	if m.Load5 != 0 {
		dAtA[i] = 0x15
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Load5))))
	}
	if m.Load15 != 0 {
		dAtA[i] = 0x1d
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Load15))))
	}
	return i, nil
}

func (m *SystemStats_CPUStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SystemStats_CPUStats) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.User != 0 {
		dAtA[i] = 0xd
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.User))))
	}
	if m.System != 0 {
		dAtA[i] = 0x15
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.System))))
	}
	if m.Idle != 0 {
		dAtA[i] = 0x1d
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Idle))))
	}
	return i, nil
}

func (m *SystemStats_MemoryStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *SystemStats_MemoryStats) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Total != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Total))
	}
	if m.Available != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Available))
	}
	if m.Used != 0 {
		dAtA[i] = 0x18
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Used))
	}
	return i, nil
}

func (m *ComponentStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ComponentStats) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Cpu != nil {
		dAtA[i] = 0xa
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Cpu.Size()))
		n4, err := m.Cpu.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.Memory != nil {
		dAtA[i] = 0x1a
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Memory.Size()))
		n5, err := m.Memory.MarshalTo(dAtA[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.Goroutines != 0 {
		dAtA[i] = 0x20
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Goroutines))
	}
	if m.GcCpuFraction != 0 {
		dAtA[i] = 0x2d
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.GcCpuFraction))))
	}
	return i, nil
}

func (m *ComponentStats_CPUStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ComponentStats_CPUStats) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.User != 0 {
		dAtA[i] = 0xd
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.User))))
	}
	if m.System != 0 {
		dAtA[i] = 0x15
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.System))))
	}
	if m.Idle != 0 {
		dAtA[i] = 0x1d
		i++
		i = encodeFixed32Api(dAtA, i, uint32(math.Float32bits(float32(m.Idle))))
	}
	return i, nil
}

func (m *ComponentStats_MemoryStats) Marshal() (dAtA []byte, err error) {
	size := m.Size()
	dAtA = make([]byte, size)
	n, err := m.MarshalTo(dAtA)
	if err != nil {
		return nil, err
	}
	return dAtA[:n], nil
}

func (m *ComponentStats_MemoryStats) MarshalTo(dAtA []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Memory != 0 {
		dAtA[i] = 0x8
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Memory))
	}
	if m.Swap != 0 {
		dAtA[i] = 0x10
		i++
		i = encodeVarintApi(dAtA, i, uint64(m.Swap))
	}
	return i, nil
}

func encodeFixed64Api(dAtA []byte, offset int, v uint64) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	dAtA[offset+4] = uint8(v >> 32)
	dAtA[offset+5] = uint8(v >> 40)
	dAtA[offset+6] = uint8(v >> 48)
	dAtA[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Api(dAtA []byte, offset int, v uint32) int {
	dAtA[offset] = uint8(v)
	dAtA[offset+1] = uint8(v >> 8)
	dAtA[offset+2] = uint8(v >> 16)
	dAtA[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintApi(dAtA []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return offset + 1
}
func (m *Percentiles) Size() (n int) {
	var l int
	_ = l
	if m.Percentile1 != 0 {
		n += 5
	}
	if m.Percentile5 != 0 {
		n += 5
	}
	if m.Percentile10 != 0 {
		n += 5
	}
	if m.Percentile25 != 0 {
		n += 5
	}
	if m.Percentile50 != 0 {
		n += 5
	}
	if m.Percentile75 != 0 {
		n += 5
	}
	if m.Percentile90 != 0 {
		n += 5
	}
	if m.Percentile95 != 0 {
		n += 5
	}
	if m.Percentile99 != 0 {
		n += 5
	}
	return n
}

func (m *Rates) Size() (n int) {
	var l int
	_ = l
	if m.Rate1 != 0 {
		n += 5
	}
	if m.Rate5 != 0 {
		n += 5
	}
	if m.Rate15 != 0 {
		n += 5
	}
	return n
}

func (m *SystemStats) Size() (n int) {
	var l int
	_ = l
	if m.Load != nil {
		l = m.Load.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Cpu != nil {
		l = m.Cpu.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Memory != nil {
		l = m.Memory.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	return n
}

func (m *SystemStats_Loadstats) Size() (n int) {
	var l int
	_ = l
	if m.Load1 != 0 {
		n += 5
	}
	if m.Load5 != 0 {
		n += 5
	}
	if m.Load15 != 0 {
		n += 5
	}
	return n
}

func (m *SystemStats_CPUStats) Size() (n int) {
	var l int
	_ = l
	if m.User != 0 {
		n += 5
	}
	if m.System != 0 {
		n += 5
	}
	if m.Idle != 0 {
		n += 5
	}
	return n
}

func (m *SystemStats_MemoryStats) Size() (n int) {
	var l int
	_ = l
	if m.Total != 0 {
		n += 1 + sovApi(uint64(m.Total))
	}
	if m.Available != 0 {
		n += 1 + sovApi(uint64(m.Available))
	}
	if m.Used != 0 {
		n += 1 + sovApi(uint64(m.Used))
	}
	return n
}

func (m *ComponentStats) Size() (n int) {
	var l int
	_ = l
	if m.Cpu != nil {
		l = m.Cpu.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Memory != nil {
		l = m.Memory.Size()
		n += 1 + l + sovApi(uint64(l))
	}
	if m.Goroutines != 0 {
		n += 1 + sovApi(uint64(m.Goroutines))
	}
	if m.GcCpuFraction != 0 {
		n += 5
	}
	return n
}

func (m *ComponentStats_CPUStats) Size() (n int) {
	var l int
	_ = l
	if m.User != 0 {
		n += 5
	}
	if m.System != 0 {
		n += 5
	}
	if m.Idle != 0 {
		n += 5
	}
	return n
}

func (m *ComponentStats_MemoryStats) Size() (n int) {
	var l int
	_ = l
	if m.Memory != 0 {
		n += 1 + sovApi(uint64(m.Memory))
	}
	if m.Swap != 0 {
		n += 1 + sovApi(uint64(m.Swap))
	}
	return n
}

func sovApi(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozApi(x uint64) (n int) {
	return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Percentiles) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Percentiles: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Percentiles: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile1", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Percentile1 = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile5", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Percentile5 = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile10", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Percentile10 = float32(math.Float32frombits(v))
		case 4:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile25", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Percentile25 = float32(math.Float32frombits(v))
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile50", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Percentile50 = float32(math.Float32frombits(v))
		case 6:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile75", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Percentile75 = float32(math.Float32frombits(v))
		case 7:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile90", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Percentile90 = float32(math.Float32frombits(v))
		case 8:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile95", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Percentile95 = float32(math.Float32frombits(v))
		case 9:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Percentile99", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Percentile99 = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Rates) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Rates: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Rates: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rate1", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Rate1 = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rate5", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Rate5 = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Rate15", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Rate15 = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SystemStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SystemStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SystemStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Load == nil {
				m.Load = &SystemStats_Loadstats{}
			}
			if err := m.Load.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cpu", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cpu == nil {
				m.Cpu = &SystemStats_CPUStats{}
			}
			if err := m.Cpu.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Memory == nil {
				m.Memory = &SystemStats_MemoryStats{}
			}
			if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SystemStats_Loadstats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Loadstats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Loadstats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load1", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Load1 = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load5", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Load5 = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Load15", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Load15 = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SystemStats_CPUStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CPUStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CPUStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.User = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field System", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.System = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Idle", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Idle = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *SystemStats_MemoryStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MemoryStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MemoryStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Total", wireType)
			}
			m.Total = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Total |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Available", wireType)
			}
			m.Available = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Available |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Used", wireType)
			}
			m.Used = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Used |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ComponentStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ComponentStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ComponentStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cpu", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Cpu == nil {
				m.Cpu = &ComponentStats_CPUStats{}
			}
			if err := m.Cpu.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthApi
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Memory == nil {
				m.Memory = &ComponentStats_MemoryStats{}
			}
			if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Goroutines", wireType)
			}
			m.Goroutines = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Goroutines |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field GcCpuFraction", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.GcCpuFraction = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ComponentStats_CPUStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: CPUStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CPUStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.User = float32(math.Float32frombits(v))
		case 2:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field System", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.System = float32(math.Float32frombits(v))
		case 3:
			if wireType != 5 {
				return fmt.Errorf("proto: wrong wireType = %d for field Idle", wireType)
			}
			var v uint32
			if (iNdEx + 4) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += 4
			v = uint32(dAtA[iNdEx-4])
			v |= uint32(dAtA[iNdEx-3]) << 8
			v |= uint32(dAtA[iNdEx-2]) << 16
			v |= uint32(dAtA[iNdEx-1]) << 24
			m.Idle = float32(math.Float32frombits(v))
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ComponentStats_MemoryStats) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowApi
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: MemoryStats: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MemoryStats: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType)
			}
			m.Memory = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Memory |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType)
			}
			m.Swap = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowApi
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Swap |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipApi(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthApi
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipApi(dAtA []byte) (n int, err error) {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowApi
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if dAtA[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowApi
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthApi
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowApi
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipApi(dAtA[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowApi   = fmt.Errorf("proto: integer overflow")
)

func init() { proto.RegisterFile("github.com/TheThingsNetwork/ttn/api/api.proto", fileDescriptorApi) }

var fileDescriptorApi = []byte{
	// 536 bytes of a gzipped FileDescriptorProto
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xac, 0x94, 0x5d, 0x8b, 0xd3, 0x4e,
	0x14, 0xc6, 0xff, 0x69, 0xd3, 0xfe, 0xb7, 0x27, 0xbe, 0xc0, 0x20, 0x4b, 0x2c, 0x4b, 0x5d, 0x2a,
	0x88, 0x20, 0xb6, 0xb5, 0x1a, 0x4a, 0x6e, 0x2d, 0x78, 0xe1, 0xeb, 0x92, 0xdd, 0xbd, 0xf1, 0x66,
	0x99, 0xa6, 0x63, 0x1b, 0x4c, 0x32, 0x21, 0x33, 0x71, 0xd9, 0xef, 0xe1, 0x85, 0x1f, 0x69, 0x6f,
	0x04, 0x3f, 0x82, 0xd4, 0x2f, 0x22, 0x73, 0x32, 0x89, 0xc9, 0x74, 0x2f, 0xbc, 0xf0, 0x22, 0x30,
	0xcf, 0x99, 0xdf, 0x3c, 0x73, 0xce, 0x13, 0x12, 0x78, 0xba, 0x89, 0xe4, 0xb6, 0x58, 0x4d, 0x42,
	0x9e, 0x4c, 0xcf, 0xb6, 0xec, 0x6c, 0x1b, 0xa5, 0x1b, 0xf1, 0x9e, 0xc9, 0x4b, 0x9e, 0x7f, 0x9e,
	0x4a, 0x99, 0x4e, 0x69, 0x16, 0xa9, 0x67, 0x92, 0xe5, 0x5c, 0x72, 0xd2, 0xa5, 0x59, 0x34, 0xfe,
	0xde, 0x01, 0xe7, 0x84, 0xe5, 0x21, 0x4b, 0x65, 0x14, 0x33, 0x41, 0x8e, 0xc1, 0xc9, 0x6a, 0xf9,
	0xcc, 0xb5, 0x8e, 0xad, 0xc7, 0x9d, 0xa0, 0x59, 0x6a, 0x13, 0x9e, 0xdb, 0x31, 0x09, 0x8f, 0x8c,
	0xe1, 0x56, 0xe3, 0xc0, 0xcc, 0xed, 0x22, 0xd2, 0xaa, 0xb5, 0x99, 0xb9, 0xe7, 0xda, 0x26, 0x33,
	0x37, 0x7c, 0xbc, 0x99, 0xdb, 0x33, 0x19, 0xcf, 0xf0, 0x59, 0x78, 0x6e, 0xdf, 0x64, 0x16, 0x86,
	0x8f, 0x3f, 0x73, 0xff, 0x37, 0x19, 0xdf, 0xf0, 0xf1, 0x3d, 0xf7, 0x60, 0x8f, 0x31, 0x7d, 0x7c,
	0x77, 0xb0, 0xc7, 0xf8, 0xe3, 0x37, 0xd0, 0x0b, 0xa8, 0x64, 0x82, 0xdc, 0x83, 0x5e, 0x4e, 0x65,
	0x1d, 0x61, 0x29, 0xaa, 0x6a, 0x15, 0x5b, 0x29, 0xc8, 0x21, 0xf4, 0x71, 0xdb, 0xd3, 0x51, 0x69,
	0x35, 0xfe, 0xda, 0x05, 0xe7, 0xf4, 0x4a, 0x48, 0x96, 0x9c, 0x4a, 0x2a, 0x05, 0x99, 0x80, 0x1d,
	0x73, 0xba, 0x46, 0x4b, 0x67, 0x3e, 0x9c, 0xa8, 0x77, 0xd9, 0xd8, 0x9f, 0xbc, 0xe5, 0x74, 0x2d,
	0xd4, 0x2a, 0x40, 0x8e, 0x3c, 0x81, 0x6e, 0x98, 0x15, 0x78, 0x97, 0x33, 0xbf, 0xbf, 0x87, 0x2f,
	0x4f, 0xce, 0x71, 0x11, 0x28, 0x8a, 0xbc, 0x80, 0x7e, 0xc2, 0x12, 0x9e, 0x5f, 0x61, 0x13, 0xce,
	0xfc, 0x68, 0x8f, 0x7f, 0x87, 0xdb, 0xe5, 0x11, 0xcd, 0x0e, 0x3f, 0xc0, 0xa0, 0xbe, 0x55, 0x4d,
	0xa7, 0xee, 0xad, 0x67, 0x46, 0x51, 0x55, 0xeb, 0x99, 0x51, 0xa8, 0x99, 0x71, 0xbb, 0x9e, 0xb9,
	0x54, 0xc3, 0xd7, 0x70, 0x50, 0xf5, 0x45, 0x08, 0xd8, 0x85, 0x60, 0xb9, 0xb6, 0xc3, 0xb5, 0x3a,
	0x27, 0xb0, 0x27, 0x6d, 0xa7, 0x95, 0x62, 0xa3, 0x75, 0xcc, 0xb4, 0x1b, 0xae, 0x87, 0xe7, 0xe0,
	0x34, 0x7a, 0x56, 0x8d, 0x48, 0x2e, 0x69, 0x8c, 0x7e, 0x76, 0x50, 0x0a, 0x72, 0x04, 0x03, 0xfa,
	0x85, 0x46, 0x31, 0x5d, 0xc5, 0x0c, 0x3d, 0xed, 0xe0, 0x4f, 0x41, 0xb7, 0xb0, 0x46, 0x5b, 0x1b,
	0x5b, 0x58, 0x8f, 0xaf, 0x3b, 0x70, 0x67, 0xc9, 0x93, 0x8c, 0xa7, 0x2c, 0x95, 0xd5, 0x9b, 0xc1,
	0xa4, 0xad, 0x46, 0x72, 0x6d, 0xc2, 0x08, 0x7b, 0x61, 0x84, 0xfd, 0xe0, 0xa6, 0x23, 0x37, 0xe4,
	0x4d, 0x46, 0x00, 0x1b, 0x9e, 0xf3, 0x42, 0x46, 0x29, 0x13, 0xf8, 0xd5, 0xd8, 0x41, 0xa3, 0x42,
	0x1e, 0xc1, 0xdd, 0x4d, 0x78, 0x11, 0x66, 0xc5, 0xc5, 0xa7, 0x9c, 0x86, 0x32, 0xe2, 0xa9, 0xfe,
	0x6c, 0x6e, 0x6f, 0xc2, 0x65, 0x56, 0xbc, 0xd2, 0xc5, 0x7f, 0x1a, 0xb3, 0xdf, 0x8e, 0xf9, 0xb0,
	0x9e, 0xad, 0xcc, 0xb9, 0x6a, 0x9d, 0x80, 0x2d, 0x2e, 0x69, 0xa6, 0x33, 0xc6, 0xf5, 0x4b, 0xef,
	0x7a, 0x37, 0xb2, 0x7e, 0xec, 0x46, 0xd6, 0xcf, 0xdd, 0xc8, 0xfa, 0xf6, 0x6b, 0xf4, 0xdf, 0xc7,
	0x87, 0x7f, 0xf1, 0x13, 0x5b, 0xf5, 0xf1, 0x0f, 0xf6, 0xfc, 0x77, 0x00, 0x00, 0x00, 0xff, 0xff,
	0x9d, 0xbc, 0x69, 0xcf, 0xf2, 0x04, 0x00, 0x00,
}