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

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

package v2

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

type TransactionStrategy_Isolation int32

const (
	TransactionStrategy_DEFAULT      TransactionStrategy_Isolation = 0
	TransactionStrategy_SERIALIZABLE TransactionStrategy_Isolation = 1
)

var TransactionStrategy_Isolation_name = map[int32]string{
	0: "DEFAULT",
	1: "SERIALIZABLE",
}

var TransactionStrategy_Isolation_value = map[string]int32{
	"DEFAULT":      0,
	"SERIALIZABLE": 1,
}

func (x TransactionStrategy_Isolation) String() string {
	return proto.EnumName(TransactionStrategy_Isolation_name, int32(x))
}

func (TransactionStrategy_Isolation) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c3a2d73bdadccc35, []int{2, 1}
}

type TransactionStatus_State int32

const (
	TransactionStatus_PENDING   TransactionStatus_State = 0
	TransactionStatus_VALIDATED TransactionStatus_State = 1
	TransactionStatus_COMMITTED TransactionStatus_State = 2
	TransactionStatus_APPLIED   TransactionStatus_State = 3
	TransactionStatus_FAILED    TransactionStatus_State = 4
)

var TransactionStatus_State_name = map[int32]string{
	0: "PENDING",
	1: "VALIDATED",
	2: "COMMITTED",
	3: "APPLIED",
	4: "FAILED",
}

var TransactionStatus_State_value = map[string]int32{
	"PENDING":   0,
	"VALIDATED": 1,
	"COMMITTED": 2,
	"APPLIED":   3,
	"FAILED":    4,
}

func (x TransactionStatus_State) String() string {
	return proto.EnumName(TransactionStatus_State_name, int32(x))
}

func (TransactionStatus_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c3a2d73bdadccc35, []int{5, 0}
}

type TransactionInitializePhase_State int32

const (
	TransactionInitializePhase_INITIALIZING TransactionInitializePhase_State = 0
	TransactionInitializePhase_INITIALIZED  TransactionInitializePhase_State = 1
	TransactionInitializePhase_FAILED       TransactionInitializePhase_State = 2
)

var TransactionInitializePhase_State_name = map[int32]string{
	0: "INITIALIZING",
	1: "INITIALIZED",
	2: "FAILED",
}

var TransactionInitializePhase_State_value = map[string]int32{
	"INITIALIZING": 0,
	"INITIALIZED":  1,
	"FAILED":       2,
}

func (x TransactionInitializePhase_State) String() string {
	return proto.EnumName(TransactionInitializePhase_State_name, int32(x))
}

func (TransactionInitializePhase_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c3a2d73bdadccc35, []int{8, 0}
}

type TransactionValidatePhase_State int32

const (
	TransactionValidatePhase_VALIDATING TransactionValidatePhase_State = 0
	TransactionValidatePhase_VALIDATED  TransactionValidatePhase_State = 1
	TransactionValidatePhase_FAILED     TransactionValidatePhase_State = 2
)

var TransactionValidatePhase_State_name = map[int32]string{
	0: "VALIDATING",
	1: "VALIDATED",
	2: "FAILED",
}

var TransactionValidatePhase_State_value = map[string]int32{
	"VALIDATING": 0,
	"VALIDATED":  1,
	"FAILED":     2,
}

func (x TransactionValidatePhase_State) String() string {
	return proto.EnumName(TransactionValidatePhase_State_name, int32(x))
}

func (TransactionValidatePhase_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c3a2d73bdadccc35, []int{9, 0}
}

type TransactionCommitPhase_State int32

const (
	TransactionCommitPhase_COMMITTING TransactionCommitPhase_State = 0
	TransactionCommitPhase_COMMITTED  TransactionCommitPhase_State = 1
)

var TransactionCommitPhase_State_name = map[int32]string{
	0: "COMMITTING",
	1: "COMMITTED",
}

var TransactionCommitPhase_State_value = map[string]int32{
	"COMMITTING": 0,
	"COMMITTED":  1,
}

func (x TransactionCommitPhase_State) String() string {
	return proto.EnumName(TransactionCommitPhase_State_name, int32(x))
}

func (TransactionCommitPhase_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c3a2d73bdadccc35, []int{10, 0}
}

type TransactionApplyPhase_State int32

