info-v4-resources_gen.go

package madmin

// Code generated by github.com/tinylib/msgp DO NOT EDIT.

import (
	"github.com/tinylib/msgp/msgp"
)

// DecodeMsg implements msgp.Decodable
func (z *ClusterResource) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 3 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "m":
			z.Mode, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Mode")
				return
			}
		case "d":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Domains")
				return
			}
			if cap(z.Domains) >= int(zb0002) {
				z.Domains = (z.Domains)[:zb0002]
			} else {
				z.Domains = make([]string, zb0002)
			}
			for za0001 := range z.Domains {
				z.Domains[za0001], err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Domains", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "r":
			z.Region, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Region")
				return
			}
			zb0001Mask |= 0x2
		case "di":
			z.DeploymentID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "DeploymentID")
				return
			}
		case "pc":
			z.PoolCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolCount")
				return
			}
		case "pl":
			var zb0003 uint32
			zb0003, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "PoolsLayout")
				return
			}
			if cap(z.PoolsLayout) >= int(zb0003) {
				z.PoolsLayout = (z.PoolsLayout)[:zb0003]
			} else {
				z.PoolsLayout = make([]PoolLayout, zb0003)
			}
			for za0002 := range z.PoolsLayout {
				err = z.PoolsLayout[za0002].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "PoolsLayout", za0002)
					return
				}
			}
			zb0001Mask |= 0x4
		case "nc":
			z.NodeCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "NodeCount")
				return
			}
		case "dc":
			z.DriveCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DriveCount")
				return
			}
		case "sc":
			z.SetCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "SetCount")
				return
			}
		case "bc":
			z.BucketCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "BucketCount")
				return
			}
		case "oc":
			z.ObjectCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "ObjectCount")
				return
			}
		case "vc":
			z.VersionCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "VersionCount")
				return
			}
		case "dmc":
			z.DeleteMarkerCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarkerCount")
				return
			}
		case "ts":
			z.TotalSize, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "TotalSize")
				return
			}
		case "od":
			z.OnlineDrives, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "OnlineDrives")
				return
			}
		case "fd":
			z.OfflineDrives, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "OfflineDrives")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if zb0001Mask != 0x7 {
		if (zb0001Mask & 0x1) == 0 {
			z.Domains = nil
		}
		if (zb0001Mask & 0x2) == 0 {
			z.Region = ""
		}
		if (zb0001Mask & 0x4) == 0 {
			z.PoolsLayout = nil
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *ClusterResource) EncodeMsg(en *msgp.Writer) (err error) {
	// check for omitted fields
	zb0001Len := uint32(16)
	var zb0001Mask uint16 /* 16 bits */
	_ = zb0001Mask
	if z.Domains == nil {
		zb0001Len--
		zb0001Mask |= 0x2
	}
	if z.Region == "" {
		zb0001Len--
		zb0001Mask |= 0x4
	}
	if z.PoolsLayout == nil {
		zb0001Len--
		zb0001Mask |= 0x20
	}
	// variable map header, size zb0001Len
	err = en.WriteMapHeader(zb0001Len)
	if err != nil {
		return
	}

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// write "m"
		err = en.Append(0xa1, 0x6d)
		if err != nil {
			return
		}
		err = en.WriteString(z.Mode)
		if err != nil {
			err = msgp.WrapError(err, "Mode")
			return
		}
		if (zb0001Mask & 0x2) == 0 { // if not omitted
			// write "d"
			err = en.Append(0xa1, 0x64)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Domains)))
			if err != nil {
				err = msgp.WrapError(err, "Domains")
				return
			}
			for za0001 := range z.Domains {
				err = en.WriteString(z.Domains[za0001])
				if err != nil {
					err = msgp.WrapError(err, "Domains", za0001)
					return
				}
			}
		}
		if (zb0001Mask & 0x4) == 0 { // if not omitted
			// write "r"
			err = en.Append(0xa1, 0x72)
			if err != nil {
				return
			}
			err = en.WriteString(z.Region)
			if err != nil {
				err = msgp.WrapError(err, "Region")
				return
			}
		}
		// write "di"
		err = en.Append(0xa2, 0x64, 0x69)
		if err != nil {
			return
		}
		err = en.WriteString(z.DeploymentID)
		if err != nil {
			err = msgp.WrapError(err, "DeploymentID")
			return
		}
		// write "pc"
		err = en.Append(0xa2, 0x70, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.PoolCount)
		if err != nil {
			err = msgp.WrapError(err, "PoolCount")
			return
		}
		if (zb0001Mask & 0x20) == 0 { // if not omitted
			// write "pl"
			err = en.Append(0xa2, 0x70, 0x6c)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.PoolsLayout)))
			if err != nil {
				err = msgp.WrapError(err, "PoolsLayout")
				return
			}
			for za0002 := range z.PoolsLayout {
				err = z.PoolsLayout[za0002].EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "PoolsLayout", za0002)
					return
				}
			}
		}
		// write "nc"
		err = en.Append(0xa2, 0x6e, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.NodeCount)
		if err != nil {
			err = msgp.WrapError(err, "NodeCount")
			return
		}
		// write "dc"
		err = en.Append(0xa2, 0x64, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.DriveCount)
		if err != nil {
			err = msgp.WrapError(err, "DriveCount")
			return
		}
		// write "sc"
		err = en.Append(0xa2, 0x73, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.SetCount)
		if err != nil {
			err = msgp.WrapError(err, "SetCount")
			return
		}
		// write "bc"
		err = en.Append(0xa2, 0x62, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.BucketCount)
		if err != nil {
			err = msgp.WrapError(err, "BucketCount")
			return
		}
		// write "oc"
		err = en.Append(0xa2, 0x6f, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.ObjectCount)
		if err != nil {
			err = msgp.WrapError(err, "ObjectCount")
			return
		}
		// write "vc"
		err = en.Append(0xa2, 0x76, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.VersionCount)
		if err != nil {
			err = msgp.WrapError(err, "VersionCount")
			return
		}
		// write "dmc"
		err = en.Append(0xa3, 0x64, 0x6d, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.DeleteMarkerCount)
		if err != nil {
			err = msgp.WrapError(err, "DeleteMarkerCount")
			return
		}
		// write "ts"
		err = en.Append(0xa2, 0x74, 0x73)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.TotalSize)
		if err != nil {
			err = msgp.WrapError(err, "TotalSize")
			return
		}
		// write "od"
		err = en.Append(0xa2, 0x6f, 0x64)
		if err != nil {
			return
		}
		err = en.WriteInt(z.OnlineDrives)
		if err != nil {
			err = msgp.WrapError(err, "OnlineDrives")
			return
		}
		// write "fd"
		err = en.Append(0xa2, 0x66, 0x64)
		if err != nil {
			return
		}
		err = en.WriteInt(z.OfflineDrives)
		if err != nil {
			err = msgp.WrapError(err, "OfflineDrives")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ClusterResource) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// check for omitted fields
	zb0001Len := uint32(16)
	var zb0001Mask uint16 /* 16 bits */
	_ = zb0001Mask
	if z.Domains == nil {
		zb0001Len--
		zb0001Mask |= 0x2
	}
	if z.Region == "" {
		zb0001Len--
		zb0001Mask |= 0x4
	}
	if z.PoolsLayout == nil {
		zb0001Len--
		zb0001Mask |= 0x20
	}
	// variable map header, size zb0001Len
	o = msgp.AppendMapHeader(o, zb0001Len)

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// string "m"
		o = append(o, 0xa1, 0x6d)
		o = msgp.AppendString(o, z.Mode)
		if (zb0001Mask & 0x2) == 0 { // if not omitted
			// string "d"
			o = append(o, 0xa1, 0x64)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Domains)))
			for za0001 := range z.Domains {
				o = msgp.AppendString(o, z.Domains[za0001])
			}
		}
		if (zb0001Mask & 0x4) == 0 { // if not omitted
			// string "r"
			o = append(o, 0xa1, 0x72)
			o = msgp.AppendString(o, z.Region)
		}
		// string "di"
		o = append(o, 0xa2, 0x64, 0x69)
		o = msgp.AppendString(o, z.DeploymentID)
		// string "pc"
		o = append(o, 0xa2, 0x70, 0x63)
		o = msgp.AppendInt(o, z.PoolCount)
		if (zb0001Mask & 0x20) == 0 { // if not omitted
			// string "pl"
			o = append(o, 0xa2, 0x70, 0x6c)
			o = msgp.AppendArrayHeader(o, uint32(len(z.PoolsLayout)))
			for za0002 := range z.PoolsLayout {
				o, err = z.PoolsLayout[za0002].MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "PoolsLayout", za0002)
					return
				}
			}
		}
		// string "nc"
		o = append(o, 0xa2, 0x6e, 0x63)
		o = msgp.AppendInt(o, z.NodeCount)
		// string "dc"
		o = append(o, 0xa2, 0x64, 0x63)
		o = msgp.AppendInt(o, z.DriveCount)
		// string "sc"
		o = append(o, 0xa2, 0x73, 0x63)
		o = msgp.AppendInt(o, z.SetCount)
		// string "bc"
		o = append(o, 0xa2, 0x62, 0x63)
		o = msgp.AppendInt(o, z.BucketCount)
		// string "oc"
		o = append(o, 0xa2, 0x6f, 0x63)
		o = msgp.AppendInt(o, z.ObjectCount)
		// string "vc"
		o = append(o, 0xa2, 0x76, 0x63)
		o = msgp.AppendInt(o, z.VersionCount)
		// string "dmc"
		o = append(o, 0xa3, 0x64, 0x6d, 0x63)
		o = msgp.AppendInt(o, z.DeleteMarkerCount)
		// string "ts"
		o = append(o, 0xa2, 0x74, 0x73)
		o = msgp.AppendUint64(o, z.TotalSize)
		// string "od"
		o = append(o, 0xa2, 0x6f, 0x64)
		o = msgp.AppendInt(o, z.OnlineDrives)
		// string "fd"
		o = append(o, 0xa2, 0x66, 0x64)
		o = msgp.AppendInt(o, z.OfflineDrives)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ClusterResource) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 3 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "m":
			z.Mode, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Mode")
				return
			}
		case "d":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Domains")
				return
			}
			if cap(z.Domains) >= int(zb0002) {
				z.Domains = (z.Domains)[:zb0002]
			} else {
				z.Domains = make([]string, zb0002)
			}
			for za0001 := range z.Domains {
				z.Domains[za0001], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Domains", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "r":
			z.Region, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Region")
				return
			}
			zb0001Mask |= 0x2
		case "di":
			z.DeploymentID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DeploymentID")
				return
			}
		case "pc":
			z.PoolCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PoolCount")
				return
			}
		case "pl":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PoolsLayout")
				return
			}
			if cap(z.PoolsLayout) >= int(zb0003) {
				z.PoolsLayout = (z.PoolsLayout)[:zb0003]
			} else {
				z.PoolsLayout = make([]PoolLayout, zb0003)
			}
			for za0002 := range z.PoolsLayout {
				bts, err = z.PoolsLayout[za0002].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "PoolsLayout", za0002)
					return
				}
			}
			zb0001Mask |= 0x4
		case "nc":
			z.NodeCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "NodeCount")
				return
			}
		case "dc":
			z.DriveCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DriveCount")
				return
			}
		case "sc":
			z.SetCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "SetCount")
				return
			}
		case "bc":
			z.BucketCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "BucketCount")
				return
			}
		case "oc":
			z.ObjectCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ObjectCount")
				return
			}
		case "vc":
			z.VersionCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "VersionCount")
				return
			}
		case "dmc":
			z.DeleteMarkerCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarkerCount")
				return
			}
		case "ts":
			z.TotalSize, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TotalSize")
				return
			}
		case "od":
			z.OnlineDrives, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "OnlineDrives")
				return
			}
		case "fd":
			z.OfflineDrives, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "OfflineDrives")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if zb0001Mask != 0x7 {
		if (zb0001Mask & 0x1) == 0 {
			z.Domains = nil
		}
		if (zb0001Mask & 0x2) == 0 {
			z.Region = ""
		}
		if (zb0001Mask & 0x4) == 0 {
			z.PoolsLayout = nil
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ClusterResource) Msgsize() (s int) {
	s = 3 + 2 + msgp.StringPrefixSize + len(z.Mode) + 2 + msgp.ArrayHeaderSize
	for za0001 := range z.Domains {
		s += msgp.StringPrefixSize + len(z.Domains[za0001])
	}
	s += 2 + msgp.StringPrefixSize + len(z.Region) + 3 + msgp.StringPrefixSize + len(z.DeploymentID) + 3 + msgp.IntSize + 3 + msgp.ArrayHeaderSize
	for za0002 := range z.PoolsLayout {
		s += z.PoolsLayout[za0002].Msgsize()
	}
	s += 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 4 + msgp.IntSize + 3 + msgp.Uint64Size + 3 + msgp.IntSize + 3 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *DriveCounts) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ok":
			z.Ok, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Ok")
				return
			}
		case "of":
			z.Offline, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Offline")
				return
			}
		case "cr":
			z.Corrupt, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Corrupt")
				return
			}
		case "mi":
			z.Missing, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Missing")
				return
			}
		case "pe":
			z.Permission, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Permission")
				return
			}
		case "fa":
			z.Faulty, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Faulty")
				return
			}
		case "ro":
			z.RootMount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "RootMount")
				return
			}
		case "un":
			z.Unknown, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Unknown")
				return
			}
		case "uf":
			z.Unformatted, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Unformatted")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *DriveCounts) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 9
	// write "ok"
	err = en.Append(0x89, 0xa2, 0x6f, 0x6b)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Ok)
	if err != nil {
		err = msgp.WrapError(err, "Ok")
		return
	}
	// write "of"
	err = en.Append(0xa2, 0x6f, 0x66)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Offline)
	if err != nil {
		err = msgp.WrapError(err, "Offline")
		return
	}
	// write "cr"
	err = en.Append(0xa2, 0x63, 0x72)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Corrupt)
	if err != nil {
		err = msgp.WrapError(err, "Corrupt")
		return
	}
	// write "mi"
	err = en.Append(0xa2, 0x6d, 0x69)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Missing)
	if err != nil {
		err = msgp.WrapError(err, "Missing")
		return
	}
	// write "pe"
	err = en.Append(0xa2, 0x70, 0x65)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Permission)
	if err != nil {
		err = msgp.WrapError(err, "Permission")
		return
	}
	// write "fa"
	err = en.Append(0xa2, 0x66, 0x61)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Faulty)
	if err != nil {
		err = msgp.WrapError(err, "Faulty")
		return
	}
	// write "ro"
	err = en.Append(0xa2, 0x72, 0x6f)
	if err != nil {
		return
	}
	err = en.WriteInt(z.RootMount)
	if err != nil {
		err = msgp.WrapError(err, "RootMount")
		return
	}
	// write "un"
	err = en.Append(0xa2, 0x75, 0x6e)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Unknown)
	if err != nil {
		err = msgp.WrapError(err, "Unknown")
		return
	}
	// write "uf"
	err = en.Append(0xa2, 0x75, 0x66)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Unformatted)
	if err != nil {
		err = msgp.WrapError(err, "Unformatted")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *DriveCounts) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 9
	// string "ok"
	o = append(o, 0x89, 0xa2, 0x6f, 0x6b)
	o = msgp.AppendInt(o, z.Ok)
	// string "of"
	o = append(o, 0xa2, 0x6f, 0x66)
	o = msgp.AppendInt(o, z.Offline)
	// string "cr"
	o = append(o, 0xa2, 0x63, 0x72)
	o = msgp.AppendInt(o, z.Corrupt)
	// string "mi"
	o = append(o, 0xa2, 0x6d, 0x69)
	o = msgp.AppendInt(o, z.Missing)
	// string "pe"
	o = append(o, 0xa2, 0x70, 0x65)
	o = msgp.AppendInt(o, z.Permission)
	// string "fa"
	o = append(o, 0xa2, 0x66, 0x61)
	o = msgp.AppendInt(o, z.Faulty)
	// string "ro"
	o = append(o, 0xa2, 0x72, 0x6f)
	o = msgp.AppendInt(o, z.RootMount)
	// string "un"
	o = append(o, 0xa2, 0x75, 0x6e)
	o = msgp.AppendInt(o, z.Unknown)
	// string "uf"
	o = append(o, 0xa2, 0x75, 0x66)
	o = msgp.AppendInt(o, z.Unformatted)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *DriveCounts) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "ok":
			z.Ok, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Ok")
				return
			}
		case "of":
			z.Offline, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Offline")
				return
			}
		case "cr":
			z.Corrupt, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Corrupt")
				return
			}
		case "mi":
			z.Missing, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Missing")
				return
			}
		case "pe":
			z.Permission, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Permission")
				return
			}
		case "fa":
			z.Faulty, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Faulty")
				return
			}
		case "ro":
			z.RootMount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RootMount")
				return
			}
		case "un":
			z.Unknown, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Unknown")
				return
			}
		case "uf":
			z.Unformatted, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Unformatted")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *DriveCounts) Msgsize() (s int) {
	s = 1 + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *DriveResource) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "i":
			z.ID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "idx":
			z.DriveIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DriveIndex")
				return
			}
		case "sidx":
			z.ServerIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "ServerIndex")
				return
			}
		case "p":
			z.Path, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Path")
				return
			}
		case "ni":
			z.NodeID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "NodeID")
				return
			}
		case "pi":
			z.PoolIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "si":
			z.SetIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "SetIndex")
				return
			}
		case "s":
			z.State, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "State")
				return
			}
		case "h":
			z.Healing, err = dc.ReadBool()
			if err != nil {
				err = msgp.WrapError(err, "Healing")
				return
			}
		case "sz":
			z.Size, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "Size")
				return
			}
		case "u":
			z.Used, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "Used")
				return
			}
		case "a":
			z.Available, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "Available")
				return
			}
		case "uid":
			z.UUID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "UUID")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *DriveResource) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 13
	// write "i"
	err = en.Append(0x8d, 0xa1, 0x69)
	if err != nil {
		return
	}
	err = en.WriteString(z.ID)
	if err != nil {
		err = msgp.WrapError(err, "ID")
		return
	}
	// write "idx"
	err = en.Append(0xa3, 0x69, 0x64, 0x78)
	if err != nil {
		return
	}
	err = en.WriteInt(z.DriveIndex)
	if err != nil {
		err = msgp.WrapError(err, "DriveIndex")
		return
	}
	// write "sidx"
	err = en.Append(0xa4, 0x73, 0x69, 0x64, 0x78)
	if err != nil {
		return
	}
	err = en.WriteInt(z.ServerIndex)
	if err != nil {
		err = msgp.WrapError(err, "ServerIndex")
		return
	}
	// write "p"
	err = en.Append(0xa1, 0x70)
	if err != nil {
		return
	}
	err = en.WriteString(z.Path)
	if err != nil {
		err = msgp.WrapError(err, "Path")
		return
	}
	// write "ni"
	err = en.Append(0xa2, 0x6e, 0x69)
	if err != nil {
		return
	}
	err = en.WriteString(z.NodeID)
	if err != nil {
		err = msgp.WrapError(err, "NodeID")
		return
	}
	// write "pi"
	err = en.Append(0xa2, 0x70, 0x69)
	if err != nil {
		return
	}
	err = en.WriteInt(z.PoolIndex)
	if err != nil {
		err = msgp.WrapError(err, "PoolIndex")
		return
	}
	// write "si"
	err = en.Append(0xa2, 0x73, 0x69)
	if err != nil {
		return
	}
	err = en.WriteInt(z.SetIndex)
	if err != nil {
		err = msgp.WrapError(err, "SetIndex")
		return
	}
	// write "s"
	err = en.Append(0xa1, 0x73)
	if err != nil {
		return
	}
	err = en.WriteString(z.State)
	if err != nil {
		err = msgp.WrapError(err, "State")
		return
	}
	// write "h"
	err = en.Append(0xa1, 0x68)
	if err != nil {
		return
	}
	err = en.WriteBool(z.Healing)
	if err != nil {
		err = msgp.WrapError(err, "Healing")
		return
	}
	// write "sz"
	err = en.Append(0xa2, 0x73, 0x7a)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.Size)
	if err != nil {
		err = msgp.WrapError(err, "Size")
		return
	}
	// write "u"
	err = en.Append(0xa1, 0x75)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.Used)
	if err != nil {
		err = msgp.WrapError(err, "Used")
		return
	}
	// write "a"
	err = en.Append(0xa1, 0x61)
	if err != nil {
		return
	}
	err = en.WriteUint64(z.Available)
	if err != nil {
		err = msgp.WrapError(err, "Available")
		return
	}
	// write "uid"
	err = en.Append(0xa3, 0x75, 0x69, 0x64)
	if err != nil {
		return
	}
	err = en.WriteString(z.UUID)
	if err != nil {
		err = msgp.WrapError(err, "UUID")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *DriveResource) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 13
	// string "i"
	o = append(o, 0x8d, 0xa1, 0x69)
	o = msgp.AppendString(o, z.ID)
	// string "idx"
	o = append(o, 0xa3, 0x69, 0x64, 0x78)
	o = msgp.AppendInt(o, z.DriveIndex)
	// string "sidx"
	o = append(o, 0xa4, 0x73, 0x69, 0x64, 0x78)
	o = msgp.AppendInt(o, z.ServerIndex)
	// string "p"
	o = append(o, 0xa1, 0x70)
	o = msgp.AppendString(o, z.Path)
	// string "ni"
	o = append(o, 0xa2, 0x6e, 0x69)
	o = msgp.AppendString(o, z.NodeID)
	// string "pi"
	o = append(o, 0xa2, 0x70, 0x69)
	o = msgp.AppendInt(o, z.PoolIndex)
	// string "si"
	o = append(o, 0xa2, 0x73, 0x69)
	o = msgp.AppendInt(o, z.SetIndex)
	// string "s"
	o = append(o, 0xa1, 0x73)
	o = msgp.AppendString(o, z.State)
	// string "h"
	o = append(o, 0xa1, 0x68)
	o = msgp.AppendBool(o, z.Healing)
	// string "sz"
	o = append(o, 0xa2, 0x73, 0x7a)
	o = msgp.AppendUint64(o, z.Size)
	// string "u"
	o = append(o, 0xa1, 0x75)
	o = msgp.AppendUint64(o, z.Used)
	// string "a"
	o = append(o, 0xa1, 0x61)
	o = msgp.AppendUint64(o, z.Available)
	// string "uid"
	o = append(o, 0xa3, 0x75, 0x69, 0x64)
	o = msgp.AppendString(o, z.UUID)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *DriveResource) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "i":
			z.ID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ID")
				return
			}
		case "idx":
			z.DriveIndex, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DriveIndex")
				return
			}
		case "sidx":
			z.ServerIndex, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ServerIndex")
				return
			}
		case "p":
			z.Path, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Path")
				return
			}
		case "ni":
			z.NodeID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "NodeID")
				return
			}
		case "pi":
			z.PoolIndex, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "si":
			z.SetIndex, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "SetIndex")
				return
			}
		case "s":
			z.State, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "State")
				return
			}
		case "h":
			z.Healing, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Healing")
				return
			}
		case "sz":
			z.Size, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Size")
				return
			}
		case "u":
			z.Used, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Used")
				return
			}
		case "a":
			z.Available, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Available")
				return
			}
		case "uid":
			z.UUID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "UUID")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *DriveResource) Msgsize() (s int) {
	s = 1 + 2 + msgp.StringPrefixSize + len(z.ID) + 4 + msgp.IntSize + 5 + msgp.IntSize + 2 + msgp.StringPrefixSize + len(z.Path) + 3 + msgp.StringPrefixSize + len(z.NodeID) + 3 + msgp.IntSize + 3 + msgp.IntSize + 2 + msgp.StringPrefixSize + len(z.State) + 2 + msgp.BoolSize + 3 + msgp.Uint64Size + 2 + msgp.Uint64Size + 2 + msgp.Uint64Size + 4 + msgp.StringPrefixSize + len(z.UUID)
	return
}

