// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: agent.proto

package proto

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	types "github.com/gogo/protobuf/types"
	io "io"
	math "math"
	math_bits "math/bits"
)

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

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

type AgentConnectStatus_StatusCode int32

const (
	AgentConnectStatus_CONNECT_UNKNOWN         AgentConnectStatus_StatusCode = 0
	AgentConnectStatus_CONNECT_OK              AgentConnectStatus_StatusCode = 1
	AgentConnectStatus_CONNECT_REJECTED_OTHER  AgentConnectStatus_StatusCode = 2
	AgentConnectStatus_CONNECT_REJECTED_DUP_ID AgentConnectStatus_StatusCode = 3
)

var AgentConnectStatus_StatusCode_name = map[int32]string{
	0: "CONNECT_UNKNOWN",
	1: "CONNECT_OK",
	2: "CONNECT_REJECTED_OTHER",
	3: "CONNECT_REJECTED_DUP_ID",
}

var AgentConnectStatus_StatusCode_value = map[string]int32{
	"CONNECT_UNKNOWN":         0,
	"CONNECT_OK":              1,
	"CONNECT_REJECTED_OTHER":  2,
	"CONNECT_REJECTED_DUP_ID": 3,
}

func (x AgentConnectStatus_StatusCode) String() string {
	return proto.EnumName(AgentConnectStatus_StatusCode_name, int32(x))
}

func (AgentConnectStatus_StatusCode) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{1, 0}
}

type AgentLogging_Level int32

const (
	AgentLogging_INFO  AgentLogging_Level = 0
	AgentLogging_DEBUG AgentLogging_Level = 1
	AgentLogging_WARN  AgentLogging_Level = 2
	AgentLogging_ERROR AgentLogging_Level = 3
	AgentLogging_FATAL AgentLogging_Level = 4
)

var AgentLogging_Level_name = map[int32]string{
	0: "INFO",
	1: "DEBUG",
	2: "WARN",
	3: "ERROR",
	4: "FATAL",
}

var AgentLogging_Level_value = map[string]int32{
	"INFO":  0,
	"DEBUG": 1,
	"WARN":  2,
	"ERROR": 3,
	"FATAL": 4,
}

func (x AgentLogging_Level) String() string {
	return proto.EnumName(AgentLogging_Level_name, int32(x))
}

func (AgentLogging_Level) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{6, 0}
}

type AgentConnectRequest struct {
	Meta                     *AgentMeta                  `protobuf:"bytes,2,opt,name=meta,proto3" json:"meta"`
	Details                  []*NginxDetails             `protobuf:"bytes,3,rep,name=details,proto3" json:"details"`
	Host                     *HostInfo                   `protobuf:"bytes,4,opt,name=host,proto3" json:"host"`
	DataplaneSoftwareDetails []*DataplaneSoftwareDetails `protobuf:"bytes,5,rep,name=dataplane_software_details,json=dataplaneSoftwareDetails,proto3" json:"dataplane_software_details"`
	XXX_NoUnkeyedLiteral     struct{}                    `json:"-"`
	XXX_unrecognized         []byte                      `json:"-"`
	XXX_sizecache            int32                       `json:"-"`
}