const (
	TransactionApplyPhase_APPLYING TransactionApplyPhase_State = 0
	TransactionApplyPhase_APPLIED  TransactionApplyPhase_State = 1
	TransactionApplyPhase_FAILED   TransactionApplyPhase_State = 2
)

var TransactionApplyPhase_State_name = map[int32]string{
	0: "APPLYING",
	1: "APPLIED",
	2: "FAILED",
}

var TransactionApplyPhase_State_value = map[string]int32{
	"APPLYING": 0,
	"APPLIED":  1,
	"FAILED":   2,
}

func (x TransactionApplyPhase_State) String() string {
	return proto.EnumName(TransactionApplyPhase_State_name, int32(x))
}

func (TransactionApplyPhase_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c3a2d73bdadccc35, []int{11, 0}
}

type TransactionAbortPhase_State int32

const (
	TransactionAbortPhase_ABORTING TransactionAbortPhase_State = 0
	TransactionAbortPhase_ABORTED  TransactionAbortPhase_State = 1
)

var TransactionAbortPhase_State_name = map[int32]string{
	0: "ABORTING",
	1: "ABORTED",
}

var TransactionAbortPhase_State_value = map[string]int32{
	"ABORTING": 0,
	"ABORTED":  1,
}

func (x TransactionAbortPhase_State) String() string {
	return proto.EnumName(TransactionAbortPhase_State_name, int32(x))
}

func (TransactionAbortPhase_State) EnumDescriptor() ([]byte, []int) {
	return fileDescriptor_c3a2d73bdadccc35, []int{12, 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_c3a2d73bdadccc35, []int{13, 0}
}

// TransactionInfo is an extension providing information about the transaction
// to clients in responses.
type TransactionInfo struct {
	ID    TransactionID `protobuf:"bytes,1,opt,name=id,proto3,casttype=TransactionID" json:"id,omitempty"`
	Index Index         `protobuf:"varint,2,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
}

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

var xxx_messageInfo_TransactionInfo proto.InternalMessageInfo

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

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

// Transaction refers to a transaction change or transaction rollback
type Transaction struct {
	ObjectMeta `protobuf:"bytes,1,opt,name=meta,proto3,embedded=meta" json:"meta"`
	// 'id' is the unique identifier of the transaction
	// This field should be set prior to persisting the object.
	ID TransactionID `protobuf:"bytes,2,opt,name=id,proto3,casttype=TransactionID" json:"id,omitempty"`
	// 'index' is a monotonically increasing, globally unique index of the change
	// The index is provided by the store, is static and unique for each unique change identifier,
	// and should not be modified by client code.
	Index Index `protobuf:"varint,3,opt,name=index,proto3,casttype=Index" json:"index,omitempty"`
	// 'username' is the name of the user that made the transaction
	Username string `protobuf:"bytes,4,opt,name=username,proto3" json:"username,omitempty"`
	// 'strategy' is the transaction strategy
	TransactionStrategy `protobuf:"bytes,5,opt,name=strategy,proto3,embedded=strategy" json:"strategy"`
	// 'details' is the transaction details
	//
	// Types that are valid to be assigned to Details:
	//	*Transaction_Change
	//	*Transaction_Rollback
	Details isTransaction_Details `protobuf_oneof:"details"`
	// 'status' is the current lifecycle status of the transaction
	Status TransactionStatus `protobuf:"bytes,8,opt,name=status,proto3" json:"status"`
	// Optional target type/version overrides.
	*TargetVersionOverrides `protobuf:"bytes,9,opt,name=version_overrides,json=versionOverrides,proto3,embedded=version_overrides" json:"version_overrides,omitempty"`
}

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

type isTransaction_Details interface {
	isTransaction_Details()
	MarshalTo([]byte) (int, error)
	Size() int
}

type Transaction_Change struct {
	Change *ChangeTransaction `protobuf:"bytes,6,opt,name=change,proto3,oneof" json:"change,omitempty"`
}
type Transaction_Rollback struct {
	Rollback *RollbackTransaction `protobuf:"bytes,7,opt,name=rollback,proto3,oneof" json:"rollback,omitempty"`
}

func (*Transaction_Change) isTransaction_Details()   {}
func (*Transaction_Rollback) isTransaction_Details() {}

func (m *Transaction) GetDetails() isTransaction_Details {
	if m != nil {
		return m.Details
	}
	return nil
}

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

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

func (m *Transaction) GetUsername() string {
	if m != nil {
		return m.Username
	}
	return ""
}

func (m *Transaction) GetChange() *ChangeTransaction {
	if x, ok := m.GetDetails().(*Transaction_Change); ok {
		return x.Change
	}
	return nil
}

func (m *Transaction) GetRollback() *RollbackTransaction {
	if x, ok := m.GetDetails().(*Transaction_Rollback); ok {
		return x.Rollback
	}
	return nil
}

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

// XXX_OneofWrappers is for the internal use of the proto package.
func (*Transaction) XXX_OneofWrappers() []interface{} {
	return []interface{}{
		(*Transaction_Change)(nil),
		(*Transaction_Rollback)(nil),
	}
}

type TransactionStrategy struct {
	// 'synchronicity' indicates the transaction synchronicity level
	Synchronicity TransactionStrategy_Synchronicity `protobuf:"varint,1,opt,name=synchronicity,proto3,enum=onos.config.v2.TransactionStrategy_Synchronicity" json:"synchronicity,omitempty"`
	// 'isolation' indicates the transaction isolation level
	Isolation TransactionStrategy_Isolation `protobuf:"varint,2,opt,name=isolation,proto3,enum=onos.config.v2.TransactionStrategy_Isolation" json:"isolation,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_c3a2d73bdadccc35, []int{2}
}
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
}

