// Code generated by mockery v2.53.3. DO NOT EDIT.

package mock_message

import (
	commonpb "github.com/milvus-io/milvus-proto/go-api/v2/commonpb"
	message "github.com/milvus-io/milvus/pkg/v2/streaming/util/message"

	messagespb "github.com/milvus-io/milvus/pkg/v2/proto/messagespb"

	mock "github.com/stretchr/testify/mock"

	zapcore "go.uber.org/zap/zapcore"
)

// MockImmutableTxnMessage is an autogenerated mock type for the ImmutableTxnMessage type
type MockImmutableTxnMessage struct {
	mock.Mock
}

type MockImmutableTxnMessage_Expecter struct {
	mock *mock.Mock
}

func (_m *MockImmutableTxnMessage) EXPECT() *MockImmutableTxnMessage_Expecter {
	return &MockImmutableTxnMessage_Expecter{mock: &_m.Mock}
}

// BarrierTimeTick provides a mock function with no fields
func (_m *MockImmutableTxnMessage) BarrierTimeTick() uint64 {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for BarrierTimeTick")
	}

	var r0 uint64
	if rf, ok := ret.Get(0).(func() uint64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(uint64)
	}

	return r0
}

// MockImmutableTxnMessage_BarrierTimeTick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BarrierTimeTick'
type MockImmutableTxnMessage_BarrierTimeTick_Call struct {
	*mock.Call
}

// BarrierTimeTick is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) BarrierTimeTick() *MockImmutableTxnMessage_BarrierTimeTick_Call {
	return &MockImmutableTxnMessage_BarrierTimeTick_Call{Call: _e.mock.On("BarrierTimeTick")}
}

func (_c *MockImmutableTxnMessage_BarrierTimeTick_Call) Run(run func()) *MockImmutableTxnMessage_BarrierTimeTick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_BarrierTimeTick_Call) Return(_a0 uint64) *MockImmutableTxnMessage_BarrierTimeTick_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_BarrierTimeTick_Call) RunAndReturn(run func() uint64) *MockImmutableTxnMessage_BarrierTimeTick_Call {
	_c.Call.Return(run)
	return _c
}

// Begin provides a mock function with no fields
func (_m *MockImmutableTxnMessage) Begin() message.ImmutableMessage {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Begin")
	}

	var r0 message.ImmutableMessage
	if rf, ok := ret.Get(0).(func() message.ImmutableMessage); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(message.ImmutableMessage)
		}
	}

	return r0
}

// MockImmutableTxnMessage_Begin_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Begin'
type MockImmutableTxnMessage_Begin_Call struct {
	*mock.Call
}

// Begin is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) Begin() *MockImmutableTxnMessage_Begin_Call {
	return &MockImmutableTxnMessage_Begin_Call{Call: _e.mock.On("Begin")}
}

func (_c *MockImmutableTxnMessage_Begin_Call) Run(run func()) *MockImmutableTxnMessage_Begin_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_Begin_Call) Return(_a0 message.ImmutableMessage) *MockImmutableTxnMessage_Begin_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_Begin_Call) RunAndReturn(run func() message.ImmutableMessage) *MockImmutableTxnMessage_Begin_Call {
	_c.Call.Return(run)
	return _c
}

// BroadcastHeader provides a mock function with no fields
func (_m *MockImmutableTxnMessage) BroadcastHeader() *message.BroadcastHeader {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for BroadcastHeader")
	}

	var r0 *message.BroadcastHeader
	if rf, ok := ret.Get(0).(func() *message.BroadcastHeader); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*message.BroadcastHeader)
		}
	}

	return r0
}

// MockImmutableTxnMessage_BroadcastHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BroadcastHeader'
type MockImmutableTxnMessage_BroadcastHeader_Call struct {
	*mock.Call
}

// BroadcastHeader is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) BroadcastHeader() *MockImmutableTxnMessage_BroadcastHeader_Call {
	return &MockImmutableTxnMessage_BroadcastHeader_Call{Call: _e.mock.On("BroadcastHeader")}
}