func (m *AgentConnectRequest) Reset()         { *m = AgentConnectRequest{} }
func (m *AgentConnectRequest) String() string { return proto.CompactTextString(m) }
func (*AgentConnectRequest) ProtoMessage()    {}
func (*AgentConnectRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{0}
}
func (m *AgentConnectRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentConnectRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentConnectRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentConnectRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentConnectRequest.Merge(m, src)
}
func (m *AgentConnectRequest) XXX_Size() int {
	return m.Size()
}
func (m *AgentConnectRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentConnectRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AgentConnectRequest proto.InternalMessageInfo

func (m *AgentConnectRequest) GetMeta() *AgentMeta {
	if m != nil {
		return m.Meta
	}
	return nil
}

func (m *AgentConnectRequest) GetDetails() []*NginxDetails {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *AgentConnectRequest) GetHost() *HostInfo {
	if m != nil {
		return m.Host
	}
	return nil
}

func (m *AgentConnectRequest) GetDataplaneSoftwareDetails() []*DataplaneSoftwareDetails {
	if m != nil {
		return m.DataplaneSoftwareDetails
	}
	return nil
}

type AgentConnectStatus struct {
	StatusCode           AgentConnectStatus_StatusCode `protobuf:"varint,1,opt,name=statusCode,proto3,enum=f5.nginx.agent.sdk.AgentConnectStatus_StatusCode" json:"status_code"`
	Message              string                        `protobuf:"bytes,2,opt,name=message,proto3" json:"message"`
	Error                string                        `protobuf:"bytes,3,opt,name=error,proto3" json:"error"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func (m *AgentConnectStatus) Reset()         { *m = AgentConnectStatus{} }
func (m *AgentConnectStatus) String() string { return proto.CompactTextString(m) }
func (*AgentConnectStatus) ProtoMessage()    {}
func (*AgentConnectStatus) Descriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{1}
}
func (m *AgentConnectStatus) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentConnectStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentConnectStatus.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentConnectStatus) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentConnectStatus.Merge(m, src)
}
func (m *AgentConnectStatus) XXX_Size() int {
	return m.Size()
}
func (m *AgentConnectStatus) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentConnectStatus.DiscardUnknown(m)
}

var xxx_messageInfo_AgentConnectStatus proto.InternalMessageInfo

func (m *AgentConnectStatus) GetStatusCode() AgentConnectStatus_StatusCode {
	if m != nil {
		return m.StatusCode
	}
	return AgentConnectStatus_CONNECT_UNKNOWN
}

func (m *AgentConnectStatus) GetMessage() string {
	if m != nil {
		return m.Message
	}
	return ""
}

func (m *AgentConnectStatus) GetError() string {
	if m != nil {
		return m.Error
	}
	return ""
}

type AgentConnectResponse struct {
	AgentConfig          *AgentConfig        `protobuf:"bytes,1,opt,name=agent_config,json=agentConfig,proto3" json:"agent_config"`
	Status               *AgentConnectStatus `protobuf:"bytes,2,opt,name=status,proto3" json:"status"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func (m *AgentConnectResponse) Reset()         { *m = AgentConnectResponse{} }
func (m *AgentConnectResponse) String() string { return proto.CompactTextString(m) }
func (*AgentConnectResponse) ProtoMessage()    {}
func (*AgentConnectResponse) Descriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{2}
}
func (m *AgentConnectResponse) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentConnectResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentConnectResponse.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentConnectResponse) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentConnectResponse.Merge(m, src)
}
func (m *AgentConnectResponse) XXX_Size() int {
	return m.Size()
}
func (m *AgentConnectResponse) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentConnectResponse.DiscardUnknown(m)
}

var xxx_messageInfo_AgentConnectResponse proto.InternalMessageInfo

func (m *AgentConnectResponse) GetAgentConfig() *AgentConfig {
	if m != nil {
		return m.AgentConfig
	}
	return nil
}

func (m *AgentConnectResponse) GetStatus() *AgentConnectStatus {
	if m != nil {
		return m.Status
	}
	return nil
}

type AgentConfigRequest struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AgentConfigRequest) Reset()         { *m = AgentConfigRequest{} }
func (m *AgentConfigRequest) String() string { return proto.CompactTextString(m) }
func (*AgentConfigRequest) ProtoMessage()    {}
func (*AgentConfigRequest) Descriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{3}
}
func (m *AgentConfigRequest) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentConfigRequest.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentConfigRequest) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentConfigRequest.Merge(m, src)
}
func (m *AgentConfigRequest) XXX_Size() int {
	return m.Size()
}
func (m *AgentConfigRequest) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentConfigRequest.DiscardUnknown(m)
}

var xxx_messageInfo_AgentConfigRequest proto.InternalMessageInfo