func (m *TransactionStrategy) GetIsolation() TransactionStrategy_Isolation {
	if m != nil {
		return m.Isolation
	}
	return TransactionStrategy_DEFAULT
}

type ChangeTransaction struct {
	// 'values' is a set of changes to apply to targets
	Values map[TargetID]*PathValues `protobuf:"bytes,1,rep,name=values,proto3,castkey=TargetID" json:"values,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_ChangeTransaction proto.InternalMessageInfo

func (m *ChangeTransaction) GetValues() map[TargetID]*PathValues {
	if m != nil {
		return m.Values
	}
	return nil
}

type RollbackTransaction struct {
	// 'rollback_index' is the index of the transaction to roll back
	RollbackIndex Index `protobuf:"varint,1,opt,name=rollback_index,json=rollbackIndex,proto3,casttype=Index" json:"rollback_index,omitempty"`
}

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

var xxx_messageInfo_RollbackTransaction proto.InternalMessageInfo

func (m *RollbackTransaction) GetRollbackIndex() Index {
	if m != nil {
		return m.RollbackIndex
	}
	return 0
}

type TransactionStatus struct {
	// 'phases' is the transaction phases
	Phases TransactionPhases `protobuf:"bytes,1,opt,name=phases,proto3" json:"phases"`
	// 'proposals' is the set of proposals managed by the transaction
	Proposals []ProposalID `protobuf:"bytes,2,rep,name=proposals,proto3,casttype=ProposalID" json:"proposals,omitempty"`
	// 'state' is the overall transaction state
	State TransactionStatus_State `protobuf:"varint,3,opt,name=state,proto3,enum=onos.config.v2.TransactionStatus_State" json:"state,omitempty"`
	// 'failure' is the transaction failure (if any)
	Failure *Failure `protobuf:"bytes,4,opt,name=failure,proto3" json:"failure,omitempty"`
}

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_c3a2d73bdadccc35, []int{5}
}
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) GetPhases() TransactionPhases {
	if m != nil {
		return m.Phases
	}
	return TransactionPhases{}
}

func (m *TransactionStatus) GetProposals() []ProposalID {
	if m != nil {
		return m.Proposals
	}
	return nil
}

func (m *TransactionStatus) GetState() TransactionStatus_State {
	if m != nil {
		return m.State
	}
	return TransactionStatus_PENDING
}

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

type TransactionPhases struct {
	// 'initialize' is the transaction initialization phase status
	Initialize *TransactionInitializePhase `protobuf:"bytes,1,opt,name=initialize,proto3" json:"initialize,omitempty"`
	// 'validate' is the transaction validation phase status
	Validate *TransactionValidatePhase `protobuf:"bytes,2,opt,name=validate,proto3" json:"validate,omitempty"`
	// 'commit' is the transaction commit phase status
	Commit *TransactionCommitPhase `protobuf:"bytes,3,opt,name=commit,proto3" json:"commit,omitempty"`
	// 'apply' is the transaction apply phase status
	Apply *TransactionApplyPhase `protobuf:"bytes,4,opt,name=apply,proto3" json:"apply,omitempty"`
	// 'abort' is the transaction abort phase status
	Abort *TransactionAbortPhase `protobuf:"bytes,5,opt,name=abort,proto3" json:"abort,omitempty"`
}

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

var xxx_messageInfo_TransactionPhases proto.InternalMessageInfo

func (m *TransactionPhases) GetInitialize() *TransactionInitializePhase {
	if m != nil {
		return m.Initialize
	}
	return nil
}

func (m *TransactionPhases) GetValidate() *TransactionValidatePhase {
	if m != nil {
		return m.Validate
	}
	return nil
}

func (m *TransactionPhases) GetCommit() *TransactionCommitPhase {
	if m != nil {
		return m.Commit
	}
	return nil
}

func (m *TransactionPhases) GetApply() *TransactionApplyPhase {
	if m != nil {
		return m.Apply
	}
	return nil
}

func (m *TransactionPhases) GetAbort() *TransactionAbortPhase {
	if m != nil {
		return m.Abort
	}
	return nil
}

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"`
}

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_c3a2d73bdadccc35, []int{7}
}
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
}

