github.com/onosproject/onos-api/go@v0.10.32/onos/topo/config.pb.go

// Code generated by protoc-gen-gogo. DO NOT EDIT.
// source: onos/topo/config.proto

package topo

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

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

// 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

// Protocol to interact with a device
type Protocol int32

const (
	//UNKNOWN_PROTOCOL constant needed to go around proto3 nullifying the 0 values
	Protocol_UNKNOWN_PROTOCOL Protocol = 0
	// GNMI protocol reference
	Protocol_GNMI Protocol = 1
	// P4RUNTIME protocol reference
	Protocol_P4RUNTIME Protocol = 2
	// GNOI protocol reference
	Protocol_GNOI Protocol = 3
	// E2 Control Plane Protocol
	Protocol_E2AP Protocol = 4
)

var Protocol_name = map[int32]string{
	0: "UNKNOWN_PROTOCOL",
	1: "GNMI",
	2: "P4RUNTIME",
	3: "GNOI",
	4: "E2AP",
}

var Protocol_value = map[string]int32{
	"UNKNOWN_PROTOCOL": 0,
	"GNMI":             1,
	"P4RUNTIME":        2,
	"GNOI":             3,
	"E2AP":             4,
}

func (x Protocol) String() string {
	return proto.EnumName(Protocol_name, int32(x))
}

func (Protocol) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{0}
}

// ConnectivityState represents the L3 reachability of a device from the service container (e.g. enos-config), independently of gRPC or the service itself (e.g. gNMI)
type ConnectivityState int32

const (
	//UNKNOWN_CONNECTIVITY_STATE constant needed to go around proto3 nullifying the 0 values
	ConnectivityState_UNKNOWN_CONNECTIVITY_STATE ConnectivityState = 0
	// REACHABLE indicates the the service can reach the device at L3
	ConnectivityState_REACHABLE ConnectivityState = 1
	// UNREACHABLE indicates the the service can't reach the device at L3
	ConnectivityState_UNREACHABLE ConnectivityState = 2
)

var ConnectivityState_name = map[int32]string{
	0: "UNKNOWN_CONNECTIVITY_STATE",
	1: "REACHABLE",
	2: "UNREACHABLE",
}

var ConnectivityState_value = map[string]int32{
	"UNKNOWN_CONNECTIVITY_STATE": 0,
	"REACHABLE":                  1,
	"UNREACHABLE":                2,
}

func (x ConnectivityState) String() string {
	return proto.EnumName(ConnectivityState_name, int32(x))
}

func (ConnectivityState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{1}
}

// ConnectivityState represents the state of a gRPC channel to the device from the service container
type ChannelState int32

const (
	//UNKNOWN_CHANNEL_STATE constant needed to go around proto3 nullifying the 0 values
	ChannelState_UNKNOWN_CHANNEL_STATE ChannelState = 0
	// CONNECTED indicates the corresponding grpc channel is connected on this device
	ChannelState_CONNECTED ChannelState = 1
	// DISCONNECTED indicates the corresponding grpc channel is not connected on this device
	ChannelState_DISCONNECTED ChannelState = 2
)

var ChannelState_name = map[int32]string{
	0: "UNKNOWN_CHANNEL_STATE",
	1: "CONNECTED",
	2: "DISCONNECTED",
}

var ChannelState_value = map[string]int32{
	"UNKNOWN_CHANNEL_STATE": 0,
	"CONNECTED":             1,
	"DISCONNECTED":          2,
}

func (x ChannelState) String() string {
	return proto.EnumName(ChannelState_name, int32(x))
}

func (ChannelState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{2}
}

// ServiceState represents the state of the gRPC service (e.g. gNMI) to the device from the service container
type ServiceState int32

const (
	//UNKNOWN_SERVICE_STATE constant needed to go around proto3 nullifying the 0 values
	ServiceState_UNKNOWN_SERVICE_STATE ServiceState = 0
	// AVAILABLE indicates the corresponding grpc service is available
	ServiceState_AVAILABLE ServiceState = 1
	// UNAVAILABLE indicates the corresponding grpc service is not available
	ServiceState_UNAVAILABLE ServiceState = 2
	// CONNECTING indicates the corresponding protocol is in the connecting phase on this device
	ServiceState_CONNECTING ServiceState = 3
)

