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

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

package v3

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

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

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

type TransactionStrategy_Synchronicity int32

const (
	TransactionStrategy_ASYNCHRONOUS TransactionStrategy_Synchronicity = 0
	TransactionStrategy_SYNCHRONOUS  TransactionStrategy_Synchronicity = 1
)

var TransactionStrategy_Synchronicity_name = map[int32]string{
	0: "ASYNCHRONOUS",
	1: "SYNCHRONOUS",
}

var TransactionStrategy_Synchronicity_value = map[string]int32{
	"ASYNCHRONOUS": 0,
	"SYNCHRONOUS":  1,
}

func (x TransactionStrategy_Synchronicity) String() string {
	return proto.EnumName(TransactionStrategy_Synchronicity_name, int32(x))
}

func (TransactionStrategy_Synchronicity) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f6ad97ee2134c290, []int{1, 0}
}

type TransactionStatus_Phase int32

const (
	TransactionStatus_CHANGE   TransactionStatus_Phase = 0
	TransactionStatus_ROLLBACK TransactionStatus_Phase = 1
)

var TransactionStatus_Phase_name = map[int32]string{
	0: "CHANGE",
	1: "ROLLBACK",
}

var TransactionStatus_Phase_value = map[string]int32{
	"CHANGE":   0,
	"ROLLBACK": 1,
}

func (x TransactionStatus_Phase) String() string {
	return proto.EnumName(TransactionStatus_Phase_name, int32(x))
}

func (TransactionStatus_Phase) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f6ad97ee2134c290, []int{3, 0}
}

type TransactionPhaseStatus_State int32

const (
	TransactionPhaseStatus_PENDING     TransactionPhaseStatus_State = 0
	TransactionPhaseStatus_IN_PROGRESS TransactionPhaseStatus_State = 1
	TransactionPhaseStatus_COMPLETE    TransactionPhaseStatus_State = 2
	TransactionPhaseStatus_ABORTED     TransactionPhaseStatus_State = 3
	TransactionPhaseStatus_CANCELED    TransactionPhaseStatus_State = 4
	TransactionPhaseStatus_FAILED      TransactionPhaseStatus_State = 5
)

var TransactionPhaseStatus_State_name = map[int32]string{
	0: "PENDING",
	1: "IN_PROGRESS",
	2: "COMPLETE",
	3: "ABORTED",
	4: "CANCELED",
	5: "FAILED",
}

var TransactionPhaseStatus_State_value = map[string]int32{
	"PENDING":     0,
	"IN_PROGRESS": 1,
	"COMPLETE":    2,
	"ABORTED":     3,
	"CANCELED":    4,
	"FAILED":      5,
}

func (x TransactionPhaseStatus_State) String() string {
	return proto.EnumName(TransactionPhaseStatus_State_name, int32(x))
}

func (TransactionPhaseStatus_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f6ad97ee2134c290, []int{4, 0}
}

// EventType transaction event types for transaction store
type TransactionEvent_EventType int32

const (
	TransactionEvent_UNKNOWN  TransactionEvent_EventType = 0
	TransactionEvent_CREATED  TransactionEvent_EventType = 1
	TransactionEvent_UPDATED  TransactionEvent_EventType = 2
	TransactionEvent_DELETED  TransactionEvent_EventType = 3
	TransactionEvent_REPLAYED TransactionEvent_EventType = 4
)

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

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

func (x TransactionEvent_EventType) String() string {
	return proto.EnumName(TransactionEvent_EventType_name, int32(x))
}

func (TransactionEvent_EventType) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_f6ad97ee2134c290, []int{7, 0}
}