type TransactionInitializePhase struct {
	TransactionPhaseStatus `protobuf:"bytes,1,opt,name=status,proto3,embedded=status" json:"status"`
	State                  TransactionInitializePhase_State `protobuf:"varint,2,opt,name=state,proto3,enum=onos.config.v2.TransactionInitializePhase_State" json:"state,omitempty"`
	Failure                *Failure                         `protobuf:"bytes,3,opt,name=failure,proto3" json:"failure,omitempty"`
}

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

var xxx_messageInfo_TransactionInitializePhase proto.InternalMessageInfo

func (m *TransactionInitializePhase) GetState() TransactionInitializePhase_State {
	if m != nil {
		return m.State
	}
	return TransactionInitializePhase_INITIALIZING
}

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

type TransactionValidatePhase struct {
	TransactionPhaseStatus `protobuf:"bytes,1,opt,name=status,proto3,embedded=status" json:"status"`
	State                  TransactionValidatePhase_State `protobuf:"varint,2,opt,name=state,proto3,enum=onos.config.v2.TransactionValidatePhase_State" json:"state,omitempty"`
	Failure                *Failure                       `protobuf:"bytes,3,opt,name=failure,proto3" json:"failure,omitempty"`
}

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

var xxx_messageInfo_TransactionValidatePhase proto.InternalMessageInfo

func (m *TransactionValidatePhase) GetState() TransactionValidatePhase_State {
	if m != nil {
		return m.State
	}
	return TransactionValidatePhase_VALIDATING
}

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

type TransactionCommitPhase struct {
	TransactionPhaseStatus `protobuf:"bytes,1,opt,name=status,proto3,embedded=status" json:"status"`
	State                  TransactionCommitPhase_State `protobuf:"varint,2,opt,name=state,proto3,enum=onos.config.v2.TransactionCommitPhase_State" json:"state,omitempty"`
}

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

var xxx_messageInfo_TransactionCommitPhase proto.InternalMessageInfo

func (m *TransactionCommitPhase) GetState() TransactionCommitPhase_State {
	if m != nil {
		return m.State
	}
	return TransactionCommitPhase_COMMITTING
}

type TransactionApplyPhase struct {
	TransactionPhaseStatus `protobuf:"bytes,1,opt,name=status,proto3,embedded=status" json:"status"`
	State                  TransactionApplyPhase_State `protobuf:"varint,2,opt,name=state,proto3,enum=onos.config.v2.TransactionApplyPhase_State" json:"state,omitempty"`
	Failure                *Failure                    `protobuf:"bytes,3,opt,name=failure,proto3" json:"failure,omitempty"`
}

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

var xxx_messageInfo_TransactionApplyPhase proto.InternalMessageInfo

func (m *TransactionApplyPhase) GetState() TransactionApplyPhase_State {
	if m != nil {
		return m.State
	}
	return TransactionApplyPhase_APPLYING
}

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

type TransactionAbortPhase struct {
	TransactionPhaseStatus `protobuf:"bytes,1,opt,name=status,proto3,embedded=status" json:"status"`
	State                  TransactionAbortPhase_State `protobuf:"varint,2,opt,name=state,proto3,enum=onos.config.v2.TransactionAbortPhase_State" json:"state,omitempty"`
}

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

var xxx_messageInfo_TransactionAbortPhase proto.InternalMessageInfo