var ServiceState_name = map[int32]string{
	0: "UNKNOWN_SERVICE_STATE",
	1: "AVAILABLE",
	2: "UNAVAILABLE",
	3: "CONNECTING",
}

var ServiceState_value = map[string]int32{
	"UNKNOWN_SERVICE_STATE": 0,
	"AVAILABLE":             1,
	"UNAVAILABLE":           2,
	"CONNECTING":            3,
}

func (x ServiceState) String() string {
	return proto.EnumName(ServiceState_name, int32(x))
}

func (ServiceState) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{3}
}

// Basic asset information
type Asset struct {
	Name         string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	Manufacturer string `protobuf:"bytes,2,opt,name=manufacturer,proto3" json:"manufacturer,omitempty"`
	Model        string `protobuf:"bytes,3,opt,name=model,proto3" json:"model,omitempty"`
	Serial       string `protobuf:"bytes,4,opt,name=serial,proto3" json:"serial,omitempty"`
	Asset        string `protobuf:"bytes,5,opt,name=asset,proto3" json:"asset,omitempty"`
	SwVersion    string `protobuf:"bytes,6,opt,name=sw_version,json=swVersion,proto3" json:"sw_version,omitempty"`
	Role         string `protobuf:"bytes,8,opt,name=role,proto3" json:"role,omitempty"`
}

func (m *Asset) Reset()         { *m = Asset{} }
func (m *Asset) String() string { return proto.CompactTextString(m) }
func (*Asset) ProtoMessage()    {}
func (*Asset) Descriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{0}
}
func (m *Asset) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Asset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Asset.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 *Asset) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Asset.Merge(m, src)
}
func (m *Asset) XXX_Size() int {
	return m.Size()
}
func (m *Asset) XXX_DiscardUnknown() {
	xxx_messageInfo_Asset.DiscardUnknown(m)
}

var xxx_messageInfo_Asset proto.InternalMessageInfo

func (m *Asset) GetName() string {
	if m != nil {
		return m.Name
	}
	return ""
}

func (m *Asset) GetManufacturer() string {
	if m != nil {
		return m.Manufacturer
	}
	return ""
}

func (m *Asset) GetModel() string {
	if m != nil {
		return m.Model
	}
	return ""
}

func (m *Asset) GetSerial() string {
	if m != nil {
		return m.Serial
	}
	return ""
}

func (m *Asset) GetAsset() string {
	if m != nil {
		return m.Asset
	}
	return ""
}

func (m *Asset) GetSwVersion() string {
	if m != nil {
		return m.SwVersion
	}
	return ""
}

func (m *Asset) GetRole() string {
	if m != nil {
		return m.Role
	}
	return ""
}

// Configurable device aspect
type Configurable struct {
	Type                 string         `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"`
	Address              string         `protobuf:"bytes,2,opt,name=address,proto3" json:"address,omitempty"`
	Target               string         `protobuf:"bytes,3,opt,name=target,proto3" json:"target,omitempty"`
	Version              string         `protobuf:"bytes,4,opt,name=version,proto3" json:"version,omitempty"`
	Timeout              *time.Duration `protobuf:"bytes,5,opt,name=timeout,proto3,stdduration" json:"timeout,omitempty"`
	Persistent           bool           `protobuf:"varint,6,opt,name=persistent,proto3" json:"persistent,omitempty"`
	ValidateCapabilities bool           `protobuf:"varint,7,opt,name=validate_capabilities,json=validateCapabilities,proto3" json:"validate_capabilities,omitempty"`
}

func (m *Configurable) Reset()         { *m = Configurable{} }
func (m *Configurable) String() string { return proto.CompactTextString(m) }
func (*Configurable) ProtoMessage()    {}
func (*Configurable) Descriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{1}
}
func (m *Configurable) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Configurable) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Configurable.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 *Configurable) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Configurable.Merge(m, src)
}
func (m *Configurable) XXX_Size() int {
	return m.Size()
}
func (m *Configurable) XXX_DiscardUnknown() {
	xxx_messageInfo_Configurable.DiscardUnknown(m)
}