func (_c *MockImmutableTxnMessage_BroadcastHeader_Call) Run(run func()) *MockImmutableTxnMessage_BroadcastHeader_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_BroadcastHeader_Call) Return(_a0 *message.BroadcastHeader) *MockImmutableTxnMessage_BroadcastHeader_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_BroadcastHeader_Call) RunAndReturn(run func() *message.BroadcastHeader) *MockImmutableTxnMessage_BroadcastHeader_Call {
	_c.Call.Return(run)
	return _c
}

// Commit provides a mock function with no fields
func (_m *MockImmutableTxnMessage) Commit() message.ImmutableMessage {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Commit")
	}

	var r0 message.ImmutableMessage
	if rf, ok := ret.Get(0).(func() message.ImmutableMessage); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(message.ImmutableMessage)
		}
	}

	return r0
}

// MockImmutableTxnMessage_Commit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Commit'
type MockImmutableTxnMessage_Commit_Call struct {
	*mock.Call
}

// Commit is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) Commit() *MockImmutableTxnMessage_Commit_Call {
	return &MockImmutableTxnMessage_Commit_Call{Call: _e.mock.On("Commit")}
}

func (_c *MockImmutableTxnMessage_Commit_Call) Run(run func()) *MockImmutableTxnMessage_Commit_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_Commit_Call) Return(_a0 message.ImmutableMessage) *MockImmutableTxnMessage_Commit_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_Commit_Call) RunAndReturn(run func() message.ImmutableMessage) *MockImmutableTxnMessage_Commit_Call {
	_c.Call.Return(run)
	return _c
}

// EstimateSize provides a mock function with no fields
func (_m *MockImmutableTxnMessage) EstimateSize() int {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for EstimateSize")
	}

	var r0 int
	if rf, ok := ret.Get(0).(func() int); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

// MockImmutableTxnMessage_EstimateSize_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EstimateSize'
type MockImmutableTxnMessage_EstimateSize_Call struct {
	*mock.Call
}

// EstimateSize is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) EstimateSize() *MockImmutableTxnMessage_EstimateSize_Call {
	return &MockImmutableTxnMessage_EstimateSize_Call{Call: _e.mock.On("EstimateSize")}
}

func (_c *MockImmutableTxnMessage_EstimateSize_Call) Run(run func()) *MockImmutableTxnMessage_EstimateSize_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_EstimateSize_Call) Return(_a0 int) *MockImmutableTxnMessage_EstimateSize_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_EstimateSize_Call) RunAndReturn(run func() int) *MockImmutableTxnMessage_EstimateSize_Call {
	_c.Call.Return(run)
	return _c
}

// IntoBroadcastMutableMessage provides a mock function with no fields
func (_m *MockImmutableTxnMessage) IntoBroadcastMutableMessage() message.BroadcastMutableMessage {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for IntoBroadcastMutableMessage")
	}

	var r0 message.BroadcastMutableMessage
	if rf, ok := ret.Get(0).(func() message.BroadcastMutableMessage); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(message.BroadcastMutableMessage)
		}
	}

	return r0
}

// MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IntoBroadcastMutableMessage'
type MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call struct {
	*mock.Call
}

// IntoBroadcastMutableMessage is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) IntoBroadcastMutableMessage() *MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call {
	return &MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call{Call: _e.mock.On("IntoBroadcastMutableMessage")}
}

func (_c *MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call) Run(run func()) *MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call) Return(_a0 message.BroadcastMutableMessage) *MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call) RunAndReturn(run func() message.BroadcastMutableMessage) *MockImmutableTxnMessage_IntoBroadcastMutableMessage_Call {
	_c.Call.Return(run)
	return _c
}

// IntoImmutableMessageProto provides a mock function with no fields
func (_m *MockImmutableTxnMessage) IntoImmutableMessageProto() *commonpb.ImmutableMessage {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for IntoImmutableMessageProto")
	}

	var r0 *commonpb.ImmutableMessage
	if rf, ok := ret.Get(0).(func() *commonpb.ImmutableMessage); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*commonpb.ImmutableMessage)
		}
	}

	return r0
}

// MockImmutableTxnMessage_IntoImmutableMessageProto_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IntoImmutableMessageProto'
type MockImmutableTxnMessage_IntoImmutableMessageProto_Call struct {
	*mock.Call
}