type AgentConfig struct {
	Details              *AgentDetails `protobuf:"bytes,1,opt,name=details,proto3" json:"details"`
	Loggers              *AgentLogging `protobuf:"bytes,2,opt,name=loggers,proto3" json:"loggers"`
	Configs              *ConfigReport `protobuf:"bytes,3,opt,name=configs,proto3" json:"configs"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func (m *AgentConfig) Reset()         { *m = AgentConfig{} }
func (m *AgentConfig) String() string { return proto.CompactTextString(m) }
func (*AgentConfig) ProtoMessage()    {}
func (*AgentConfig) Descriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{4}
}
func (m *AgentConfig) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentConfig.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentConfig) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentConfig.Merge(m, src)
}
func (m *AgentConfig) XXX_Size() int {
	return m.Size()
}
func (m *AgentConfig) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentConfig.DiscardUnknown(m)
}

var xxx_messageInfo_AgentConfig proto.InternalMessageInfo

func (m *AgentConfig) GetDetails() *AgentDetails {
	if m != nil {
		return m.Details
	}
	return nil
}

func (m *AgentConfig) GetLoggers() *AgentLogging {
	if m != nil {
		return m.Loggers
	}
	return nil
}

func (m *AgentConfig) GetConfigs() *ConfigReport {
	if m != nil {
		return m.Configs
	}
	return nil
}

type AgentDetails struct {
	Features             []string `protobuf:"bytes,1,rep,name=features,proto3" json:"features"`
	Extensions           []string `protobuf:"bytes,2,rep,name=extensions,proto3" json:"extensions"`
	Tags                 []string `protobuf:"bytes,3,rep,name=tags,proto3" json:"tags"`
	Alias                string   `protobuf:"bytes,4,opt,name=alias,proto3" json:"alias"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (m *AgentDetails) Reset()         { *m = AgentDetails{} }
func (m *AgentDetails) String() string { return proto.CompactTextString(m) }
func (*AgentDetails) ProtoMessage()    {}
func (*AgentDetails) Descriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{5}
}
func (m *AgentDetails) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentDetails) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentDetails.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentDetails) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentDetails.Merge(m, src)
}
func (m *AgentDetails) XXX_Size() int {
	return m.Size()
}
func (m *AgentDetails) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentDetails.DiscardUnknown(m)
}

var xxx_messageInfo_AgentDetails proto.InternalMessageInfo

func (m *AgentDetails) GetFeatures() []string {
	if m != nil {
		return m.Features
	}
	return nil
}

func (m *AgentDetails) GetExtensions() []string {
	if m != nil {
		return m.Extensions
	}
	return nil
}

func (m *AgentDetails) GetTags() []string {
	if m != nil {
		return m.Tags
	}
	return nil
}

func (m *AgentDetails) GetAlias() string {
	if m != nil {
		return m.Alias
	}
	return ""
}

type AgentLogging struct {
	Level                AgentLogging_Level `protobuf:"varint,1,opt,name=level,proto3,enum=f5.nginx.agent.sdk.AgentLogging_Level" json:"level"`
	Dir                  string             `protobuf:"bytes,2,opt,name=dir,proto3" json:"dir"`
	File                 string             `protobuf:"bytes,3,opt,name=file,proto3" json:"file"`
	MaxSize              uint32             `protobuf:"varint,4,opt,name=max_size,json=maxSize,proto3" json:"max_size"`
	MaxBackups           uint32             `protobuf:"varint,5,opt,name=max_backups,json=maxBackups,proto3" json:"max_backups"`
	MaxAge               uint32             `protobuf:"varint,6,opt,name=max_age,json=maxAge,proto3" json:"max_age"`
	Compress             bool               `protobuf:"varint,7,opt,name=compress,proto3" json:"compress"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_unrecognized     []byte             `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (m *AgentLogging) Reset()         { *m = AgentLogging{} }
func (m *AgentLogging) String() string { return proto.CompactTextString(m) }
func (*AgentLogging) ProtoMessage()    {}
func (*AgentLogging) Descriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{6}
}
func (m *AgentLogging) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentLogging) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentLogging.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentLogging) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentLogging.Merge(m, src)
}
func (m *AgentLogging) XXX_Size() int {
	return m.Size()
}
func (m *AgentLogging) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentLogging.DiscardUnknown(m)
}

var xxx_messageInfo_AgentLogging proto.InternalMessageInfo

func (m *AgentLogging) GetLevel() AgentLogging_Level {
	if m != nil {
		return m.Level
	}
	return AgentLogging_INFO
}

func (m *AgentLogging) GetDir() string {
	if m != nil {
		return m.Dir
	}
	return ""
}

func (m *AgentLogging) GetFile() string {
	if m != nil {
		return m.File
	}
	return ""
}

func (m *AgentLogging) GetMaxSize() uint32 {
	if m != nil {
		return m.MaxSize
	}
	return 0
}

func (m *AgentLogging) GetMaxBackups() uint32 {
	if m != nil {
		return m.MaxBackups
	}
	return 0
}

func (m *AgentLogging) GetMaxAge() uint32 {
	if m != nil {
		return m.MaxAge
	}
	return 0
}

func (m *AgentLogging) GetCompress() bool {
	if m != nil {
		return m.Compress
	}
	return false
}