var xxx_messageInfo_Configurable proto.InternalMessageInfo

func (m *Configurable) GetType() string {
	if m != nil {
		return m.Type
	}
	return ""
}

func (m *Configurable) GetAddress() string {
	if m != nil {
		return m.Address
	}
	return ""
}

func (m *Configurable) GetTarget() string {
	if m != nil {
		return m.Target
	}
	return ""
}

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

func (m *Configurable) GetTimeout() *time.Duration {
	if m != nil {
		return m.Timeout
	}
	return nil
}

func (m *Configurable) GetPersistent() bool {
	if m != nil {
		return m.Persistent
	}
	return false
}

func (m *Configurable) GetValidateCapabilities() bool {
	if m != nil {
		return m.ValidateCapabilities
	}
	return false
}

// Aspect for tracking device mastership
type MastershipState struct {
	Term   uint64 `protobuf:"varint,1,opt,name=term,proto3" json:"term,omitempty"`
	NodeId string `protobuf:"bytes,2,opt,name=node_id,json=nodeId,proto3" json:"node_id,omitempty"`
}

func (m *MastershipState) Reset()         { *m = MastershipState{} }
func (m *MastershipState) String() string { return proto.CompactTextString(m) }
func (*MastershipState) ProtoMessage()    {}
func (*MastershipState) Descriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{2}
}
func (m *MastershipState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *MastershipState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_MastershipState.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 *MastershipState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_MastershipState.Merge(m, src)
}
func (m *MastershipState) XXX_Size() int {
	return m.Size()
}
func (m *MastershipState) XXX_DiscardUnknown() {
	xxx_messageInfo_MastershipState.DiscardUnknown(m)
}

var xxx_messageInfo_MastershipState proto.InternalMessageInfo

func (m *MastershipState) GetTerm() uint64 {
	if m != nil {
		return m.Term
	}
	return 0
}

func (m *MastershipState) GetNodeId() string {
	if m != nil {
		return m.NodeId
	}
	return ""
}

// TLS connectivity aspect
type TLSOptions struct {
	Insecure bool   `protobuf:"varint,1,opt,name=insecure,proto3" json:"insecure,omitempty"`
	Plain    bool   `protobuf:"varint,2,opt,name=plain,proto3" json:"plain,omitempty"`
	Key      string `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
	CaCert   string `protobuf:"bytes,4,opt,name=ca_cert,json=caCert,proto3" json:"ca_cert,omitempty"`
	Cert     string `protobuf:"bytes,5,opt,name=cert,proto3" json:"cert,omitempty"`
}

func (m *TLSOptions) Reset()         { *m = TLSOptions{} }
func (m *TLSOptions) String() string { return proto.CompactTextString(m) }
func (*TLSOptions) ProtoMessage()    {}
func (*TLSOptions) Descriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{3}
}
func (m *TLSOptions) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *TLSOptions) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_TLSOptions.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 *TLSOptions) XXX_Merge(src proto.Message) {
	xxx_messageInfo_TLSOptions.Merge(m, src)
}
func (m *TLSOptions) XXX_Size() int {
	return m.Size()
}
func (m *TLSOptions) XXX_DiscardUnknown() {
	xxx_messageInfo_TLSOptions.DiscardUnknown(m)
}

var xxx_messageInfo_TLSOptions proto.InternalMessageInfo

func (m *TLSOptions) GetInsecure() bool {
	if m != nil {
		return m.Insecure
	}
	return false
}

func (m *TLSOptions) GetPlain() bool {
	if m != nil {
		return m.Plain
	}
	return false
}

func (m *TLSOptions) GetKey() string {
	if m != nil {
		return m.Key
	}
	return ""
}

func (m *TLSOptions) GetCaCert() string {
	if m != nil {
		return m.CaCert
	}
	return ""
}

func (m *TLSOptions) GetCert() string {
	if m != nil {
		return m.Cert
	}
	return ""
}

// Aspect for ad-hoc properties
type AdHoc struct {
	Properties map[string]string `protobuf:"bytes,1,rep,name=properties,proto3" json:"properties,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

func (m *AdHoc) Reset()         { *m = AdHoc{} }
func (m *AdHoc) String() string { return proto.CompactTextString(m) }
func (*AdHoc) ProtoMessage()    {}
func (*AdHoc) Descriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{4}
}
func (m *AdHoc) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *AdHoc) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_AdHoc.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 *AdHoc) XXX_Merge(src proto.Message) {
	xxx_messageInfo_AdHoc.Merge(m, src)
}
func (m *AdHoc) XXX_Size() int {
	return m.Size()
}
func (m *AdHoc) XXX_DiscardUnknown() {
	xxx_messageInfo_AdHoc.DiscardUnknown(m)
}