func (m *TransactionAbortPhase) GetState() TransactionAbortPhase_State {
	if m != nil {
		return m.State
	}
	return TransactionAbortPhase_ABORTING
}

// TransactionEvent transaction store event
type TransactionEvent struct {
	Type        TransactionEvent_EventType `protobuf:"varint,1,opt,name=type,proto3,enum=onos.config.v2.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_c3a2d73bdadccc35, []int{13}
}
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{}
}

// TargetVersionOverrides carries optional mappings of targets to their model type and version overrides.
type TargetVersionOverrides struct {
	Overrides map[string]*TargetTypeVersion `protobuf:"bytes,1,rep,name=overrides,proto3" json:"overrides,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
}

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

var xxx_messageInfo_TargetVersionOverrides proto.InternalMessageInfo

func (m *TargetVersionOverrides) GetOverrides() map[string]*TargetTypeVersion {
	if m != nil {
		return m.Overrides
	}
	return nil
}

func init() {
	proto.RegisterEnum("onos.config.v2.TransactionStrategy_Synchronicity", TransactionStrategy_Synchronicity_name, TransactionStrategy_Synchronicity_value)
	proto.RegisterEnum("onos.config.v2.TransactionStrategy_Isolation", TransactionStrategy_Isolation_name, TransactionStrategy_Isolation_value)
	proto.RegisterEnum("onos.config.v2.TransactionStatus_State", TransactionStatus_State_name, TransactionStatus_State_value)
	proto.RegisterEnum("onos.config.v2.TransactionInitializePhase_State", TransactionInitializePhase_State_name, TransactionInitializePhase_State_value)
	proto.RegisterEnum("onos.config.v2.TransactionValidatePhase_State", TransactionValidatePhase_State_name, TransactionValidatePhase_State_value)
	proto.RegisterEnum("onos.config.v2.TransactionCommitPhase_State", TransactionCommitPhase_State_name, TransactionCommitPhase_State_value)
	proto.RegisterEnum("onos.config.v2.TransactionApplyPhase_State", TransactionApplyPhase_State_name, TransactionApplyPhase_State_value)
	proto.RegisterEnum("onos.config.v2.TransactionAbortPhase_State", TransactionAbortPhase_State_name, TransactionAbortPhase_State_value)
	proto.RegisterEnum("onos.config.v2.TransactionEvent_EventType", TransactionEvent_EventType_name, TransactionEvent_EventType_value)
	proto.RegisterType((*TransactionInfo)(nil), "onos.config.v2.TransactionInfo")
	proto.RegisterType((*Transaction)(nil), "onos.config.v2.Transaction")
	proto.RegisterType((*TransactionStrategy)(nil), "onos.config.v2.TransactionStrategy")
	proto.RegisterType((*ChangeTransaction)(nil), "onos.config.v2.ChangeTransaction")
	proto.RegisterMapType((map[TargetID]*PathValues)(nil), "onos.config.v2.ChangeTransaction.ValuesEntry")
	proto.RegisterType((*RollbackTransaction)(nil), "onos.config.v2.RollbackTransaction")
	proto.RegisterType((*TransactionStatus)(nil), "onos.config.v2.TransactionStatus")
	proto.RegisterType((*TransactionPhases)(nil), "onos.config.v2.TransactionPhases")
	proto.RegisterType((*TransactionPhaseStatus)(nil), "onos.config.v2.TransactionPhaseStatus")
	proto.RegisterType((*TransactionInitializePhase)(nil), "onos.config.v2.TransactionInitializePhase")
	proto.RegisterType((*TransactionValidatePhase)(nil), "onos.config.v2.TransactionValidatePhase")
	proto.RegisterType((*TransactionCommitPhase)(nil), "onos.config.v2.TransactionCommitPhase")
	proto.RegisterType((*TransactionApplyPhase)(nil), "onos.config.v2.TransactionApplyPhase")
	proto.RegisterType((*TransactionAbortPhase)(nil), "onos.config.v2.TransactionAbortPhase")
	proto.RegisterType((*TransactionEvent)(nil), "onos.config.v2.TransactionEvent")
	proto.RegisterType((*TargetVersionOverrides)(nil), "onos.config.v2.TargetVersionOverrides")
	proto.RegisterMapType((map[string]*TargetTypeVersion)(nil), "onos.config.v2.TargetVersionOverrides.OverridesEntry")
}