// DecodeMsg implements msgp.Decodable
func (z *ErasureSetResource) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "pi":
			z.PoolIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "si":
			z.SetIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "SetIndex")
				return
			}
		case "dc":
			z.DriveCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DriveCount")
				return
			}
		case "od":
			z.OfflineDrives, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "OfflineDrives")
				return
			}
		case "ond":
			z.OnlineDrives, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "OnlineDrives")
				return
			}
		case "hd":
			z.HealDisks, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "HealDisks")
				return
			}
		case "rq":
			z.ReadQuorum, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "ReadQuorum")
				return
			}
		case "wq":
			z.WriteQuorum, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "WriteQuorum")
				return
			}
		case "n":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Nodes")
				return
			}
			if cap(z.Nodes) >= int(zb0002) {
				z.Nodes = (z.Nodes)[:zb0002]
			} else {
				z.Nodes = make([]string, zb0002)
			}
			for za0001 := range z.Nodes {
				z.Nodes[za0001], err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Nodes", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "ru":
			z.RawUsage, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "RawUsage")
				return
			}
		case "rc":
			z.RawCapacity, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "RawCapacity")
				return
			}
		case "u":
			z.Usage, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "Usage")
				return
			}
		case "oc":
			z.ObjectsCount, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "ObjectsCount")
				return
			}
		case "vc":
			z.VersionsCount, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "VersionsCount")
				return
			}
		case "dmc":
			z.DeleteMarkersCount, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarkersCount")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Nodes = nil
	}

	return
}