var xxx_messageInfo_AdHoc proto.InternalMessageInfo

func (m *AdHoc) GetProperties() map[string]string {
	if m != nil {
		return m.Properties
	}
	return nil
}

// ProtocolState contains information related to service and connectivity to a device
type ProtocolState struct {
	// The protocol to which state relates
	Protocol Protocol `protobuf:"varint,1,opt,name=protocol,proto3,enum=onos.topo.Protocol" json:"protocol,omitempty"`
	// ConnectivityState contains the L3 connectivity information
	ConnectivityState ConnectivityState `protobuf:"varint,2,opt,name=connectivityState,proto3,enum=onos.topo.ConnectivityState" json:"connectivityState,omitempty"`
	// ChannelState relates to the availability of the gRPC channel
	ChannelState ChannelState `protobuf:"varint,3,opt,name=channelState,proto3,enum=onos.topo.ChannelState" json:"channelState,omitempty"`
	// ServiceState indicates the availability of the gRPC servic on top of the channel
	ServiceState ServiceState `protobuf:"varint,4,opt,name=serviceState,proto3,enum=onos.topo.ServiceState" json:"serviceState,omitempty"`
}

func (m *ProtocolState) Reset()         { *m = ProtocolState{} }
func (m *ProtocolState) String() string { return proto.CompactTextString(m) }
func (*ProtocolState) ProtoMessage()    {}
func (*ProtocolState) Descriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{5}
}
func (m *ProtocolState) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *ProtocolState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_ProtocolState.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 *ProtocolState) XXX_Merge(src proto.Message) {
	xxx_messageInfo_ProtocolState.Merge(m, src)
}
func (m *ProtocolState) XXX_Size() int {
	return m.Size()
}
func (m *ProtocolState) XXX_DiscardUnknown() {
	xxx_messageInfo_ProtocolState.DiscardUnknown(m)
}

var xxx_messageInfo_ProtocolState proto.InternalMessageInfo

func (m *ProtocolState) GetProtocol() Protocol {
	if m != nil {
		return m.Protocol
	}
	return Protocol_UNKNOWN_PROTOCOL
}

func (m *ProtocolState) GetConnectivityState() ConnectivityState {
	if m != nil {
		return m.ConnectivityState
	}
	return ConnectivityState_UNKNOWN_CONNECTIVITY_STATE
}

func (m *ProtocolState) GetChannelState() ChannelState {
	if m != nil {
		return m.ChannelState
	}
	return ChannelState_UNKNOWN_CHANNEL_STATE
}

func (m *ProtocolState) GetServiceState() ServiceState {
	if m != nil {
		return m.ServiceState
	}
	return ServiceState_UNKNOWN_SERVICE_STATE
}

// Protocols
type Protocols struct {
	State []*ProtocolState `protobuf:"bytes,1,rep,name=state,proto3" json:"state,omitempty"`
}

func (m *Protocols) Reset()         { *m = Protocols{} }
func (m *Protocols) String() string { return proto.CompactTextString(m) }
func (*Protocols) ProtoMessage()    {}
func (*Protocols) Descriptor() ([]byte, []int) {
	return fileDescriptor_6fc2683aefb53254, []int{6}
}
func (m *Protocols) XXX_Unmarshal(b []byte) error {
	return m.Unmarshal(b)
}
func (m *Protocols) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
	if deterministic {
		return xxx_messageInfo_Protocols.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 *Protocols) XXX_Merge(src proto.Message) {
	xxx_messageInfo_Protocols.Merge(m, src)
}
func (m *Protocols) XXX_Size() int {
	return m.Size()
}
func (m *Protocols) XXX_DiscardUnknown() {
	xxx_messageInfo_Protocols.DiscardUnknown(m)
}