// IntoImmutableMessageProto is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) IntoImmutableMessageProto() *MockImmutableTxnMessage_IntoImmutableMessageProto_Call {
	return &MockImmutableTxnMessage_IntoImmutableMessageProto_Call{Call: _e.mock.On("IntoImmutableMessageProto")}
}

func (_c *MockImmutableTxnMessage_IntoImmutableMessageProto_Call) Run(run func()) *MockImmutableTxnMessage_IntoImmutableMessageProto_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_IntoImmutableMessageProto_Call) Return(_a0 *commonpb.ImmutableMessage) *MockImmutableTxnMessage_IntoImmutableMessageProto_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_IntoImmutableMessageProto_Call) RunAndReturn(run func() *commonpb.ImmutableMessage) *MockImmutableTxnMessage_IntoImmutableMessageProto_Call {
	_c.Call.Return(run)
	return _c
}

// IntoMessageProto provides a mock function with no fields
func (_m *MockImmutableTxnMessage) IntoMessageProto() *messagespb.Message {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for IntoMessageProto")
	}

	var r0 *messagespb.Message
	if rf, ok := ret.Get(0).(func() *messagespb.Message); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*messagespb.Message)
		}
	}

	return r0
}

// MockImmutableTxnMessage_IntoMessageProto_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IntoMessageProto'
type MockImmutableTxnMessage_IntoMessageProto_Call struct {
	*mock.Call
}

// IntoMessageProto is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) IntoMessageProto() *MockImmutableTxnMessage_IntoMessageProto_Call {
	return &MockImmutableTxnMessage_IntoMessageProto_Call{Call: _e.mock.On("IntoMessageProto")}
}

func (_c *MockImmutableTxnMessage_IntoMessageProto_Call) Run(run func()) *MockImmutableTxnMessage_IntoMessageProto_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_IntoMessageProto_Call) Return(_a0 *messagespb.Message) *MockImmutableTxnMessage_IntoMessageProto_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_IntoMessageProto_Call) RunAndReturn(run func() *messagespb.Message) *MockImmutableTxnMessage_IntoMessageProto_Call {
	_c.Call.Return(run)
	return _c
}

// IsPersisted provides a mock function with no fields
func (_m *MockImmutableTxnMessage) IsPersisted() bool {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for IsPersisted")
	}

	var r0 bool
	if rf, ok := ret.Get(0).(func() bool); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(bool)
	}

	return r0
}

// MockImmutableTxnMessage_IsPersisted_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsPersisted'
type MockImmutableTxnMessage_IsPersisted_Call struct {
	*mock.Call
}

// IsPersisted is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) IsPersisted() *MockImmutableTxnMessage_IsPersisted_Call {
	return &MockImmutableTxnMessage_IsPersisted_Call{Call: _e.mock.On("IsPersisted")}
}

func (_c *MockImmutableTxnMessage_IsPersisted_Call) Run(run func()) *MockImmutableTxnMessage_IsPersisted_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_IsPersisted_Call) Return(_a0 bool) *MockImmutableTxnMessage_IsPersisted_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_IsPersisted_Call) RunAndReturn(run func() bool) *MockImmutableTxnMessage_IsPersisted_Call {
	_c.Call.Return(run)
	return _c
}

// LastConfirmedMessageID provides a mock function with no fields
func (_m *MockImmutableTxnMessage) LastConfirmedMessageID() message.MessageID {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for LastConfirmedMessageID")
	}

	var r0 message.MessageID
	if rf, ok := ret.Get(0).(func() message.MessageID); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(message.MessageID)
		}
	}

	return r0
}

// MockImmutableTxnMessage_LastConfirmedMessageID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LastConfirmedMessageID'
type MockImmutableTxnMessage_LastConfirmedMessageID_Call struct {
	*mock.Call
}

// LastConfirmedMessageID is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) LastConfirmedMessageID() *MockImmutableTxnMessage_LastConfirmedMessageID_Call {
	return &MockImmutableTxnMessage_LastConfirmedMessageID_Call{Call: _e.mock.On("LastConfirmedMessageID")}
}