// EncodeMsg implements msgp.Encodable
func (z *ErasureSetResource) EncodeMsg(en *msgp.Writer) (err error) {
	// check for omitted fields
	zb0001Len := uint32(15)
	var zb0001Mask uint16 /* 15 bits */
	_ = zb0001Mask
	if z.Nodes == nil {
		zb0001Len--
		zb0001Mask |= 0x100
	}
	// variable map header, size zb0001Len
	err = en.Append(0x80 | uint8(zb0001Len))
	if err != nil {
		return
	}

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// write "pi"
		err = en.Append(0xa2, 0x70, 0x69)
		if err != nil {
			return
		}
		err = en.WriteInt(z.PoolIndex)
		if err != nil {
			err = msgp.WrapError(err, "PoolIndex")
			return
		}
		// write "si"
		err = en.Append(0xa2, 0x73, 0x69)
		if err != nil {
			return
		}
		err = en.WriteInt(z.SetIndex)
		if err != nil {
			err = msgp.WrapError(err, "SetIndex")
			return
		}
		// write "dc"
		err = en.Append(0xa2, 0x64, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.DriveCount)
		if err != nil {
			err = msgp.WrapError(err, "DriveCount")
			return
		}
		// write "od"
		err = en.Append(0xa2, 0x6f, 0x64)
		if err != nil {
			return
		}
		err = en.WriteInt(z.OfflineDrives)
		if err != nil {
			err = msgp.WrapError(err, "OfflineDrives")
			return
		}
		// write "ond"
		err = en.Append(0xa3, 0x6f, 0x6e, 0x64)
		if err != nil {
			return
		}
		err = en.WriteInt(z.OnlineDrives)
		if err != nil {
			err = msgp.WrapError(err, "OnlineDrives")
			return
		}
		// write "hd"
		err = en.Append(0xa2, 0x68, 0x64)
		if err != nil {
			return
		}
		err = en.WriteInt(z.HealDisks)
		if err != nil {
			err = msgp.WrapError(err, "HealDisks")
			return
		}
		// write "rq"
		err = en.Append(0xa2, 0x72, 0x71)
		if err != nil {
			return
		}
		err = en.WriteInt(z.ReadQuorum)
		if err != nil {
			err = msgp.WrapError(err, "ReadQuorum")
			return
		}
		// write "wq"
		err = en.Append(0xa2, 0x77, 0x71)
		if err != nil {
			return
		}
		err = en.WriteInt(z.WriteQuorum)
		if err != nil {
			err = msgp.WrapError(err, "WriteQuorum")
			return
		}
		if (zb0001Mask & 0x100) == 0 { // if not omitted
			// write "n"
			err = en.Append(0xa1, 0x6e)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Nodes)))
			if err != nil {
				err = msgp.WrapError(err, "Nodes")
				return
			}
			for za0001 := range z.Nodes {
				err = en.WriteString(z.Nodes[za0001])
				if err != nil {
					err = msgp.WrapError(err, "Nodes", za0001)
					return
				}
			}
		}
		// write "ru"
		err = en.Append(0xa2, 0x72, 0x75)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.RawUsage)
		if err != nil {
			err = msgp.WrapError(err, "RawUsage")
			return
		}
		// write "rc"
		err = en.Append(0xa2, 0x72, 0x63)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.RawCapacity)
		if err != nil {
			err = msgp.WrapError(err, "RawCapacity")
			return
		}
		// write "u"
		err = en.Append(0xa1, 0x75)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.Usage)
		if err != nil {
			err = msgp.WrapError(err, "Usage")
			return
		}
		// write "oc"
		err = en.Append(0xa2, 0x6f, 0x63)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.ObjectsCount)
		if err != nil {
			err = msgp.WrapError(err, "ObjectsCount")
			return
		}
		// write "vc"
		err = en.Append(0xa2, 0x76, 0x63)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.VersionsCount)
		if err != nil {
			err = msgp.WrapError(err, "VersionsCount")
			return
		}
		// write "dmc"
		err = en.Append(0xa3, 0x64, 0x6d, 0x63)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.DeleteMarkersCount)
		if err != nil {
			err = msgp.WrapError(err, "DeleteMarkersCount")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ErasureSetResource) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// check for omitted fields
	zb0001Len := uint32(15)
	var zb0001Mask uint16 /* 15 bits */
	_ = zb0001Mask
	if z.Nodes == nil {
		zb0001Len--
		zb0001Mask |= 0x100
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// string "pi"
		o = append(o, 0xa2, 0x70, 0x69)
		o = msgp.AppendInt(o, z.PoolIndex)
		// string "si"
		o = append(o, 0xa2, 0x73, 0x69)
		o = msgp.AppendInt(o, z.SetIndex)
		// string "dc"
		o = append(o, 0xa2, 0x64, 0x63)
		o = msgp.AppendInt(o, z.DriveCount)
		// string "od"
		o = append(o, 0xa2, 0x6f, 0x64)
		o = msgp.AppendInt(o, z.OfflineDrives)
		// string "ond"
		o = append(o, 0xa3, 0x6f, 0x6e, 0x64)
		o = msgp.AppendInt(o, z.OnlineDrives)
		// string "hd"
		o = append(o, 0xa2, 0x68, 0x64)
		o = msgp.AppendInt(o, z.HealDisks)
		// string "rq"
		o = append(o, 0xa2, 0x72, 0x71)
		o = msgp.AppendInt(o, z.ReadQuorum)
		// string "wq"
		o = append(o, 0xa2, 0x77, 0x71)
		o = msgp.AppendInt(o, z.WriteQuorum)
		if (zb0001Mask & 0x100) == 0 { // if not omitted
			// string "n"
			o = append(o, 0xa1, 0x6e)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Nodes)))
			for za0001 := range z.Nodes {
				o = msgp.AppendString(o, z.Nodes[za0001])
			}
		}
		// string "ru"
		o = append(o, 0xa2, 0x72, 0x75)
		o = msgp.AppendUint64(o, z.RawUsage)
		// string "rc"
		o = append(o, 0xa2, 0x72, 0x63)
		o = msgp.AppendUint64(o, z.RawCapacity)
		// string "u"
		o = append(o, 0xa1, 0x75)
		o = msgp.AppendUint64(o, z.Usage)
		// string "oc"
		o = append(o, 0xa2, 0x6f, 0x63)
		o = msgp.AppendUint64(o, z.ObjectsCount)
		// string "vc"
		o = append(o, 0xa2, 0x76, 0x63)
		o = msgp.AppendUint64(o, z.VersionsCount)
		// string "dmc"
		o = append(o, 0xa3, 0x64, 0x6d, 0x63)
		o = msgp.AppendUint64(o, z.DeleteMarkersCount)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ErasureSetResource) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "pi":
			z.PoolIndex, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "si":
			z.SetIndex, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "SetIndex")
				return
			}
		case "dc":
			z.DriveCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DriveCount")
				return
			}
		case "od":
			z.OfflineDrives, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "OfflineDrives")
				return
			}
		case "ond":
			z.OnlineDrives, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "OnlineDrives")
				return
			}
		case "hd":
			z.HealDisks, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "HealDisks")
				return
			}
		case "rq":
			z.ReadQuorum, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ReadQuorum")
				return
			}
		case "wq":
			z.WriteQuorum, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "WriteQuorum")
				return
			}
		case "n":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Nodes")
				return
			}
			if cap(z.Nodes) >= int(zb0002) {
				z.Nodes = (z.Nodes)[:zb0002]
			} else {
				z.Nodes = make([]string, zb0002)
			}
			for za0001 := range z.Nodes {
				z.Nodes[za0001], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Nodes", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "ru":
			z.RawUsage, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RawUsage")
				return
			}
		case "rc":
			z.RawCapacity, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RawCapacity")
				return
			}
		case "u":
			z.Usage, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Usage")
				return
			}
		case "oc":
			z.ObjectsCount, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ObjectsCount")
				return
			}
		case "vc":
			z.VersionsCount, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "VersionsCount")
				return
			}
		case "dmc":
			z.DeleteMarkersCount, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarkersCount")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Nodes = nil
	}

	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ErasureSetResource) Msgsize() (s int) {
	s = 1 + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 4 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 2 + msgp.ArrayHeaderSize
	for za0001 := range z.Nodes {
		s += msgp.StringPrefixSize + len(z.Nodes[za0001])
	}
	s += 3 + msgp.Uint64Size + 3 + msgp.Uint64Size + 2 + msgp.Uint64Size + 3 + msgp.Uint64Size + 3 + msgp.Uint64Size + 4 + msgp.Uint64Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *NodeResource) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "h":
			z.Host, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Host")
				return
			}
		case "v":
			z.Version, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "Version")
				return
			}
		case "c":
			z.CommitID, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "CommitID")
				return
			}
		case "u":
			z.Uptime, err = dc.ReadInt64()
			if err != nil {
				err = msgp.WrapError(err, "Uptime")
				return
			}
		case "s":
			z.State, err = dc.ReadString()
			if err != nil {
				err = msgp.WrapError(err, "State")
				return
			}
		case "td":
			z.TotalDrives, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "TotalDrives")
				return
			}
		case "dc":
			err = z.DriveCounts.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "DriveCounts")
				return
			}
		case "pi":
			z.PoolIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "pis":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndexes")
				return
			}
			if cap(z.PoolIndexes) >= int(zb0002) {
				z.PoolIndexes = (z.PoolIndexes)[:zb0002]
			} else {
				z.PoolIndexes = make([]int, zb0002)
			}
			for za0001 := range z.PoolIndexes {
				z.PoolIndexes[za0001], err = dc.ReadInt()
				if err != nil {
					err = msgp.WrapError(err, "PoolIndexes", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.PoolIndexes = nil
	}

	return
}

// EncodeMsg implements msgp.Encodable
func (z *NodeResource) EncodeMsg(en *msgp.Writer) (err error) {
	// check for omitted fields
	zb0001Len := uint32(9)
	var zb0001Mask uint16 /* 9 bits */
	_ = zb0001Mask
	if z.PoolIndexes == nil {
		zb0001Len--
		zb0001Mask |= 0x100
	}
	// variable map header, size zb0001Len
	err = en.Append(0x80 | uint8(zb0001Len))
	if err != nil {
		return
	}

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// write "h"
		err = en.Append(0xa1, 0x68)
		if err != nil {
			return
		}
		err = en.WriteString(z.Host)
		if err != nil {
			err = msgp.WrapError(err, "Host")
			return
		}
		// write "v"
		err = en.Append(0xa1, 0x76)
		if err != nil {
			return
		}
		err = en.WriteString(z.Version)
		if err != nil {
			err = msgp.WrapError(err, "Version")
			return
		}
		// write "c"
		err = en.Append(0xa1, 0x63)
		if err != nil {
			return
		}
		err = en.WriteString(z.CommitID)
		if err != nil {
			err = msgp.WrapError(err, "CommitID")
			return
		}
		// write "u"
		err = en.Append(0xa1, 0x75)
		if err != nil {
			return
		}
		err = en.WriteInt64(z.Uptime)
		if err != nil {
			err = msgp.WrapError(err, "Uptime")
			return
		}
		// write "s"
		err = en.Append(0xa1, 0x73)
		if err != nil {
			return
		}
		err = en.WriteString(z.State)
		if err != nil {
			err = msgp.WrapError(err, "State")
			return
		}
		// write "td"
		err = en.Append(0xa2, 0x74, 0x64)
		if err != nil {
			return
		}
		err = en.WriteInt(z.TotalDrives)
		if err != nil {
			err = msgp.WrapError(err, "TotalDrives")
			return
		}
		// write "dc"
		err = en.Append(0xa2, 0x64, 0x63)
		if err != nil {
			return
		}
		err = z.DriveCounts.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "DriveCounts")
			return
		}
		// write "pi"
		err = en.Append(0xa2, 0x70, 0x69)
		if err != nil {
			return
		}
		err = en.WriteInt(z.PoolIndex)
		if err != nil {
			err = msgp.WrapError(err, "PoolIndex")
			return
		}
		if (zb0001Mask & 0x100) == 0 { // if not omitted
			// write "pis"
			err = en.Append(0xa3, 0x70, 0x69, 0x73)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.PoolIndexes)))
			if err != nil {
				err = msgp.WrapError(err, "PoolIndexes")
				return
			}
			for za0001 := range z.PoolIndexes {
				err = en.WriteInt(z.PoolIndexes[za0001])
				if err != nil {
					err = msgp.WrapError(err, "PoolIndexes", za0001)
					return
				}
			}
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *NodeResource) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// check for omitted fields
	zb0001Len := uint32(9)
	var zb0001Mask uint16 /* 9 bits */
	_ = zb0001Mask
	if z.PoolIndexes == nil {
		zb0001Len--
		zb0001Mask |= 0x100
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// string "h"
		o = append(o, 0xa1, 0x68)
		o = msgp.AppendString(o, z.Host)
		// string "v"
		o = append(o, 0xa1, 0x76)
		o = msgp.AppendString(o, z.Version)
		// string "c"
		o = append(o, 0xa1, 0x63)
		o = msgp.AppendString(o, z.CommitID)
		// string "u"
		o = append(o, 0xa1, 0x75)
		o = msgp.AppendInt64(o, z.Uptime)
		// string "s"
		o = append(o, 0xa1, 0x73)
		o = msgp.AppendString(o, z.State)
		// string "td"
		o = append(o, 0xa2, 0x74, 0x64)
		o = msgp.AppendInt(o, z.TotalDrives)
		// string "dc"
		o = append(o, 0xa2, 0x64, 0x63)
		o, err = z.DriveCounts.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "DriveCounts")
			return
		}
		// string "pi"
		o = append(o, 0xa2, 0x70, 0x69)
		o = msgp.AppendInt(o, z.PoolIndex)
		if (zb0001Mask & 0x100) == 0 { // if not omitted
			// string "pis"
			o = append(o, 0xa3, 0x70, 0x69, 0x73)
			o = msgp.AppendArrayHeader(o, uint32(len(z.PoolIndexes)))
			for za0001 := range z.PoolIndexes {
				o = msgp.AppendInt(o, z.PoolIndexes[za0001])
			}
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *NodeResource) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "h":
			z.Host, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Host")
				return
			}
		case "v":
			z.Version, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Version")
				return
			}
		case "c":
			z.CommitID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "CommitID")
				return
			}
		case "u":
			z.Uptime, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Uptime")
				return
			}
		case "s":
			z.State, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "State")
				return
			}
		case "td":
			z.TotalDrives, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TotalDrives")
				return
			}
		case "dc":
			bts, err = z.DriveCounts.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "DriveCounts")
				return
			}
		case "pi":
			z.PoolIndex, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "pis":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PoolIndexes")
				return
			}
			if cap(z.PoolIndexes) >= int(zb0002) {
				z.PoolIndexes = (z.PoolIndexes)[:zb0002]
			} else {
				z.PoolIndexes = make([]int, zb0002)
			}
			for za0001 := range z.PoolIndexes {
				z.PoolIndexes[za0001], bts, err = msgp.ReadIntBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "PoolIndexes", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.PoolIndexes = nil
	}

	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *NodeResource) Msgsize() (s int) {
	s = 1 + 2 + msgp.StringPrefixSize + len(z.Host) + 2 + msgp.StringPrefixSize + len(z.Version) + 2 + msgp.StringPrefixSize + len(z.CommitID) + 2 + msgp.Int64Size + 2 + msgp.StringPrefixSize + len(z.State) + 3 + msgp.IntSize + 3 + z.DriveCounts.Msgsize() + 3 + msgp.IntSize + 4 + msgp.ArrayHeaderSize + (len(z.PoolIndexes) * (msgp.IntSize))
	return
}