type TransactionID struct {
	Target Target `protobuf:"bytes,1,opt,name=target,proto3" json:"target"`
	Index  Index  `protobuf:"varint,2,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
}

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

var xxx_messageInfo_TransactionID proto.InternalMessageInfo

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

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

type TransactionStrategy struct {
	// 'synchronicity' indicates the transaction synchronicity level
	Synchronicity TransactionStrategy_Synchronicity `protobuf:"varint,1,opt,name=synchronicity,proto3,enum=onos.config.v3.TransactionStrategy_Synchronicity" json:"synchronicity,omitempty"`
}

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

var xxx_messageInfo_TransactionStrategy proto.InternalMessageInfo

func (m *TransactionStrategy) GetSynchronicity() TransactionStrategy_Synchronicity {
	if m != nil {
		return m.Synchronicity
	}
	return TransactionStrategy_ASYNCHRONOUS
}

type Transaction struct {
	ObjectMeta `protobuf:"bytes,1,opt,name=meta,proto3,embedded=meta" json:"meta"`
	// 'id' is the unique identifier of the transaction
	ID TransactionID `protobuf:"bytes,2,opt,name=id,proto3" json:"id"`
	// 'values' is a set of changes to apply to targets
	Values map[string]PathValue `protobuf:"bytes,3,rep,name=values,proto3" json:"values" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
	// 'status' is the transaction status
	Status TransactionStatus `protobuf:"bytes,4,opt,name=status,proto3" json:"status"`
}

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

var xxx_messageInfo_Transaction proto.InternalMessageInfo

func (m *Transaction) GetID() TransactionID {
	if m != nil {
		return m.ID
	}
	return TransactionID{}
}

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

func (m *Transaction) GetStatus() TransactionStatus {
	if m != nil {
		return m.Status
	}
	return TransactionStatus{}
}

type TransactionStatus struct {
	Phase    TransactionStatus_Phase   `protobuf:"varint,1,opt,name=phase,proto3,enum=onos.config.v3.TransactionStatus_Phase" json:"phase,omitempty"`
	Change   TransactionChangeStatus   `protobuf:"bytes,2,opt,name=change,proto3" json:"change"`
	Rollback TransactionRollbackStatus `protobuf:"bytes,3,opt,name=rollback,proto3" json:"rollback"`
}

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

var xxx_messageInfo_TransactionStatus proto.InternalMessageInfo

func (m *TransactionStatus) GetPhase() TransactionStatus_Phase {
	if m != nil {
		return m.Phase
	}
	return TransactionStatus_CHANGE
}

func (m *TransactionStatus) GetChange() TransactionChangeStatus {
	if m != nil {
		return m.Change
	}
	return TransactionChangeStatus{}
}

func (m *TransactionStatus) GetRollback() TransactionRollbackStatus {
	if m != nil {
		return m.Rollback
	}
	return TransactionRollbackStatus{}
}

type TransactionPhaseStatus struct {
	Start   *time.Time                   `protobuf:"bytes,1,opt,name=start,proto3,stdtime" json:"start,omitempty"`
	End     *time.Time                   `protobuf:"bytes,2,opt,name=end,proto3,stdtime" json:"end,omitempty"`
	State   TransactionPhaseStatus_State `protobuf:"varint,3,opt,name=state,proto3,enum=onos.config.v3.TransactionPhaseStatus_State" json:"state,omitempty"`
	Failure *Failure                     `protobuf:"bytes,4,opt,name=failure,proto3" json:"failure,omitempty"`
}

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

var xxx_messageInfo_TransactionPhaseStatus proto.InternalMessageInfo

func (m *TransactionPhaseStatus) GetStart() *time.Time {
	if m != nil {
		return m.Start
	}
	return nil
}

func (m *TransactionPhaseStatus) GetEnd() *time.Time {
	if m != nil {
		return m.End
	}
	return nil
}

func (m *TransactionPhaseStatus) GetState() TransactionPhaseStatus_State {
	if m != nil {
		return m.State
	}
	return TransactionPhaseStatus_PENDING
}

func (m *TransactionPhaseStatus) GetFailure() *Failure {
	if m != nil {
		return m.Failure
	}
	return nil
}

type TransactionChangeStatus struct {
	Ordinal Ordinal                 `protobuf:"varint,1,opt,name=ordinal,proto3,casttype=Ordinal" json:"ordinal,omitempty"`
	Commit  *TransactionPhaseStatus `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"`
	Apply   *TransactionPhaseStatus `protobuf:"bytes,3,opt,name=apply,proto3" json:"apply,omitempty"`
}

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

var xxx_messageInfo_TransactionChangeStatus proto.InternalMessageInfo

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