type AgentMeta struct {
	Version              string           `protobuf:"bytes,1,opt,name=version,proto3" json:"version"`
	DisplayName          string           `protobuf:"bytes,2,opt,name=display_name,json=displayName,proto3" json:"display_name"`
	Tag                  []string         `protobuf:"bytes,3,rep,name=tag,proto3" json:"tag"`
	InstanceGroup        string           `protobuf:"bytes,5,opt,name=instance_group,json=instanceGroup,proto3" json:"instance_group"`
	Updated              *types.Timestamp `protobuf:"bytes,6,opt,name=updated,proto3" json:"updated"`
	SystemUid            string           `protobuf:"bytes,7,opt,name=system_uid,json=systemUid,proto3" json:"system_uid"`
	AgentDetails         *AgentDetails    `protobuf:"bytes,8,opt,name=agent_details,json=agentDetails,proto3" json:"agent_details"`
	XXX_NoUnkeyedLiteral struct{}         `json:"-"`
	XXX_unrecognized     []byte           `json:"-"`
	XXX_sizecache        int32            `json:"-"`
}

func (m *AgentMeta) Reset()         { *m = AgentMeta{} }
func (m *AgentMeta) String() string { return proto.CompactTextString(m) }
func (*AgentMeta) ProtoMessage()    {}
func (*AgentMeta) Descriptor() ([]byte, []int) {
	return fileDescriptor_56ede974c0020f77, []int{7}
}
func (m *AgentMeta) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AgentMeta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AgentMeta.Marshal(b, m, deterministic)
	} else {
		b = b[:cap(b)]
		n, err := m.MarshalToSizedBuffer(b)
		if err != nil {
			return nil, err
		}
		return b[:n], nil
	}
}
func (m *AgentMeta) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AgentMeta.Merge(m, src)
}
func (m *AgentMeta) XXX_Size() int {
	return m.Size()
}
func (m *AgentMeta) XXX_DiscardUnknown() {
	xxx_messageInfo_AgentMeta.DiscardUnknown(m)
}

var xxx_messageInfo_AgentMeta proto.InternalMessageInfo

func (m *AgentMeta) GetVersion() string {
	if m != nil {
		return m.Version
	}
	return ""
}

func (m *AgentMeta) GetDisplayName() string {
	if m != nil {
		return m.DisplayName
	}
	return ""
}

func (m *AgentMeta) GetTag() []string {
	if m != nil {
		return m.Tag
	}
	return nil
}

func (m *AgentMeta) GetInstanceGroup() string {
	if m != nil {
		return m.InstanceGroup
	}
	return ""
}

func (m *AgentMeta) GetUpdated() *types.Timestamp {
	if m != nil {
		return m.Updated
	}
	return nil
}

func (m *AgentMeta) GetSystemUid() string {
	if m != nil {
		return m.SystemUid
	}
	return ""
}

func (m *AgentMeta) GetAgentDetails() *AgentDetails {
	if m != nil {
		return m.AgentDetails
	}
	return nil
}

func init() {
	proto.RegisterEnum("f5.nginx.agent.sdk.AgentConnectStatus_StatusCode", AgentConnectStatus_StatusCode_name, AgentConnectStatus_StatusCode_value)
	proto.RegisterEnum("f5.nginx.agent.sdk.AgentLogging_Level", AgentLogging_Level_name, AgentLogging_Level_value)
	proto.RegisterType((*AgentConnectRequest)(nil), "f5.nginx.agent.sdk.AgentConnectRequest")
	proto.RegisterType((*AgentConnectStatus)(nil), "f5.nginx.agent.sdk.AgentConnectStatus")
	proto.RegisterType((*AgentConnectResponse)(nil), "f5.nginx.agent.sdk.AgentConnectResponse")
	proto.RegisterType((*AgentConfigRequest)(nil), "f5.nginx.agent.sdk.AgentConfigRequest")
	proto.RegisterType((*AgentConfig)(nil), "f5.nginx.agent.sdk.AgentConfig")
	proto.RegisterType((*AgentDetails)(nil), "f5.nginx.agent.sdk.AgentDetails")
	proto.RegisterType((*AgentLogging)(nil), "f5.nginx.agent.sdk.AgentLogging")
	proto.RegisterType((*AgentMeta)(nil), "f5.nginx.agent.sdk.AgentMeta")
}

func init() { proto.RegisterFile("agent.proto", fileDescriptor_56ede974c0020f77) }

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

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