// DecodeMsg implements msgp.Decodable
func (z *PaginatedDrivesResponse) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "r":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			if cap(z.Results) >= int(zb0002) {
				z.Results = (z.Results)[:zb0002]
			} else {
				z.Results = make([]DriveResource, zb0002)
			}
			for za0001 := range z.Results {
				err = z.Results[za0001].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "c":
			z.Count, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "t":
			z.Total, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "o":
			z.Offset, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Offset")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Results = nil
	}

	return
}

// EncodeMsg implements msgp.Encodable
func (z *PaginatedDrivesResponse) EncodeMsg(en *msgp.Writer) (err error) {
	// check for omitted fields
	zb0001Len := uint32(4)
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	if z.Results == nil {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	err = en.Append(0x80 | uint8(zb0001Len))
	if err != nil {
		return
	}

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not omitted
			// write "r"
			err = en.Append(0xa1, 0x72)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Results)))
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			for za0001 := range z.Results {
				err = z.Results[za0001].EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
		}
		// write "c"
		err = en.Append(0xa1, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Count)
		if err != nil {
			err = msgp.WrapError(err, "Count")
			return
		}
		// write "t"
		err = en.Append(0xa1, 0x74)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Total)
		if err != nil {
			err = msgp.WrapError(err, "Total")
			return
		}
		// write "o"
		err = en.Append(0xa1, 0x6f)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Offset)
		if err != nil {
			err = msgp.WrapError(err, "Offset")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *PaginatedDrivesResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// check for omitted fields
	zb0001Len := uint32(4)
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	if z.Results == nil {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not omitted
			// string "r"
			o = append(o, 0xa1, 0x72)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Results)))
			for za0001 := range z.Results {
				o, err = z.Results[za0001].MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
		}
		// string "c"
		o = append(o, 0xa1, 0x63)
		o = msgp.AppendInt(o, z.Count)
		// string "t"
		o = append(o, 0xa1, 0x74)
		o = msgp.AppendInt(o, z.Total)
		// string "o"
		o = append(o, 0xa1, 0x6f)
		o = msgp.AppendInt(o, z.Offset)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *PaginatedDrivesResponse) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "r":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			if cap(z.Results) >= int(zb0002) {
				z.Results = (z.Results)[:zb0002]
			} else {
				z.Results = make([]DriveResource, zb0002)
			}
			for za0001 := range z.Results {
				bts, err = z.Results[za0001].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "c":
			z.Count, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "t":
			z.Total, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "o":
			z.Offset, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Offset")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Results = nil
	}

	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *PaginatedDrivesResponse) Msgsize() (s int) {
	s = 1 + 2 + msgp.ArrayHeaderSize
	for za0001 := range z.Results {
		s += z.Results[za0001].Msgsize()
	}
	s += 2 + msgp.IntSize + 2 + msgp.IntSize + 2 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *PaginatedErasureSetsResponse) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "r":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			if cap(z.Results) >= int(zb0002) {
				z.Results = (z.Results)[:zb0002]
			} else {
				z.Results = make([]ErasureSetResource, zb0002)
			}
			for za0001 := range z.Results {
				err = z.Results[za0001].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "c":
			z.Count, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "t":
			z.Total, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "o":
			z.Offset, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Offset")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Results = nil
	}

	return
}

