remoteconfig_gen.go

package core

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

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

// MarshalMsg implements msgp.Marshaler
func (z *Client) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 11
	// string "State"
	o = append(o, 0x8b, 0xa5, 0x53, 0x74, 0x61, 0x74, 0x65)
	if z.State == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.State.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "State")
			return
		}
	}
	// string "Id"
	o = append(o, 0xa2, 0x49, 0x64)
	o = msgp.AppendString(o, z.Id)
	// string "Products"
	o = append(o, 0xa8, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Products)))
	for za0001 := range z.Products {
		o = msgp.AppendString(o, z.Products[za0001])
	}
	// string "IsTracer"
	o = append(o, 0xa8, 0x49, 0x73, 0x54, 0x72, 0x61, 0x63, 0x65, 0x72)
	o = msgp.AppendBool(o, z.IsTracer)
	// string "ClientTracer"
	o = append(o, 0xac, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x54, 0x72, 0x61, 0x63, 0x65, 0x72)
	if z.ClientTracer == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.ClientTracer.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "ClientTracer")
			return
		}
	}
	// string "IsAgent"
	o = append(o, 0xa7, 0x49, 0x73, 0x41, 0x67, 0x65, 0x6e, 0x74)
	o = msgp.AppendBool(o, z.IsAgent)
	// string "ClientAgent"
	o = append(o, 0xab, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x41, 0x67, 0x65, 0x6e, 0x74)
	if z.ClientAgent == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.ClientAgent.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "ClientAgent")
			return
		}
	}
	// string "LastSeen"
	o = append(o, 0xa8, 0x4c, 0x61, 0x73, 0x74, 0x53, 0x65, 0x65, 0x6e)
	o = msgp.AppendUint64(o, z.LastSeen)
	// string "Capabilities"
	o = append(o, 0xac, 0x43, 0x61, 0x70, 0x61, 0x62, 0x69, 0x6c, 0x69, 0x74, 0x69, 0x65, 0x73)
	o = msgp.AppendBytes(o, z.Capabilities)
	// string "IsUpdater"
	o = append(o, 0xa9, 0x49, 0x73, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x72)
	o = msgp.AppendBool(o, z.IsUpdater)
	// string "ClientUpdater"
	o = append(o, 0xad, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x55, 0x70, 0x64, 0x61, 0x74, 0x65, 0x72)
	if z.ClientUpdater == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.ClientUpdater.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "ClientUpdater")
			return
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *Client) 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 "State":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.State = nil
			} else {
				if z.State == nil {
					z.State = new(ClientState)
				}
				bts, err = z.State.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "State")
					return
				}
			}
		case "Id":
			z.Id, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Id")
				return
			}
		case "Products":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Products")
				return
			}
			if cap(z.Products) >= int(zb0002) {
				z.Products = (z.Products)[:zb0002]
			} else {
				z.Products = make([]string, zb0002)
			}
			for za0001 := range z.Products {
				z.Products[za0001], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Products", za0001)
					return
				}
			}
		case "IsTracer":
			z.IsTracer, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "IsTracer")
				return
			}
		case "ClientTracer":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.ClientTracer = nil
			} else {
				if z.ClientTracer == nil {
					z.ClientTracer = new(ClientTracer)
				}
				bts, err = z.ClientTracer.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "ClientTracer")
					return
				}
			}
		case "IsAgent":
			z.IsAgent, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "IsAgent")
				return
			}
		case "ClientAgent":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.ClientAgent = nil
			} else {
				if z.ClientAgent == nil {
					z.ClientAgent = new(ClientAgent)
				}
				bts, err = z.ClientAgent.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "ClientAgent")
					return
				}
			}
		case "LastSeen":
			z.LastSeen, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "LastSeen")
				return
			}
		case "Capabilities":
			z.Capabilities, bts, err = msgp.ReadBytesBytes(bts, z.Capabilities)
			if err != nil {
				err = msgp.WrapError(err, "Capabilities")
				return
			}
		case "IsUpdater":
			z.IsUpdater, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "IsUpdater")
				return
			}
		case "ClientUpdater":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.ClientUpdater = nil
			} else {
				if z.ClientUpdater == nil {
					z.ClientUpdater = new(ClientUpdater)
				}
				bts, err = z.ClientUpdater.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "ClientUpdater")
					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 *Client) Msgsize() (s int) {
	s = 1 + 6
	if z.State == nil {
		s += msgp.NilSize
	} else {
		s += z.State.Msgsize()
	}
	s += 3 + msgp.StringPrefixSize + len(z.Id) + 9 + msgp.ArrayHeaderSize
	for za0001 := range z.Products {
		s += msgp.StringPrefixSize + len(z.Products[za0001])
	}
	s += 9 + msgp.BoolSize + 13
	if z.ClientTracer == nil {
		s += msgp.NilSize
	} else {
		s += z.ClientTracer.Msgsize()
	}
	s += 8 + msgp.BoolSize + 12
	if z.ClientAgent == nil {
		s += msgp.NilSize
	} else {
		s += z.ClientAgent.Msgsize()
	}
	s += 9 + msgp.Uint64Size + 13 + msgp.BytesPrefixSize + len(z.Capabilities) + 10 + msgp.BoolSize + 14
	if z.ClientUpdater == nil {
		s += msgp.NilSize
	} else {
		s += z.ClientUpdater.Msgsize()
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ClientAgent) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 5
	// string "Name"
	o = append(o, 0x85, 0xa4, 0x4e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Name)
	// string "Version"
	o = append(o, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.Version)
	// string "ClusterName"
	o = append(o, 0xab, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x4e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.ClusterName)
	// string "ClusterId"
	o = append(o, 0xa9, 0x43, 0x6c, 0x75, 0x73, 0x74, 0x65, 0x72, 0x49, 0x64)
	o = msgp.AppendString(o, z.ClusterId)
	// string "CwsWorkloads"
	o = append(o, 0xac, 0x43, 0x77, 0x73, 0x57, 0x6f, 0x72, 0x6b, 0x6c, 0x6f, 0x61, 0x64, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.CwsWorkloads)))
	for za0001 := range z.CwsWorkloads {
		o = msgp.AppendString(o, z.CwsWorkloads[za0001])
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ClientAgent) 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 "Name":
			z.Name, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Name")
				return
			}
		case "Version":
			z.Version, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Version")
				return
			}
		case "ClusterName":
			z.ClusterName, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ClusterName")
				return
			}
		case "ClusterId":
			z.ClusterId, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ClusterId")
				return
			}
		case "CwsWorkloads":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "CwsWorkloads")
				return
			}
			if cap(z.CwsWorkloads) >= int(zb0002) {
				z.CwsWorkloads = (z.CwsWorkloads)[:zb0002]
			} else {
				z.CwsWorkloads = make([]string, zb0002)
			}
			for za0001 := range z.CwsWorkloads {
				z.CwsWorkloads[za0001], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "CwsWorkloads", za0001)
					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 *ClientAgent) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Name) + 8 + msgp.StringPrefixSize + len(z.Version) + 12 + msgp.StringPrefixSize + len(z.ClusterName) + 10 + msgp.StringPrefixSize + len(z.ClusterId) + 13 + msgp.ArrayHeaderSize
	for za0001 := range z.CwsWorkloads {
		s += msgp.StringPrefixSize + len(z.CwsWorkloads[za0001])
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ClientGetConfigsRequest) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Client"
	o = append(o, 0x82, 0xa6, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74)
	if z.Client == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.Client.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "Client")
			return
		}
	}
	// string "CachedTargetFiles"
	o = append(o, 0xb1, 0x43, 0x61, 0x63, 0x68, 0x65, 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.CachedTargetFiles)))
	for za0001 := range z.CachedTargetFiles {
		if z.CachedTargetFiles[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.CachedTargetFiles[za0001].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "CachedTargetFiles", za0001)
				return
			}
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ClientGetConfigsRequest) 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 "Client":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Client = nil
			} else {
				if z.Client == nil {
					z.Client = new(Client)
				}
				bts, err = z.Client.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "Client")
					return
				}
			}
		case "CachedTargetFiles":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "CachedTargetFiles")
				return
			}
			if cap(z.CachedTargetFiles) >= int(zb0002) {
				z.CachedTargetFiles = (z.CachedTargetFiles)[:zb0002]
			} else {
				z.CachedTargetFiles = make([]*TargetFileMeta, zb0002)
			}
			for za0001 := range z.CachedTargetFiles {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.CachedTargetFiles[za0001] = nil
				} else {
					if z.CachedTargetFiles[za0001] == nil {
						z.CachedTargetFiles[za0001] = new(TargetFileMeta)
					}
					bts, err = z.CachedTargetFiles[za0001].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "CachedTargetFiles", za0001)
						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 *ClientGetConfigsRequest) Msgsize() (s int) {
	s = 1 + 7
	if z.Client == nil {
		s += msgp.NilSize
	} else {
		s += z.Client.Msgsize()
	}
	s += 18 + msgp.ArrayHeaderSize
	for za0001 := range z.CachedTargetFiles {
		if z.CachedTargetFiles[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += z.CachedTargetFiles[za0001].Msgsize()
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ClientGetConfigsResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "Roots"
	o = append(o, 0x84, 0xa5, 0x52, 0x6f, 0x6f, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Roots)))
	for za0001 := range z.Roots {
		o = msgp.AppendBytes(o, z.Roots[za0001])
	}
	// string "Targets"
	o = append(o, 0xa7, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73)
	o = msgp.AppendBytes(o, z.Targets)
	// string "TargetFiles"
	o = append(o, 0xab, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.TargetFiles)))
	for za0002 := range z.TargetFiles {
		if z.TargetFiles[za0002] == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 2
			// string "Path"
			o = append(o, 0x82, 0xa4, 0x50, 0x61, 0x74, 0x68)
			o = msgp.AppendString(o, z.TargetFiles[za0002].Path)
			// string "Raw"
			o = append(o, 0xa3, 0x52, 0x61, 0x77)
			o = msgp.AppendBytes(o, z.TargetFiles[za0002].Raw)
		}
	}
	// string "ClientConfigs"
	o = append(o, 0xad, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.ClientConfigs)))
	for za0003 := range z.ClientConfigs {
		o = msgp.AppendString(o, z.ClientConfigs[za0003])
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ClientGetConfigsResponse) 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 "Roots":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Roots")
				return
			}
			if cap(z.Roots) >= int(zb0002) {
				z.Roots = (z.Roots)[:zb0002]
			} else {
				z.Roots = make([][]byte, zb0002)
			}
			for za0001 := range z.Roots {
				z.Roots[za0001], bts, err = msgp.ReadBytesBytes(bts, z.Roots[za0001])
				if err != nil {
					err = msgp.WrapError(err, "Roots", za0001)
					return
				}
			}
		case "Targets":
			z.Targets, bts, err = msgp.ReadBytesBytes(bts, z.Targets)
			if err != nil {
				err = msgp.WrapError(err, "Targets")
				return
			}
		case "TargetFiles":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TargetFiles")
				return
			}
			if cap(z.TargetFiles) >= int(zb0003) {
				z.TargetFiles = (z.TargetFiles)[:zb0003]
			} else {
				z.TargetFiles = make([]*File, zb0003)
			}
			for za0002 := range z.TargetFiles {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.TargetFiles[za0002] = nil
				} else {
					if z.TargetFiles[za0002] == nil {
						z.TargetFiles[za0002] = new(File)
					}
					var zb0004 uint32
					zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "TargetFiles", za0002)
						return
					}
					for zb0004 > 0 {
						zb0004--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "TargetFiles", za0002)
							return
						}
						switch msgp.UnsafeString(field) {
						case "Path":
							z.TargetFiles[za0002].Path, bts, err = msgp.ReadStringBytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "TargetFiles", za0002, "Path")
								return
							}
						case "Raw":
							z.TargetFiles[za0002].Raw, bts, err = msgp.ReadBytesBytes(bts, z.TargetFiles[za0002].Raw)
							if err != nil {
								err = msgp.WrapError(err, "TargetFiles", za0002, "Raw")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "TargetFiles", za0002)
								return
							}
						}
					}
				}
			}
		case "ClientConfigs":
			var zb0005 uint32
			zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ClientConfigs")
				return
			}
			if cap(z.ClientConfigs) >= int(zb0005) {
				z.ClientConfigs = (z.ClientConfigs)[:zb0005]
			} else {
				z.ClientConfigs = make([]string, zb0005)
			}
			for za0003 := range z.ClientConfigs {
				z.ClientConfigs[za0003], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "ClientConfigs", za0003)
					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 *ClientGetConfigsResponse) Msgsize() (s int) {
	s = 1 + 6 + msgp.ArrayHeaderSize
	for za0001 := range z.Roots {
		s += msgp.BytesPrefixSize + len(z.Roots[za0001])
	}
	s += 8 + msgp.BytesPrefixSize + len(z.Targets) + 12 + msgp.ArrayHeaderSize
	for za0002 := range z.TargetFiles {
		if z.TargetFiles[za0002] == nil {
			s += msgp.NilSize
		} else {
			s += 1 + 5 + msgp.StringPrefixSize + len(z.TargetFiles[za0002].Path) + 4 + msgp.BytesPrefixSize + len(z.TargetFiles[za0002].Raw)
		}
	}
	s += 14 + msgp.ArrayHeaderSize
	for za0003 := range z.ClientConfigs {
		s += msgp.StringPrefixSize + len(z.ClientConfigs[za0003])
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ClientState) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 6
	// string "RootVersion"
	o = append(o, 0x86, 0xab, 0x52, 0x6f, 0x6f, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendUint64(o, z.RootVersion)
	// string "TargetsVersion"
	o = append(o, 0xae, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendUint64(o, z.TargetsVersion)
	// string "ConfigStates"
	o = append(o, 0xac, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.ConfigStates)))
	for za0001 := range z.ConfigStates {
		if z.ConfigStates[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.ConfigStates[za0001].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "ConfigStates", za0001)
				return
			}
		}
	}
	// string "HasError"
	o = append(o, 0xa8, 0x48, 0x61, 0x73, 0x45, 0x72, 0x72, 0x6f, 0x72)
	o = msgp.AppendBool(o, z.HasError)
	// string "Error"
	o = append(o, 0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72)
	o = msgp.AppendString(o, z.Error)
	// string "BackendClientState"
	o = append(o, 0xb2, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65)
	o = msgp.AppendBytes(o, z.BackendClientState)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ClientState) 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 "RootVersion":
			z.RootVersion, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RootVersion")
				return
			}
		case "TargetsVersion":
			z.TargetsVersion, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TargetsVersion")
				return
			}
		case "ConfigStates":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ConfigStates")
				return
			}
			if cap(z.ConfigStates) >= int(zb0002) {
				z.ConfigStates = (z.ConfigStates)[:zb0002]
			} else {
				z.ConfigStates = make([]*ConfigState, zb0002)
			}
			for za0001 := range z.ConfigStates {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.ConfigStates[za0001] = nil
				} else {
					if z.ConfigStates[za0001] == nil {
						z.ConfigStates[za0001] = new(ConfigState)
					}
					bts, err = z.ConfigStates[za0001].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "ConfigStates", za0001)
						return
					}
				}
			}
		case "HasError":
			z.HasError, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "HasError")
				return
			}
		case "Error":
			z.Error, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Error")
				return
			}
		case "BackendClientState":
			z.BackendClientState, bts, err = msgp.ReadBytesBytes(bts, z.BackendClientState)
			if err != nil {
				err = msgp.WrapError(err, "BackendClientState")
				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 *ClientState) Msgsize() (s int) {
	s = 1 + 12 + msgp.Uint64Size + 15 + msgp.Uint64Size + 13 + msgp.ArrayHeaderSize
	for za0001 := range z.ConfigStates {
		if z.ConfigStates[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += z.ConfigStates[za0001].Msgsize()
		}
	}
	s += 9 + msgp.BoolSize + 6 + msgp.StringPrefixSize + len(z.Error) + 19 + msgp.BytesPrefixSize + len(z.BackendClientState)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ClientTracer) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 8
	// string "RuntimeId"
	o = append(o, 0x88, 0xa9, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x49, 0x64)
	o = msgp.AppendString(o, z.RuntimeId)
	// string "Language"
	o = append(o, 0xa8, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65)
	o = msgp.AppendString(o, z.Language)
	// string "TracerVersion"
	o = append(o, 0xad, 0x54, 0x72, 0x61, 0x63, 0x65, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.TracerVersion)
	// string "Service"
	o = append(o, 0xa7, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65)
	o = msgp.AppendString(o, z.Service)
	// string "ExtraServices"
	o = append(o, 0xad, 0x45, 0x78, 0x74, 0x72, 0x61, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.ExtraServices)))
	for za0001 := range z.ExtraServices {
		o = msgp.AppendString(o, z.ExtraServices[za0001])
	}
	// string "Env"
	o = append(o, 0xa3, 0x45, 0x6e, 0x76)
	o = msgp.AppendString(o, z.Env)
	// string "AppVersion"
	o = append(o, 0xaa, 0x41, 0x70, 0x70, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.AppVersion)
	// string "Tags"
	o = append(o, 0xa4, 0x54, 0x61, 0x67, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Tags)))
	for za0002 := range z.Tags {
		o = msgp.AppendString(o, z.Tags[za0002])
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ClientTracer) 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 "RuntimeId":
			z.RuntimeId, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RuntimeId")
				return
			}
		case "Language":
			z.Language, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Language")
				return
			}
		case "TracerVersion":
			z.TracerVersion, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TracerVersion")
				return
			}
		case "Service":
			z.Service, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Service")
				return
			}
		case "ExtraServices":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ExtraServices")
				return
			}
			if cap(z.ExtraServices) >= int(zb0002) {
				z.ExtraServices = (z.ExtraServices)[:zb0002]
			} else {
				z.ExtraServices = make([]string, zb0002)
			}
			for za0001 := range z.ExtraServices {
				z.ExtraServices[za0001], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "ExtraServices", za0001)
					return
				}
			}
		case "Env":
			z.Env, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Env")
				return
			}
		case "AppVersion":
			z.AppVersion, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AppVersion")
				return
			}
		case "Tags":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Tags")
				return
			}
			if cap(z.Tags) >= int(zb0003) {
				z.Tags = (z.Tags)[:zb0003]
			} else {
				z.Tags = make([]string, zb0003)
			}
			for za0002 := range z.Tags {
				z.Tags[za0002], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Tags", za0002)
					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 *ClientTracer) Msgsize() (s int) {
	s = 1 + 10 + msgp.StringPrefixSize + len(z.RuntimeId) + 9 + msgp.StringPrefixSize + len(z.Language) + 14 + msgp.StringPrefixSize + len(z.TracerVersion) + 8 + msgp.StringPrefixSize + len(z.Service) + 14 + msgp.ArrayHeaderSize
	for za0001 := range z.ExtraServices {
		s += msgp.StringPrefixSize + len(z.ExtraServices[za0001])
	}
	s += 4 + msgp.StringPrefixSize + len(z.Env) + 11 + msgp.StringPrefixSize + len(z.AppVersion) + 5 + msgp.ArrayHeaderSize
	for za0002 := range z.Tags {
		s += msgp.StringPrefixSize + len(z.Tags[za0002])
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ClientUpdater) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Tags"
	o = append(o, 0x82, 0xa4, 0x54, 0x61, 0x67, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Tags)))
	for za0001 := range z.Tags {
		o = msgp.AppendString(o, z.Tags[za0001])
	}
	// string "Packages"
	o = append(o, 0xa8, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Packages)))
	for za0002 := range z.Packages {
		if z.Packages[za0002] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.Packages[za0002].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "Packages", za0002)
				return
			}
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ClientUpdater) 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 "Tags":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Tags")
				return
			}
			if cap(z.Tags) >= int(zb0002) {
				z.Tags = (z.Tags)[:zb0002]
			} else {
				z.Tags = make([]string, zb0002)
			}
			for za0001 := range z.Tags {
				z.Tags[za0001], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Tags", za0001)
					return
				}
			}
		case "Packages":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Packages")
				return
			}
			if cap(z.Packages) >= int(zb0003) {
				z.Packages = (z.Packages)[:zb0003]
			} else {
				z.Packages = make([]*PackageState, zb0003)
			}
			for za0002 := range z.Packages {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.Packages[za0002] = nil
				} else {
					if z.Packages[za0002] == nil {
						z.Packages[za0002] = new(PackageState)
					}
					bts, err = z.Packages[za0002].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "Packages", za0002)
						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 *ClientUpdater) Msgsize() (s int) {
	s = 1 + 5 + msgp.ArrayHeaderSize
	for za0001 := range z.Tags {
		s += msgp.StringPrefixSize + len(z.Tags[za0001])
	}
	s += 9 + msgp.ArrayHeaderSize
	for za0002 := range z.Packages {
		if z.Packages[za0002] == nil {
			s += msgp.NilSize
		} else {
			s += z.Packages[za0002].Msgsize()
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ConfigMetas) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 5
	// string "Roots"
	o = append(o, 0x85, 0xa5, 0x52, 0x6f, 0x6f, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Roots)))
	for za0001 := range z.Roots {
		if z.Roots[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 2
			// string "Version"
			o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
			o = msgp.AppendUint64(o, z.Roots[za0001].Version)
			// string "Raw"
			o = append(o, 0xa3, 0x52, 0x61, 0x77)
			o = msgp.AppendBytes(o, z.Roots[za0001].Raw)
		}
	}
	// string "Timestamp"
	o = append(o, 0xa9, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70)
	if z.Timestamp == nil {
		o = msgp.AppendNil(o)
	} else {
		// map header, size 2
		// string "Version"
		o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
		o = msgp.AppendUint64(o, z.Timestamp.Version)
		// string "Raw"
		o = append(o, 0xa3, 0x52, 0x61, 0x77)
		o = msgp.AppendBytes(o, z.Timestamp.Raw)
	}
	// string "Snapshot"
	o = append(o, 0xa8, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74)
	if z.Snapshot == nil {
		o = msgp.AppendNil(o)
	} else {
		// map header, size 2
		// string "Version"
		o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
		o = msgp.AppendUint64(o, z.Snapshot.Version)
		// string "Raw"
		o = append(o, 0xa3, 0x52, 0x61, 0x77)
		o = msgp.AppendBytes(o, z.Snapshot.Raw)
	}
	// string "TopTargets"
	o = append(o, 0xaa, 0x54, 0x6f, 0x70, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73)
	if z.TopTargets == nil {
		o = msgp.AppendNil(o)
	} else {
		// map header, size 2
		// string "Version"
		o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
		o = msgp.AppendUint64(o, z.TopTargets.Version)
		// string "Raw"
		o = append(o, 0xa3, 0x52, 0x61, 0x77)
		o = msgp.AppendBytes(o, z.TopTargets.Raw)
	}
	// string "DelegatedTargets"
	o = append(o, 0xb0, 0x44, 0x65, 0x6c, 0x65, 0x67, 0x61, 0x74, 0x65, 0x64, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.DelegatedTargets)))
	for za0002 := range z.DelegatedTargets {
		if z.DelegatedTargets[za0002] == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 3
			// string "Version"
			o = append(o, 0x83, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
			o = msgp.AppendUint64(o, z.DelegatedTargets[za0002].Version)
			// string "Role"
			o = append(o, 0xa4, 0x52, 0x6f, 0x6c, 0x65)
			o = msgp.AppendString(o, z.DelegatedTargets[za0002].Role)
			// string "Raw"
			o = append(o, 0xa3, 0x52, 0x61, 0x77)
			o = msgp.AppendBytes(o, z.DelegatedTargets[za0002].Raw)
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ConfigMetas) 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 "Roots":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Roots")
				return
			}
			if cap(z.Roots) >= int(zb0002) {
				z.Roots = (z.Roots)[:zb0002]
			} else {
				z.Roots = make([]*TopMeta, zb0002)
			}
			for za0001 := range z.Roots {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.Roots[za0001] = nil
				} else {
					if z.Roots[za0001] == nil {
						z.Roots[za0001] = new(TopMeta)
					}
					var zb0003 uint32
					zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Roots", za0001)
						return
					}
					for zb0003 > 0 {
						zb0003--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "Roots", za0001)
							return
						}
						switch msgp.UnsafeString(field) {
						case "Version":
							z.Roots[za0001].Version, bts, err = msgp.ReadUint64Bytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "Roots", za0001, "Version")
								return
							}
						case "Raw":
							z.Roots[za0001].Raw, bts, err = msgp.ReadBytesBytes(bts, z.Roots[za0001].Raw)
							if err != nil {
								err = msgp.WrapError(err, "Roots", za0001, "Raw")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "Roots", za0001)
								return
							}
						}
					}
				}
			}
		case "Timestamp":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Timestamp = nil
			} else {
				if z.Timestamp == nil {
					z.Timestamp = new(TopMeta)
				}
				var zb0004 uint32
				zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Timestamp")
					return
				}
				for zb0004 > 0 {
					zb0004--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "Timestamp")
						return
					}
					switch msgp.UnsafeString(field) {
					case "Version":
						z.Timestamp.Version, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Timestamp", "Version")
							return
						}
					case "Raw":
						z.Timestamp.Raw, bts, err = msgp.ReadBytesBytes(bts, z.Timestamp.Raw)
						if err != nil {
							err = msgp.WrapError(err, "Timestamp", "Raw")
							return
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "Timestamp")
							return
						}
					}
				}
			}
		case "Snapshot":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Snapshot = nil
			} else {
				if z.Snapshot == nil {
					z.Snapshot = new(TopMeta)
				}
				var zb0005 uint32
				zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Snapshot")
					return
				}
				for zb0005 > 0 {
					zb0005--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "Snapshot")
						return
					}
					switch msgp.UnsafeString(field) {
					case "Version":
						z.Snapshot.Version, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Snapshot", "Version")
							return
						}
					case "Raw":
						z.Snapshot.Raw, bts, err = msgp.ReadBytesBytes(bts, z.Snapshot.Raw)
						if err != nil {
							err = msgp.WrapError(err, "Snapshot", "Raw")
							return
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "Snapshot")
							return
						}
					}
				}
			}
		case "TopTargets":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.TopTargets = nil
			} else {
				if z.TopTargets == nil {
					z.TopTargets = new(TopMeta)
				}
				var zb0006 uint32
				zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TopTargets")
					return
				}
				for zb0006 > 0 {
					zb0006--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "TopTargets")
						return
					}
					switch msgp.UnsafeString(field) {
					case "Version":
						z.TopTargets.Version, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "TopTargets", "Version")
							return
						}
					case "Raw":
						z.TopTargets.Raw, bts, err = msgp.ReadBytesBytes(bts, z.TopTargets.Raw)
						if err != nil {
							err = msgp.WrapError(err, "TopTargets", "Raw")
							return
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "TopTargets")
							return
						}
					}
				}
			}
		case "DelegatedTargets":
			var zb0007 uint32
			zb0007, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DelegatedTargets")
				return
			}
			if cap(z.DelegatedTargets) >= int(zb0007) {
				z.DelegatedTargets = (z.DelegatedTargets)[:zb0007]
			} else {
				z.DelegatedTargets = make([]*DelegatedMeta, zb0007)
			}
			for za0002 := range z.DelegatedTargets {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.DelegatedTargets[za0002] = nil
				} else {
					if z.DelegatedTargets[za0002] == nil {
						z.DelegatedTargets[za0002] = new(DelegatedMeta)
					}
					var zb0008 uint32
					zb0008, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "DelegatedTargets", za0002)
						return
					}
					for zb0008 > 0 {
						zb0008--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "DelegatedTargets", za0002)
							return
						}
						switch msgp.UnsafeString(field) {
						case "Version":
							z.DelegatedTargets[za0002].Version, bts, err = msgp.ReadUint64Bytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "DelegatedTargets", za0002, "Version")
								return
							}
						case "Role":
							z.DelegatedTargets[za0002].Role, bts, err = msgp.ReadStringBytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "DelegatedTargets", za0002, "Role")
								return
							}
						case "Raw":
							z.DelegatedTargets[za0002].Raw, bts, err = msgp.ReadBytesBytes(bts, z.DelegatedTargets[za0002].Raw)
							if err != nil {
								err = msgp.WrapError(err, "DelegatedTargets", za0002, "Raw")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "DelegatedTargets", za0002)
								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 *ConfigMetas) Msgsize() (s int) {
	s = 1 + 6 + msgp.ArrayHeaderSize
	for za0001 := range z.Roots {
		if z.Roots[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += 1 + 8 + msgp.Uint64Size + 4 + msgp.BytesPrefixSize + len(z.Roots[za0001].Raw)
		}
	}
	s += 10
	if z.Timestamp == nil {
		s += msgp.NilSize
	} else {
		s += 1 + 8 + msgp.Uint64Size + 4 + msgp.BytesPrefixSize + len(z.Timestamp.Raw)
	}
	s += 9
	if z.Snapshot == nil {
		s += msgp.NilSize
	} else {
		s += 1 + 8 + msgp.Uint64Size + 4 + msgp.BytesPrefixSize + len(z.Snapshot.Raw)
	}
	s += 11
	if z.TopTargets == nil {
		s += msgp.NilSize
	} else {
		s += 1 + 8 + msgp.Uint64Size + 4 + msgp.BytesPrefixSize + len(z.TopTargets.Raw)
	}
	s += 17 + msgp.ArrayHeaderSize
	for za0002 := range z.DelegatedTargets {
		if z.DelegatedTargets[za0002] == nil {
			s += msgp.NilSize
		} else {
			s += 1 + 8 + msgp.Uint64Size + 5 + msgp.StringPrefixSize + len(z.DelegatedTargets[za0002].Role) + 4 + msgp.BytesPrefixSize + len(z.DelegatedTargets[za0002].Raw)
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *ConfigState) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 5
	// string "Id"
	o = append(o, 0x85, 0xa2, 0x49, 0x64)
	o = msgp.AppendString(o, z.Id)
	// string "Version"
	o = append(o, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendUint64(o, z.Version)
	// string "Product"
	o = append(o, 0xa7, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74)
	o = msgp.AppendString(o, z.Product)
	// string "ApplyState"
	o = append(o, 0xaa, 0x41, 0x70, 0x70, 0x6c, 0x79, 0x53, 0x74, 0x61, 0x74, 0x65)
	o = msgp.AppendUint64(o, z.ApplyState)
	// string "ApplyError"
	o = append(o, 0xaa, 0x41, 0x70, 0x70, 0x6c, 0x79, 0x45, 0x72, 0x72, 0x6f, 0x72)
	o = msgp.AppendString(o, z.ApplyError)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ConfigState) 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 "Id":
			z.Id, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Id")
				return
			}
		case "Version":
			z.Version, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Version")
				return
			}
		case "Product":
			z.Product, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Product")
				return
			}
		case "ApplyState":
			z.ApplyState, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ApplyState")
				return
			}
		case "ApplyError":
			z.ApplyError, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ApplyError")
				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 *ConfigState) Msgsize() (s int) {
	s = 1 + 3 + msgp.StringPrefixSize + len(z.Id) + 8 + msgp.Uint64Size + 8 + msgp.StringPrefixSize + len(z.Product) + 11 + msgp.Uint64Size + 11 + msgp.StringPrefixSize + len(z.ApplyError)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *DelegatedMeta) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "Version"
	o = append(o, 0x83, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendUint64(o, z.Version)
	// string "Role"
	o = append(o, 0xa4, 0x52, 0x6f, 0x6c, 0x65)
	o = msgp.AppendString(o, z.Role)
	// string "Raw"
	o = append(o, 0xa3, 0x52, 0x61, 0x77)
	o = msgp.AppendBytes(o, z.Raw)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *DelegatedMeta) 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 "Version":
			z.Version, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Version")
				return
			}
		case "Role":
			z.Role, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Role")
				return
			}
		case "Raw":
			z.Raw, bts, err = msgp.ReadBytesBytes(bts, z.Raw)
			if err != nil {
				err = msgp.WrapError(err, "Raw")
				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 *DelegatedMeta) Msgsize() (s int) {
	s = 1 + 8 + msgp.Uint64Size + 5 + msgp.StringPrefixSize + len(z.Role) + 4 + msgp.BytesPrefixSize + len(z.Raw)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *DirectorMetas) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "Roots"
	o = append(o, 0x84, 0xa5, 0x52, 0x6f, 0x6f, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Roots)))
	for za0001 := range z.Roots {
		if z.Roots[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 2
			// string "Version"
			o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
			o = msgp.AppendUint64(o, z.Roots[za0001].Version)
			// string "Raw"
			o = append(o, 0xa3, 0x52, 0x61, 0x77)
			o = msgp.AppendBytes(o, z.Roots[za0001].Raw)
		}
	}
	// string "Timestamp"
	o = append(o, 0xa9, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70)
	if z.Timestamp == nil {
		o = msgp.AppendNil(o)
	} else {
		// map header, size 2
		// string "Version"
		o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
		o = msgp.AppendUint64(o, z.Timestamp.Version)
		// string "Raw"
		o = append(o, 0xa3, 0x52, 0x61, 0x77)
		o = msgp.AppendBytes(o, z.Timestamp.Raw)
	}
	// string "Snapshot"
	o = append(o, 0xa8, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74)
	if z.Snapshot == nil {
		o = msgp.AppendNil(o)
	} else {
		// map header, size 2
		// string "Version"
		o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
		o = msgp.AppendUint64(o, z.Snapshot.Version)
		// string "Raw"
		o = append(o, 0xa3, 0x52, 0x61, 0x77)
		o = msgp.AppendBytes(o, z.Snapshot.Raw)
	}
	// string "Targets"
	o = append(o, 0xa7, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x73)
	if z.Targets == nil {
		o = msgp.AppendNil(o)
	} else {
		// map header, size 2
		// string "Version"
		o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
		o = msgp.AppendUint64(o, z.Targets.Version)
		// string "Raw"
		o = append(o, 0xa3, 0x52, 0x61, 0x77)
		o = msgp.AppendBytes(o, z.Targets.Raw)
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *DirectorMetas) 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 "Roots":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Roots")
				return
			}
			if cap(z.Roots) >= int(zb0002) {
				z.Roots = (z.Roots)[:zb0002]
			} else {
				z.Roots = make([]*TopMeta, zb0002)
			}
			for za0001 := range z.Roots {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.Roots[za0001] = nil
				} else {
					if z.Roots[za0001] == nil {
						z.Roots[za0001] = new(TopMeta)
					}
					var zb0003 uint32
					zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Roots", za0001)
						return
					}
					for zb0003 > 0 {
						zb0003--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "Roots", za0001)
							return
						}
						switch msgp.UnsafeString(field) {
						case "Version":
							z.Roots[za0001].Version, bts, err = msgp.ReadUint64Bytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "Roots", za0001, "Version")
								return
							}
						case "Raw":
							z.Roots[za0001].Raw, bts, err = msgp.ReadBytesBytes(bts, z.Roots[za0001].Raw)
							if err != nil {
								err = msgp.WrapError(err, "Roots", za0001, "Raw")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "Roots", za0001)
								return
							}
						}
					}
				}
			}
		case "Timestamp":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Timestamp = nil
			} else {
				if z.Timestamp == nil {
					z.Timestamp = new(TopMeta)
				}
				var zb0004 uint32
				zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Timestamp")
					return
				}
				for zb0004 > 0 {
					zb0004--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "Timestamp")
						return
					}
					switch msgp.UnsafeString(field) {
					case "Version":
						z.Timestamp.Version, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Timestamp", "Version")
							return
						}
					case "Raw":
						z.Timestamp.Raw, bts, err = msgp.ReadBytesBytes(bts, z.Timestamp.Raw)
						if err != nil {
							err = msgp.WrapError(err, "Timestamp", "Raw")
							return
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "Timestamp")
							return
						}
					}
				}
			}
		case "Snapshot":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Snapshot = nil
			} else {
				if z.Snapshot == nil {
					z.Snapshot = new(TopMeta)
				}
				var zb0005 uint32
				zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Snapshot")
					return
				}
				for zb0005 > 0 {
					zb0005--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "Snapshot")
						return
					}
					switch msgp.UnsafeString(field) {
					case "Version":
						z.Snapshot.Version, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Snapshot", "Version")
							return
						}
					case "Raw":
						z.Snapshot.Raw, bts, err = msgp.ReadBytesBytes(bts, z.Snapshot.Raw)
						if err != nil {
							err = msgp.WrapError(err, "Snapshot", "Raw")
							return
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "Snapshot")
							return
						}
					}
				}
			}
		case "Targets":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.Targets = nil
			} else {
				if z.Targets == nil {
					z.Targets = new(TopMeta)
				}
				var zb0006 uint32
				zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Targets")
					return
				}
				for zb0006 > 0 {
					zb0006--
					field, bts, err = msgp.ReadMapKeyZC(bts)
					if err != nil {
						err = msgp.WrapError(err, "Targets")
						return
					}
					switch msgp.UnsafeString(field) {
					case "Version":
						z.Targets.Version, bts, err = msgp.ReadUint64Bytes(bts)
						if err != nil {
							err = msgp.WrapError(err, "Targets", "Version")
							return
						}
					case "Raw":
						z.Targets.Raw, bts, err = msgp.ReadBytesBytes(bts, z.Targets.Raw)
						if err != nil {
							err = msgp.WrapError(err, "Targets", "Raw")
							return
						}
					default:
						bts, err = msgp.Skip(bts)
						if err != nil {
							err = msgp.WrapError(err, "Targets")
							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 *DirectorMetas) Msgsize() (s int) {
	s = 1 + 6 + msgp.ArrayHeaderSize
	for za0001 := range z.Roots {
		if z.Roots[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += 1 + 8 + msgp.Uint64Size + 4 + msgp.BytesPrefixSize + len(z.Roots[za0001].Raw)
		}
	}
	s += 10
	if z.Timestamp == nil {
		s += msgp.NilSize
	} else {
		s += 1 + 8 + msgp.Uint64Size + 4 + msgp.BytesPrefixSize + len(z.Timestamp.Raw)
	}
	s += 9
	if z.Snapshot == nil {
		s += msgp.NilSize
	} else {
		s += 1 + 8 + msgp.Uint64Size + 4 + msgp.BytesPrefixSize + len(z.Snapshot.Raw)
	}
	s += 8
	if z.Targets == nil {
		s += msgp.NilSize
	} else {
		s += 1 + 8 + msgp.Uint64Size + 4 + msgp.BytesPrefixSize + len(z.Targets.Raw)
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z ExperimentState) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	o = msgp.AppendInt32(o, int32(z))
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *ExperimentState) UnmarshalMsg(bts []byte) (o []byte, err error) {
	{
		var zb0001 int32
		zb0001, bts, err = msgp.ReadInt32Bytes(bts)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		(*z) = ExperimentState(zb0001)
	}
	o = bts
	return
}

// Msgsize returns an upper bound estimate of the number of bytes occupied by the serialized message
func (z ExperimentState) Msgsize() (s int) {
	s = msgp.Int32Size
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *File) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Path"
	o = append(o, 0x82, 0xa4, 0x50, 0x61, 0x74, 0x68)
	o = msgp.AppendString(o, z.Path)
	// string "Raw"
	o = append(o, 0xa3, 0x52, 0x61, 0x77)
	o = msgp.AppendBytes(o, z.Raw)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *File) 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 "Path":
			z.Path, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Path")
				return
			}
		case "Raw":
			z.Raw, bts, err = msgp.ReadBytesBytes(bts, z.Raw)
			if err != nil {
				err = msgp.WrapError(err, "Raw")
				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 *File) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Path) + 4 + msgp.BytesPrefixSize + len(z.Raw)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z FileMetaState) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Version"
	o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendUint64(o, z.Version)
	// string "Hash"
	o = append(o, 0xa4, 0x48, 0x61, 0x73, 0x68)
	o = msgp.AppendString(o, z.Hash)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *FileMetaState) 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 "Version":
			z.Version, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Version")
				return
			}
		case "Hash":
			z.Hash, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Hash")
				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 FileMetaState) Msgsize() (s int) {
	s = 1 + 8 + msgp.Uint64Size + 5 + msgp.StringPrefixSize + len(z.Hash)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *GetStateConfigResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 4
	// string "ConfigState"
	o = append(o, 0x84, 0xab, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x53, 0x74, 0x61, 0x74, 0x65)
	o = msgp.AppendMapHeader(o, uint32(len(z.ConfigState)))
	for za0001, za0002 := range z.ConfigState {
		o = msgp.AppendString(o, za0001)
		if za0002 == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 2
			// string "Version"
			o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
			o = msgp.AppendUint64(o, za0002.Version)
			// string "Hash"
			o = append(o, 0xa4, 0x48, 0x61, 0x73, 0x68)
			o = msgp.AppendString(o, za0002.Hash)
		}
	}
	// string "DirectorState"
	o = append(o, 0xad, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x53, 0x74, 0x61, 0x74, 0x65)
	o = msgp.AppendMapHeader(o, uint32(len(z.DirectorState)))
	for za0003, za0004 := range z.DirectorState {
		o = msgp.AppendString(o, za0003)
		if za0004 == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 2
			// string "Version"
			o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
			o = msgp.AppendUint64(o, za0004.Version)
			// string "Hash"
			o = append(o, 0xa4, 0x48, 0x61, 0x73, 0x68)
			o = msgp.AppendString(o, za0004.Hash)
		}
	}
	// string "TargetFilenames"
	o = append(o, 0xaf, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x73)
	o = msgp.AppendMapHeader(o, uint32(len(z.TargetFilenames)))
	for za0005, za0006 := range z.TargetFilenames {
		o = msgp.AppendString(o, za0005)
		o = msgp.AppendString(o, za0006)
	}
	// string "ActiveClients"
	o = append(o, 0xad, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.ActiveClients)))
	for za0007 := range z.ActiveClients {
		if z.ActiveClients[za0007] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.ActiveClients[za0007].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "ActiveClients", za0007)
				return
			}
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *GetStateConfigResponse) 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 "ConfigState":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ConfigState")
				return
			}
			if z.ConfigState == nil {
				z.ConfigState = make(map[string]*FileMetaState, zb0002)
			} else if len(z.ConfigState) > 0 {
				for key := range z.ConfigState {
					delete(z.ConfigState, key)
				}
			}
			for zb0002 > 0 {
				var za0001 string
				var za0002 *FileMetaState
				zb0002--
				za0001, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "ConfigState")
					return
				}
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					za0002 = nil
				} else {
					if za0002 == nil {
						za0002 = new(FileMetaState)
					}
					var zb0003 uint32
					zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "ConfigState", za0001)
						return
					}
					for zb0003 > 0 {
						zb0003--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "ConfigState", za0001)
							return
						}
						switch msgp.UnsafeString(field) {
						case "Version":
							za0002.Version, bts, err = msgp.ReadUint64Bytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "ConfigState", za0001, "Version")
								return
							}
						case "Hash":
							za0002.Hash, bts, err = msgp.ReadStringBytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "ConfigState", za0001, "Hash")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "ConfigState", za0001)
								return
							}
						}
					}
				}
				z.ConfigState[za0001] = za0002
			}
		case "DirectorState":
			var zb0004 uint32
			zb0004, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "DirectorState")
				return
			}
			if z.DirectorState == nil {
				z.DirectorState = make(map[string]*FileMetaState, zb0004)
			} else if len(z.DirectorState) > 0 {
				for key := range z.DirectorState {
					delete(z.DirectorState, key)
				}
			}
			for zb0004 > 0 {
				var za0003 string
				var za0004 *FileMetaState
				zb0004--
				za0003, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "DirectorState")
					return
				}
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					za0004 = nil
				} else {
					if za0004 == nil {
						za0004 = new(FileMetaState)
					}
					var zb0005 uint32
					zb0005, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "DirectorState", za0003)
						return
					}
					for zb0005 > 0 {
						zb0005--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "DirectorState", za0003)
							return
						}
						switch msgp.UnsafeString(field) {
						case "Version":
							za0004.Version, bts, err = msgp.ReadUint64Bytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "DirectorState", za0003, "Version")
								return
							}
						case "Hash":
							za0004.Hash, bts, err = msgp.ReadStringBytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "DirectorState", za0003, "Hash")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "DirectorState", za0003)
								return
							}
						}
					}
				}
				z.DirectorState[za0003] = za0004
			}
		case "TargetFilenames":
			var zb0006 uint32
			zb0006, bts, err = msgp.ReadMapHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TargetFilenames")
				return
			}
			if z.TargetFilenames == nil {
				z.TargetFilenames = make(map[string]string, zb0006)
			} else if len(z.TargetFilenames) > 0 {
				for key := range z.TargetFilenames {
					delete(z.TargetFilenames, key)
				}
			}
			for zb0006 > 0 {
				var za0005 string
				var za0006 string
				zb0006--
				za0005, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TargetFilenames")
					return
				}
				za0006, bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "TargetFilenames", za0005)
					return
				}
				z.TargetFilenames[za0005] = za0006
			}
		case "ActiveClients":
			var zb0007 uint32
			zb0007, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ActiveClients")
				return
			}
			if cap(z.ActiveClients) >= int(zb0007) {
				z.ActiveClients = (z.ActiveClients)[:zb0007]
			} else {
				z.ActiveClients = make([]*Client, zb0007)
			}
			for za0007 := range z.ActiveClients {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.ActiveClients[za0007] = nil
				} else {
					if z.ActiveClients[za0007] == nil {
						z.ActiveClients[za0007] = new(Client)
					}
					bts, err = z.ActiveClients[za0007].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "ActiveClients", za0007)
						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 *GetStateConfigResponse) Msgsize() (s int) {
	s = 1 + 12 + msgp.MapHeaderSize
	if z.ConfigState != nil {
		for za0001, za0002 := range z.ConfigState {
			_ = za0002
			s += msgp.StringPrefixSize + len(za0001)
			if za0002 == nil {
				s += msgp.NilSize
			} else {
				s += 1 + 8 + msgp.Uint64Size + 5 + msgp.StringPrefixSize + len(za0002.Hash)
			}
		}
	}
	s += 14 + msgp.MapHeaderSize
	if z.DirectorState != nil {
		for za0003, za0004 := range z.DirectorState {
			_ = za0004
			s += msgp.StringPrefixSize + len(za0003)
			if za0004 == nil {
				s += msgp.NilSize
			} else {
				s += 1 + 8 + msgp.Uint64Size + 5 + msgp.StringPrefixSize + len(za0004.Hash)
			}
		}
	}
	s += 16 + msgp.MapHeaderSize
	if z.TargetFilenames != nil {
		for za0005, za0006 := range z.TargetFilenames {
			_ = za0006
			s += msgp.StringPrefixSize + len(za0005) + msgp.StringPrefixSize + len(za0006)
		}
	}
	s += 14 + msgp.ArrayHeaderSize
	for za0007 := range z.ActiveClients {
		if z.ActiveClients[za0007] == nil {
			s += msgp.NilSize
		} else {
			s += z.ActiveClients[za0007].Msgsize()
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *LatestConfigsRequest) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 15
	// string "Hostname"
	o = append(o, 0x8f, 0xa8, 0x48, 0x6f, 0x73, 0x74, 0x6e, 0x61, 0x6d, 0x65)
	o = msgp.AppendString(o, z.Hostname)
	// string "AgentVersion"
	o = append(o, 0xac, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.AgentVersion)
	// string "CurrentConfigSnapshotVersion"
	o = append(o, 0xbc, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x53, 0x6e, 0x61, 0x70, 0x73, 0x68, 0x6f, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendUint64(o, z.CurrentConfigSnapshotVersion)
	// string "CurrentConfigRootVersion"
	o = append(o, 0xb8, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x6f, 0x6f, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendUint64(o, z.CurrentConfigRootVersion)
	// string "CurrentDirectorRootVersion"
	o = append(o, 0xba, 0x43, 0x75, 0x72, 0x72, 0x65, 0x6e, 0x74, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x52, 0x6f, 0x6f, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendUint64(o, z.CurrentDirectorRootVersion)
	// string "Products"
	o = append(o, 0xa8, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Products)))
	for za0001 := range z.Products {
		o = msgp.AppendString(o, z.Products[za0001])
	}
	// string "NewProducts"
	o = append(o, 0xab, 0x4e, 0x65, 0x77, 0x50, 0x72, 0x6f, 0x64, 0x75, 0x63, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.NewProducts)))
	for za0002 := range z.NewProducts {
		o = msgp.AppendString(o, z.NewProducts[za0002])
	}
	// string "ActiveClients"
	o = append(o, 0xad, 0x41, 0x63, 0x74, 0x69, 0x76, 0x65, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.ActiveClients)))
	for za0003 := range z.ActiveClients {
		if z.ActiveClients[za0003] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.ActiveClients[za0003].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "ActiveClients", za0003)
				return
			}
		}
	}
	// string "BackendClientState"
	o = append(o, 0xb2, 0x42, 0x61, 0x63, 0x6b, 0x65, 0x6e, 0x64, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65)
	o = msgp.AppendBytes(o, z.BackendClientState)
	// string "HasError"
	o = append(o, 0xa8, 0x48, 0x61, 0x73, 0x45, 0x72, 0x72, 0x6f, 0x72)
	o = msgp.AppendBool(o, z.HasError)
	// string "Error"
	o = append(o, 0xa5, 0x45, 0x72, 0x72, 0x6f, 0x72)
	o = msgp.AppendString(o, z.Error)
	// string "TraceAgentEnv"
	o = append(o, 0xad, 0x54, 0x72, 0x61, 0x63, 0x65, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x45, 0x6e, 0x76)
	o = msgp.AppendString(o, z.TraceAgentEnv)
	// string "OrgUuid"
	o = append(o, 0xa7, 0x4f, 0x72, 0x67, 0x55, 0x75, 0x69, 0x64)
	o = msgp.AppendString(o, z.OrgUuid)
	// string "Tags"
	o = append(o, 0xa4, 0x54, 0x61, 0x67, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Tags)))
	for za0004 := range z.Tags {
		o = msgp.AppendString(o, z.Tags[za0004])
	}
	// string "AgentUuid"
	o = append(o, 0xa9, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x55, 0x75, 0x69, 0x64)
	o = msgp.AppendString(o, z.AgentUuid)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *LatestConfigsRequest) 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 "Hostname":
			z.Hostname, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Hostname")
				return
			}
		case "AgentVersion":
			z.AgentVersion, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AgentVersion")
				return
			}
		case "CurrentConfigSnapshotVersion":
			z.CurrentConfigSnapshotVersion, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "CurrentConfigSnapshotVersion")
				return
			}
		case "CurrentConfigRootVersion":
			z.CurrentConfigRootVersion, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "CurrentConfigRootVersion")
				return
			}
		case "CurrentDirectorRootVersion":
			z.CurrentDirectorRootVersion, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "CurrentDirectorRootVersion")
				return
			}
		case "Products":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Products")
				return
			}
			if cap(z.Products) >= int(zb0002) {
				z.Products = (z.Products)[:zb0002]
			} else {
				z.Products = make([]string, zb0002)
			}
			for za0001 := range z.Products {
				z.Products[za0001], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Products", za0001)
					return
				}
			}
		case "NewProducts":
			var zb0003 uint32
			zb0003, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "NewProducts")
				return
			}
			if cap(z.NewProducts) >= int(zb0003) {
				z.NewProducts = (z.NewProducts)[:zb0003]
			} else {
				z.NewProducts = make([]string, zb0003)
			}
			for za0002 := range z.NewProducts {
				z.NewProducts[za0002], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "NewProducts", za0002)
					return
				}
			}
		case "ActiveClients":
			var zb0004 uint32
			zb0004, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ActiveClients")
				return
			}
			if cap(z.ActiveClients) >= int(zb0004) {
				z.ActiveClients = (z.ActiveClients)[:zb0004]
			} else {
				z.ActiveClients = make([]*Client, zb0004)
			}
			for za0003 := range z.ActiveClients {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.ActiveClients[za0003] = nil
				} else {
					if z.ActiveClients[za0003] == nil {
						z.ActiveClients[za0003] = new(Client)
					}
					bts, err = z.ActiveClients[za0003].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "ActiveClients", za0003)
						return
					}
				}
			}
		case "BackendClientState":
			z.BackendClientState, bts, err = msgp.ReadBytesBytes(bts, z.BackendClientState)
			if err != nil {
				err = msgp.WrapError(err, "BackendClientState")
				return
			}
		case "HasError":
			z.HasError, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "HasError")
				return
			}
		case "Error":
			z.Error, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Error")
				return
			}
		case "TraceAgentEnv":
			z.TraceAgentEnv, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TraceAgentEnv")
				return
			}
		case "OrgUuid":
			z.OrgUuid, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "OrgUuid")
				return
			}
		case "Tags":
			var zb0005 uint32
			zb0005, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Tags")
				return
			}
			if cap(z.Tags) >= int(zb0005) {
				z.Tags = (z.Tags)[:zb0005]
			} else {
				z.Tags = make([]string, zb0005)
			}
			for za0004 := range z.Tags {
				z.Tags[za0004], bts, err = msgp.ReadStringBytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "Tags", za0004)
					return
				}
			}
		case "AgentUuid":
			z.AgentUuid, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AgentUuid")
				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 *LatestConfigsRequest) Msgsize() (s int) {
	s = 1 + 9 + msgp.StringPrefixSize + len(z.Hostname) + 13 + msgp.StringPrefixSize + len(z.AgentVersion) + 29 + msgp.Uint64Size + 25 + msgp.Uint64Size + 27 + msgp.Uint64Size + 9 + msgp.ArrayHeaderSize
	for za0001 := range z.Products {
		s += msgp.StringPrefixSize + len(z.Products[za0001])
	}
	s += 12 + msgp.ArrayHeaderSize
	for za0002 := range z.NewProducts {
		s += msgp.StringPrefixSize + len(z.NewProducts[za0002])
	}
	s += 14 + msgp.ArrayHeaderSize
	for za0003 := range z.ActiveClients {
		if z.ActiveClients[za0003] == nil {
			s += msgp.NilSize
		} else {
			s += z.ActiveClients[za0003].Msgsize()
		}
	}
	s += 19 + msgp.BytesPrefixSize + len(z.BackendClientState) + 9 + msgp.BoolSize + 6 + msgp.StringPrefixSize + len(z.Error) + 14 + msgp.StringPrefixSize + len(z.TraceAgentEnv) + 8 + msgp.StringPrefixSize + len(z.OrgUuid) + 5 + msgp.ArrayHeaderSize
	for za0004 := range z.Tags {
		s += msgp.StringPrefixSize + len(z.Tags[za0004])
	}
	s += 10 + msgp.StringPrefixSize + len(z.AgentUuid)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *LatestConfigsResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "ConfigMetas"
	o = append(o, 0x83, 0xab, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x4d, 0x65, 0x74, 0x61, 0x73)
	if z.ConfigMetas == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.ConfigMetas.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "ConfigMetas")
			return
		}
	}
	// string "DirectorMetas"
	o = append(o, 0xad, 0x44, 0x69, 0x72, 0x65, 0x63, 0x74, 0x6f, 0x72, 0x4d, 0x65, 0x74, 0x61, 0x73)
	if z.DirectorMetas == nil {
		o = msgp.AppendNil(o)
	} else {
		o, err = z.DirectorMetas.MarshalMsg(o)
		if err != nil {
			err = msgp.WrapError(err, "DirectorMetas")
			return
		}
	}
	// string "TargetFiles"
	o = append(o, 0xab, 0x54, 0x61, 0x72, 0x67, 0x65, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.TargetFiles)))
	for za0001 := range z.TargetFiles {
		if z.TargetFiles[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 2
			// string "Path"
			o = append(o, 0x82, 0xa4, 0x50, 0x61, 0x74, 0x68)
			o = msgp.AppendString(o, z.TargetFiles[za0001].Path)
			// string "Raw"
			o = append(o, 0xa3, 0x52, 0x61, 0x77)
			o = msgp.AppendBytes(o, z.TargetFiles[za0001].Raw)
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *LatestConfigsResponse) 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 "ConfigMetas":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.ConfigMetas = nil
			} else {
				if z.ConfigMetas == nil {
					z.ConfigMetas = new(ConfigMetas)
				}
				bts, err = z.ConfigMetas.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "ConfigMetas")
					return
				}
			}
		case "DirectorMetas":
			if msgp.IsNil(bts) {
				bts, err = msgp.ReadNilBytes(bts)
				if err != nil {
					return
				}
				z.DirectorMetas = nil
			} else {
				if z.DirectorMetas == nil {
					z.DirectorMetas = new(DirectorMetas)
				}
				bts, err = z.DirectorMetas.UnmarshalMsg(bts)
				if err != nil {
					err = msgp.WrapError(err, "DirectorMetas")
					return
				}
			}
		case "TargetFiles":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TargetFiles")
				return
			}
			if cap(z.TargetFiles) >= int(zb0002) {
				z.TargetFiles = (z.TargetFiles)[:zb0002]
			} else {
				z.TargetFiles = make([]*File, zb0002)
			}
			for za0001 := range z.TargetFiles {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.TargetFiles[za0001] = nil
				} else {
					if z.TargetFiles[za0001] == nil {
						z.TargetFiles[za0001] = new(File)
					}
					var zb0003 uint32
					zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "TargetFiles", za0001)
						return
					}
					for zb0003 > 0 {
						zb0003--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "TargetFiles", za0001)
							return
						}
						switch msgp.UnsafeString(field) {
						case "Path":
							z.TargetFiles[za0001].Path, bts, err = msgp.ReadStringBytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "TargetFiles", za0001, "Path")
								return
							}
						case "Raw":
							z.TargetFiles[za0001].Raw, bts, err = msgp.ReadBytesBytes(bts, z.TargetFiles[za0001].Raw)
							if err != nil {
								err = msgp.WrapError(err, "TargetFiles", za0001, "Raw")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "TargetFiles", za0001)
								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 *LatestConfigsResponse) Msgsize() (s int) {
	s = 1 + 12
	if z.ConfigMetas == nil {
		s += msgp.NilSize
	} else {
		s += z.ConfigMetas.Msgsize()
	}
	s += 14
	if z.DirectorMetas == nil {
		s += msgp.NilSize
	} else {
		s += z.DirectorMetas.Msgsize()
	}
	s += 12 + msgp.ArrayHeaderSize
	for za0001 := range z.TargetFiles {
		if z.TargetFiles[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += 1 + 5 + msgp.StringPrefixSize + len(z.TargetFiles[za0001].Path) + 4 + msgp.BytesPrefixSize + len(z.TargetFiles[za0001].Raw)
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z OrgDataResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "Uuid"
	o = append(o, 0x81, 0xa4, 0x55, 0x75, 0x69, 0x64)
	o = msgp.AppendString(o, z.Uuid)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *OrgDataResponse) 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 "Uuid":
			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 OrgDataResponse) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Uuid)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z OrgStatusResponse) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Enabled"
	o = append(o, 0x82, 0xa7, 0x45, 0x6e, 0x61, 0x62, 0x6c, 0x65, 0x64)
	o = msgp.AppendBool(o, z.Enabled)
	// string "Authorized"
	o = append(o, 0xaa, 0x41, 0x75, 0x74, 0x68, 0x6f, 0x72, 0x69, 0x7a, 0x65, 0x64)
	o = msgp.AppendBool(o, z.Authorized)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *OrgStatusResponse) 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 "Enabled":
			z.Enabled, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Enabled")
				return
			}
		case "Authorized":
			z.Authorized, bts, err = msgp.ReadBoolBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Authorized")
				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 OrgStatusResponse) Msgsize() (s int) {
	s = 1 + 8 + msgp.BoolSize + 11 + msgp.BoolSize
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *PackageState) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 6
	// string "Package"
	o = append(o, 0x86, 0xa7, 0x50, 0x61, 0x63, 0x6b, 0x61, 0x67, 0x65)
	o = msgp.AppendString(o, z.Package)
	// string "StableVersion"
	o = append(o, 0xad, 0x53, 0x74, 0x61, 0x62, 0x6c, 0x65, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.StableVersion)
	// string "ExperimentVersion"
	o = append(o, 0xb1, 0x45, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.ExperimentVersion)
	// string "ExperimentState"
	o = append(o, 0xaf, 0x45, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65)
	o = msgp.AppendInt32(o, int32(z.ExperimentState))
	// string "ExperimentErrorCode"
	o = append(o, 0xb3, 0x45, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x43, 0x6f, 0x64, 0x65)
	o = msgp.AppendUint64(o, z.ExperimentErrorCode)
	// string "ExperimentErrorMessage"
	o = append(o, 0xb6, 0x45, 0x78, 0x70, 0x65, 0x72, 0x69, 0x6d, 0x65, 0x6e, 0x74, 0x45, 0x72, 0x72, 0x6f, 0x72, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65)
	o = msgp.AppendString(o, z.ExperimentErrorMessage)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *PackageState) 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 "Package":
			z.Package, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Package")
				return
			}
		case "StableVersion":
			z.StableVersion, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "StableVersion")
				return
			}
		case "ExperimentVersion":
			z.ExperimentVersion, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ExperimentVersion")
				return
			}
		case "ExperimentState":
			{
				var zb0002 int32
				zb0002, bts, err = msgp.ReadInt32Bytes(bts)
				if err != nil {
					err = msgp.WrapError(err, "ExperimentState")
					return
				}
				z.ExperimentState = ExperimentState(zb0002)
			}
		case "ExperimentErrorCode":
			z.ExperimentErrorCode, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ExperimentErrorCode")
				return
			}
		case "ExperimentErrorMessage":
			z.ExperimentErrorMessage, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ExperimentErrorMessage")
				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 *PackageState) Msgsize() (s int) {
	s = 1 + 8 + msgp.StringPrefixSize + len(z.Package) + 14 + msgp.StringPrefixSize + len(z.StableVersion) + 18 + msgp.StringPrefixSize + len(z.ExperimentVersion) + 16 + msgp.Int32Size + 20 + msgp.Uint64Size + 23 + msgp.StringPrefixSize + len(z.ExperimentErrorMessage)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z TargetFileHash) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Algorithm"
	o = append(o, 0x82, 0xa9, 0x41, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d)
	o = msgp.AppendString(o, z.Algorithm)
	// string "Hash"
	o = append(o, 0xa4, 0x48, 0x61, 0x73, 0x68)
	o = msgp.AppendString(o, z.Hash)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *TargetFileHash) 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 "Algorithm":
			z.Algorithm, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Algorithm")
				return
			}
		case "Hash":
			z.Hash, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Hash")
				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 TargetFileHash) Msgsize() (s int) {
	s = 1 + 10 + msgp.StringPrefixSize + len(z.Algorithm) + 5 + msgp.StringPrefixSize + len(z.Hash)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *TargetFileMeta) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 3
	// string "Path"
	o = append(o, 0x83, 0xa4, 0x50, 0x61, 0x74, 0x68)
	o = msgp.AppendString(o, z.Path)
	// string "Length"
	o = append(o, 0xa6, 0x4c, 0x65, 0x6e, 0x67, 0x74, 0x68)
	o = msgp.AppendInt64(o, z.Length)
	// string "Hashes"
	o = append(o, 0xa6, 0x48, 0x61, 0x73, 0x68, 0x65, 0x73)
	o = msgp.AppendArrayHeader(o, uint32(len(z.Hashes)))
	for za0001 := range z.Hashes {
		if z.Hashes[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			// map header, size 2
			// string "Algorithm"
			o = append(o, 0x82, 0xa9, 0x41, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d)
			o = msgp.AppendString(o, z.Hashes[za0001].Algorithm)
			// string "Hash"
			o = append(o, 0xa4, 0x48, 0x61, 0x73, 0x68)
			o = msgp.AppendString(o, z.Hashes[za0001].Hash)
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *TargetFileMeta) 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 "Path":
			z.Path, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Path")
				return
			}
		case "Length":
			z.Length, bts, err = msgp.ReadInt64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Length")
				return
			}
		case "Hashes":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Hashes")
				return
			}
			if cap(z.Hashes) >= int(zb0002) {
				z.Hashes = (z.Hashes)[:zb0002]
			} else {
				z.Hashes = make([]*TargetFileHash, zb0002)
			}
			for za0001 := range z.Hashes {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.Hashes[za0001] = nil
				} else {
					if z.Hashes[za0001] == nil {
						z.Hashes[za0001] = new(TargetFileHash)
					}
					var zb0003 uint32
					zb0003, bts, err = msgp.ReadMapHeaderBytes(bts)
					if err != nil {
						err = msgp.WrapError(err, "Hashes", za0001)
						return
					}
					for zb0003 > 0 {
						zb0003--
						field, bts, err = msgp.ReadMapKeyZC(bts)
						if err != nil {
							err = msgp.WrapError(err, "Hashes", za0001)
							return
						}
						switch msgp.UnsafeString(field) {
						case "Algorithm":
							z.Hashes[za0001].Algorithm, bts, err = msgp.ReadStringBytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "Hashes", za0001, "Algorithm")
								return
							}
						case "Hash":
							z.Hashes[za0001].Hash, bts, err = msgp.ReadStringBytes(bts)
							if err != nil {
								err = msgp.WrapError(err, "Hashes", za0001, "Hash")
								return
							}
						default:
							bts, err = msgp.Skip(bts)
							if err != nil {
								err = msgp.WrapError(err, "Hashes", za0001)
								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 *TargetFileMeta) Msgsize() (s int) {
	s = 1 + 5 + msgp.StringPrefixSize + len(z.Path) + 7 + msgp.Int64Size + 7 + msgp.ArrayHeaderSize
	for za0001 := range z.Hashes {
		if z.Hashes[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += 1 + 10 + msgp.StringPrefixSize + len(z.Hashes[za0001].Algorithm) + 5 + msgp.StringPrefixSize + len(z.Hashes[za0001].Hash)
		}
	}
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *TopMeta) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 2
	// string "Version"
	o = append(o, 0x82, 0xa7, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendUint64(o, z.Version)
	// string "Raw"
	o = append(o, 0xa3, 0x52, 0x61, 0x77)
	o = msgp.AppendBytes(o, z.Raw)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *TopMeta) 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 "Version":
			z.Version, bts, err = msgp.ReadUint64Bytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Version")
				return
			}
		case "Raw":
			z.Raw, bts, err = msgp.ReadBytesBytes(bts, z.Raw)
			if err != nil {
				err = msgp.WrapError(err, "Raw")
				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 *TopMeta) Msgsize() (s int) {
	s = 1 + 8 + msgp.Uint64Size + 4 + msgp.BytesPrefixSize + len(z.Raw)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *TracerPredicateV1) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 7
	// string "ClientID"
	o = append(o, 0x87, 0xa8, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x49, 0x44)
	o = msgp.AppendString(o, z.ClientID)
	// string "Service"
	o = append(o, 0xa7, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65)
	o = msgp.AppendString(o, z.Service)
	// string "Environment"
	o = append(o, 0xab, 0x45, 0x6e, 0x76, 0x69, 0x72, 0x6f, 0x6e, 0x6d, 0x65, 0x6e, 0x74)
	o = msgp.AppendString(o, z.Environment)
	// string "AppVersion"
	o = append(o, 0xaa, 0x41, 0x70, 0x70, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.AppVersion)
	// string "TracerVersion"
	o = append(o, 0xad, 0x54, 0x72, 0x61, 0x63, 0x65, 0x72, 0x56, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e)
	o = msgp.AppendString(o, z.TracerVersion)
	// string "Language"
	o = append(o, 0xa8, 0x4c, 0x61, 0x6e, 0x67, 0x75, 0x61, 0x67, 0x65)
	o = msgp.AppendString(o, z.Language)
	// string "RuntimeID"
	o = append(o, 0xa9, 0x52, 0x75, 0x6e, 0x74, 0x69, 0x6d, 0x65, 0x49, 0x44)
	o = msgp.AppendString(o, z.RuntimeID)
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *TracerPredicateV1) 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 "ClientID":
			z.ClientID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "ClientID")
				return
			}
		case "Service":
			z.Service, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Service")
				return
			}
		case "Environment":
			z.Environment, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Environment")
				return
			}
		case "AppVersion":
			z.AppVersion, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "AppVersion")
				return
			}
		case "TracerVersion":
			z.TracerVersion, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TracerVersion")
				return
			}
		case "Language":
			z.Language, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "Language")
				return
			}
		case "RuntimeID":
			z.RuntimeID, bts, err = msgp.ReadStringBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "RuntimeID")
				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 *TracerPredicateV1) Msgsize() (s int) {
	s = 1 + 9 + msgp.StringPrefixSize + len(z.ClientID) + 8 + msgp.StringPrefixSize + len(z.Service) + 12 + msgp.StringPrefixSize + len(z.Environment) + 11 + msgp.StringPrefixSize + len(z.AppVersion) + 14 + msgp.StringPrefixSize + len(z.TracerVersion) + 9 + msgp.StringPrefixSize + len(z.Language) + 10 + msgp.StringPrefixSize + len(z.RuntimeID)
	return
}