var xxx_messageInfo_Protocols proto.InternalMessageInfo

func (m *Protocols) GetState() []*ProtocolState {
	if m != nil {
		return m.State
	}
	return nil
}

func init() {
	proto.RegisterEnum("onos.topo.Protocol", Protocol_name, Protocol_value)
	proto.RegisterEnum("onos.topo.ConnectivityState", ConnectivityState_name, ConnectivityState_value)
	proto.RegisterEnum("onos.topo.ChannelState", ChannelState_name, ChannelState_value)
	proto.RegisterEnum("onos.topo.ServiceState", ServiceState_name, ServiceState_value)
	proto.RegisterType((*Asset)(nil), "onos.topo.Asset")
	proto.RegisterType((*Configurable)(nil), "onos.topo.Configurable")
	proto.RegisterType((*MastershipState)(nil), "onos.topo.MastershipState")
	proto.RegisterType((*TLSOptions)(nil), "onos.topo.TLSOptions")
	proto.RegisterType((*AdHoc)(nil), "onos.topo.AdHoc")
	proto.RegisterMapType((map[string]string)(nil), "onos.topo.AdHoc.PropertiesEntry")
	proto.RegisterType((*ProtocolState)(nil), "onos.topo.ProtocolState")
	proto.RegisterType((*Protocols)(nil), "onos.topo.Protocols")
}

func init() { proto.RegisterFile("onos/topo/config.proto", fileDescriptor_6fc2683aefb53254) }

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

func (m *Asset) 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 *Asset) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Asset) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Role) > 0 {
		i -= len(m.Role)
		copy(dAtA[i:], m.Role)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Role)))
		i--
		dAtA[i] = 0x42
	}
	if len(m.SwVersion) > 0 {
		i -= len(m.SwVersion)
		copy(dAtA[i:], m.SwVersion)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.SwVersion)))
		i--
		dAtA[i] = 0x32
	}
	if len(m.Asset) > 0 {
		i -= len(m.Asset)
		copy(dAtA[i:], m.Asset)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Asset)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Serial) > 0 {
		i -= len(m.Serial)
		copy(dAtA[i:], m.Serial)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Serial)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Model) > 0 {
		i -= len(m.Model)
		copy(dAtA[i:], m.Model)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Model)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Manufacturer) > 0 {
		i -= len(m.Manufacturer)
		copy(dAtA[i:], m.Manufacturer)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Manufacturer)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Name) > 0 {
		i -= len(m.Name)
		copy(dAtA[i:], m.Name)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Name)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *Configurable) 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 *Configurable) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Configurable) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ValidateCapabilities {
		i--
		if m.ValidateCapabilities {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x38
	}
	if m.Persistent {
		i--
		if m.Persistent {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x30
	}
	if m.Timeout != nil {
		n1, err1 := github_com_gogo_protobuf_types.StdDurationMarshalTo(*m.Timeout, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Timeout):])
		if err1 != nil {
			return 0, err1
		}
		i -= n1
		i = encodeVarintConfig(dAtA, i, uint64(n1))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.Version) > 0 {
		i -= len(m.Version)
		copy(dAtA[i:], m.Version)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Version)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Target) > 0 {
		i -= len(m.Target)
		copy(dAtA[i:], m.Target)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Target)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.Address) > 0 {
		i -= len(m.Address)
		copy(dAtA[i:], m.Address)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Address)))
		i--
		dAtA[i] = 0x12
	}
	if len(m.Type) > 0 {
		i -= len(m.Type)
		copy(dAtA[i:], m.Type)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Type)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