// EncodeMsg implements msgp.Encodable
func (z *PaginatedErasureSetsResponse) EncodeMsg(en *msgp.Writer) (err error) {
	// check for omitted fields
	zb0001Len := uint32(4)
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	if z.Results == nil {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	err = en.Append(0x80 | uint8(zb0001Len))
	if err != nil {
		return
	}

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not omitted
			// write "r"
			err = en.Append(0xa1, 0x72)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Results)))
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			for za0001 := range z.Results {
				err = z.Results[za0001].EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
		}
		// write "c"
		err = en.Append(0xa1, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Count)
		if err != nil {
			err = msgp.WrapError(err, "Count")
			return
		}
		// write "t"
		err = en.Append(0xa1, 0x74)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Total)
		if err != nil {
			err = msgp.WrapError(err, "Total")
			return
		}
		// write "o"
		err = en.Append(0xa1, 0x6f)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Offset)
		if err != nil {
			err = msgp.WrapError(err, "Offset")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *PaginatedErasureSetsResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// check for omitted fields
	zb0001Len := uint32(4)
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	if z.Results == nil {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not omitted
			// string "r"
			o = append(o, 0xa1, 0x72)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Results)))
			for za0001 := range z.Results {
				o, err = z.Results[za0001].MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
		}
		// string "c"
		o = append(o, 0xa1, 0x63)
		o = msgp.AppendInt(o, z.Count)
		// string "t"
		o = append(o, 0xa1, 0x74)
		o = msgp.AppendInt(o, z.Total)
		// string "o"
		o = append(o, 0xa1, 0x6f)
		o = msgp.AppendInt(o, z.Offset)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *PaginatedErasureSetsResponse) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "r":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			if cap(z.Results) >= int(zb0002) {
				z.Results = (z.Results)[:zb0002]
			} else {
				z.Results = make([]ErasureSetResource, zb0002)
			}
			for za0001 := range z.Results {
				bts, err = z.Results[za0001].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "c":
			z.Count, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "t":
			z.Total, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "o":
			z.Offset, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Offset")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Results = nil
	}

	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *PaginatedErasureSetsResponse) Msgsize() (s int) {
	s = 1 + 2 + msgp.ArrayHeaderSize
	for za0001 := range z.Results {
		s += z.Results[za0001].Msgsize()
	}
	s += 2 + msgp.IntSize + 2 + msgp.IntSize + 2 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *PaginatedNodesResponse) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "r":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			if cap(z.Results) >= int(zb0002) {
				z.Results = (z.Results)[:zb0002]
			} else {
				z.Results = make([]NodeResource, zb0002)
			}
			for za0001 := range z.Results {
				err = z.Results[za0001].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "c":
			z.Count, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "t":
			z.Total, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "o":
			z.Offset, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Offset")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Results = nil
	}

	return
}

// EncodeMsg implements msgp.Encodable
func (z *PaginatedNodesResponse) EncodeMsg(en *msgp.Writer) (err error) {
	// check for omitted fields
	zb0001Len := uint32(4)
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	if z.Results == nil {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	err = en.Append(0x80 | uint8(zb0001Len))
	if err != nil {
		return
	}

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not omitted
			// write "r"
			err = en.Append(0xa1, 0x72)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Results)))
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			for za0001 := range z.Results {
				err = z.Results[za0001].EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
		}
		// write "c"
		err = en.Append(0xa1, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Count)
		if err != nil {
			err = msgp.WrapError(err, "Count")
			return
		}
		// write "t"
		err = en.Append(0xa1, 0x74)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Total)
		if err != nil {
			err = msgp.WrapError(err, "Total")
			return
		}
		// write "o"
		err = en.Append(0xa1, 0x6f)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Offset)
		if err != nil {
			err = msgp.WrapError(err, "Offset")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *PaginatedNodesResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// check for omitted fields
	zb0001Len := uint32(4)
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	if z.Results == nil {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not omitted
			// string "r"
			o = append(o, 0xa1, 0x72)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Results)))
			for za0001 := range z.Results {
				o, err = z.Results[za0001].MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
		}
		// string "c"
		o = append(o, 0xa1, 0x63)
		o = msgp.AppendInt(o, z.Count)
		// string "t"
		o = append(o, 0xa1, 0x74)
		o = msgp.AppendInt(o, z.Total)
		// string "o"
		o = append(o, 0xa1, 0x6f)
		o = msgp.AppendInt(o, z.Offset)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *PaginatedNodesResponse) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "r":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			if cap(z.Results) >= int(zb0002) {
				z.Results = (z.Results)[:zb0002]
			} else {
				z.Results = make([]NodeResource, zb0002)
			}
			for za0001 := range z.Results {
				bts, err = z.Results[za0001].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "c":
			z.Count, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "t":
			z.Total, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "o":
			z.Offset, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Offset")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Results = nil
	}

	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *PaginatedNodesResponse) Msgsize() (s int) {
	s = 1 + 2 + msgp.ArrayHeaderSize
	for za0001 := range z.Results {
		s += z.Results[za0001].Msgsize()
	}
	s += 2 + msgp.IntSize + 2 + msgp.IntSize + 2 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *PaginatedPoolsResponse) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "r":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			if cap(z.Results) >= int(zb0002) {
				z.Results = (z.Results)[:zb0002]
			} else {
				z.Results = make([]PoolResource, zb0002)
			}
			for za0001 := range z.Results {
				err = z.Results[za0001].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "c":
			z.Count, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "t":
			z.Total, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "o":
			z.Offset, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Offset")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Results = nil
	}

	return
}