func (m *AgentConnectRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentConnectRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.DataplaneSoftwareDetails) > 0 {
		for iNdEx := len(m.DataplaneSoftwareDetails) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.DataplaneSoftwareDetails[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAgent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Host != nil {
		{
			size, err := m.Host.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if len(m.Details) > 0 {
		for iNdEx := len(m.Details) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.Details[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintAgent(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x1a
		}
	}
	if m.Meta != nil {
		{
			size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	return len(dAtA) - i, nil
}

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

func (m *AgentConnectStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentConnectStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Error) > 0 {
		i -= len(m.Error)
		copy(dAtA[i:], m.Error)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Error)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Message) > 0 {
		i -= len(m.Message)
		copy(dAtA[i:], m.Message)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Message)))
		i--
		dAtA[i] = 0x12
	}
	if m.StatusCode != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.StatusCode))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *AgentConnectResponse) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentConnectResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Status != nil {
		{
			size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.AgentConfig != nil {
		{
			size, err := m.AgentConfig.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AgentConfigRequest) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	return len(dAtA) - i, nil
}

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

func (m *AgentConfig) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Configs != nil {
		{
			size, err := m.Configs.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Loggers != nil {
		{
			size, err := m.Loggers.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Details != nil {
		{
			size, err := m.Details.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *AgentDetails) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentDetails) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if len(m.Alias) > 0 {
		i -= len(m.Alias)
		copy(dAtA[i:], m.Alias)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Alias)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Tags) > 0 {
		for iNdEx := len(m.Tags) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Tags[iNdEx])
			copy(dAtA[i:], m.Tags[iNdEx])
			i = encodeVarintAgent(dAtA, i, uint64(len(m.Tags[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.Extensions) > 0 {
		for iNdEx := len(m.Extensions) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Extensions[iNdEx])
			copy(dAtA[i:], m.Extensions[iNdEx])
			i = encodeVarintAgent(dAtA, i, uint64(len(m.Extensions[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	if len(m.Features) > 0 {
		for iNdEx := len(m.Features) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Features[iNdEx])
			copy(dAtA[i:], m.Features[iNdEx])
			i = encodeVarintAgent(dAtA, i, uint64(len(m.Features[iNdEx])))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *AgentLogging) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentLogging) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.Compress {
		i--
		if m.Compress {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.MaxAge != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.MaxAge))
		i--
		dAtA[i] = 0x30
	}
	if m.MaxBackups != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.MaxBackups))
		i--
		dAtA[i] = 0x28
	}
	if m.MaxSize != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.MaxSize))
		i--
		dAtA[i] = 0x20
	}
	if len(m.File) > 0 {
		i -= len(m.File)
		copy(dAtA[i:], m.File)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.File)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Dir) > 0 {
		i -= len(m.Dir)
		copy(dAtA[i:], m.Dir)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Dir)))
		i--
		dAtA[i] = 0x12
	}
	if m.Level != 0 {
		i = encodeVarintAgent(dAtA, i, uint64(m.Level))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *AgentMeta) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AgentMeta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		i -= len(m.XXX_unrecognized)
		copy(dAtA[i:], m.XXX_unrecognized)
	}
	if m.AgentDetails != nil {
		{
			size, err := m.AgentDetails.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x42
	}
	if len(m.SystemUid) > 0 {
		i -= len(m.SystemUid)
		copy(dAtA[i:], m.SystemUid)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.SystemUid)))
		i--
		dAtA[i] = 0x3a
	}
	if m.Updated != nil {
		{
			size, err := m.Updated.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintAgent(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	if len(m.InstanceGroup) > 0 {
		i -= len(m.InstanceGroup)
		copy(dAtA[i:], m.InstanceGroup)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.InstanceGroup)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Tag) > 0 {
		for iNdEx := len(m.Tag) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Tag[iNdEx])
			copy(dAtA[i:], m.Tag[iNdEx])
			i = encodeVarintAgent(dAtA, i, uint64(len(m.Tag[iNdEx])))
			i--
			dAtA[i] = 0x1a
		}
	}
	if len(m.DisplayName) > 0 {
		i -= len(m.DisplayName)
		copy(dAtA[i:], m.DisplayName)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.DisplayName)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintAgent(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func encodeVarintAgent(dAtA []byte, offset int, v uint64) int {
	offset -= sovAgent(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *AgentConnectRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Meta != nil {
		l = m.Meta.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if len(m.Details) > 0 {
		for _, e := range m.Details {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if m.Host != nil {
		l = m.Host.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if len(m.DataplaneSoftwareDetails) > 0 {
		for _, e := range m.DataplaneSoftwareDetails {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AgentConnectStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.StatusCode != 0 {
		n += 1 + sovAgent(uint64(m.StatusCode))
	}
	l = len(m.Message)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.Error)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AgentConnectResponse) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.AgentConfig != nil {
		l = m.AgentConfig.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Status != nil {
		l = m.Status.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AgentConfigRequest) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AgentConfig) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Details != nil {
		l = m.Details.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Loggers != nil {
		l = m.Loggers.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Configs != nil {
		l = m.Configs.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AgentDetails) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Features) > 0 {
		for _, s := range m.Features {
			l = len(s)
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if len(m.Extensions) > 0 {
		for _, s := range m.Extensions {
			l = len(s)
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if len(m.Tags) > 0 {
		for _, s := range m.Tags {
			l = len(s)
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	l = len(m.Alias)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AgentLogging) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Level != 0 {
		n += 1 + sovAgent(uint64(m.Level))
	}
	l = len(m.Dir)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.File)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.MaxSize != 0 {
		n += 1 + sovAgent(uint64(m.MaxSize))
	}
	if m.MaxBackups != 0 {
		n += 1 + sovAgent(uint64(m.MaxBackups))
	}
	if m.MaxAge != 0 {
		n += 1 + sovAgent(uint64(m.MaxAge))
	}
	if m.Compress {
		n += 2
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func (m *AgentMeta) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.DisplayName)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if len(m.Tag) > 0 {
		for _, s := range m.Tag {
			l = len(s)
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	l = len(m.InstanceGroup)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Updated != nil {
		l = m.Updated.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	l = len(m.SystemUid)
	if l > 0 {
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.AgentDetails != nil {
		l = m.AgentDetails.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.XXX_unrecognized != nil {
		n += len(m.XXX_unrecognized)
	}
	return n
}

func sovAgent(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozAgent(x uint64) (n int) {
	return sovAgent(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *AgentConnectRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentConnectRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentConnectRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Meta == nil {
				m.Meta = &AgentMeta{}
			}
			if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Details = append(m.Details, &NginxDetails{})
			if err := m.Details[len(m.Details)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Host == nil {
				m.Host = &HostInfo{}
			}
			if err := m.Host.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DataplaneSoftwareDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DataplaneSoftwareDetails = append(m.DataplaneSoftwareDetails, &DataplaneSoftwareDetails{})
			if err := m.DataplaneSoftwareDetails[len(m.DataplaneSoftwareDetails)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentConnectStatus) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentConnectStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentConnectStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field StatusCode", wireType)
			}
			m.StatusCode = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.StatusCode |= AgentConnectStatus_StatusCode(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Message = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Error = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentConfigRequest) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentConfigRequest: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentConfig) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentConfig: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentConfig: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Details", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Details == nil {
				m.Details = &AgentDetails{}
			}
			if err := m.Details.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Loggers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Loggers == nil {
				m.Loggers = &AgentLogging{}
			}
			if err := m.Loggers.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Configs", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Configs == nil {
				m.Configs = &ConfigReport{}
			}
			if err := m.Configs.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentDetails) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentDetails: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentDetails: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Features", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Features = append(m.Features, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Extensions", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Extensions = append(m.Extensions, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tags", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tags = append(m.Tags, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Alias", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Alias = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentLogging) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentLogging: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentLogging: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
			}
			m.Level = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Level |= AgentLogging_Level(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Dir", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Dir = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.File = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxSize", wireType)
			}
			m.MaxSize = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxSize |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxBackups", wireType)
			}
			m.MaxBackups = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxBackups |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field MaxAge", wireType)
			}
			m.MaxAge = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.MaxAge |= uint32(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Compress", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Compress = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AgentMeta) Unmarshal(dAtA []byte) error {
	l := len(dAtA)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := dAtA[iNdEx]
			iNdEx++
			wire |= uint64(b&0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AgentMeta: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AgentMeta: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field DisplayName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.DisplayName = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Tag", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Tag = append(m.Tag, string(dAtA[iNdEx:postIndex]))
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field InstanceGroup", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.InstanceGroup = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Updated", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Updated == nil {
				m.Updated = &types.Timestamp{}
			}
			if err := m.Updated.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SystemUid", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				stringLen |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SystemUid = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AgentDetails", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthAgent
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AgentDetails == nil {
				m.AgentDetails = &AgentDetails{}
			}
			if err := m.AgentDetails.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthAgent        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAgent          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupAgent = fmt.Errorf("proto: unexpected end of group")
)