func init() { proto.RegisterFile("onos/config/v2/transaction.proto", fileDescriptor_c3a2d73bdadccc35) }

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

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

func (m *TransactionInfo) 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
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintTransaction(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0xa
	}
	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
	if m.TargetVersionOverrides != nil {
		{
			size, err := m.TargetVersionOverrides.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x4a
	}
	{
		size, err := m.Status.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTransaction(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x42
	if m.Details != nil {
		{
			size := m.Details.Size()
			i -= size
			if _, err := m.Details.MarshalTo(dAtA[i:]); err != nil {
				return 0, err
			}
		}
	}
	{
		size, err := m.TransactionStrategy.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTransaction(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0x2a
	if len(m.Username) > 0 {
		i -= len(m.Username)
		copy(dAtA[i:], m.Username)
		i = encodeVarintTransaction(dAtA, i, uint64(len(m.Username)))
		i--
		dAtA[i] = 0x22
	}
	if m.Index != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.Index))
		i--
		dAtA[i] = 0x18
	}
	if len(m.ID) > 0 {
		i -= len(m.ID)
		copy(dAtA[i:], m.ID)
		i = encodeVarintTransaction(dAtA, i, uint64(len(m.ID)))
		i--
		dAtA[i] = 0x12
	}
	{
		size, err := m.ObjectMeta.MarshalToSizedBuffer(dAtA[:i])
		if err != nil {
			return 0, err
		}
		i -= size
		i = encodeVarintTransaction(dAtA, i, uint64(size))
	}
	i--
	dAtA[i] = 0xa
	return len(dAtA) - i, nil
}

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

func (m *Transaction_Change) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Change != nil {
		{
			size, err := m.Change.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x32
	}
	return len(dAtA) - i, nil
}
func (m *Transaction_Rollback) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *Transaction_Rollback) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	if m.Rollback != nil {
		{
			size, err := m.Rollback.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x3a
	}
	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.Isolation != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.Isolation))
		i--
		dAtA[i] = 0x10
	}
	if m.Synchronicity != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.Synchronicity))
		i--
		dAtA[i] = 0x8
	}
	return len(dAtA) - i, nil
}

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

func (m *ChangeTransaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Values) > 0 {
		for k := range m.Values {
			v := m.Values[k]
			baseI := i
			if v != nil {
				{
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
					if err != nil {
						return 0, err
					}
					i -= size
					i = 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] = 0xa
		}
	}
	return len(dAtA) - i, nil
}

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

func (m *RollbackTransaction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.RollbackIndex != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.RollbackIndex))
		i--
		dAtA[i] = 0x8
	}
	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
	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 len(m.Proposals) > 0 {
		for iNdEx := len(m.Proposals) - 1; iNdEx >= 0; iNdEx-- {
			i -= len(m.Proposals[iNdEx])
			copy(dAtA[i:], m.Proposals[iNdEx])
			i = encodeVarintTransaction(dAtA, i, uint64(len(m.Proposals[iNdEx])))
			i--
			dAtA[i] = 0x12
		}
	}
	{
		size, err := m.Phases.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 *TransactionPhases) 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 *TransactionPhases) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionPhases) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.Abort != nil {
		{
			size, err := m.Abort.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x2a
	}
	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] = 0x22
	}
	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] = 0x1a
	}
	if m.Validate != nil {
		{
			size, err := m.Validate.MarshalToSizedBuffer(dAtA[:i])
			if err != nil {
				return 0, err
			}
			i -= size
			i = encodeVarintTransaction(dAtA, i, uint64(size))
		}
		i--
		dAtA[i] = 0x12
	}
	if m.Initialize != nil {
		{
			size, err := m.Initialize.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 *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.End != nil {
		n15, err15 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.End):])
		if err15 != nil {
			return 0, err15
		}
		i -= n15
		i = encodeVarintTransaction(dAtA, i, uint64(n15))
		i--
		dAtA[i] = 0x12
	}
	if m.Start != nil {
		n16, err16 := github_com_gogo_protobuf_types.StdTimeMarshalTo(*m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(*m.Start):])
		if err16 != nil {
			return 0, err16
		}
		i -= n16
		i = encodeVarintTransaction(dAtA, i, uint64(n16))
		i--
		dAtA[i] = 0xa
	}
	return len(dAtA) - i, nil
}

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