// EncodeMsg implements msgp.Encodable
func (z *PaginatedPoolsResponse) EncodeMsg(en *msgp.Writer) (err error) {
	// check for omitted fields
	zb0001Len := uint32(4)
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	if z.Results == nil {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	err = en.Append(0x80 | uint8(zb0001Len))
	if err != nil {
		return
	}

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not omitted
			// write "r"
			err = en.Append(0xa1, 0x72)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Results)))
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			for za0001 := range z.Results {
				err = z.Results[za0001].EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
		}
		// write "c"
		err = en.Append(0xa1, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Count)
		if err != nil {
			err = msgp.WrapError(err, "Count")
			return
		}
		// write "t"
		err = en.Append(0xa1, 0x74)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Total)
		if err != nil {
			err = msgp.WrapError(err, "Total")
			return
		}
		// write "o"
		err = en.Append(0xa1, 0x6f)
		if err != nil {
			return
		}
		err = en.WriteInt(z.Offset)
		if err != nil {
			err = msgp.WrapError(err, "Offset")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *PaginatedPoolsResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// check for omitted fields
	zb0001Len := uint32(4)
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	if z.Results == nil {
		zb0001Len--
		zb0001Mask |= 0x1
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		if (zb0001Mask & 0x1) == 0 { // if not omitted
			// string "r"
			o = append(o, 0xa1, 0x72)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Results)))
			for za0001 := range z.Results {
				o, err = z.Results[za0001].MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
		}
		// string "c"
		o = append(o, 0xa1, 0x63)
		o = msgp.AppendInt(o, z.Count)
		// string "t"
		o = append(o, 0xa1, 0x74)
		o = msgp.AppendInt(o, z.Total)
		// string "o"
		o = append(o, 0xa1, 0x6f)
		o = msgp.AppendInt(o, z.Offset)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *PaginatedPoolsResponse) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "r":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Results")
				return
			}
			if cap(z.Results) >= int(zb0002) {
				z.Results = (z.Results)[:zb0002]
			} else {
				z.Results = make([]PoolResource, zb0002)
			}
			for za0001 := range z.Results {
				bts, err = z.Results[za0001].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Results", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "c":
			z.Count, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Count")
				return
			}
		case "t":
			z.Total, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Total")
				return
			}
		case "o":
			z.Offset, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Offset")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Results = nil
	}

	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *PaginatedPoolsResponse) Msgsize() (s int) {
	s = 1 + 2 + msgp.ArrayHeaderSize
	for za0001 := range z.Results {
		s += z.Results[za0001].Msgsize()
	}
	s += 2 + msgp.IntSize + 2 + msgp.IntSize + 2 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *PoolLayout) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "s":
			z.Servers, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Servers")
				return
			}
		case "d":
			z.Drives, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "Drives")
				return
			}
		case "do":
			z.DrivesOffline, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DrivesOffline")
				return
			}
		case "dh":
			z.DrivesHealing, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DrivesHealing")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *PoolLayout) EncodeMsg(en *msgp.Writer) (err error) {
	// map header, size 4
	// write "s"
	err = en.Append(0x84, 0xa1, 0x73)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Servers)
	if err != nil {
		err = msgp.WrapError(err, "Servers")
		return
	}
	// write "d"
	err = en.Append(0xa1, 0x64)
	if err != nil {
		return
	}
	err = en.WriteInt(z.Drives)
	if err != nil {
		err = msgp.WrapError(err, "Drives")
		return
	}
	// write "do"
	err = en.Append(0xa2, 0x64, 0x6f)
	if err != nil {
		return
	}
	err = en.WriteInt(z.DrivesOffline)
	if err != nil {
		err = msgp.WrapError(err, "DrivesOffline")
		return
	}
	// write "dh"
	err = en.Append(0xa2, 0x64, 0x68)
	if err != nil {
		return
	}
	err = en.WriteInt(z.DrivesHealing)
	if err != nil {
		err = msgp.WrapError(err, "DrivesHealing")
		return
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *PoolLayout) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "s"
	o = append(o, 0x84, 0xa1, 0x73)
	o = msgp.AppendInt(o, z.Servers)
	// string "d"
	o = append(o, 0xa1, 0x64)
	o = msgp.AppendInt(o, z.Drives)
	// string "do"
	o = append(o, 0xa2, 0x64, 0x6f)
	o = msgp.AppendInt(o, z.DrivesOffline)
	// string "dh"
	o = append(o, 0xa2, 0x64, 0x68)
	o = msgp.AppendInt(o, z.DrivesHealing)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *PoolLayout) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "s":
			z.Servers, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Servers")
				return
			}
		case "d":
			z.Drives, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Drives")
				return
			}
		case "do":
			z.DrivesOffline, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DrivesOffline")
				return
			}
		case "dh":
			z.DrivesHealing, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DrivesHealing")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *PoolLayout) Msgsize() (s int) {
	s = 1 + 2 + msgp.IntSize + 2 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize
	return
}

// DecodeMsg implements msgp.Decodable
func (z *PoolResource) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "i":
			z.PoolIndex, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "ss":
			z.StripeSize, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "StripeSize")
				return
			}
		case "ts":
			z.TotalSets, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "TotalSets")
				return
			}
		case "wq":
			z.WriteQuorum, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "WriteQuorum")
				return
			}
		case "rq":
			z.ReadQuorum, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "ReadQuorum")
				return
			}
		case "n":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Nodes")
				return
			}
			if cap(z.Nodes) >= int(zb0002) {
				z.Nodes = (z.Nodes)[:zb0002]
			} else {
				z.Nodes = make([]string, zb0002)
			}
			for za0001 := range z.Nodes {
				z.Nodes[za0001], err = dc.ReadString()
				if err != nil {
					err = msgp.WrapError(err, "Nodes", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "dc":
			z.DriveCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DriveCount")
				return
			}
		case "do":
			z.DrivesOnline, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DrivesOnline")
				return
			}
		case "doff":
			z.DrivesOffline, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DrivesOffline")
				return
			}
		case "dh":
			z.DrivesHealing, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "DrivesHealing")
				return
			}
		case "nc":
			z.NodeCount, err = dc.ReadInt()
			if err != nil {
				err = msgp.WrapError(err, "NodeCount")
				return
			}
		case "ru":
			z.RawUsage, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "RawUsage")
				return
			}
		case "rc":
			z.RawCapacity, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "RawCapacity")
				return
			}
		case "u":
			z.Usage, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "Usage")
				return
			}
		case "oc":
			z.ObjectsCount, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "ObjectsCount")
				return
			}
		case "vc":
			z.VersionsCount, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "VersionsCount")
				return
			}
		case "dmc":
			z.DeleteMarkersCount, err = dc.ReadUint64()
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarkersCount")
				return
			}
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Nodes = nil
	}

	return
}