func (m *MastershipState) 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 *MastershipState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MastershipState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.NodeId) > 0 {
		i -= len(m.NodeId)
		copy(dAtA[i:], m.NodeId)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.NodeId)))
		i--
		dAtA[i] = 0x12
	}
	if m.Term != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.Term))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *TLSOptions) 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 *TLSOptions) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TLSOptions) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Cert) > 0 {
		i -= len(m.Cert)
		copy(dAtA[i:], m.Cert)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Cert)))
		i--
		dAtA[i] = 0x2a
	}
	if len(m.CaCert) > 0 {
		i -= len(m.CaCert)
		copy(dAtA[i:], m.CaCert)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.CaCert)))
		i--
		dAtA[i] = 0x22
	}
	if len(m.Key) > 0 {
		i -= len(m.Key)
		copy(dAtA[i:], m.Key)
		i = encodeVarintConfig(dAtA, i, uint64(len(m.Key)))
		i--
		dAtA[i] = 0x1a
	}
	if m.Plain {
		i--
		if m.Plain {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x10
	}
	if m.Insecure {
		i--
		if m.Insecure {
			dAtA[i] = 1
		} else {
			dAtA[i] = 0
		}
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *AdHoc) 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 *AdHoc) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *AdHoc) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Properties) > 0 {
		for k := range m.Properties {
			v := m.Properties[k]
			baseI := i
			i -= len(v)
			copy(dAtA[i:], v)
			i = encodeVarintConfig(dAtA, i, uint64(len(v)))
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintConfig(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintConfig(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func (m *ProtocolState) 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 *ProtocolState) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *ProtocolState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.ServiceState != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.ServiceState))
		i--
		dAtA[i] = 0x20
	}
	if m.ChannelState != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.ChannelState))
		i--
		dAtA[i] = 0x18
	}
	if m.ConnectivityState != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.ConnectivityState))
		i--
		dAtA[i] = 0x10
	}
	if m.Protocol != 0 {
		i = encodeVarintConfig(dAtA, i, uint64(m.Protocol))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func (m *Protocols) 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 *Protocols) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Protocols) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.State) > 0 {
		for iNdEx := len(m.State) - 1; iNdEx >= 0; iNdEx-- {
			{
				size, err := m.State[iNdEx].MarshalToSizedBuffer(dAtA[:i])
				if err != nil {
					return 0, err
				}
				i -= size
				i = encodeVarintConfig(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

func encodeVarintConfig(dAtA []byte, offset int, v uint64) int {
	offset -= sovConfig(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Asset) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Name)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Manufacturer)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Model)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Serial)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Asset)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.SwVersion)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Role)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func (m *Configurable) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.Type)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Address)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Target)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Version)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.Timeout != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdDuration(*m.Timeout)
		n += 1 + l + sovConfig(uint64(l))
	}
	if m.Persistent {
		n += 2
	}
	if m.ValidateCapabilities {
		n += 2
	}
	return n
}

func (m *MastershipState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Term != 0 {
		n += 1 + sovConfig(uint64(m.Term))
	}
	l = len(m.NodeId)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func (m *TLSOptions) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Insecure {
		n += 2
	}
	if m.Plain {
		n += 2
	}
	l = len(m.Key)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.CaCert)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	l = len(m.Cert)
	if l > 0 {
		n += 1 + l + sovConfig(uint64(l))
	}
	return n
}

func (m *AdHoc) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Properties) > 0 {
		for k, v := range m.Properties {
			_ = k
			_ = v
			mapEntrySize := 1 + len(k) + sovConfig(uint64(len(k))) + 1 + len(v) + sovConfig(uint64(len(v)))
			n += mapEntrySize + 1 + sovConfig(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *ProtocolState) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Protocol != 0 {
		n += 1 + sovConfig(uint64(m.Protocol))
	}
	if m.ConnectivityState != 0 {
		n += 1 + sovConfig(uint64(m.ConnectivityState))
	}
	if m.ChannelState != 0 {
		n += 1 + sovConfig(uint64(m.ChannelState))
	}
	if m.ServiceState != 0 {
		n += 1 + sovConfig(uint64(m.ServiceState))
	}
	return n
}

func (m *Protocols) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.State) > 0 {
		for _, e := range m.State {
			l = e.Size()
			n += 1 + l + sovConfig(uint64(l))
		}
	}
	return n
}