func (m *TransactionInitializePhase) 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] = 0x1a
	}
	if m.State != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.TransactionPhaseStatus.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 *TransactionValidatePhase) 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 *TransactionValidatePhase) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionValidatePhase) 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] = 0x1a
	}
	if m.State != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.TransactionPhaseStatus.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 *TransactionCommitPhase) 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 *TransactionCommitPhase) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionCommitPhase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.State != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.TransactionPhaseStatus.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 *TransactionApplyPhase) 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 *TransactionApplyPhase) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionApplyPhase) 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] = 0x1a
	}
	if m.State != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.TransactionPhaseStatus.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 *TransactionAbortPhase) 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 *TransactionAbortPhase) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TransactionAbortPhase) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if m.State != 0 {
		i = encodeVarintTransaction(dAtA, i, uint64(m.State))
		i--
		dAtA[i] = 0x10
	}
	{
		size, err := m.TransactionPhaseStatus.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 *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 (m *TargetVersionOverrides) 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 *TargetVersionOverrides) MarshalTo(dAtA []byte) (int, error) {
	size := m.Size()
	return m.MarshalToSizedBuffer(dAtA[:size])
}

func (m *TargetVersionOverrides) MarshalToSizedBuffer(dAtA []byte) (int, error) {
	i := len(dAtA)
	_ = i
	var l int
	_ = l
	if len(m.Overrides) > 0 {
		for k := range m.Overrides {
			v := m.Overrides[k]
			baseI := i
			if v != nil {
				{
					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] = 0xa
		}
	}
	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 *TransactionInfo) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = len(m.ID)
	if l > 0 {
		n += 1 + l + sovTransaction(uint64(l))
	}
	if m.Index != 0 {
		n += 1 + sovTransaction(uint64(m.Index))
	}
	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 = len(m.ID)
	if l > 0 {
		n += 1 + l + sovTransaction(uint64(l))
	}
	if m.Index != 0 {
		n += 1 + sovTransaction(uint64(m.Index))
	}
	l = len(m.Username)
	if l > 0 {
		n += 1 + l + sovTransaction(uint64(l))
	}
	l = m.TransactionStrategy.Size()
	n += 1 + l + sovTransaction(uint64(l))
	if m.Details != nil {
		n += m.Details.Size()
	}
	l = m.Status.Size()
	n += 1 + l + sovTransaction(uint64(l))
	if m.TargetVersionOverrides != nil {
		l = m.TargetVersionOverrides.Size()
		n += 1 + l + sovTransaction(uint64(l))
	}
	return n
}

func (m *Transaction_Change) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Change != nil {
		l = m.Change.Size()
		n += 1 + l + sovTransaction(uint64(l))
	}
	return n
}
func (m *Transaction_Rollback) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Rollback != nil {
		l = m.Rollback.Size()
		n += 1 + l + sovTransaction(uint64(l))
	}
	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))
	}
	if m.Isolation != 0 {
		n += 1 + sovTransaction(uint64(m.Isolation))
	}
	return n
}

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

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

func (m *TransactionStatus) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.Phases.Size()
	n += 1 + l + sovTransaction(uint64(l))
	if len(m.Proposals) > 0 {
		for _, s := range m.Proposals {
			l = len(s)
			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 *TransactionPhases) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if m.Initialize != nil {
		l = m.Initialize.Size()
		n += 1 + l + sovTransaction(uint64(l))
	}
	if m.Validate != nil {
		l = m.Validate.Size()
		n += 1 + l + sovTransaction(uint64(l))
	}
	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.Abort != nil {
		l = m.Abort.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))
	}
	return n
}

func (m *TransactionInitializePhase) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TransactionPhaseStatus.Size()
	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 *TransactionValidatePhase) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TransactionPhaseStatus.Size()
	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 *TransactionCommitPhase) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TransactionPhaseStatus.Size()
	n += 1 + l + sovTransaction(uint64(l))
	if m.State != 0 {
		n += 1 + sovTransaction(uint64(m.State))
	}
	return n
}