// EncodeMsg implements msgp.Encodable
func (z *PoolResource) EncodeMsg(en *msgp.Writer) (err error) {
	// check for omitted fields
	zb0001Len := uint32(17)
	var zb0001Mask uint32 /* 17 bits */
	_ = zb0001Mask
	if z.Nodes == nil {
		zb0001Len--
		zb0001Mask |= 0x20
	}
	// variable map header, size zb0001Len
	err = en.WriteMapHeader(zb0001Len)
	if err != nil {
		return
	}

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// write "i"
		err = en.Append(0xa1, 0x69)
		if err != nil {
			return
		}
		err = en.WriteInt(z.PoolIndex)
		if err != nil {
			err = msgp.WrapError(err, "PoolIndex")
			return
		}
		// write "ss"
		err = en.Append(0xa2, 0x73, 0x73)
		if err != nil {
			return
		}
		err = en.WriteInt(z.StripeSize)
		if err != nil {
			err = msgp.WrapError(err, "StripeSize")
			return
		}
		// write "ts"
		err = en.Append(0xa2, 0x74, 0x73)
		if err != nil {
			return
		}
		err = en.WriteInt(z.TotalSets)
		if err != nil {
			err = msgp.WrapError(err, "TotalSets")
			return
		}
		// write "wq"
		err = en.Append(0xa2, 0x77, 0x71)
		if err != nil {
			return
		}
		err = en.WriteInt(z.WriteQuorum)
		if err != nil {
			err = msgp.WrapError(err, "WriteQuorum")
			return
		}
		// write "rq"
		err = en.Append(0xa2, 0x72, 0x71)
		if err != nil {
			return
		}
		err = en.WriteInt(z.ReadQuorum)
		if err != nil {
			err = msgp.WrapError(err, "ReadQuorum")
			return
		}
		if (zb0001Mask & 0x20) == 0 { // if not omitted
			// write "n"
			err = en.Append(0xa1, 0x6e)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Nodes)))
			if err != nil {
				err = msgp.WrapError(err, "Nodes")
				return
			}
			for za0001 := range z.Nodes {
				err = en.WriteString(z.Nodes[za0001])
				if err != nil {
					err = msgp.WrapError(err, "Nodes", za0001)
					return
				}
			}
		}
		// write "dc"
		err = en.Append(0xa2, 0x64, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.DriveCount)
		if err != nil {
			err = msgp.WrapError(err, "DriveCount")
			return
		}
		// write "do"
		err = en.Append(0xa2, 0x64, 0x6f)
		if err != nil {
			return
		}
		err = en.WriteInt(z.DrivesOnline)
		if err != nil {
			err = msgp.WrapError(err, "DrivesOnline")
			return
		}
		// write "doff"
		err = en.Append(0xa4, 0x64, 0x6f, 0x66, 0x66)
		if err != nil {
			return
		}
		err = en.WriteInt(z.DrivesOffline)
		if err != nil {
			err = msgp.WrapError(err, "DrivesOffline")
			return
		}
		// write "dh"
		err = en.Append(0xa2, 0x64, 0x68)
		if err != nil {
			return
		}
		err = en.WriteInt(z.DrivesHealing)
		if err != nil {
			err = msgp.WrapError(err, "DrivesHealing")
			return
		}
		// write "nc"
		err = en.Append(0xa2, 0x6e, 0x63)
		if err != nil {
			return
		}
		err = en.WriteInt(z.NodeCount)
		if err != nil {
			err = msgp.WrapError(err, "NodeCount")
			return
		}
		// write "ru"
		err = en.Append(0xa2, 0x72, 0x75)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.RawUsage)
		if err != nil {
			err = msgp.WrapError(err, "RawUsage")
			return
		}
		// write "rc"
		err = en.Append(0xa2, 0x72, 0x63)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.RawCapacity)
		if err != nil {
			err = msgp.WrapError(err, "RawCapacity")
			return
		}
		// write "u"
		err = en.Append(0xa1, 0x75)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.Usage)
		if err != nil {
			err = msgp.WrapError(err, "Usage")
			return
		}
		// write "oc"
		err = en.Append(0xa2, 0x6f, 0x63)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.ObjectsCount)
		if err != nil {
			err = msgp.WrapError(err, "ObjectsCount")
			return
		}
		// write "vc"
		err = en.Append(0xa2, 0x76, 0x63)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.VersionsCount)
		if err != nil {
			err = msgp.WrapError(err, "VersionsCount")
			return
		}
		// write "dmc"
		err = en.Append(0xa3, 0x64, 0x6d, 0x63)
		if err != nil {
			return
		}
		err = en.WriteUint64(z.DeleteMarkersCount)
		if err != nil {
			err = msgp.WrapError(err, "DeleteMarkersCount")
			return
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *PoolResource) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// check for omitted fields
	zb0001Len := uint32(17)
	var zb0001Mask uint32 /* 17 bits */
	_ = zb0001Mask
	if z.Nodes == nil {
		zb0001Len--
		zb0001Mask |= 0x20
	}
	// variable map header, size zb0001Len
	o = msgp.AppendMapHeader(o, zb0001Len)

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// string "i"
		o = append(o, 0xa1, 0x69)
		o = msgp.AppendInt(o, z.PoolIndex)
		// string "ss"
		o = append(o, 0xa2, 0x73, 0x73)
		o = msgp.AppendInt(o, z.StripeSize)
		// string "ts"
		o = append(o, 0xa2, 0x74, 0x73)
		o = msgp.AppendInt(o, z.TotalSets)
		// string "wq"
		o = append(o, 0xa2, 0x77, 0x71)
		o = msgp.AppendInt(o, z.WriteQuorum)
		// string "rq"
		o = append(o, 0xa2, 0x72, 0x71)
		o = msgp.AppendInt(o, z.ReadQuorum)
		if (zb0001Mask & 0x20) == 0 { // if not omitted
			// string "n"
			o = append(o, 0xa1, 0x6e)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Nodes)))
			for za0001 := range z.Nodes {
				o = msgp.AppendString(o, z.Nodes[za0001])
			}
		}
		// string "dc"
		o = append(o, 0xa2, 0x64, 0x63)
		o = msgp.AppendInt(o, z.DriveCount)
		// string "do"
		o = append(o, 0xa2, 0x64, 0x6f)
		o = msgp.AppendInt(o, z.DrivesOnline)
		// string "doff"
		o = append(o, 0xa4, 0x64, 0x6f, 0x66, 0x66)
		o = msgp.AppendInt(o, z.DrivesOffline)
		// string "dh"
		o = append(o, 0xa2, 0x64, 0x68)
		o = msgp.AppendInt(o, z.DrivesHealing)
		// string "nc"
		o = append(o, 0xa2, 0x6e, 0x63)
		o = msgp.AppendInt(o, z.NodeCount)
		// string "ru"
		o = append(o, 0xa2, 0x72, 0x75)
		o = msgp.AppendUint64(o, z.RawUsage)
		// string "rc"
		o = append(o, 0xa2, 0x72, 0x63)
		o = msgp.AppendUint64(o, z.RawCapacity)
		// string "u"
		o = append(o, 0xa1, 0x75)
		o = msgp.AppendUint64(o, z.Usage)
		// string "oc"
		o = append(o, 0xa2, 0x6f, 0x63)
		o = msgp.AppendUint64(o, z.ObjectsCount)
		// string "vc"
		o = append(o, 0xa2, 0x76, 0x63)
		o = msgp.AppendUint64(o, z.VersionsCount)
		// string "dmc"
		o = append(o, 0xa3, 0x64, 0x6d, 0x63)
		o = msgp.AppendUint64(o, z.DeleteMarkersCount)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *PoolResource) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 1 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "i":
			z.PoolIndex, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "PoolIndex")
				return
			}
		case "ss":
			z.StripeSize, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "StripeSize")
				return
			}
		case "ts":
			z.TotalSets, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TotalSets")
				return
			}
		case "wq":
			z.WriteQuorum, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "WriteQuorum")
				return
			}
		case "rq":
			z.ReadQuorum, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ReadQuorum")
				return
			}
		case "n":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Nodes")
				return
			}
			if cap(z.Nodes) >= int(zb0002) {
				z.Nodes = (z.Nodes)[:zb0002]
			} else {
				z.Nodes = make([]string, zb0002)
			}
			for za0001 := range z.Nodes {
				z.Nodes[za0001], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Nodes", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "dc":
			z.DriveCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DriveCount")
				return
			}
		case "do":
			z.DrivesOnline, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DrivesOnline")
				return
			}
		case "doff":
			z.DrivesOffline, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DrivesOffline")
				return
			}
		case "dh":
			z.DrivesHealing, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DrivesHealing")
				return
			}
		case "nc":
			z.NodeCount, bts, err = msgp.ReadIntBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "NodeCount")
				return
			}
		case "ru":
			z.RawUsage, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RawUsage")
				return
			}
		case "rc":
			z.RawCapacity, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RawCapacity")
				return
			}
		case "u":
			z.Usage, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Usage")
				return
			}
		case "oc":
			z.ObjectsCount, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ObjectsCount")
				return
			}
		case "vc":
			z.VersionsCount, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "VersionsCount")
				return
			}
		case "dmc":
			z.DeleteMarkersCount, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DeleteMarkersCount")
				return
			}
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if (zb0001Mask & 0x1) == 0 {
		z.Nodes = nil
	}

	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *PoolResource) Msgsize() (s int) {
	s = 3 + 2 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 2 + msgp.ArrayHeaderSize
	for za0001 := range z.Nodes {
		s += msgp.StringPrefixSize + len(z.Nodes[za0001])
	}
	s += 3 + msgp.IntSize + 3 + msgp.IntSize + 5 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.IntSize + 3 + msgp.Uint64Size + 3 + msgp.Uint64Size + 2 + msgp.Uint64Size + 3 + msgp.Uint64Size + 3 + msgp.Uint64Size + 4 + msgp.Uint64Size
	return
}

// DecodeMsg implements msgp.Decodable
func (z *ServicesResourceInfo) DecodeMsg(dc *msgp.Reader) (err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, err = dc.ReadMapHeader()
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, err = dc.ReadMapKeyPtr()
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "l":
			err = z.LDAP.DecodeMsg(dc)
			if err != nil {
				err = msgp.WrapError(err, "LDAP")
				return
			}
		case "lg":
			var zb0002 uint32
			zb0002, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Logger")
				return
			}
			if cap(z.Logger) >= int(zb0002) {
				z.Logger = (z.Logger)[:zb0002]
			} else {
				z.Logger = make([]Logger, zb0002)
			}
			for za0001 := range z.Logger {
				err = z.Logger[za0001].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Logger", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "a":
			var zb0003 uint32
			zb0003, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Audit")
				return
			}
			if cap(z.Audit) >= int(zb0003) {
				z.Audit = (z.Audit)[:zb0003]
			} else {
				z.Audit = make([]Audit, zb0003)
			}
			for za0002 := range z.Audit {
				err = z.Audit[za0002].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "Audit", za0002)
					return
				}
			}
			zb0001Mask |= 0x2
		case "n":
			var zb0004 uint32
			zb0004, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "Notifications")
				return
			}
			if cap(z.Notifications) >= int(zb0004) {
				z.Notifications = (z.Notifications)[:zb0004]
			} else {
				z.Notifications = make([]map[string][]TargetIDStatus, zb0004)
			}
			for za0003 := range z.Notifications {
				var zb0005 uint32
				zb0005, err = dc.ReadMapHeader()
				if err != nil {
					err = msgp.WrapError(err, "Notifications", za0003)
					return
				}
				if z.Notifications[za0003] == nil {
					z.Notifications[za0003] = make(map[string][]TargetIDStatus, zb0005)
				} else if len(z.Notifications[za0003]) > 0 {
					for key := range z.Notifications[za0003] {
						delete(z.Notifications[za0003], key)
					}
				}
				for zb0005 > 0 {
					zb0005--
					var za0004 string
					var za0005 []TargetIDStatus
					za0004, err = dc.ReadString()
					if err != nil {
						err = msgp.WrapError(err, "Notifications", za0003)
						return
					}
					var zb0006 uint32
					zb0006, err = dc.ReadArrayHeader()
					if err != nil {
						err = msgp.WrapError(err, "Notifications", za0003, za0004)
						return
					}
					if cap(za0005) >= int(zb0006) {
						za0005 = (za0005)[:zb0006]
					} else {
						za0005 = make([]TargetIDStatus, zb0006)
					}
					for za0006 := range za0005 {
						err = za0005[za0006].DecodeMsg(dc)
						if err != nil {
							err = msgp.WrapError(err, "Notifications", za0003, za0004, za0006)
							return
						}
					}
					z.Notifications[za0003][za0004] = za0005
				}
			}
			zb0001Mask |= 0x4
		case "k":
			var zb0007 uint32
			zb0007, err = dc.ReadArrayHeader()
			if err != nil {
				err = msgp.WrapError(err, "KMSStatus")
				return
			}
			if cap(z.KMSStatus) >= int(zb0007) {
				z.KMSStatus = (z.KMSStatus)[:zb0007]
			} else {
				z.KMSStatus = make([]KMS, zb0007)
			}
			for za0007 := range z.KMSStatus {
				err = z.KMSStatus[za0007].DecodeMsg(dc)
				if err != nil {
					err = msgp.WrapError(err, "KMSStatus", za0007)
					return
				}
			}
			zb0001Mask |= 0x8
		default:
			err = dc.Skip()
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if zb0001Mask != 0xf {
		if (zb0001Mask & 0x1) == 0 {
			z.Logger = nil
		}
		if (zb0001Mask & 0x2) == 0 {
			z.Audit = nil
		}
		if (zb0001Mask & 0x4) == 0 {
			z.Notifications = nil
		}
		if (zb0001Mask & 0x8) == 0 {
			z.KMSStatus = nil
		}
	}
	return
}