func (_c *MockImmutableTxnMessage_LastConfirmedMessageID_Call) Run(run func()) *MockImmutableTxnMessage_LastConfirmedMessageID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_LastConfirmedMessageID_Call) Return(_a0 message.MessageID) *MockImmutableTxnMessage_LastConfirmedMessageID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_LastConfirmedMessageID_Call) RunAndReturn(run func() message.MessageID) *MockImmutableTxnMessage_LastConfirmedMessageID_Call {
	_c.Call.Return(run)
	return _c
}

// MarshalLogObject provides a mock function with given fields: _a0
func (_m *MockImmutableTxnMessage) MarshalLogObject(_a0 zapcore.ObjectEncoder) error {
	ret := _m.Called(_a0)

	if len(ret) == 0 {
		panic("no return value specified for MarshalLogObject")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(zapcore.ObjectEncoder) error); ok {
		r0 = rf(_a0)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockImmutableTxnMessage_MarshalLogObject_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MarshalLogObject'
type MockImmutableTxnMessage_MarshalLogObject_Call struct {
	*mock.Call
}

// MarshalLogObject is a helper method to define mock.On call
//   - _a0 zapcore.ObjectEncoder
func (_e *MockImmutableTxnMessage_Expecter) MarshalLogObject(_a0 interface{}) *MockImmutableTxnMessage_MarshalLogObject_Call {
	return &MockImmutableTxnMessage_MarshalLogObject_Call{Call: _e.mock.On("MarshalLogObject", _a0)}
}

func (_c *MockImmutableTxnMessage_MarshalLogObject_Call) Run(run func(_a0 zapcore.ObjectEncoder)) *MockImmutableTxnMessage_MarshalLogObject_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(zapcore.ObjectEncoder))
	})
	return _c
}

func (_c *MockImmutableTxnMessage_MarshalLogObject_Call) Return(_a0 error) *MockImmutableTxnMessage_MarshalLogObject_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_MarshalLogObject_Call) RunAndReturn(run func(zapcore.ObjectEncoder) error) *MockImmutableTxnMessage_MarshalLogObject_Call {
	_c.Call.Return(run)
	return _c
}

// MessageID provides a mock function with no fields
func (_m *MockImmutableTxnMessage) MessageID() message.MessageID {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for MessageID")
	}

	var r0 message.MessageID
	if rf, ok := ret.Get(0).(func() message.MessageID); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(message.MessageID)
		}
	}

	return r0
}

// MockImmutableTxnMessage_MessageID_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MessageID'
type MockImmutableTxnMessage_MessageID_Call struct {
	*mock.Call
}

// MessageID is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) MessageID() *MockImmutableTxnMessage_MessageID_Call {
	return &MockImmutableTxnMessage_MessageID_Call{Call: _e.mock.On("MessageID")}
}

func (_c *MockImmutableTxnMessage_MessageID_Call) Run(run func()) *MockImmutableTxnMessage_MessageID_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_MessageID_Call) Return(_a0 message.MessageID) *MockImmutableTxnMessage_MessageID_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_MessageID_Call) RunAndReturn(run func() message.MessageID) *MockImmutableTxnMessage_MessageID_Call {
	_c.Call.Return(run)
	return _c
}

// MessageType provides a mock function with no fields
func (_m *MockImmutableTxnMessage) MessageType() message.MessageType {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for MessageType")
	}

	var r0 message.MessageType
	if rf, ok := ret.Get(0).(func() message.MessageType); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(message.MessageType)
	}

	return r0
}

// MockImmutableTxnMessage_MessageType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MessageType'
type MockImmutableTxnMessage_MessageType_Call struct {
	*mock.Call
}

// MessageType is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) MessageType() *MockImmutableTxnMessage_MessageType_Call {
	return &MockImmutableTxnMessage_MessageType_Call{Call: _e.mock.On("MessageType")}
}

func (_c *MockImmutableTxnMessage_MessageType_Call) Run(run func()) *MockImmutableTxnMessage_MessageType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_MessageType_Call) Return(_a0 message.MessageType) *MockImmutableTxnMessage_MessageType_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_MessageType_Call) RunAndReturn(run func() message.MessageType) *MockImmutableTxnMessage_MessageType_Call {
	_c.Call.Return(run)
	return _c
}