func (m *TransactionChangeStatus) GetCommit() *TransactionPhaseStatus {
	if m != nil {
		return m.Commit
	}
	return nil
}

func (m *TransactionChangeStatus) GetApply() *TransactionPhaseStatus {
	if m != nil {
		return m.Apply
	}
	return nil
}

type TransactionRollbackStatus struct {
	Ordinal Ordinal                 `protobuf:"varint,1,opt,name=ordinal,proto3,casttype=Ordinal" json:"ordinal,omitempty"`
	Commit  *TransactionPhaseStatus `protobuf:"bytes,2,opt,name=commit,proto3" json:"commit,omitempty"`
	Apply   *TransactionPhaseStatus `protobuf:"bytes,3,opt,name=apply,proto3" json:"apply,omitempty"`
	Index   Index                   `protobuf:"varint,4,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	Values  map[string]PathValue    `protobuf:"bytes,5,rep,name=values,proto3" json:"values" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_TransactionRollbackStatus proto.InternalMessageInfo

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

func (m *TransactionRollbackStatus) GetCommit() *TransactionPhaseStatus {
	if m != nil {
		return m.Commit
	}
	return nil
}

func (m *TransactionRollbackStatus) GetApply() *TransactionPhaseStatus {
	if m != nil {
		return m.Apply
	}
	return nil
}

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

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

// TransactionEvent transaction store event
type TransactionEvent struct {
	Type        TransactionEvent_EventType `protobuf:"varint,1,opt,name=type,proto3,enum=onos.config.v3.TransactionEvent_EventType" json:"type,omitempty"`
	Transaction Transaction                `protobuf:"bytes,2,opt,name=transaction,proto3" json:"transaction"`
}

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

var xxx_messageInfo_TransactionEvent proto.InternalMessageInfo

func (m *TransactionEvent) GetType() TransactionEvent_EventType {
	if m != nil {
		return m.Type
	}
	return TransactionEvent_UNKNOWN
}

func (m *TransactionEvent) GetTransaction() Transaction {
	if m != nil {
		return m.Transaction
	}
	return Transaction{}
}

func init() {
	proto.RegisterEnum("onos.config.v3.TransactionStrategy_Synchronicity", TransactionStrategy_Synchronicity_name, TransactionStrategy_Synchronicity_value)
	proto.RegisterEnum("onos.config.v3.TransactionStatus_Phase", TransactionStatus_Phase_name, TransactionStatus_Phase_value)
	proto.RegisterEnum("onos.config.v3.TransactionPhaseStatus_State", TransactionPhaseStatus_State_name, TransactionPhaseStatus_State_value)
	proto.RegisterEnum("onos.config.v3.TransactionEvent_EventType", TransactionEvent_EventType_name, TransactionEvent_EventType_value)
	proto.RegisterType((*TransactionID)(nil), "onos.config.v3.TransactionID")
	proto.RegisterType((*TransactionStrategy)(nil), "onos.config.v3.TransactionStrategy")
	proto.RegisterType((*Transaction)(nil), "onos.config.v3.Transaction")
	proto.RegisterMapType((map[string]PathValue)(nil), "onos.config.v3.Transaction.ValuesEntry")
	proto.RegisterType((*TransactionStatus)(nil), "onos.config.v3.TransactionStatus")
	proto.RegisterType((*TransactionPhaseStatus)(nil), "onos.config.v3.TransactionPhaseStatus")
	proto.RegisterType((*TransactionChangeStatus)(nil), "onos.config.v3.TransactionChangeStatus")
	proto.RegisterType((*TransactionRollbackStatus)(nil), "onos.config.v3.TransactionRollbackStatus")
	proto.RegisterMapType((map[string]PathValue)(nil), "onos.config.v3.TransactionRollbackStatus.ValuesEntry")
	proto.RegisterType((*TransactionEvent)(nil), "onos.config.v3.TransactionEvent")
}

func init() { proto.RegisterFile("onos/config/v3/transaction.proto", fileDescriptor_f6ad97ee2134c290) }

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

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

func (m *TransactionID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Index != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.Target.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTransaction(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

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

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

func (m *Transaction) 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 = encodeVarintTransaction(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x22
	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 = encodeVarintTransaction(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTransaction(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTransaction(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x1a
		}
	}
	{
		size, err := m.ID.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTransaction(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTransaction(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *TransactionStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	{
		size, err := m.Rollback.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTransaction(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x1a
	{
		size, err := m.Change.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTransaction(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x12
	if m.Phase != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.Phase))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TransactionPhaseStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Failure != nil {
		{
			size, err := m.Failure.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x22
	}
	if m.State != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x18
	}
	if m.End != nil {
		n9, err9 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.End):])
		if err9 != nil {
			return 0, err9
		}
		i -= n9
		i = encodeVarintTransaction(dAtA, i, uint64(n9))
		i--
		dAtA[i] = 0x12
	}
	if m.Start != nil {
		n10, err10 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Start):])
		if err10 != nil {
			return 0, err10
		}
		i -= n10
		i = encodeVarintTransaction(dAtA, i, uint64(n10))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TransactionChangeStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Apply != nil {
		{
			size, err := m.Apply.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Commit != nil {
		{
			size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Ordinal != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.Ordinal))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *TransactionRollbackStatus) 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 = encodeVarintTransaction(dAtA, i, uint64(size))
			}
			i--
			dAtA[i] = 0x12
			i -= len(k)
			copy(dAtA[i:], k)
			i = encodeVarintTransaction(dAtA, i, uint64(len(k)))
			i--
			dAtA[i] = 0xa
			i = encodeVarintTransaction(dAtA, i, uint64(baseI-i))
			i--
			dAtA[i] = 0x2a
		}
	}
	if m.Index != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x20
	}
	if m.Apply != nil {
		{
			size, err := m.Apply.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x1a
	}
	if m.Commit != nil {
		{
			size, err := m.Commit.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Ordinal != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.Ordinal))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

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

func encodeVarintTransaction(dAtA []byte, offset int, v uint64) int {
	offset -= sovTransaction(v)
	base := offset
	for v >= 1<<7 {
		dAtA[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	dAtA[offset] = uint8(v)
	return base
}
func (m *TransactionID) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Target.Size()
	n += 1 + l + sovTransaction(uint64(l))
	if m.Index != 0 {
		n += 1 + sovTransaction(uint64(m.Index))
	}
	return n
}

func (m *TransactionStrategy) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Synchronicity != 0 {
		n += 1 + sovTransaction(uint64(m.Synchronicity))
	}
	return n
}

func (m *Transaction) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.ObjectMeta.Size()
	n += 1 + l + sovTransaction(uint64(l))
	l = m.ID.Size()
	n += 1 + l + sovTransaction(uint64(l))
	if len(m.Values) > 0 {
		for k, v := range m.Values {
			_ = k
			_ = v
			l = v.Size()
			mapEntrySize := 1 + len(k) + sovTransaction(uint64(len(k))) + 1 + l + sovTransaction(uint64(l))
			n += mapEntrySize + 1 + sovTransaction(uint64(mapEntrySize))
		}
	}
	l = m.Status.Size()
	n += 1 + l + sovTransaction(uint64(l))
	return n
}

func (m *TransactionStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Phase != 0 {
		n += 1 + sovTransaction(uint64(m.Phase))
	}
	l = m.Change.Size()
	n += 1 + l + sovTransaction(uint64(l))
	l = m.Rollback.Size()
	n += 1 + l + sovTransaction(uint64(l))
	return n
}

func (m *TransactionPhaseStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Start != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.Start)
		n += 1 + l + sovTransaction(uint64(l))
	}
	if m.End != nil {
		l = github_com_gogo_protobuf_types.SizeOfStdTime(*m.End)
		n += 1 + l + sovTransaction(uint64(l))
	}
	if m.State != 0 {
		n += 1 + sovTransaction(uint64(m.State))
	}
	if m.Failure != nil {
		l = m.Failure.Size()
		n += 1 + l + sovTransaction(uint64(l))
	}
	return n
}