// MarshalMsg implements msgp.Marshaler
func (z *TracerPredicates) MarshalMsg(b []byte) (o []byte, err error) {
	o = msgp.Require(b, z.Msgsize())
	// map header, size 1
	// string "TracerPredicatesV1"
	o = append(o, 0x81, 0xb2, 0x54, 0x72, 0x61, 0x63, 0x65, 0x72, 0x50, 0x72, 0x65, 0x64, 0x69, 0x63, 0x61, 0x74, 0x65, 0x73, 0x56, 0x31)
	o = msgp.AppendArrayHeader(o, uint32(len(z.TracerPredicatesV1)))
	for za0001 := range z.TracerPredicatesV1 {
		if z.TracerPredicatesV1[za0001] == nil {
			o = msgp.AppendNil(o)
		} else {
			o, err = z.TracerPredicatesV1[za0001].MarshalMsg(o)
			if err != nil {
				err = msgp.WrapError(err, "TracerPredicatesV1", za0001)
				return
			}
		}
	}
	return
}

// UnmarshalMsg implements msgp.Unmarshaler
func (z *TracerPredicates) 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 "TracerPredicatesV1":
			var zb0002 uint32
			zb0002, bts, err = msgp.ReadArrayHeaderBytes(bts)
			if err != nil {
				err = msgp.WrapError(err, "TracerPredicatesV1")
				return
			}
			if cap(z.TracerPredicatesV1) >= int(zb0002) {
				z.TracerPredicatesV1 = (z.TracerPredicatesV1)[:zb0002]
			} else {
				z.TracerPredicatesV1 = make([]*TracerPredicateV1, zb0002)
			}
			for za0001 := range z.TracerPredicatesV1 {
				if msgp.IsNil(bts) {
					bts, err = msgp.ReadNilBytes(bts)
					if err != nil {
						return
					}
					z.TracerPredicatesV1[za0001] = nil
				} else {
					if z.TracerPredicatesV1[za0001] == nil {
						z.TracerPredicatesV1[za0001] = new(TracerPredicateV1)
					}
					bts, err = z.TracerPredicatesV1[za0001].UnmarshalMsg(bts)
					if err != nil {
						err = msgp.WrapError(err, "TracerPredicatesV1", za0001)
						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 *TracerPredicates) Msgsize() (s int) {
	s = 1 + 19 + msgp.ArrayHeaderSize
	for za0001 := range z.TracerPredicatesV1 {
		if z.TracerPredicatesV1[za0001] == nil {
			s += msgp.NilSize
		} else {
			s += z.TracerPredicatesV1[za0001].Msgsize()
		}
	}
	return
}