// MessageTypeWithVersion provides a mock function with no fields
func (_m *MockImmutableTxnMessage) MessageTypeWithVersion() message.MessageTypeWithVersion {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for MessageTypeWithVersion")
	}

	var r0 message.MessageTypeWithVersion
	if rf, ok := ret.Get(0).(func() message.MessageTypeWithVersion); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(message.MessageTypeWithVersion)
	}

	return r0
}

// MockImmutableTxnMessage_MessageTypeWithVersion_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MessageTypeWithVersion'
type MockImmutableTxnMessage_MessageTypeWithVersion_Call struct {
	*mock.Call
}

// MessageTypeWithVersion is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) MessageTypeWithVersion() *MockImmutableTxnMessage_MessageTypeWithVersion_Call {
	return &MockImmutableTxnMessage_MessageTypeWithVersion_Call{Call: _e.mock.On("MessageTypeWithVersion")}
}

func (_c *MockImmutableTxnMessage_MessageTypeWithVersion_Call) Run(run func()) *MockImmutableTxnMessage_MessageTypeWithVersion_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_MessageTypeWithVersion_Call) Return(_a0 message.MessageTypeWithVersion) *MockImmutableTxnMessage_MessageTypeWithVersion_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_MessageTypeWithVersion_Call) RunAndReturn(run func() message.MessageTypeWithVersion) *MockImmutableTxnMessage_MessageTypeWithVersion_Call {
	_c.Call.Return(run)
	return _c
}

// Payload provides a mock function with no fields
func (_m *MockImmutableTxnMessage) Payload() []byte {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Payload")
	}

	var r0 []byte
	if rf, ok := ret.Get(0).(func() []byte); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]byte)
		}
	}

	return r0
}

// MockImmutableTxnMessage_Payload_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Payload'
type MockImmutableTxnMessage_Payload_Call struct {
	*mock.Call
}

// Payload is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) Payload() *MockImmutableTxnMessage_Payload_Call {
	return &MockImmutableTxnMessage_Payload_Call{Call: _e.mock.On("Payload")}
}

func (_c *MockImmutableTxnMessage_Payload_Call) Run(run func()) *MockImmutableTxnMessage_Payload_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_Payload_Call) Return(_a0 []byte) *MockImmutableTxnMessage_Payload_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_Payload_Call) RunAndReturn(run func() []byte) *MockImmutableTxnMessage_Payload_Call {
	_c.Call.Return(run)
	return _c
}

// Properties provides a mock function with no fields
func (_m *MockImmutableTxnMessage) Properties() message.RProperties {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Properties")
	}

	var r0 message.RProperties
	if rf, ok := ret.Get(0).(func() message.RProperties); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(message.RProperties)
		}
	}

	return r0
}

// MockImmutableTxnMessage_Properties_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Properties'
type MockImmutableTxnMessage_Properties_Call struct {
	*mock.Call
}

// Properties is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) Properties() *MockImmutableTxnMessage_Properties_Call {
	return &MockImmutableTxnMessage_Properties_Call{Call: _e.mock.On("Properties")}
}

func (_c *MockImmutableTxnMessage_Properties_Call) Run(run func()) *MockImmutableTxnMessage_Properties_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_Properties_Call) Return(_a0 message.RProperties) *MockImmutableTxnMessage_Properties_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_Properties_Call) RunAndReturn(run func() message.RProperties) *MockImmutableTxnMessage_Properties_Call {
	_c.Call.Return(run)
	return _c
}

// RangeOver provides a mock function with given fields: visitor
func (_m *MockImmutableTxnMessage) RangeOver(visitor func(message.ImmutableMessage) error) error {
	ret := _m.Called(visitor)

	if len(ret) == 0 {
		panic("no return value specified for RangeOver")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(func(message.ImmutableMessage) error) error); ok {
		r0 = rf(visitor)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// MockImmutableTxnMessage_RangeOver_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RangeOver'
type MockImmutableTxnMessage_RangeOver_Call struct {
	*mock.Call
}

// RangeOver is a helper method to define mock.On call
//   - visitor func(message.ImmutableMessage) error
func (_e *MockImmutableTxnMessage_Expecter) RangeOver(visitor interface{}) *MockImmutableTxnMessage_RangeOver_Call {
	return &MockImmutableTxnMessage_RangeOver_Call{Call: _e.mock.On("RangeOver", visitor)}
}

func (_c *MockImmutableTxnMessage_RangeOver_Call) Run(run func(visitor func(message.ImmutableMessage) error)) *MockImmutableTxnMessage_RangeOver_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(func(message.ImmutableMessage) error))
	})
	return _c
}

