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

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

package v2

import (
	fmt "fmt"
	_ "github.com/gogo/protobuf/gogoproto"
	proto "github.com/gogo/protobuf/proto"
	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

// State is the configuration state
type ConfigurationStatus_State int32

const (
	ConfigurationStatus_UNKNOWN       ConfigurationStatus_State = 0
	ConfigurationStatus_SYNCHRONIZING ConfigurationStatus_State = 1
	ConfigurationStatus_SYNCHRONIZED  ConfigurationStatus_State = 2
	ConfigurationStatus_PERSISTED     ConfigurationStatus_State = 3
)

var ConfigurationStatus_State_name = map[int32]string{
	0: "UNKNOWN",
	1: "SYNCHRONIZING",
	2: "SYNCHRONIZED",
	3: "PERSISTED",
}

var ConfigurationStatus_State_value = map[string]int32{
	"UNKNOWN":       0,
	"SYNCHRONIZING": 1,
	"SYNCHRONIZED":  2,
	"PERSISTED":     3,
}

func (x ConfigurationStatus_State) String() string {
	return proto.EnumName(ConfigurationStatus_State_name, int32(x))
}

func (ConfigurationStatus_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a1b457d3c759d10b, []int{1, 0}
}

// EventType configuration event types for configuration store
type ConfigurationEvent_EventType int32

const (
	// UNKNOWN indicates unknown configuration store event
	ConfigurationEvent_UNKNOWN ConfigurationEvent_EventType = 0
	// CREATED indicates the configuration entry in the store is created
	ConfigurationEvent_CREATED ConfigurationEvent_EventType = 1
	// UPDATED indicates the configuration entry in the store is updated
	ConfigurationEvent_UPDATED ConfigurationEvent_EventType = 2
	// DELETED indicates the configuration entry in the store is deleted
	ConfigurationEvent_DELETED ConfigurationEvent_EventType = 3
	// REPLAYED
	ConfigurationEvent_REPLAYED ConfigurationEvent_EventType = 4
)

var ConfigurationEvent_EventType_name = map[int32]string{
	0: "UNKNOWN",
	1: "CREATED",
	2: "UPDATED",
	3: "DELETED",
	4: "REPLAYED",
}

var ConfigurationEvent_EventType_value = map[string]int32{
	"UNKNOWN":  0,
	"CREATED":  1,
	"UPDATED":  2,
	"DELETED":  3,
	"REPLAYED": 4,
}

func (x ConfigurationEvent_EventType) String() string {
	return proto.EnumName(ConfigurationEvent_EventType_name, int32(x))
}

func (ConfigurationEvent_EventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_a1b457d3c759d10b, []int{6, 0}
}

// Configuration represents complete desired target configuration
type Configuration struct {
	ObjectMeta `protobuf:"bytes,1,opt,name=meta,proto3,embedded=meta" json:"meta"`
	// 'id' is a unique configuration identifier
	ID ConfigurationID `protobuf:"bytes,2,opt,name=id,proto3,casttype=ConfigurationID" json:"id,omitempty"`
	// 'target_id' is the target to which the desired target configuration applies
	TargetID TargetID `protobuf:"bytes,3,opt,name=target_id,json=targetId,proto3,casttype=TargetID" json:"target_id,omitempty"`
	// 'values' is a map of path/values to set
	Values map[string]*PathValue `protobuf:"bytes,4,rep,name=values,proto3" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// 'index' is the index of the configuration values
	Index Index `protobuf:"varint,5,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	// 'ConfigurationStatus' is the current lifecycle status of the configuration
	Status            ConfigurationStatus `protobuf:"bytes,6,opt,name=status,proto3" json:"status"`
	TargetTypeVersion `protobuf:"bytes,7,opt,name=target_info,json=targetInfo,proto3,embedded=target_info" json:"target_info"`
}

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

var xxx_messageInfo_Configuration proto.InternalMessageInfo

func (m *Configuration) GetID() ConfigurationID {
	if m != nil {
		return m.ID
	}
	return ""
}

func (m *Configuration) GetTargetID() TargetID {
	if m != nil {
		return m.TargetID
	}
	return ""
}

func (m *Configuration) GetValues() map[string]*PathValue {
	if m != nil {
		return m.Values
	}
	return nil
}

func (m *Configuration) GetIndex() Index {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *Configuration) GetStatus() ConfigurationStatus {
	if m != nil {
		return m.Status
	}
	return ConfigurationStatus{}
}

// ConfigurationStatus is the status of a Configuration
type ConfigurationStatus struct {
	// 'state' is the configuration state
	State ConfigurationStatus_State `protobuf:"varint,1,opt,name=state,proto3,enum=onos.config.v2.ConfigurationStatus_State" json:"state,omitempty"`
	// 'mastership' is the current mastership info for the configuration
	Mastership MastershipInfo `protobuf:"bytes,2,opt,name=mastership,proto3" json:"mastership"`
	// 'proposed' is the proposed configuration status
	Proposed ProposedConfigurationStatus `protobuf:"bytes,3,opt,name=proposed,proto3" json:"proposed"`
	// 'committed' is the committed configuration status
	Committed CommittedConfigurationStatus `protobuf:"bytes,4,opt,name=committed,proto3" json:"committed"`
	// 'applied' is the applied configuration status
	Applied AppliedConfigurationStatus `protobuf:"bytes,5,opt,name=applied,proto3" json:"applied"`
}

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

var xxx_messageInfo_ConfigurationStatus proto.InternalMessageInfo

func (m *ConfigurationStatus) GetState() ConfigurationStatus_State {
	if m != nil {
		return m.State
	}
	return ConfigurationStatus_UNKNOWN
}

func (m *ConfigurationStatus) GetMastership() MastershipInfo {
	if m != nil {
		return m.Mastership
	}
	return MastershipInfo{}
}

func (m *ConfigurationStatus) GetProposed() ProposedConfigurationStatus {
	if m != nil {
		return m.Proposed
	}
	return ProposedConfigurationStatus{}
}

func (m *ConfigurationStatus) GetCommitted() CommittedConfigurationStatus {
	if m != nil {
		return m.Committed
	}
	return CommittedConfigurationStatus{}
}

func (m *ConfigurationStatus) GetApplied() AppliedConfigurationStatus {
	if m != nil {
		return m.Applied
	}
	return AppliedConfigurationStatus{}
}

type ProposedConfigurationStatus struct {
	Index Index `protobuf:"varint,1,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
}

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

var xxx_messageInfo_ProposedConfigurationStatus proto.InternalMessageInfo

func (m *ProposedConfigurationStatus) GetIndex() Index {
	if m != nil {
		return m.Index
	}
	return 0
}

type CommittedConfigurationStatus struct {
	Index Index `protobuf:"varint,1,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
}

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

var xxx_messageInfo_CommittedConfigurationStatus proto.InternalMessageInfo

func (m *CommittedConfigurationStatus) GetIndex() Index {
	if m != nil {
		return m.Index
	}
	return 0
}

type AppliedConfigurationStatus struct {
	Index      Index                 `protobuf:"varint,1,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	Mastership MastershipInfo        `protobuf:"bytes,2,opt,name=mastership,proto3" json:"mastership"`
	Values     map[string]*PathValue `protobuf:"bytes,3,rep,name=values,proto3" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_AppliedConfigurationStatus proto.InternalMessageInfo

func (m *AppliedConfigurationStatus) GetIndex() Index {
	if m != nil {
		return m.Index
	}
	return 0
}

func (m *AppliedConfigurationStatus) GetMastership() MastershipInfo {
	if m != nil {
		return m.Mastership
	}
	return MastershipInfo{}
}

func (m *AppliedConfigurationStatus) GetValues() map[string]*PathValue {
	if m != nil {
		return m.Values
	}
	return nil
}

type MastershipInfo struct {
	Master string         `protobuf:"bytes,1,opt,name=master,proto3" json:"master,omitempty"`
	Term   MastershipTerm `protobuf:"varint,2,opt,name=term,proto3,casttype=MastershipTerm" json:"term,omitempty"`
}

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

var xxx_messageInfo_MastershipInfo proto.InternalMessageInfo

func (m *MastershipInfo) GetMaster() string {
	if m != nil {
		return m.Master
	}
	return ""
}

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

// ConfigurationEvent configuration store event
type ConfigurationEvent struct {
	// EventType configuration event type
	Type          ConfigurationEvent_EventType `protobuf:"varint,1,opt,name=type,proto3,enum=onos.config.v2.ConfigurationEvent_EventType" json:"type,omitempty"`
	Configuration Configuration                `protobuf:"bytes,2,opt,name=configuration,proto3" json:"configuration"`
}

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

var xxx_messageInfo_ConfigurationEvent proto.InternalMessageInfo

func (m *ConfigurationEvent) GetType() ConfigurationEvent_EventType {
	if m != nil {
		return m.Type
	}
	return ConfigurationEvent_UNKNOWN
}

func (m *ConfigurationEvent) GetConfiguration() Configuration {
	if m != nil {
		return m.Configuration
	}
	return Configuration{}
}

func init() {
	proto.RegisterEnum("onos.config.v2.ConfigurationStatus_State", ConfigurationStatus_State_name, ConfigurationStatus_State_value)
	proto.RegisterEnum("onos.config.v2.ConfigurationEvent_EventType", ConfigurationEvent_EventType_name, ConfigurationEvent_EventType_value)
	proto.RegisterType((*Configuration)(nil), "onos.config.v2.Configuration")
	proto.RegisterMapType((map[string]*PathValue)(nil), "onos.config.v2.Configuration.ValuesEntry")
	proto.RegisterType((*ConfigurationStatus)(nil), "onos.config.v2.ConfigurationStatus")
	proto.RegisterType((*ProposedConfigurationStatus)(nil), "onos.config.v2.ProposedConfigurationStatus")
	proto.RegisterType((*CommittedConfigurationStatus)(nil), "onos.config.v2.CommittedConfigurationStatus")
	proto.RegisterType((*AppliedConfigurationStatus)(nil), "onos.config.v2.AppliedConfigurationStatus")
	proto.RegisterMapType((map[string]*PathValue)(nil), "onos.config.v2.AppliedConfigurationStatus.ValuesEntry")
	proto.RegisterType((*MastershipInfo)(nil), "onos.config.v2.MastershipInfo")
	proto.RegisterType((*ConfigurationEvent)(nil), "onos.config.v2.ConfigurationEvent")
}

func init() {
	proto.RegisterFile("onos/config/v2/configuration.proto", fileDescriptor_a1b457d3c759d10b)
}

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

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

func (m *Configuration) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.TargetTypeVersion.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x3a
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x32
	if m.Index != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x28
	}
	if len(m.Values) > 0 {
		for k := range m.Values {
			v := m.Values[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintConfiguration(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintConfiguration(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintConfiguration(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x22
		}
	}
	if len(m.TargetID) > 0 {
		i -= len(m.TargetID)
		copy(dAtA[i:], m.TargetID)
		i = encodeVarintConfiguration(dAtA, i, uint64(len(m.TargetID)))
		i--
		dAtA[i] = 0x1a
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintConfiguration(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *ConfigurationStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Applied.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.Committed.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.Proposed.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Mastership.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.State != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ProposedConfigurationStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *CommittedConfigurationStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *AppliedConfigurationStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		for k := range m.Values {
			v := m.Values[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = encodeVarintConfiguration(dAtA, i, uint64(size))
				}
				i--
				dAtA[i] = 0x12
			}
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintConfiguration(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintConfiguration(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.Mastership.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Index != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *MastershipInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Term != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Term))
		i--
		dAtA[i] = 0x10
	}
	if len(m.Master) > 0 {
		i -= len(m.Master)
		copy(dAtA[i:], m.Master)
		i = encodeVarintConfiguration(dAtA, i, uint64(len(m.Master)))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *ConfigurationEvent) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Configuration.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Type != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Type))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

func encodeVarintConfiguration(dAtA []byte, offset int, v uint64) int {
	offset -= sovConfiguration(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *Configuration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovConfiguration(uint64(l))
	}
	l = len(m.TargetID)
	if l > 0 {
		n += 1 + l + sovConfiguration(uint64(l))
	}
	if len(m.Values) > 0 {
		for k, v := range m.Values {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovConfiguration(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovConfiguration(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovConfiguration(uint64(mapEntrySize))
		}
	}
	if m.Index != 0 {
		n += 1 + sovConfiguration(uint64(m.Index))
	}
	l = m.Status.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	l = m.TargetTypeVersion.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	return n
}

func (m *ConfigurationStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.State != 0 {
		n += 1 + sovConfiguration(uint64(m.State))
	}
	l = m.Mastership.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	l = m.Proposed.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	l = m.Committed.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	l = m.Applied.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	return n
}

func (m *ProposedConfigurationStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovConfiguration(uint64(m.Index))
	}
	return n
}

func (m *CommittedConfigurationStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovConfiguration(uint64(m.Index))
	}
	return n
}

func (m *AppliedConfigurationStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovConfiguration(uint64(m.Index))
	}
	l = m.Mastership.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	if len(m.Values) > 0 {
		for k, v := range m.Values {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovConfiguration(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovConfiguration(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovConfiguration(uint64(mapEntrySize))
		}
	}
	return n
}

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

func (m *ConfigurationEvent) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Type != 0 {
		n += 1 + sovConfiguration(uint64(m.Type))
	}
	l = m.Configuration.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	return n
}

func sovConfiguration(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozConfiguration(x uint64) (n int) {
	return sovConfiguration(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *Configuration) 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 ErrIntOverflowConfiguration
			}
			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: Configuration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Configuration: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ObjectMeta", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.ObjectMeta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				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 ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = ConfigurationID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				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 ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TargetID = TargetID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Values == nil {
				m.Values = make(map[string]*PathValue)
			}
			var mapkey string
			var mapvalue *PathValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowConfiguration
					}
					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 ErrIntOverflowConfiguration
						}
						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 ErrInvalidLengthConfiguration
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthConfiguration
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowConfiguration
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthConfiguration
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthConfiguration
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &PathValue{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipConfiguration(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthConfiguration
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Values[mapkey] = mapvalue
			iNdEx = postIndex
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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 ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetTypeVersion", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.TargetTypeVersion.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfiguration(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfiguration
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ConfigurationStatus) 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 ErrIntOverflowConfiguration
			}
			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: ConfigurationStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigurationStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field State", wireType)
			}
			m.State = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= ConfigurationStatus_State(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mastership", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Mastership.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proposed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Proposed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Committed", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Committed.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Applied", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Applied.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfiguration(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfiguration
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *AppliedConfigurationStatus) 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 ErrIntOverflowConfiguration
			}
			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: AppliedConfigurationStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppliedConfigurationStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
			}
			m.Index = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Mastership", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Mastership.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Values", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthConfiguration
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthConfiguration
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Values == nil {
				m.Values = make(map[string]*PathValue)
			}
			var mapkey string
			var mapvalue *PathValue
			for iNdEx < postIndex {
				entryPreIndex := iNdEx
				var wire uint64
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return ErrIntOverflowConfiguration
					}
					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 ErrIntOverflowConfiguration
						}
						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 ErrInvalidLengthConfiguration
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthConfiguration
					}
					if postStringIndexmapkey > l {
						return io.ErrUnexpectedEOF
					}
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
					iNdEx = postStringIndexmapkey
				} else if fieldNum == 2 {
					var mapmsglen int
					for shift := uint(0); ; shift += 7 {
						if shift >= 64 {
							return ErrIntOverflowConfiguration
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthConfiguration
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthConfiguration
					}
					if postmsgIndex > l {
						return io.ErrUnexpectedEOF
					}
					mapvalue = &PathValue{}
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
						return err
					}
					iNdEx = postmsgIndex
				} else {
					iNdEx = entryPreIndex
					skippy, err := skipConfiguration(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthConfiguration
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Values[mapkey] = mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipConfiguration(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthConfiguration
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

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

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

var (
	ErrInvalidLengthConfiguration        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowConfiguration          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupConfiguration = fmt.Errorf("proto: unexpected end of group")
)