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

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

package v3

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_135723e9c41e9d07, []int{2, 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_135723e9c41e9d07, []int{6, 0}
}

type ConfigurationID struct {
	Target Target `protobuf:"bytes,1,opt,name=target,proto3" json:"target"`
}

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

var xxx_messageInfo_ConfigurationID proto.InternalMessageInfo

func (m *ConfigurationID) GetTarget() Target {
	if m != nil {
		return m.Target
	}
	return Target{}
}

// Configuration represents complete desired target configuration
type Configuration struct {
	ObjectMeta `protobuf:"bytes,1,opt,name=meta,proto3,embedded=meta" json:"meta"`
	// 'id' is the unique identifier of the configuration
	ID        ConfigurationID        `protobuf:"bytes,2,opt,name=id,proto3" json:"id"`
	Committed CommittedConfiguration `protobuf:"bytes,3,opt,name=committed,proto3" json:"committed"`
	Applied   AppliedConfiguration   `protobuf:"bytes,4,opt,name=applied,proto3" json:"applied"`
	// 'ConfigurationStatus' is the current lifecycle status of the configuration
	Status ConfigurationStatus `protobuf:"bytes,5,opt,name=status,proto3" json:"status"`
}

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_135723e9c41e9d07, []int{1}
}
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 ConfigurationID{}
}

func (m *Configuration) GetCommitted() CommittedConfiguration {
	if m != nil {
		return m.Committed
	}
	return CommittedConfiguration{}
}

func (m *Configuration) GetApplied() AppliedConfiguration {
	if m != nil {
		return m.Applied
	}
	return AppliedConfiguration{}
}

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.v3.ConfigurationStatus_State" json:"state,omitempty"`
	Mastership *MastershipStatus         `protobuf:"bytes,2,opt,name=mastership,proto3" json:"mastership,omitempty"`
}

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_135723e9c41e9d07, []int{2}
}
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() *MastershipStatus {
	if m != nil {
		return m.Mastership
	}
	return nil
}

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

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

var xxx_messageInfo_MastershipStatus proto.InternalMessageInfo

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

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