func (m *TransactionApplyPhase) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TransactionPhaseStatus.Size()
	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 *TransactionAbortPhase) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	l = m.TransactionPhaseStatus.Size()
	n += 1 + l + sovTransaction(uint64(l))
	if m.State != 0 {
		n += 1 + sovTransaction(uint64(m.State))
	}
	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 (m *TargetVersionOverrides) Size() (n int) {
	if m == nil {
		return 0
	}
	var l int
	_ = l
	if len(m.Overrides) > 0 {
		for k, v := range m.Overrides {
			_ = k
			_ = v
			l = 0
			if v != nil {
				l = v.Size()
				l += 1 + sovTransaction(uint64(l))
			}
			mapEntrySize := 1 + len(k) + sovTransaction(uint64(len(k))) + l
			n += mapEntrySize + 1 + sovTransaction(uint64(mapEntrySize))
		}
	}
	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 *TransactionInfo) 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: TransactionInfo: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionInfo: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				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 ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = TransactionID(dAtA[iNdEx:postIndex])
			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 *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 stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				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 ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.ID = TransactionID(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 3:
			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 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				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 ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Username = string(dAtA[iNdEx:postIndex])
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionStrategy", 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.TransactionStrategy.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			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
			}
			v := &ChangeTransaction{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Details = &Transaction_Change{v}
			iNdEx = postIndex
		case 7:
			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
			}
			v := &RollbackTransaction{}
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			m.Details = &Transaction_Rollback{v}
			iNdEx = postIndex
		case 8:
			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
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TargetVersionOverrides", 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.TargetVersionOverrides == nil {
				m.TargetVersionOverrides = &TargetVersionOverrides{}
			}
			if err := m.TargetVersionOverrides.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 *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
				}
			}
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Isolation", wireType)
			}
			m.Isolation = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.Isolation |= TransactionStrategy_Isolation(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 *ChangeTransaction) 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: ChangeTransaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ChangeTransaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			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[TargetID]*PathValues)
			}
			var mapkey TargetID
			var mapvalue *PathValues
			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 = TargetID(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 = &PathValues{}
					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[TargetID(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 *RollbackTransaction) 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: RollbackTransaction: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: RollbackTransaction: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field RollbackIndex", wireType)
			}
			m.RollbackIndex = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := dAtA[iNdEx]
				iNdEx++
				m.RollbackIndex |= 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 *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 != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Phases", 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.Phases.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Proposals", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowTransaction
				}
				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 ErrInvalidLengthTransaction
			}
			postIndex := iNdEx + intStringLen
			if postIndex < 0 {
				return ErrInvalidLengthTransaction
			}
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Proposals = append(m.Proposals, ProposalID(dAtA[iNdEx:postIndex]))
			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 |= TransactionStatus_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 *TransactionPhases) 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: TransactionPhases: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionPhases: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Initialize", 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.Initialize == nil {
				m.Initialize = &TransactionInitializePhase{}
			}
			if err := m.Initialize.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Validate", 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.Validate == nil {
				m.Validate = &TransactionValidatePhase{}
			}
			if err := m.Validate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			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 = &TransactionCommitPhase{}
			}
			if err := m.Commit.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			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 = &TransactionApplyPhase{}
			}
			if err := m.Apply.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Abort", 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.Abort == nil {
				m.Abort = &TransactionAbortPhase{}
			}
			if err := m.Abort.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
		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 *TransactionInitializePhase) 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: TransactionInitializePhase: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionInitializePhase: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionPhaseStatus", 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.TransactionPhaseStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 |= TransactionInitializePhase_State(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 *TransactionValidatePhase) 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: TransactionValidatePhase: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionValidatePhase: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionPhaseStatus", 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.TransactionPhaseStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 |= TransactionValidatePhase_State(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 *TransactionCommitPhase) 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: TransactionCommitPhase: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionCommitPhase: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionPhaseStatus", 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.TransactionPhaseStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 |= TransactionCommitPhase_State(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 *TransactionApplyPhase) 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: TransactionApplyPhase: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionApplyPhase: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionPhaseStatus", 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.TransactionPhaseStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 |= TransactionApplyPhase_State(b&0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		case 3:
			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 *TransactionAbortPhase) 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: TransactionAbortPhase: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TransactionAbortPhase: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TransactionPhaseStatus", 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.TransactionPhaseStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			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 |= TransactionAbortPhase_State(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 *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 (m *TargetVersionOverrides) 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: TargetVersionOverrides: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: TargetVersionOverrides: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Overrides", 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.Overrides == nil {
				m.Overrides = make(map[string]*TargetTypeVersion)
			}
			var mapkey string
			var mapvalue *TargetTypeVersion
			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 = &TargetTypeVersion{}
					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.Overrides[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 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")
)