func sovConfig(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozConfig(x uint64) (n int) {
	return sovConfig(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Asset) 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 ErrIntOverflowConfig
			}
			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: Asset: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Asset: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Name = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Manufacturer", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Manufacturer = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Model", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Model = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Serial", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Serial = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Asset", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Asset = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SwVersion", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.SwVersion = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Role = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Configurable) 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 ErrIntOverflowConfig
			}
			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: Configurable: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Configurable: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Type = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Address = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Target = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Version = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timeout == nil {
				m.Timeout = new(time.Duration)
			}
			if err := github_com_gogo_protobuf_types.StdDurationUnmarshal(m.Timeout, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Persistent", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Persistent = bool(v != 0)
		case 7:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ValidateCapabilities", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ValidateCapabilities = bool(v != 0)
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *MastershipState) 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 ErrIntOverflowConfig
			}
			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: MastershipState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MastershipState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Term", wireType)
			}
			m.Term = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Term |= uint64(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field NodeId", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.NodeId = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TLSOptions) 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 ErrIntOverflowConfig
			}
			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: TLSOptions: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TLSOptions: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Insecure", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Insecure = bool(v != 0)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Plain", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				v |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Plain = bool(v != 0)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Key = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CaCert", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CaCert = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Cert", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				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 ErrInvalidLengthConfig
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Cert = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AdHoc) 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 ErrIntOverflowConfig
			}
			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: AdHoc: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AdHoc: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Properties", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Properties == nil {
				m.Properties = make(map[string]string)
			}
			var mapkey string
			var mapvalue string
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowConfig
					}
					if iNdEx >= l {
						return io.ErrUnexpectedEOF
					}
					b := dAtA[iNdEx]
					iNdEx++
					wire |= uint64(b&0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				fieldNum := int32(wire >> 3)
				if fieldNum == 1 {
					var stringLenmapkey uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowConfig
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapkey |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapkey := int(stringLenmapkey)
					if intStringLenmapkey < 0 {
						return ErrInvalidLengthConfig
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthConfig
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var stringLenmapvalue uint64
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowConfig
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						stringLenmapvalue |= uint64(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					intStringLenmapvalue := int(stringLenmapvalue)
					if intStringLenmapvalue < 0 {
						return ErrInvalidLengthConfig
					}
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
					if postStringIndexmapvalue < 0 {
						return ErrInvalidLengthConfig
					}
					if postStringIndexmapvalue > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
					iNdEx = postStringIndexmapvalue
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipConfig(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthConfig
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Properties[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProtocolState) 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 ErrIntOverflowConfig
			}
			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: ProtocolState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProtocolState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType)
			}
			m.Protocol = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Protocol |= Protocol(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ConnectivityState", wireType)
			}
			m.ConnectivityState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ConnectivityState |= ConnectivityState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ChannelState", wireType)
			}
			m.ChannelState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ChannelState |= ChannelState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ServiceState", wireType)
			}
			m.ServiceState = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.ServiceState |= ServiceState(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Protocols) 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 ErrIntOverflowConfig
			}
			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: Protocols: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Protocols: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfig
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfig
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfig
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.State = append(m.State, &ProtocolState{})
			if err := m.State[len(m.State)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfig(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfig
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipConfig(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, ErrIntOverflowConfig
			}
			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, ErrIntOverflowConfig
				}
				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, ErrIntOverflowConfig
				}
				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, ErrInvalidLengthConfig
			}
			iNdEx += length
		case 3:
			depth++
		case 4:
			if depth == 0 {
				return 0, ErrUnexpectedEndOfGroupConfig
			}
			depth--
		case 5:
			iNdEx += 4
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
		if iNdEx < 0 {
			return 0, ErrInvalidLengthConfig
		}
		if depth == 0 {
			return iNdEx, nil
		}
	}
	return 0, io.ErrUnexpectedEOF
}

var (
	ErrInvalidLengthConfig        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowConfig          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupConfig = fmt.Errorf("proto: unexpected end of group")
)