// EncodeMsg implements msgp.Encodable
func (z *ServicesResourceInfo) EncodeMsg(en *msgp.Writer) (err error) {
	// check for omitted fields
	zb0001Len := uint32(5)
	var zb0001Mask uint8 /* 5 bits */
	_ = zb0001Mask
	if z.Logger == nil {
		zb0001Len--
		zb0001Mask |= 0x2
	}
	if z.Audit == nil {
		zb0001Len--
		zb0001Mask |= 0x4
	}
	if z.Notifications == nil {
		zb0001Len--
		zb0001Mask |= 0x8
	}
	if z.KMSStatus == nil {
		zb0001Len--
		zb0001Mask |= 0x10
	}
	// variable map header, size zb0001Len
	err = en.Append(0x80 | uint8(zb0001Len))
	if err != nil {
		return
	}

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// write "l"
		err = en.Append(0xa1, 0x6c)
		if err != nil {
			return
		}
		err = z.LDAP.EncodeMsg(en)
		if err != nil {
			err = msgp.WrapError(err, "LDAP")
			return
		}
		if (zb0001Mask & 0x2) == 0 { // if not omitted
			// write "lg"
			err = en.Append(0xa2, 0x6c, 0x67)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Logger)))
			if err != nil {
				err = msgp.WrapError(err, "Logger")
				return
			}
			for za0001 := range z.Logger {
				err = z.Logger[za0001].EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "Logger", za0001)
					return
				}
			}
		}
		if (zb0001Mask & 0x4) == 0 { // if not omitted
			// write "a"
			err = en.Append(0xa1, 0x61)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Audit)))
			if err != nil {
				err = msgp.WrapError(err, "Audit")
				return
			}
			for za0002 := range z.Audit {
				err = z.Audit[za0002].EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "Audit", za0002)
					return
				}
			}
		}
		if (zb0001Mask & 0x8) == 0 { // if not omitted
			// write "n"
			err = en.Append(0xa1, 0x6e)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.Notifications)))
			if err != nil {
				err = msgp.WrapError(err, "Notifications")
				return
			}
			for za0003 := range z.Notifications {
				err = en.WriteMapHeader(uint32(len(z.Notifications[za0003])))
				if err != nil {
					err = msgp.WrapError(err, "Notifications", za0003)
					return
				}
				for za0004, za0005 := range z.Notifications[za0003] {
					err = en.WriteString(za0004)
					if err != nil {
						err = msgp.WrapError(err, "Notifications", za0003)
						return
					}
					err = en.WriteArrayHeader(uint32(len(za0005)))
					if err != nil {
						err = msgp.WrapError(err, "Notifications", za0003, za0004)
						return
					}
					for za0006 := range za0005 {
						err = za0005[za0006].EncodeMsg(en)
						if err != nil {
							err = msgp.WrapError(err, "Notifications", za0003, za0004, za0006)
							return
						}
					}
				}
			}
		}
		if (zb0001Mask & 0x10) == 0 { // if not omitted
			// write "k"
			err = en.Append(0xa1, 0x6b)
			if err != nil {
				return
			}
			err = en.WriteArrayHeader(uint32(len(z.KMSStatus)))
			if err != nil {
				err = msgp.WrapError(err, "KMSStatus")
				return
			}
			for za0007 := range z.KMSStatus {
				err = z.KMSStatus[za0007].EncodeMsg(en)
				if err != nil {
					err = msgp.WrapError(err, "KMSStatus", za0007)
					return
				}
			}
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ServicesResourceInfo) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// check for omitted fields
	zb0001Len := uint32(5)
	var zb0001Mask uint8 /* 5 bits */
	_ = zb0001Mask
	if z.Logger == nil {
		zb0001Len--
		zb0001Mask |= 0x2
	}
	if z.Audit == nil {
		zb0001Len--
		zb0001Mask |= 0x4
	}
	if z.Notifications == nil {
		zb0001Len--
		zb0001Mask |= 0x8
	}
	if z.KMSStatus == nil {
		zb0001Len--
		zb0001Mask |= 0x10
	}
	// variable map header, size zb0001Len
	o = append(o, 0x80|uint8(zb0001Len))

	// skip if no fields are to be emitted
	if zb0001Len != 0 {
		// string "l"
		o = append(o, 0xa1, 0x6c)
		o, err = z.LDAP.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "LDAP")
			return
		}
		if (zb0001Mask & 0x2) == 0 { // if not omitted
			// string "lg"
			o = append(o, 0xa2, 0x6c, 0x67)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Logger)))
			for za0001 := range z.Logger {
				o, err = z.Logger[za0001].MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "Logger", za0001)
					return
				}
			}
		}
		if (zb0001Mask & 0x4) == 0 { // if not omitted
			// string "a"
			o = append(o, 0xa1, 0x61)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Audit)))
			for za0002 := range z.Audit {
				o, err = z.Audit[za0002].MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "Audit", za0002)
					return
				}
			}
		}
		if (zb0001Mask & 0x8) == 0 { // if not omitted
			// string "n"
			o = append(o, 0xa1, 0x6e)
			o = msgp.AppendArrayHeader(o, uint32(len(z.Notifications)))
			for za0003 := range z.Notifications {
				o = msgp.AppendMapHeader(o, uint32(len(z.Notifications[za0003])))
				for za0004, za0005 := range z.Notifications[za0003] {
					o = msgp.AppendString(o, za0004)
					o = msgp.AppendArrayHeader(o, uint32(len(za0005)))
					for za0006 := range za0005 {
						o, err = za0005[za0006].MarshalMsg(o)
						if err != nil {
							err = msgp.WrapError(err, "Notifications", za0003, za0004, za0006)
							return
						}
					}
				}
			}
		}
		if (zb0001Mask & 0x10) == 0 { // if not omitted
			// string "k"
			o = append(o, 0xa1, 0x6b)
			o = msgp.AppendArrayHeader(o, uint32(len(z.KMSStatus)))
			for za0007 := range z.KMSStatus {
				o, err = z.KMSStatus[za0007].MarshalMsg(o)
				if err != nil {
					err = msgp.WrapError(err, "KMSStatus", za0007)
					return
				}
			}
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ServicesResourceInfo) UnmarshalMsg(bts []byte) (o []byte, err error) {
	var field []byte
	_ = field
	var zb0001 uint32
	zb0001, bts, err = msgp.ReadMapHeaderBytes(bts)
	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	var zb0001Mask uint8 /* 4 bits */
	_ = zb0001Mask
	for zb0001 > 0 {
		zb0001--
		field, bts, err = msgp.ReadMapKeyZC(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		switch msgp.UnsafeString(field) {
		case "l":
			bts, err = z.LDAP.UnmarshalMsg(bts)
			if err != nil {
				err = msgp.WrapError(err, "LDAP")
				return
			}
		case "lg":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Logger")
				return
			}
			if cap(z.Logger) >= int(zb0002) {
				z.Logger = (z.Logger)[:zb0002]
			} else {
				z.Logger = make([]Logger, zb0002)
			}
			for za0001 := range z.Logger {
				bts, err = z.Logger[za0001].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Logger", za0001)
					return
				}
			}
			zb0001Mask |= 0x1
		case "a":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Audit")
				return
			}
			if cap(z.Audit) >= int(zb0003) {
				z.Audit = (z.Audit)[:zb0003]
			} else {
				z.Audit = make([]Audit, zb0003)
			}
			for za0002 := range z.Audit {
				bts, err = z.Audit[za0002].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Audit", za0002)
					return
				}
			}
			zb0001Mask |= 0x2
		case "n":
			var zb0004 uint32
			zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Notifications")
				return
			}
			if cap(z.Notifications) >= int(zb0004) {
				z.Notifications = (z.Notifications)[:zb0004]
			} else {
				z.Notifications = make([]map[string][]TargetIDStatus, zb0004)
			}
			for za0003 := range z.Notifications {
				var zb0005 uint32
				zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Notifications", za0003)
					return
				}
				if z.Notifications[za0003] == nil {
					z.Notifications[za0003] = make(map[string][]TargetIDStatus, zb0005)
				} else if len(z.Notifications[za0003]) > 0 {
					for key := range z.Notifications[za0003] {
						delete(z.Notifications[za0003], key)
					}
				}
				for zb0005 > 0 {
					var za0004 string
					var za0005 []TargetIDStatus
					zb0005--
					za0004, bts, err = msgp.ReadStringBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Notifications", za0003)
						return
					}
					var zb0006 uint32
					zb0006, bts, err = msgp.ReadArrayHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Notifications", za0003, za0004)
						return
					}
					if cap(za0005) >= int(zb0006) {
						za0005 = (za0005)[:zb0006]
					} else {
						za0005 = make([]TargetIDStatus, zb0006)
					}
					for za0006 := range za0005 {
						bts, err = za0005[za0006].UnmarshalMsg(bts)
						if err != nil {
							err = msgp.WrapError(err, "Notifications", za0003, za0004, za0006)
							return
						}
					}
					z.Notifications[za0003][za0004] = za0005
				}
			}
			zb0001Mask |= 0x4
		case "k":
			var zb0007 uint32
			zb0007, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "KMSStatus")
				return
			}
			if cap(z.KMSStatus) >= int(zb0007) {
				z.KMSStatus = (z.KMSStatus)[:zb0007]
			} else {
				z.KMSStatus = make([]KMS, zb0007)
			}
			for za0007 := range z.KMSStatus {
				bts, err = z.KMSStatus[za0007].UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "KMSStatus", za0007)
					return
				}
			}
			zb0001Mask |= 0x8
		default:
			bts, err = msgp.Skip(bts)
			if err != nil {
				err = msgp.WrapError(err)
				return
			}
		}
	}
	// Clear omitted fields.
	if zb0001Mask != 0xf {
		if (zb0001Mask & 0x1) == 0 {
			z.Logger = nil
		}
		if (zb0001Mask & 0x2) == 0 {
			z.Audit = nil
		}
		if (zb0001Mask & 0x4) == 0 {
			z.Notifications = nil
		}
		if (zb0001Mask & 0x8) == 0 {
			z.KMSStatus = nil
		}
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z *ServicesResourceInfo) Msgsize() (s int) {
	s = 1 + 2 + z.LDAP.Msgsize() + 3 + msgp.ArrayHeaderSize
	for za0001 := range z.Logger {
		s += z.Logger[za0001].Msgsize()
	}
	s += 2 + msgp.ArrayHeaderSize
	for za0002 := range z.Audit {
		s += z.Audit[za0002].Msgsize()
	}
	s += 2 + msgp.ArrayHeaderSize
	for za0003 := range z.Notifications {
		s += msgp.MapHeaderSize
		if z.Notifications[za0003] != nil {
			for za0004, za0005 := range z.Notifications[za0003] {
				_ = za0005
				s += msgp.StringPrefixSize + len(za0004) + msgp.ArrayHeaderSize
				for za0006 := range za0005 {
					s += za0005[za0006].Msgsize()
				}
			}
		}
	}
	s += 2 + msgp.ArrayHeaderSize
	for za0007 := range z.KMSStatus {
		s += z.KMSStatus[za0007].Msgsize()
	}
	return
}