func (m *TransactionChangeStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Ordinal != 0 {
		n += 1 + sovTransaction(uint64(m.Ordinal))
	}
	if m.Commit != nil {
		l = m.Commit.Size()
		n += 1 + l + sovTransaction(uint64(l))
	}
	if m.Apply != nil {
		l = m.Apply.Size()
		n += 1 + l + sovTransaction(uint64(l))
	}
	return n
}

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

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

func sovTransaction(x uint64) (n int) {
	return (math_bits.Len64(x|1) + 6) / 7
}
func sozTransaction(x uint64) (n int) {
	return sovTransaction(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (m *TransactionID) 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 ErrIntOverflowTransaction
			}
			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: TransactionID: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionID: 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 ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Target.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 ErrIntOverflowTransaction
				}
				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 := skipTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Transaction) 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 ErrIntOverflowTransaction
			}
			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: Transaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Transaction: 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 ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			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 ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			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 Values", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			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 ErrIntOverflowTransaction
					}
					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 ErrIntOverflowTransaction
						}
						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 ErrInvalidLengthTransaction
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTransaction
					}
					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 ErrIntOverflowTransaction
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTransaction
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTransaction
					}
					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 := skipTransaction(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTransaction
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Values[mapkey] = *mapvalue
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			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 := skipTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TransactionPhaseStatus) 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 ErrIntOverflowTransaction
			}
			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: TransactionPhaseStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionPhaseStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Start == nil {
				m.Start = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.Start, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.End == nil {
				m.End = new(time.Time)
			}
			if err := github_com_gogo_protobuf_types.StdTimeUnmarshal(m.End, dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.State |= TransactionPhaseStatus_State(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Failure", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Failure == nil {
				m.Failure = &Failure{}
			}
			if err := m.Failure.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TransactionRollbackStatus) 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 ErrIntOverflowTransaction
			}
			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: TransactionRollbackStatus: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionRollbackStatus: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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 ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Ordinal |= Ordinal(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Commit", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Commit == nil {
				m.Commit = &TransactionPhaseStatus{}
			}
			if err := m.Commit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Apply", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Apply == nil {
				m.Apply = &TransactionPhaseStatus{}
			}
			if err := m.Apply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Index |= Index(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 5:
			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 ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			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 ErrIntOverflowTransaction
					}
					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 ErrIntOverflowTransaction
						}
						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 ErrInvalidLengthTransaction
					}
					postStringIndexmapkey := iNdEx + intStringLenmapkey
					if postStringIndexmapkey < 0 {
						return ErrInvalidLengthTransaction
					}
					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 ErrIntOverflowTransaction
						}
						if iNdEx >= l {
							return io.ErrUnexpectedEOF
						}
						b := dAtA[iNdEx]
						iNdEx++
						mapmsglen |= int(b&0x7F) << shift
						if b < 0x80 {
							break
						}
					}
					if mapmsglen < 0 {
						return ErrInvalidLengthTransaction
					}
					postmsgIndex := iNdEx + mapmsglen
					if postmsgIndex < 0 {
						return ErrInvalidLengthTransaction
					}
					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 := skipTransaction(dAtA[iNdEx:])
					if err != nil {
						return err
					}
					if (skippy < 0) || (iNdEx+skippy) < 0 {
						return ErrInvalidLengthTransaction
					}
					if (iNdEx + skippy) > postIndex {
						return io.ErrUnexpectedEOF
					}
					iNdEx += skippy
				}
			}
			m.Values[mapkey] = *mapvalue
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *TransactionEvent) 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 ErrIntOverflowTransaction
			}
			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: TransactionEvent: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionEvent: 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 ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Type |= TransactionEvent_EventType(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Transaction", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				msglen |= int(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + msglen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if err := m.Transaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipTransaction(dAtA[iNdEx:])
			if err != nil {
				return err
			}
			if (skippy < 0) || (iNdEx+skippy) < 0 {
				return ErrInvalidLengthTransaction
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

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

var (
	ErrInvalidLengthTransaction        = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowTransaction          = fmt.Errorf("proto: integer overflow")
	ErrUnexpectedEndOfGroupTransaction = fmt.Errorf("proto: unexpected end of group")
)