func (_c *MockImmutableTxnMessage_RangeOver_Call) Return(_a0 error) *MockImmutableTxnMessage_RangeOver_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_RangeOver_Call) RunAndReturn(run func(func(message.ImmutableMessage) error) error) *MockImmutableTxnMessage_RangeOver_Call {
	_c.Call.Return(run)
	return _c
}

// ReplicateHeader provides a mock function with no fields
func (_m *MockImmutableTxnMessage) ReplicateHeader() *message.ReplicateHeader {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for ReplicateHeader")
	}

	var r0 *message.ReplicateHeader
	if rf, ok := ret.Get(0).(func() *message.ReplicateHeader); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*message.ReplicateHeader)
		}
	}

	return r0
}

// MockImmutableTxnMessage_ReplicateHeader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplicateHeader'
type MockImmutableTxnMessage_ReplicateHeader_Call struct {
	*mock.Call
}

// ReplicateHeader is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) ReplicateHeader() *MockImmutableTxnMessage_ReplicateHeader_Call {
	return &MockImmutableTxnMessage_ReplicateHeader_Call{Call: _e.mock.On("ReplicateHeader")}
}

func (_c *MockImmutableTxnMessage_ReplicateHeader_Call) Run(run func()) *MockImmutableTxnMessage_ReplicateHeader_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_ReplicateHeader_Call) Return(_a0 *message.ReplicateHeader) *MockImmutableTxnMessage_ReplicateHeader_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_ReplicateHeader_Call) RunAndReturn(run func() *message.ReplicateHeader) *MockImmutableTxnMessage_ReplicateHeader_Call {
	_c.Call.Return(run)
	return _c
}

// Size provides a mock function with no fields
func (_m *MockImmutableTxnMessage) Size() int {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Size")
	}

	var r0 int
	if rf, ok := ret.Get(0).(func() int); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(int)
	}

	return r0
}

// MockImmutableTxnMessage_Size_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Size'
type MockImmutableTxnMessage_Size_Call struct {
	*mock.Call
}

// Size is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) Size() *MockImmutableTxnMessage_Size_Call {
	return &MockImmutableTxnMessage_Size_Call{Call: _e.mock.On("Size")}
}

func (_c *MockImmutableTxnMessage_Size_Call) Run(run func()) *MockImmutableTxnMessage_Size_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_Size_Call) Return(_a0 int) *MockImmutableTxnMessage_Size_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_Size_Call) RunAndReturn(run func() int) *MockImmutableTxnMessage_Size_Call {
	_c.Call.Return(run)
	return _c
}

// TimeTick provides a mock function with no fields
func (_m *MockImmutableTxnMessage) TimeTick() uint64 {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for TimeTick")
	}

	var r0 uint64
	if rf, ok := ret.Get(0).(func() uint64); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(uint64)
	}

	return r0
}

// MockImmutableTxnMessage_TimeTick_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TimeTick'
type MockImmutableTxnMessage_TimeTick_Call struct {
	*mock.Call
}

// TimeTick is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) TimeTick() *MockImmutableTxnMessage_TimeTick_Call {
	return &MockImmutableTxnMessage_TimeTick_Call{Call: _e.mock.On("TimeTick")}
}

func (_c *MockImmutableTxnMessage_TimeTick_Call) Run(run func()) *MockImmutableTxnMessage_TimeTick_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_TimeTick_Call) Return(_a0 uint64) *MockImmutableTxnMessage_TimeTick_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_TimeTick_Call) RunAndReturn(run func() uint64) *MockImmutableTxnMessage_TimeTick_Call {
	_c.Call.Return(run)
	return _c
}

// TxnContext provides a mock function with no fields
func (_m *MockImmutableTxnMessage) TxnContext() *message.TxnContext {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for TxnContext")
	}

	var r0 *message.TxnContext
	if rf, ok := ret.Get(0).(func() *message.TxnContext); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*message.TxnContext)
		}
	}

	return r0
}