type CommittedConfiguration struct {
	Index    Index                `protobuf:"varint,1,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	Ordinal  Ordinal              `protobuf:"varint,2,opt,name=ordinal,proto3,casttype=Ordinal" json:"ordinal,omitempty"`
	Revision Revision             `protobuf:"varint,3,opt,name=revision,proto3,casttype=Revision" json:"revision,omitempty"`
	Target   Index                `protobuf:"varint,4,opt,name=target,proto3,casttype=Index" json:"target,omitempty"`
	Change   Index                `protobuf:"varint,5,opt,name=change,proto3,casttype=Index" json:"change,omitempty"`
	Values   map[string]PathValue `protobuf:"bytes,6,rep,name=values,proto3" json:"values" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_CommittedConfiguration proto.InternalMessageInfo

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

func (m *CommittedConfiguration) GetOrdinal() Ordinal {
	if m != nil {
		return m.Ordinal
	}
	return 0
}

func (m *CommittedConfiguration) GetRevision() Revision {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *CommittedConfiguration) GetTarget() Index {
	if m != nil {
		return m.Target
	}
	return 0
}

func (m *CommittedConfiguration) GetChange() Index {
	if m != nil {
		return m.Change
	}
	return 0
}

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

type AppliedConfiguration struct {
	Index    Index                `protobuf:"varint,1,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	Ordinal  Ordinal              `protobuf:"varint,2,opt,name=ordinal,proto3,casttype=Ordinal" json:"ordinal,omitempty"`
	Revision Revision             `protobuf:"varint,3,opt,name=revision,proto3,casttype=Revision" json:"revision,omitempty"`
	Target   Index                `protobuf:"varint,4,opt,name=target,proto3,casttype=Index" json:"target,omitempty"`
	Term     MastershipTerm       `protobuf:"varint,5,opt,name=term,proto3,casttype=MastershipTerm" json:"term,omitempty"`
	Values   map[string]PathValue `protobuf:"bytes,6,rep,name=values,proto3" json:"values" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_AppliedConfiguration proto.InternalMessageInfo

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

func (m *AppliedConfiguration) GetOrdinal() Ordinal {
	if m != nil {
		return m.Ordinal
	}
	return 0
}

func (m *AppliedConfiguration) GetRevision() Revision {
	if m != nil {
		return m.Revision
	}
	return 0
}

func (m *AppliedConfiguration) GetTarget() Index {
	if m != nil {
		return m.Target
	}
	return 0
}

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

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

// ConfigurationEvent configuration store event
type ConfigurationEvent struct {
	// EventType configuration event type
	Type          ConfigurationEvent_EventType `protobuf:"varint,1,opt,name=type,proto3,enum=onos.config.v3.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_135723e9c41e9d07, []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.v3.ConfigurationStatus_State", ConfigurationStatus_State_name, ConfigurationStatus_State_value)
	proto.RegisterEnum("onos.config.v3.ConfigurationEvent_EventType", ConfigurationEvent_EventType_name, ConfigurationEvent_EventType_value)
	proto.RegisterType((*ConfigurationID)(nil), "onos.config.v3.ConfigurationID")
	proto.RegisterType((*Configuration)(nil), "onos.config.v3.Configuration")
	proto.RegisterType((*ConfigurationStatus)(nil), "onos.config.v3.ConfigurationStatus")
	proto.RegisterType((*MastershipStatus)(nil), "onos.config.v3.MastershipStatus")
	proto.RegisterType((*CommittedConfiguration)(nil), "onos.config.v3.CommittedConfiguration")
	proto.RegisterMapType((map[string]PathValue)(nil), "onos.config.v3.CommittedConfiguration.ValuesEntry")
	proto.RegisterType((*AppliedConfiguration)(nil), "onos.config.v3.AppliedConfiguration")
	proto.RegisterMapType((map[string]PathValue)(nil), "onos.config.v3.AppliedConfiguration.ValuesEntry")
	proto.RegisterType((*ConfigurationEvent)(nil), "onos.config.v3.ConfigurationEvent")
}

func init() {
	proto.RegisterFile("onos/config/v3/configuration.proto", fileDescriptor_135723e9c41e9d07)
}

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

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

func (m *ConfigurationID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Target.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 *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.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	{
		size, err := m.Applied.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	{
		size, err := m.Committed.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintConfiguration(dAtA, i, uint64(size))
	}
	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
	if m.Mastership != nil {
		{
			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 *MastershipStatus) 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 *MastershipStatus) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *MastershipStatus) 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] = 0x18
	}
	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] = 0x12
	}
	return len(dAtA) - i, nil
}

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

func (m *CommittedConfiguration) 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
			{
				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] = 0x32
		}
	}
	if m.Change != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Change))
		i--
		dAtA[i] = 0x28
	}
	if m.Target != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Target))
		i--
		dAtA[i] = 0x20
	}
	if m.Revision != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Revision))
		i--
		dAtA[i] = 0x18
	}
	if m.Ordinal != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Ordinal))
		i--
		dAtA[i] = 0x10
	}
	if m.Index != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *AppliedConfiguration) 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
			{
				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] = 0x32
		}
	}
	if m.Term != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Term))
		i--
		dAtA[i] = 0x28
	}
	if m.Target != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Target))
		i--
		dAtA[i] = 0x20
	}
	if m.Revision != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Revision))
		i--
		dAtA[i] = 0x18
	}
	if m.Ordinal != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Ordinal))
		i--
		dAtA[i] = 0x10
	}
	if m.Index != 0 {
		i = encodeVarintConfiguration(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x8
	}
	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 *ConfigurationID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Target.Size()
	n += 1 + l + sovConfiguration(uint64(l))
	return n
}

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 = m.ID.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))
	l = m.Status.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))
	}
	if m.Mastership != nil {
		l = m.Mastership.Size()
		n += 1 + l + sovConfiguration(uint64(l))
	}
	return n
}

func (m *MastershipStatus) 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 *CommittedConfiguration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovConfiguration(uint64(m.Index))
	}
	if m.Ordinal != 0 {
		n += 1 + sovConfiguration(uint64(m.Ordinal))
	}
	if m.Revision != 0 {
		n += 1 + sovConfiguration(uint64(m.Revision))
	}
	if m.Target != 0 {
		n += 1 + sovConfiguration(uint64(m.Target))
	}
	if m.Change != 0 {
		n += 1 + sovConfiguration(uint64(m.Change))
	}
	if len(m.Values) > 0 {
		for k, v := range m.Values {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovConfiguration(uint64(len(k))) + 1 + l + sovConfiguration(uint64(l))
			n += mapEntrySize + 1 + sovConfiguration(uint64(mapEntrySize))
		}
	}
	return n
}

func (m *AppliedConfiguration) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Index != 0 {
		n += 1 + sovConfiguration(uint64(m.Index))
	}
	if m.Ordinal != 0 {
		n += 1 + sovConfiguration(uint64(m.Ordinal))
	}
	if m.Revision != 0 {
		n += 1 + sovConfiguration(uint64(m.Revision))
	}
	if m.Target != 0 {
		n += 1 + sovConfiguration(uint64(m.Target))
	}
	if m.Term != 0 {
		n += 1 + sovConfiguration(uint64(m.Term))
	}
	if len(m.Values) > 0 {
		for k, v := range m.Values {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovConfiguration(uint64(len(k))) + 1 + l + sovConfiguration(uint64(l))
			n += mapEntrySize + 1 + sovConfiguration(uint64(mapEntrySize))
		}
	}
	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 *ConfigurationID) 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: ConfigurationID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ConfigurationID: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Target", 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.Target.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 *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 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.ID.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 4:
			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
		case 5:
			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
		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 m.Mastership == nil {
				m.Mastership = &MastershipStatus{}
			}
			if err := m.Mastership.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 *MastershipStatus) 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: MastershipStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: MastershipStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 2:
			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 = NodeID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 *CommittedConfiguration) 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: CommittedConfiguration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: CommittedConfiguration: 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ordinal", wireType)
			}
			m.Ordinal = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ordinal |= Ordinal(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
			}
			m.Revision = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Revision |= Revision(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
			}
			m.Target = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Target |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Change", wireType)
			}
			m.Change = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Change |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 6:
			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
			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 *AppliedConfiguration) 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: AppliedConfiguration: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AppliedConfiguration: 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 != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Ordinal", wireType)
			}
			m.Ordinal = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ordinal |= Ordinal(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
			}
			m.Revision = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Revision |= Revision(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
			}
			m.Target = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowConfiguration
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Target |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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
				}
			}
		case 6:
			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
			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 *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")
)