// MockImmutableTxnMessage_TxnContext_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TxnContext'
type MockImmutableTxnMessage_TxnContext_Call struct {
	*mock.Call
}

// TxnContext is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) TxnContext() *MockImmutableTxnMessage_TxnContext_Call {
	return &MockImmutableTxnMessage_TxnContext_Call{Call: _e.mock.On("TxnContext")}
}

func (_c *MockImmutableTxnMessage_TxnContext_Call) Run(run func()) *MockImmutableTxnMessage_TxnContext_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_TxnContext_Call) Return(_a0 *message.TxnContext) *MockImmutableTxnMessage_TxnContext_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_TxnContext_Call) RunAndReturn(run func() *message.TxnContext) *MockImmutableTxnMessage_TxnContext_Call {
	_c.Call.Return(run)
	return _c
}

// VChannel provides a mock function with no fields
func (_m *MockImmutableTxnMessage) VChannel() string {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for VChannel")
	}

	var r0 string
	if rf, ok := ret.Get(0).(func() string); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(string)
	}

	return r0
}

// MockImmutableTxnMessage_VChannel_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VChannel'
type MockImmutableTxnMessage_VChannel_Call struct {
	*mock.Call
}

// VChannel is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) VChannel() *MockImmutableTxnMessage_VChannel_Call {
	return &MockImmutableTxnMessage_VChannel_Call{Call: _e.mock.On("VChannel")}
}

func (_c *MockImmutableTxnMessage_VChannel_Call) Run(run func()) *MockImmutableTxnMessage_VChannel_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_VChannel_Call) Return(_a0 string) *MockImmutableTxnMessage_VChannel_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_VChannel_Call) RunAndReturn(run func() string) *MockImmutableTxnMessage_VChannel_Call {
	_c.Call.Return(run)
	return _c
}

// Version provides a mock function with no fields
func (_m *MockImmutableTxnMessage) Version() message.Version {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Version")
	}

	var r0 message.Version
	if rf, ok := ret.Get(0).(func() message.Version); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(message.Version)
	}

	return r0
}

// MockImmutableTxnMessage_Version_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Version'
type MockImmutableTxnMessage_Version_Call struct {
	*mock.Call
}

// Version is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) Version() *MockImmutableTxnMessage_Version_Call {
	return &MockImmutableTxnMessage_Version_Call{Call: _e.mock.On("Version")}
}

func (_c *MockImmutableTxnMessage_Version_Call) Run(run func()) *MockImmutableTxnMessage_Version_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_Version_Call) Return(_a0 message.Version) *MockImmutableTxnMessage_Version_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_Version_Call) RunAndReturn(run func() message.Version) *MockImmutableTxnMessage_Version_Call {
	_c.Call.Return(run)
	return _c
}

// WALName provides a mock function with no fields
func (_m *MockImmutableTxnMessage) WALName() message.WALName {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for WALName")
	}

	var r0 message.WALName
	if rf, ok := ret.Get(0).(func() message.WALName); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(message.WALName)
	}

	return r0
}

// MockImmutableTxnMessage_WALName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WALName'
type MockImmutableTxnMessage_WALName_Call struct {
	*mock.Call
}

// WALName is a helper method to define mock.On call
func (_e *MockImmutableTxnMessage_Expecter) WALName() *MockImmutableTxnMessage_WALName_Call {
	return &MockImmutableTxnMessage_WALName_Call{Call: _e.mock.On("WALName")}
}

func (_c *MockImmutableTxnMessage_WALName_Call) Run(run func()) *MockImmutableTxnMessage_WALName_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *MockImmutableTxnMessage_WALName_Call) Return(_a0 message.WALName) *MockImmutableTxnMessage_WALName_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *MockImmutableTxnMessage_WALName_Call) RunAndReturn(run func() message.WALName) *MockImmutableTxnMessage_WALName_Call {
	_c.Call.Return(run)
	return _c
}

// NewMockImmutableTxnMessage creates a new instance of MockImmutableTxnMessage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewMockImmutableTxnMessage(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockImmutableTxnMessage {
	mock := &MockImmutableTxnMessage{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}
